@atproto/common 0.1.0 → 0.2.0

package/src/async.ts

@@ -1,100 +0,0 @@
-import { bailableWait } from './util'
-
-// reads values from a generator into a list
-// NOTE: does not signal generator to close. it *will* continue to produce values
-export const readFromGenerator = async <T>(
-  gen: AsyncGenerator<T>,
-  maxLength = Number.MAX_SAFE_INTEGER,
-  timeout = 2000,
-): Promise<T[]> => {
-  const evts: T[] = []
-  while (evts.length < maxLength) {
-    const { bail, wait } = bailableWait(timeout)
-    const maybeEvt = await Promise.race([gen.next(), wait()])
-    bail()
-    if (!maybeEvt) break
-    const evt = maybeEvt as IteratorResult<T>
-    if (evt.done) break
-    evts.push(evt.value)
-  }
-  return evts
-}
-
-export type Deferrable = {
-  resolve: () => void
-  complete: Promise<void>
-}
-
-export const createDeferrable = (): Deferrable => {
-  let resolve
-  const promise: Promise<void> = new Promise((res) => {
-    resolve = () => res()
-  })
-  return { resolve, complete: promise }
-}
-
-export const createDeferrables = (count: number): Deferrable[] => {
-  const list: Deferrable[] = []
-  for (let i = 0; i < count; i++) {
-    list.push(createDeferrable())
-  }
-  return list
-}
-
-export const allComplete = async (deferrables: Deferrable[]): Promise<void> => {
-  await Promise.all(deferrables.map((d) => d.complete))
-}
-
-export class AsyncBuffer<T> {
-  private buffer: T[] = []
-  private promise: Promise<void>
-  private resolve: () => void
-
-  constructor(public maxSize?: number) {
-    this.resetPromise()
-  }
-
-  get curr(): T[] {
-    return this.buffer
-  }
-
-  get size(): number {
-    return this.buffer.length
-  }
-
-  resetPromise() {
-    this.promise = new Promise<void>((r) => (this.resolve = r))
-  }
-
-  push(item: T) {
-    this.buffer.push(item)
-    this.resolve()
-  }
-
-  pushMany(items: T[]) {
-    items.forEach((i) => this.buffer.push(i))
-    this.resolve()
-  }
-
-  async *events(): AsyncGenerator<T> {
-    while (true) {
-      await this.promise
-      if (this.maxSize && this.size > this.maxSize) {
-        throw new AsyncBufferFullError(this.maxSize)
-      }
-      const [first, ...rest] = this.buffer
-      if (first) {
-        this.buffer = rest
-        yield first
-      } else {
-        this.resetPromise()
-      }
-    }
-  }
-}
-
-export class AsyncBufferFullError extends Error {
-  constructor(maxSize: number) {
-    super(`ReachedMaxBufferSize: ${maxSize}`)
-  }
-}

package/src/check.ts

@@ -1,25 +0,0 @@
-import { ZodError } from 'zod'
-
-export interface Checkable<T> {
-  parse: (obj: unknown) => T
-  safeParse: (
-    obj: unknown,
-  ) => { success: true; data: T } | { success: false; error: ZodError }
-}
-
-export interface Def<T> {
-  name: string
-  schema: Checkable<T>
-}
-
-export const is = <T>(obj: unknown, def: Checkable<T>): obj is T => {
-  return def.safeParse(obj).success
-}
-
-export const assure = <T>(def: Checkable<T>, obj: unknown): T => {
-  return def.parse(obj)
-}
-
-export const isObject = (obj: unknown): obj is Record<string, unknown> => {
-  return typeof obj === 'object' && obj !== null
-}

package/src/tid.ts

