@atproto/common-web 0.5.1 → 0.5.3

package/src/ipld.ts

@@ -1,48 +0,0 @@
-import { LexValue, lexEquals } from '@atproto/lex-data'
-import { JsonValue, jsonToLex, lexToJson } from '@atproto/lex-json'
-
-/**
- * @deprecated Use {@link JsonValue} from `@atproto/lex-cbor` instead.
- */
-export type LegacyJsonValue = unknown
-
-export type { LegacyJsonValue as JsonValue }
-
-/**
- * @deprecated Use {@link LexValue} from `@atproto/lex-cbor` instead.
- */
-export type IpldValue = unknown
-
-/**
- * Converts a JSON-compatible value to an IPLD-compatible value.
- * @deprecated Use {@link jsonToLex} from `@atproto/lex-cbor` instead.
- */
-export const jsonToIpld = (val: LegacyJsonValue): IpldValue => {
-  return jsonToLex(val as JsonValue, { strict: false })
-}
-
-/**
- * Converts an IPLD-compatible value to a JSON-compatible value.
- * @deprecated Use {@link lexToJson} from `@atproto/lex-cbor` instead.
- */
-export const ipldToJson = (val: IpldValue): LegacyJsonValue => {
-  // Legacy behavior(s)
-  if (val === undefined) return val
-  if (Number.isNaN(val)) return val
-
-  return lexToJson(val as LexValue)
-}
-
-/**
- * Compares two IPLD-compatible values for deep equality.
- * @deprecated Use {@link lexEquals} from `@atproto/lex-cbor` instead.
- */
-export const ipldEquals = (a: IpldValue, b: IpldValue): boolean => {
-  if (!lexEquals(a as LexValue, b as LexValue)) return false
-
-  // @NOTE The previous implementation used "===" which treats NaN as unequal to
-  // NaN.
-  if (Number.isNaN(a)) return false
-
-  return true
-}

package/src/retry.ts

@@ -1,58 +0,0 @@
-import { wait } from './util.js'
-
-export type RetryOptions = {
-  maxRetries?: number
-  getWaitMs?: (n: number) => number | null
-}
-
-export async function retry<T>(
-  fn: () => Promise<T>,
-  opts: RetryOptions & {
-    retryable?: (err: unknown) => boolean
-  } = {},
-): Promise<T> {
-  const { maxRetries = 3, retryable = () => true, getWaitMs = backoffMs } = opts
-  let retries = 0
-  let doneError: unknown
-  while (!doneError) {
-    try {
-      return await fn()
-    } catch (err) {
-      const waitMs = getWaitMs(retries)
-      const willRetry =
-        retries < maxRetries && waitMs !== null && retryable(err)
-      if (willRetry) {
-        retries += 1
-        if (waitMs !== 0) {
-          await wait(waitMs)
-        }
-      } else {
-        doneError = err
-      }
-    }
-  }
-  throw doneError
-}
-
-export function createRetryable(retryable: (err: unknown) => boolean) {
-  return async <T>(fn: () => Promise<T>, opts?: RetryOptions) =>
-    retry(fn, { ...opts, retryable })
-}
-
-// Waits exponential backoff with max and jitter: ~100, ~200, ~400, ~800, ~1000, ~1000, ...
-export function backoffMs(n: number, multiplier = 100, max = 1000) {
-  const exponentialMs = Math.pow(2, n) * multiplier
-  const ms = Math.min(exponentialMs, max)
-  return jitter(ms)
-}
-
-// Adds randomness +/-15% of value
-function jitter(value: number) {
-  const delta = value * 0.15
-  return value + randomRange(-delta, delta)
-}
-
-function randomRange(from: number, to: number) {
-  const rand = Math.random() * (to - from)
-  return rand + from
-}

package/src/strings.ts

