typeofweb

// Also available on NPM: https://www.npmjs.com/package/safe-try

// By @typeofweb 2024
// License: MIT

type PromiseToTupleResult<T> = [Error, null] | [null, Awaited<T>];
export const try_ = async <T extends Promise<unknown>>(
	promise: T,
): Promise<PromiseToTupleResult<T>> => {
	try {

typeofweb

// See https://typeofweb.hashnode.dev/nextjs-prefetch-onmouseenter for a detailed explanation and more code
// See it in action: https://demo.yournextstore.com
"use client";

import Link from "next/link";
import { useRouter } from "next/navigation";
import { type ComponentPropsWithRef } from "react";

export const SuperLink = (props: ComponentPropsWithRef<typeof Link>) => {
	const router = useRouter();

typeofweb

import { clsx } from "clsx";
import { type ButtonHTMLAttributes } from "react";
import { Slot } from "./Slot";

interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
	asChild?: boolean;
	children: React.ReactNode;
}

export const Button = ({ asChild = false, ...props }: ButtonProps) => {

typeofweb

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "Permission": {
      "title": "Permission",
      "description": "An enumeration.",
      "enum": [
        "MANAGE_USERS",
        "MANAGE_STAFF",
        "IMPERSONATE_USER",

typeofweb

import type { Stripe } from "stripe";

type StripeWebhookEventTypes = Stripe.WebhookEndpointCreateParams.EnabledEvent;

type StripeWebhookEvent<EventType extends StripeWebhookEventTypes, Payload> = {
  type: EventType;
  data: {
    object: Payload;
  };
};

typeofweb

import Fetch from 'node-fetch';

interface JJITOffer {
  title: string;
  street: string;
  city: string;
  country_code: string;
  address_text: string;
  marker_icon: string;
  workplace_type: string;

typeofweb

const LogicValues = [true, false] as const;
type Logic = typeof LogicValues[number];
const CARDINALITY = LogicValues.length;

type Literal = { __t: "Literal"; symbol: string };
type UnaryOperator = { __t: "Unary"; e: (a: Logic) => Logic };
type BinaryOperator = { __t: "Binary"; e: (a: Logic, b: Logic) => Logic };

type Token = Literal | UnaryOperator | BinaryOperator;

typeofweb

/* eslint-disable functional/no-this-expression -- it's a class */
/* eslint-disable functional/prefer-readonly-type -- it's a class */
export const useBodyFix = () => {
  return fixBodyService;
};

class FixBodyService {
  private windowOffsetY: number = 0;
  private scrollbarWidth: number = 0;

typeofweb

function getHexValue(intInput: number) {
  return intInput.toString(16).padStart(2, "0");
}

function getTintValue(tint: number, bgTint: number, alpha: number) {
  return Math.min(Math.floor((1 - alpha) * bgTint + alpha * tint), 255);
}

class Color {
  constructor(

typeofweb

const getAllCSSVariableNames = () =>
  Array.from(document.styleSheets)
    .filter((s) => s.href === null || s.href.startsWith(window.location.origin))
    .flatMap((s) => Array.from(s.cssRules))
    .filter((r): r is CSSStyleRule => r.type === CSSRule.STYLE_RULE)
    .flatMap((r) => (r.selectorText === ":root" ? Array.from(r.style) : []))
    .filter((name) => name.startsWith("--"))
    .sort();

const getCSSColorVariableNames = () =>