@@ -1,108 +0,0 @@
-import { s32encode, s32decode } from './util'
-let lastTimestamp = 0
-let timestampCount = 0
-let clockid: number | null = null
-
-export class TID {
-  str: string
-
-  constructor(str: string) {
-    const noDashes = str.replace(/-/g, '')
-    if (noDashes.length !== 13) {
-      throw new Error(`Poorly formatted TID: ${noDashes.length} length`)
-    }
-    this.str = noDashes
-  }
-
-  static next(): 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)
-    }
-    return TID.fromTime(timestamp, clockid)
-  }
-
-  static nextStr(): string {
-    return TID.next().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 newestFirst(a: TID, b: TID): number {
-    return a.compareTo(b) * -1
-  }
-
-  static oldestFirst(a: TID, b: TID): number {
-    return a.compareTo(b)
-  }
-
-  static is(str: string): boolean {
-    try {
-      TID.fromStr(str)
-      return true
-    } catch (err) {
-      return false
-    }
-  }
-
-  timestamp(): number {
-    const substr = this.str.slice(0, 11)
-    return s32decode(substr)
-  }
-
-  clockid(): number {
-    const substr = this.str.slice(11, 13)
-    return s32decode(substr)
-  }
-
-  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.compareTo(other) === 0
-  }
-
-  newerThan(other: TID): boolean {
-    return this.compareTo(other) > 0
-  }
-
-  olderThan(other: TID): boolean {
-    return this.compareTo(other) < 0
-  }
-}
-
-export default TID

package/src/times.ts

@@ -1,4 +0,0 @@
-export const SECOND = 1000
-export const MINUTE = SECOND * 60
-export const HOUR = MINUTE * 60
-export const DAY = HOUR * 24

package/src/types.ts

@@ -1,43 +0,0 @@
-import * as mf from 'multiformats/cid'
-import { z } from 'zod'
-import { Def } from './check'
-
-const cidSchema = z
-  .any()
-  .refine((obj: unknown) => mf.CID.asCID(obj) !== null, {
-    message: 'Not a CID',
-  })
-  .transform((obj: unknown) => mf.CID.asCID(obj) as mf.CID)
-
-export const schema = {
-  cid: cidSchema,
-  bytes: z.instanceof(Uint8Array),
-  string: z.string(),
-  record: z.record(z.string(), z.unknown()),
-  unknown: z.unknown(),
-}
-
-export const def = {
-  cid: {
-    name: 'cid',
-    schema: schema.cid,
-  } as Def<mf.CID>,
-  bytes: {
-    name: 'bytes',
-    schema: schema.bytes,
-  } as Def<Uint8Array>,
-  string: {
-    name: 'string',
-    schema: schema.string,
-  } as Def<string>,
-  record: {
-    name: 'record',
-    schema: schema.record,
-  } 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

package/src/util.ts

@@ -1,108 +0,0 @@
-export const noUndefinedVals = <T>(
-  obj: Record<string, T>,
-): Record<string, T> => {
-  Object.keys(obj).forEach((k) => {
-    if (obj[k] === undefined) {
-      delete obj[k]
-    }
-  })
-  return obj
-}
-
-export const wait = (ms: number) => {
-  return new Promise((res) => setTimeout(res, ms))
-}
-
-export const bailableWait = (
-  ms: number,
-): { bail: () => void; wait: () => Promise<void> } => {
-  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 streamToArray = 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
-}

package/tests/async.test.ts

@@ -1,22 +0,0 @@
-import { readFromGenerator, wait } from '../src'
-
-describe('async', () => {
-  describe('readFromGenerator', () => {
-    async function* waitToYield(time: number) {
-      for (let i = 0; i < 5; i++) {
-        await wait(time)
-        yield true
-      }
-    }
-
-    it('reads from generator with timeout', async () => {
-      const read = await readFromGenerator(waitToYield(100), undefined, 105)
-      expect(read).toEqual([true, true, true, true, true])
-    })
-
-    it('stops reading at timeout', async () => {
-      const read = await readFromGenerator(waitToYield(100), undefined, 95)
-      expect(read).toEqual([])
-    })
-  })
-})

package/tests/tid.test.ts

@@ -1,18 +0,0 @@
-import TID from '../src/tid'
-
-describe('TIDs', () => {
-  it('creates a new TID', () => {
-    const tid = TID.next()
-    const str = tid.toString()
-    expect(typeof str).toEqual('string')
-    expect(str.length).toEqual(13)
-  })
-
-  it('parses a TID', () => {
-    const tid = TID.next()
-    const str = tid.toString()
-    const parsed = TID.fromStr(str)
-    expect(parsed.timestamp()).toEqual(tid.timestamp())
-    expect(parsed.clockid()).toEqual(tid.clockid())
-  })
-})