@@ -1,49 +0,0 @@
-import { fromBase64, graphemeLen, toBase64, utf8Len } from '@atproto/lex-data'
-import {
-  LanguageTag,
-  isValidLanguage,
-  parseLanguageString,
-} from '@atproto/syntax'
-
-/**
- * @deprecated Use {@link graphemeLen} from `@atproto/lex-data` instead.
- */
-const graphemeLenLegacy = graphemeLen
-export { graphemeLenLegacy as graphemeLen }
-
-/**
- * @deprecated Use {@link utf8Len} from `@atproto/lex-data` instead.
- */
-const utf8LenLegacy = utf8Len
-export { utf8LenLegacy as utf8Len }
-
-/**
- * @deprecated Use {@link LanguageTag} from `@atproto/lex-data` instead.
- */
-type LanguageTagLegacy = LanguageTag
-export type { LanguageTagLegacy as LanguageTag }
-
-/**
- * @deprecated Use {@link parseLanguageString} from `@atproto/syntax` instead.
- */
-const parseLanguageLegacy = parseLanguageString
-export { parseLanguageLegacy as parseLanguage }
-
-/**
- * @deprecated Use {@link isLanguageString} from `@atproto/syntax` instead.
- */
-export const validateLanguage = isValidLanguage
-
-/**
- * @deprecated Use {@link toBase64} from `@atproto/lex-data` instead.
- */
-export const utf8ToB64Url = (utf8: string): string => {
-  return toBase64(new TextEncoder().encode(utf8), 'base64url')
-}
-
-/**
- * @deprecated Use {@link fromBase64} from `@atproto/lex-data` instead.
- */
-export const b64UrlToUtf8 = (b64: string): string => {
-  return new TextDecoder().decode(fromBase64(b64, 'base64url'))
-}

package/src/tid.ts

@@ -1,110 +0,0 @@
-import { s32decode, s32encode } from './util.js'
-
-const TID_LEN = 13
-
-let lastTimestamp = 0
-let timestampCount = 0
-let clockid: number | null = null
-
-function dedash(str: string): string {
-  return str.replaceAll('-', '')
-}
-
-export class TID {
-  str: string
-
-  constructor(str: string) {
-    const noDashes = dedash(str)
-    if (noDashes.length !== TID_LEN) {
-      throw new Error(`Poorly formatted TID: ${noDashes.length} length`)
-    }
-    this.str = noDashes
-  }
-
-  static next(prev?: TID): TID {
-    // javascript does not have microsecond precision
-    // instead, we append a counter to the timestamp to indicate if multiple timestamps were created within the same millisecond
-    // take max of current time & last timestamp to prevent tids moving backwards if system clock drifts backwards
-    const time = Math.max(Date.now(), lastTimestamp)
-    if (time === lastTimestamp) {
-      timestampCount++
-    }
-    lastTimestamp = time
-    const timestamp = time * 1000 + timestampCount
-    // the bottom 32 clock ids can be randomized & are not guaranteed to be collision resistant
-    // we use the same clockid for all tids coming from this machine
-    if (clockid === null) {
-      clockid = Math.floor(Math.random() * 32)
-    }
-    const tid = TID.fromTime(timestamp, clockid)
-    if (!prev || tid.newerThan(prev)) {
-      return tid
-    }
-    return TID.fromTime(prev.timestamp() + 1, clockid)
-  }
-
-  static nextStr(prev?: string): string {
-    return TID.next(prev ? new TID(prev) : undefined).toString()
-  }
-
-  static fromTime(timestamp: number, clockid: number): TID {
-    // base32 encode with encoding variant sort (s32)
-    const str = `${s32encode(timestamp)}${s32encode(clockid).padStart(2, '2')}`
-    return new TID(str)
-  }
-
-  static fromStr(str: string): TID {
-    return new TID(str)
-  }
-
-  static oldestFirst(a: TID, b: TID): number {
-    return a.compareTo(b)
-  }
-
-  static newestFirst(a: TID, b: TID): number {
-    return b.compareTo(a)
-  }
-
-  static is(str: string): boolean {
-    return dedash(str).length === TID_LEN
-  }
-
-  timestamp(): number {
-    return s32decode(this.str.slice(0, 11))
-  }
-
-  clockid(): number {
-    return s32decode(this.str.slice(11, 13))
-  }
-
-  formatted(): string {
-    const str = this.toString()
-    return `${str.slice(0, 4)}-${str.slice(4, 7)}-${str.slice(
-      7,
-      11,
-    )}-${str.slice(11, 13)}`
-  }
-
-  toString(): string {
-    return this.str
-  }
-
-  // newer > older
-  compareTo(other: TID): number {
-    if (this.str > other.str) return 1
-    if (this.str < other.str) return -1
-    return 0
-  }
-
-  equals(other: TID): boolean {
-    return this.str === other.str
-  }
-
-  newerThan(other: TID): boolean {
-    return this.compareTo(other) > 0
-  }
-
-  olderThan(other: TID): boolean {
-    return this.compareTo(other) < 0
-  }
-}

