xzec

import type { AuthErrorType } from '~/auth/types'

export class AuthError extends Error {
  readonly type: AuthErrorType

  constructor(
    type: AuthErrorType,
    { message, cause }: { message?: string } & ErrorOptions = {},
  ) {
    super(message ?? AuthError.defaultMessage[type], { cause })

xzec

import { debounce } from 'https://deno.land/std@0.224.0/async/debounce.ts'

await Array.fromAsync(
  Deno.watchFs('file.txt'),
  debounce((event) => console.debug(`[${event.kind}] ${event.paths[0]}`), 50),
)

// Credits: https://github.com/denoland/deno/issues/12874#issuecomment-1935198354

xzec

import { z } from 'zod'

const privateKeySchema = z.object({
  MY_PRIVATE_KEY: z
    .string()
    .regex(
      /-----BEGIN PRIVATE KEY-----\s*\S[\s\S]*?\s*-----END PRIVATE KEY-----/,
      'MY_PRIVATE_KEY must be a valid private key.',
    )
    .describe('Full contents of the private key used to sign/encrypt the thing.'),

xzec

import { setTimeout } from 'node:timers/promises'

export async function* fibonacci(frequencyMs = 200) {
  let a = 0n
  let b = 1n

  while (true) {
    yield String(b)
    b = a + b
    a = b - a

xzec

const parametrize = (url: string, params: ConstructorParameters<typeof URLSearchParams>[0]) => {
  return `${url}?${new URLSearchParams(params)}`
}

xzec

type RegExpMatchArrayWithGroups<G extends string> = RegExpMatchArray & {
  groups: Record<G, string> & Record<string, never>
}

const isRegExpMatchArrayWithGroups = <G extends string>(
  match: RegExpMatchArray | null,
  ...groups: G[]
): match is RegExpMatchArrayWithGroups<G> => groups.every((g) => match?.groups !== undefined && g in match.groups)

// usage

xzec

import resolve from './resolve' // https://gist.github.com/xzec/fac8ca82ce0e5cee41cf3d9769f9c9d0

const resolveFetch = (promise: Promise<Response>) =>
  resolve(
    promise.then((response) => {
      if (response.ok) return response
      throw new Error(`${response.status} ${response.statusText}`)
    })
  )

xzec

type Sensor = {
  lastMeasuredValue?: number | null
}

const sensors: Sensor[] = []

// type of `values` is narrowed down to `number[]`
const values = sensors
  .map((sensor) => sensor.lastMeasuredValue)
  .filter((value): value is number => typeof value === 'number')

xzec

type Resolved<Data> = [undefined, Data] | [Error, undefined]

export const resolve = <Data>(promise: Promise<Data>): Promise<Resolved<Data>> =>
  promise
    .then((data): [undefined, Data] => [undefined, data])
    .catch((error): [Error, undefined] => [error, undefined])

xzec

const resolveAllSettled = <T>(results: PromiseSettledResult<T>[]): [errors: string[], data: T[]] => {
  const errors = results
    .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
    .map(({ reason }) => {
      if (reason instanceof Error) return reason.message
      if (typeof reason === 'string') return reason
      return 'undetected reason'
    })

  const data = results