@atproto/lex-data 0.1.2 → 0.1.4

package/src/lex-equals.test.ts

@@ -1,183 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { parseCid } from './cid.js'
-import { lexEquals } from './lex-equals.js'
-import { LexValue } from './lex.js'
-
-function expectLexEqual(a: LexValue, b: LexValue, expected: boolean) {
-  expect(lexEquals(a, b)).toBe(expected)
-  expect(lexEquals(b, a)).toBe(expected)
-}
-
-describe('lexEquals', () => {
-  it('compares primitive values', () => {
-    expectLexEqual(null, null, true)
-    expectLexEqual(true, true, true)
-    expectLexEqual(false, false, true)
-    expectLexEqual(42, 42, true)
-    expectLexEqual('hello', 'hello', true)
-
-    expectLexEqual(null, false, false)
-    expectLexEqual(false, null, false)
-    expectLexEqual(true, false, false)
-    expectLexEqual(false, true, false)
-    expectLexEqual(42, 43, false)
-    expectLexEqual('hello', 'world', false)
-  })
-
-  it('compares NaN and Infinity correctly', () => {
-    expectLexEqual(NaN, NaN, true)
-    expectLexEqual(Infinity, Infinity, true)
-    expectLexEqual(-Infinity, -Infinity, true)
-
-    expectLexEqual(NaN, 0, false)
-    expectLexEqual(NaN, null, false)
-    expectLexEqual(Infinity, -Infinity, false)
-  })
-
-  it('compares arrays', () => {
-    expectLexEqual([1, 2, 3], [1, 2, 3], true)
-    expectLexEqual([1, 2, 3], [1, 2, 4], false)
-    expectLexEqual([1, 2, 3], [1, 2], false)
-    expectLexEqual([1, 2, 3], 'not an array', false)
-    expectLexEqual([1, 2, 3], { 0: 1, 1: 2, 2: 3 }, false)
-  })
-
-  it('compares Uint8Arrays', () => {
-    expectLexEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]), true)
-    expectLexEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]), false)
-    expectLexEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2]), false)
-    expectLexEqual(new Uint8Array([1, 2, 3]), 'not a Uint8Array', false)
-  })
-
-  it('compares CIDs', () => {
-    const cid1 = parseCid(
-      'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-    )
-    const cid2 = parseCid(cid1.toString())
-    const cid3 = parseCid(cid1.toString())
-
-    expectLexEqual(cid1, cid2, true)
-    expectLexEqual(cid1, cid3, true)
-    expectLexEqual(cid2, cid3, true)
-
-    expectLexEqual(cid1, cid1.toString(), false)
-    expectLexEqual(cid1, { not: 'a cid' }, false)
-    expectLexEqual(cid1, [], false)
-    expectLexEqual(cid1, cid1.bytes, false)
-  })
-
-  it('compares objects', () => {
-    expectLexEqual({ a: 1, b: 2 }, { a: 1, b: 2 }, true)
-    expectLexEqual(
-      { a: 1, b: 2, c: undefined },
-      { a: 1, b: 2, c: undefined },
-      true,
-    )
-    expectLexEqual(
-      { a: 1, b: 2, c: { e: 1, d: undefined } },
-      { a: 1, b: 2, c: { d: undefined, e: 1 } },
-      true,
-    )
-    expectLexEqual(
-      { a: 1, b: { unicode: 'a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧' } },
-      { a: 1, b: { unicode: 'a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧' } },
-      true,
-    )
-
-    expectLexEqual({ a: 1, b: 2 }, { a: 1, b: 3 }, false)
-    expectLexEqual({ a: 1, b: 2 }, { a: 1 }, false)
-    expectLexEqual({ a: 1, b: 2 }, 'not an object', false)
-    expectLexEqual({ a: 1, b: 2 }, null, false)
-  })
-
-  it('accounts for undefined (but present) properties in objects', () => {
-    expectLexEqual({ a: 1, b: undefined }, { a: 1 }, false)
-    expectLexEqual(
-      { a: 1, b: { c: undefined, d: 2 } },
-      { a: 1, b: { d: 2 } },
-      false,
-    )
-
-    expectLexEqual(
-      { a: 1, b: { c: undefined, d: 2 } },
-      { a: 1, b: { c: 3, d: 2 } },
-      false,
-    )
-  })
-
-  it('compares nested structures', () => {
-    const lex1 = {
-      foo: [1, 2, { bar: new Uint8Array([3, 4, 5]) }],
-      baz: parseCid(
-        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-      ),
-    }
-    const lex2 = {
-      foo: [1, 2, { bar: new Uint8Array([3, 4, 5]) }],
-      baz: parseCid(
-        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-      ),
-    }
-    const lex3 = {
-      foo: [1, 2, { bar: new Uint8Array([3, 4, 5 + 1]) }],
-      baz: parseCid(
-        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-      ),
-    }
-
-    expectLexEqual(lex1, lex2, true)
-    expectLexEqual(lex1, lex3, false)
-    expectLexEqual(lex2, lex3, false)
-  })
-
-  it('allows comparing invalid numbers (floats, NaN, Infinity)', () => {
-    expectLexEqual(3.14, 2.71, false)
-    expectLexEqual(NaN, 0, false)
-    expectLexEqual(Infinity, -Infinity, false)
-  })
-
-  describe('reference equality', () => {
-    for (const value of [3.14, NaN, Infinity, -Infinity]) {
-      it(`returns true for identical references of ${String(value)}`, () => {
-        expectLexEqual(value, value, true)
-        expectLexEqual([value], [value], true)
-        expectLexEqual({ foo: value }, { foo: value }, true)
-        expectLexEqual([{ foo: value }], [{ foo: value }], true)
-      })
-    }
-  })
-
-  it('returns true for identical references', () => {
-    const arr = [1, 2, 3]
-    expectLexEqual(arr, arr, true)
-
-    const obj = { a: 1, b: 2 }
-    expectLexEqual(obj, obj, true)
-
-    const u8 = new Uint8Array([1, 2, 3])
-    expectLexEqual(u8, u8, true)
-
-    const cid = parseCid(
-      'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-    )
-    expectLexEqual(cid, cid, true)
-  })
-
-  it('throws when comparing plain object with non-allowed class instance', () => {
-    // @ts-expect-error
-    expect(() => lexEquals({}, new Map())).toThrow()
-    // @ts-expect-error
-    expect(() => lexEquals(new Map(), {})).toThrow()
-    // @ts-expect-error
-    expect(() => lexEquals({ foo: {} }, { foo: new Map() })).toThrow()
-    // @ts-expect-error
-    expect(() => lexEquals({ foo: new Map() }, { foo: {} })).toThrow()
-
-    expect(() => lexEquals({ foo: {} }, { foo: new (class {})() })).toThrow()
-    expect(() => lexEquals({ foo: new (class {})() }, { foo: {} })).toThrow()
-
-    expect(() =>
-      lexEquals({ foo: {} }, { foo: new (class Object {})() }),
-    ).toThrow()
-  })
-})