package/src/times.ts

@@ -1,15 +0,0 @@
-export const SECOND = 1000
-export const MINUTE = SECOND * 60
-export const HOUR = MINUTE * 60
-export const DAY = HOUR * 24
-
-export const lessThanAgoMs = (time: Date, range: number) => {
-  return Date.now() < time.getTime() + range
-}
-
-export const addHoursToDate = (hours: number, startingDate?: Date): Date => {
-  // When date is passed, clone before calling `setHours()` so that we are not mutating the original date
-  const currentDate = startingDate ? new Date(startingDate) : new Date()
-  currentDate.setHours(currentDate.getHours() + hours)
-  return currentDate
-}

package/src/types.ts

@@ -1,64 +0,0 @@
-import { z } from 'zod'
-import { CID } from '@atproto/lex-data'
-import { Def } from './check.js'
-
-const cidSchema = z.unknown().transform((obj, ctx): CID => {
-  const cid = CID.asCID(obj)
-
-  if (cid == null) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'Not a valid CID',
-    })
-    return z.NEVER
-  }
-
-  return cid
-})
-
-const carHeader = z.object({
-  version: z.literal(1),
-  roots: z.array(cidSchema),
-})
-export type CarHeader = z.infer<typeof carHeader>
-
-export const schema = {
-  cid: cidSchema,
-  carHeader,
-  bytes: z.instanceof(Uint8Array<ArrayBufferLike>),
-  string: z.string(),
-  array: z.array(z.unknown()),
-  map: z.record(z.string(), z.unknown()),
-  unknown: z.unknown(),
-}
-
-export const def = {
-  cid: {
-    name: 'cid',
-    schema: schema.cid,
-  } as Def<CID>,
-  carHeader: {
-    name: 'CAR header',
-    schema: schema.carHeader,
-  } as Def<CarHeader>,
-  bytes: {
-    name: 'bytes',
-    schema: schema.bytes,
-  } as Def<Uint8Array>,
-  string: {
-    name: 'string',
-    schema: schema.string,
-  } as Def<string>,
-  map: {
-    name: 'map',
-    schema: schema.map,
-  } as Def<Record<string, unknown>>,
-  unknown: {
-    name: 'unknown',
-    schema: schema.unknown,
-  } as Def<unknown>,
-}
-
-export type ArrayEl<A> = A extends readonly (infer T)[] ? T : never
-
-export type NotEmptyArray<T> = [T, ...T[]]

package/src/util.ts