package/src/lex-equals.ts

@@ -1,123 +0,0 @@
-import { ifCid, isCid } from './cid.js'
-import { LexValue } from './lex.js'
-import { isPlainObject } from './object.js'
-import { ui8Equals } from './uint8array.js'
-
-/**
- * Performs deep equality comparison between two {@link LexValue}s.
- *
- * This function correctly handles all Lexicon data types including:
- * - Primitives (string, number, boolean, null)
- * - Arrays (recursive element comparison)
- * - Objects/LexMaps (recursive key-value comparison)
- * - Uint8Arrays (byte-by-byte comparison)
- * - CIDs (using CID equality)
- *
- * @param a - First LexValue to compare
- * @param b - Second LexValue to compare
- * @returns `true` if the values are deeply equal
- * @throws {TypeError} If either value is not a valid LexValue (e.g., contains unsupported types)
- *
- * @example
- * ```typescript
- * import { lexEquals } from '@atproto/lex-data'
- *
- * // Primitives
- * lexEquals('hello', 'hello')  // true
- * lexEquals(42, 42)            // true
- *
- * // Arrays
- * lexEquals([1, 2, 3], [1, 2, 3])  // true
- * lexEquals([1, 2], [1, 2, 3])     // false
- *
- * // Objects
- * lexEquals({ a: 1, b: 2 }, { a: 1, b: 2 })  // true
- * lexEquals({ a: 1 }, { a: 1, b: 2 })        // false
- *
- * // CIDs
- * lexEquals(cid1, cid2)  // true if CIDs are equal
- *
- * // Uint8Arrays
- * lexEquals(new Uint8Array([1, 2]), new Uint8Array([1, 2]))  // true
- * ```
- */
-export function lexEquals(a: LexValue, b: LexValue): boolean {
-  if (Object.is(a, b)) {
-    return true
-  }
-
-  if (
-    a == null ||
-    b == null ||
-    typeof a !== 'object' ||
-    typeof b !== 'object'
-  ) {
-    return false
-  }
-
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false
-    }
-    if (a.length !== b.length) {
-      return false
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!lexEquals(a[i], b[i])) {
-        return false
-      }
-    }
-    return true
-  } else if (Array.isArray(b)) {
-    return false
-  }
-
-  if (ArrayBuffer.isView(a)) {
-    if (!ArrayBuffer.isView(b)) return false
-    return ui8Equals(a, b)
-  } else if (ArrayBuffer.isView(b)) {
-    return false
-  }
-
-  if (isCid(a)) {
-    // @NOTE CID.equals returns its argument when it is falsy (e.g. null or
-    // undefined) so we need to explicitly check that the output is "true".
-    return ifCid(b)?.equals(a) === true
-  } else if (isCid(b)) {
-    return false
-  }
-
-  if (!isPlainObject(a) || !isPlainObject(b)) {
-    // Foolproof (should never happen)
-    throw new TypeError(
-      'Invalid LexValue (expected CID, Uint8Array, or LexMap)',
-    )
-  }
-
-  const aKeys = Object.keys(a)
-  const bKeys = Object.keys(b)
-
-  if (aKeys.length !== bKeys.length) {
-    return false
-  }
-
-  for (const key of aKeys) {
-    const aVal = a[key]
-    const bVal = b[key]
-
-    // Needed because of the optional index signature in the Lex object type
-    // though, in practice, aVal should never be undefined here.
-    if (aVal === undefined) {
-      if (bVal === undefined && bKeys.includes(key)) continue
-      return false
-    } else if (bVal === undefined) {
-      return false
-    }
-
-    if (!lexEquals(aVal, bVal)) {
-      return false
-    }
-  }
-
-  return true
-}