@@ -1,180 +0,0 @@
-export const noUndefinedVals = <T>(
-  obj: Record<string, T | undefined>,
-): Record<string, T> => {
-  for (const k of Object.keys(obj)) {
-    if (obj[k] === undefined) {
-      delete obj[k]
-    }
-  }
-  return obj as Record<string, T>
-}
-
-export function aggregateErrors(
-  errors: unknown[],
-  message?: string,
-): Error | AggregateError {
-  if (errors.length === 1) {
-    return errors[0] instanceof Error
-      ? errors[0]
-      : new Error(message ?? stringifyError(errors[0]), { cause: errors[0] })
-  } else {
-    return new AggregateError(
-      errors,
-      message ?? `Multiple errors: ${errors.map(stringifyError).join('\n')}`,
-    )
-  }
-}
-
-function stringifyError(reason: unknown): string {
-  if (reason instanceof Error) {
-    return reason.message
-  }
-  return String(reason)
-}
-
-/**
- * Returns a shallow copy of the object without the specified keys. If the input
- * is nullish, it returns the input.
- */
-export function omit<
-  T extends undefined | null | Record<string, unknown>,
-  K extends keyof NonNullable<T>,
->(
-  object: T,
-  rejectedKeys: readonly K[],
-): T extends undefined ? undefined : T extends null ? null : Omit<T, K>
-export function omit(
-  src: undefined | null | Record<string, unknown>,
-  rejectedKeys: readonly string[],
-): undefined | null | Record<string, unknown> {
-  // Hot path
-
-  if (!src) return src
-
-  const dst = {}
-  const srcKeys = Object.keys(src)
-  for (let i = 0; i < srcKeys.length; i++) {
-    const key = srcKeys[i]
-    if (!rejectedKeys.includes(key)) {
-      dst[key] = src[key]
-    }
-  }
-  return dst
-}
-
-export const jitter = (maxMs: number) => {
-  return Math.round((Math.random() - 0.5) * maxMs * 2)
-}
-
-export const wait = (ms: number) => {
-  return new Promise((res) => setTimeout(res, ms))
-}
-
-export type BailableWait = {
-  bail: () => void
-  wait: () => Promise<void>
-}
-
-export const bailableWait = (ms: number): BailableWait => {
-  let bail
-  const waitPromise = new Promise<void>((res) => {
-    const timeout = setTimeout(res, ms)
-    bail = () => {
-      clearTimeout(timeout)
-      res()
-    }
-  })
-  return { bail, wait: () => waitPromise }
-}
-
-export const flattenUint8Arrays = (arrs: Uint8Array[]): Uint8Array => {
-  const length = arrs.reduce((acc, cur) => {
-    return acc + cur.length
-  }, 0)
-  const flattened = new Uint8Array(length)
-  let offset = 0
-  arrs.forEach((arr) => {
-    flattened.set(arr, offset)
-    offset += arr.length
-  })
-  return flattened
-}
-
-export const streamToBuffer = async (
-  stream: AsyncIterable<Uint8Array>,
-): Promise<Uint8Array> => {
-  const arrays: Uint8Array[] = []
-  for await (const chunk of stream) {
-    arrays.push(chunk)
-  }
-  return flattenUint8Arrays(arrays)
-}
-
-const S32_CHAR = '234567abcdefghijklmnopqrstuvwxyz'
-
-export const s32encode = (i: number): string => {
-  let s = ''
-  while (i) {
-    const c = i % 32
-    i = Math.floor(i / 32)
-    s = S32_CHAR.charAt(c) + s
-  }
-  return s
-}
-
-export const s32decode = (s: string): number => {
-  let i = 0
-  for (const c of s) {
-    i = i * 32 + S32_CHAR.indexOf(c)
-  }
-  return i
-}
-
-export const asyncFilter = async <T>(
-  arr: T[],
-  fn: (t: T) => Promise<boolean>,
-) => {
-  const results = await Promise.all(arr.map((t) => fn(t)))
-  return arr.filter((_, i) => results[i])
-}
-
-export const isErrnoException = (
-  err: unknown,
-): err is NodeJS.ErrnoException => {
-  return !!err && err['code']
-}
-
-export const errHasMsg = (err: unknown, msg: string): boolean => {
-  return !!err && typeof err === 'object' && err['message'] === msg
-}
-
-export const chunkArray = <T>(arr: T[], chunkSize: number): T[][] => {
-  return arr.reduce((acc, cur, i) => {
-    const chunkI = Math.floor(i / chunkSize)
-    if (!acc[chunkI]) {
-      acc[chunkI] = []
-    }
-    acc[chunkI].push(cur)
-    return acc
-  }, [] as T[][])
-}
-
-export const range = (num: number): number[] => {
-  const nums: number[] = []
-  for (let i = 0; i < num; i++) {
-    nums.push(i)
-  }
-  return nums
-}
-
-export const dedupeStrs = <T extends string>(strs: Iterable<T>): T[] => {
-  return [...new Set(strs)]
-}
-
-export const parseIntWithFallback = <T>(
-  value: string | undefined,
-  fallback: T,
-): number | T => {
-  const parsed = parseInt(value || '', 10)
-  return isNaN(parsed) ? fallback : parsed
-}

package/tests/check.test.ts