package/src/lex-error.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { LexError } from './lex-error.js'
-
-describe(LexError, () => {
-  it('stores error code and message', () => {
-    const err = new LexError('TestError', 'This is a test error')
-    expect(err.error).toBe('TestError')
-    expect(err.message).toBe('This is a test error')
-  })
-
-  it('strips empty message in toJSON output', () => {
-    const err = new LexError('TestError')
-    expect(err.toJSON()).toEqual({ error: 'TestError' })
-  })
-
-  it('includes message in toJSON when present', () => {
-    const err = new LexError('TestError', 'details here')
-    expect(err.toJSON()).toEqual({
-      error: 'TestError',
-      message: 'details here',
-    })
-  })
-
-  it('formats string output correctly', () => {
-    const err = new LexError('TestError', 'This is a test error')
-    expect(err.toString()).toBe('LexError: [TestError] This is a test error')
-  })
-
-  it('uses constructor name for the name property', () => {
-    const err = new LexError('TestError')
-    expect(err.name).toBe('LexError')
-  })
-
-  it('subclasses use their own constructor name', () => {
-    class MyCustomError extends LexError {
-      name = 'MyCustomError'
-    }
-    const err = new MyCustomError('CustomCode', 'custom message')
-    expect(err.name).toBe('MyCustomError')
-    expect(err.toString()).toBe('MyCustomError: [CustomCode] custom message')
-  })
-
-  it('preserves cause option', () => {
-    const cause = new Error('original')
-    const err = new LexError('TestError', 'wrapped', { cause })
-    expect(err.cause).toBe(cause)
-  })
-
-  it('is an instance of Error', () => {
-    const err = new LexError('TestError')
-    expect(err).toBeInstanceOf(Error)
-    expect(err).toBeInstanceOf(LexError)
-  })
-})

package/src/lex-error.ts

@@ -1,83 +0,0 @@
-/**
- * Error code type for Lexicon errors.
- *
- * Error codes identify the type of error that occurred (e.g., 'InvalidRequest').
- *
- * @example
- * ```typescript
- * import type { LexErrorCode } from '@atproto/lex-data'
- *
- * const errorCode: LexErrorCode = 'InvalidRequest'
- * ```
- */
-export type LexErrorCode = string & NonNullable<unknown>
-
-/**
- * JSON-serializable error data structure.
- *
- * This is the standard format for error responses in the AT Protocol XRPC protocol.
- *
- * @typeParam N - The specific error code type
- *
- * @example
- * ```typescript
- * import type { LexErrorData } from '@atproto/lex-data'
- *
- * const errorData: LexErrorData = {
- *   error: 'InvalidRequest',
- *   message: 'Missing required field: handle'
- * }
- * ```
- */
-export type LexErrorData<N extends LexErrorCode = LexErrorCode> = {
-  /** The error code identifying the type of error. */
-  error: N
-  /** Optional human-readable error message. */
-  message?: string
-}
-
-/**
- * Error class for Lexicon-related errors.
- *
- * LexError extends the standard JavaScript {@link Error} with AT
- * Protocol-specific functionality including an `error` code property and
- * methods for representation as (XRPC) error responses payloads.
- *
- * @typeParam N - The specific error code type
- */
-export class LexError<N extends LexErrorCode = LexErrorCode> extends Error {
-  name = 'LexError'
-
-  /**
-   * @param error - The error code identifying the type of error, typically used in XRPC error payloads
-   * @param message - Optional human-readable error message
-   * @param options - Standard Error options (e.g., cause)
-   */
-  constructor(
-    readonly error: N,
-    message?: string, // Defaults to empty string in Error constructor
-    options?: ErrorOptions,
-  ) {
-    super(message, options)
-  }
-
-  /**
-   * Returns a string representation of this error.
-   *
-   * @returns A formatted string: "LexErrorClass: [MyErrorCode] My message"
-   */
-  toString(): string {
-    return `${this.name}: [${this.error}] ${this.message}`
-  }
-
-  /**
-   * Converts this error to a JSON-serializable object.
-   *
-   * @returns The error data suitable for JSON serialization
-   * @note The `error` generic is *not* constrained to {@link N} to allow subclasses to override the error code type.
-   */
-  toJSON(): LexErrorData<LexErrorCode> {
-    const { error, message } = this
-    return { error, message: message || undefined }
-  }
-}