@@ -1,89 +0,0 @@
-import { ZodError } from 'zod'
-import { check } from '../src/index.js'
-
-describe('check', () => {
-  describe('is', () => {
-    it('checks object against definition', () => {
-      const checkable: check.Checkable<boolean> = {
-        parse(obj) {
-          return Boolean(obj)
-        },
-        safeParse(obj) {
-          return {
-            success: true,
-            data: Boolean(obj),
-          }
-        },
-      }
-
-      expect(check.is(true, checkable)).toBe(true)
-    })
-
-    it('handles failed checks', () => {
-      const checkable: check.Checkable<boolean> = {
-        parse(obj) {
-          return Boolean(obj)
-        },
-        safeParse() {
-          return {
-            success: false,
-            error: new ZodError([]),
-          }
-        },
-      }
-
-      expect(check.is(true, checkable)).toBe(false)
-    })
-  })
-
-  describe('assure', () => {
-    it('returns value on success', () => {
-      const checkable: check.Checkable<boolean> = {
-        parse(obj) {
-          return Boolean(obj)
-        },
-        safeParse(obj) {
-          return {
-            success: true,
-            data: Boolean(obj),
-          }
-        },
-      }
-
-      expect(check.assure(checkable, true)).toEqual(true)
-    })
-
-    it('throws on failure', () => {
-      const err = new Error('foo')
-      const checkable: check.Checkable<boolean> = {
-        parse() {
-          throw err
-        },
-        safeParse() {
-          throw err
-        },
-      }
-
-      expect(() => check.assure(checkable, true)).toThrow(err)
-    })
-  })
-
-  describe('isObject', () => {
-    const falseTestValues: unknown[] = [null, undefined, 'foo', 123, true]
-
-    for (const obj of falseTestValues) {
-      it(`returns false for ${obj}`, () => {
-        expect(check.isObject(obj)).toBe(false)
-      })
-    }
-
-    it('returns true for objects', () => {
-      expect(check.isObject({})).toBe(true)
-    })
-
-    it('returns true for instances of classes', () => {
-      const obj = new (class {})()
-      expect(check.isObject(obj)).toBe(true)
-    })
-  })
-})

package/tests/retry.test.ts

@@ -1,93 +0,0 @@
-import { retry } from '../src/index.js'
-
-describe('retry', () => {
-  describe('retry()', () => {
-    it('retries until max retries', async () => {
-      let fnCalls = 0
-      let waitMsCalls = 0
-      const fn = async () => {
-        fnCalls++
-        throw new Error(`Oops ${fnCalls}!`)
-      }
-      const getWaitMs = (retries) => {
-        waitMsCalls++
-        expect(retries).toEqual(waitMsCalls - 1)
-        return 0
-      }
-      await expect(retry(fn, { maxRetries: 13, getWaitMs })).rejects.toThrow(
-        'Oops 14!',
-      )
-      expect(fnCalls).toEqual(14)
-      expect(waitMsCalls).toEqual(14)
-    })
-
-    it('retries until max wait', async () => {
-      let fnCalls = 0
-      let waitMsCalls = 0
-      const fn = async () => {
-        fnCalls++
-        throw new Error(`Oops ${fnCalls}!`)
-      }
-      const getWaitMs = (retries) => {
-        waitMsCalls++
-        expect(retries).toEqual(waitMsCalls - 1)
-        if (retries === 13) {
-          return null
-        }
-        return 0
-      }
-      await expect(
-        retry(fn, { maxRetries: Infinity, getWaitMs }),
-      ).rejects.toThrow('Oops 14!')
-      expect(fnCalls).toEqual(14)
-      expect(waitMsCalls).toEqual(14)
-    })
-
-    it('retries until non-retryable error', async () => {
-      let fnCalls = 0
-      let waitMsCalls = 0
-      const fn = async () => {
-        fnCalls++
-        throw new Error(`Oops ${fnCalls}!`)
-      }
-      const getWaitMs = (retries) => {
-        waitMsCalls++
-        expect(retries).toEqual(waitMsCalls - 1)
-        return 0
-      }
-      const retryable = (err: unknown) => err?.['message'] !== 'Oops 14!'
-      await expect(
-        retry(fn, { maxRetries: Infinity, getWaitMs, retryable }),
-      ).rejects.toThrow('Oops 14!')
-      expect(fnCalls).toEqual(14)
-      expect(waitMsCalls).toEqual(14)
-    })
-
-    it('returns latest result after retries', async () => {
-      let fnCalls = 0
-      const fn = async () => {
-        fnCalls++
-        if (fnCalls < 14) {
-          throw new Error(`Oops ${fnCalls}!`)
-        }
-        return 'ok'
-      }
-      const getWaitMs = () => 0
-      const result = await retry(fn, { maxRetries: Infinity, getWaitMs })
-      expect(result).toBe('ok')
-      expect(fnCalls).toBe(14)
-    })
-
-    it('returns result immediately on success', async () => {
-      let fnCalls = 0
-      const fn = async () => {
-        fnCalls++
-        return 'ok'
-      }
-      const getWaitMs = () => 0
-      const result = await retry(fn, { maxRetries: Infinity, getWaitMs })
-      expect(result).toBe('ok')
-      expect(fnCalls).toBe(1)
-    })
-  })
-})