@atproto/lex-installer 0.1.2 → 0.1.4

package/src/lexicons-manifest.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { lexiconsManifestSchema } from './lexicons-manifest.js'
-
-describe('lexiconsManifestSchema', () => {
-  it('parses a valid manifest', () => {
-    expect(
-      lexiconsManifestSchema.parse({
-        version: 1,
-        lexicons: ['com.example.lexicon'],
-        resolutions: {
-          'com.example.lexicon': {
-            uri: 'at://did:plc:foobar/com.atproto.lexicon.schema/com.example.lexicon',
-            cid: 'bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku',
-          },
-        },
-      }),
-    ).toEqual({
-      version: 1,
-      lexicons: ['com.example.lexicon'],
-      resolutions: {
-        'com.example.lexicon': {
-          uri: 'at://did:plc:foobar/com.atproto.lexicon.schema/com.example.lexicon',
-          cid: 'bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku',
-        },
-      },
-    })
-  })
-
-  it('rejects an invalid manifest', () => {
-    expect(() =>
-      lexiconsManifestSchema.parse({
-        version: 1,
-        lexicons: ['com.example.lexicon'],
-        resolutions: {
-          'com.example.lexicon': {
-            uri: 'invalid-uri',
-            cid: 'not-a-cid',
-          },
-        },
-      }),
-    ).toThrow()
-
-    expect(() =>
-      lexiconsManifestSchema.parse({
-        version: 2,
-        lexicons: ['com.example.lexicon'],
-        resolutions: {},
-      }),
-    ).toThrow()
-  })
-})

package/src/lexicons-manifest.ts

@@ -1,66 +0,0 @@
-import { l } from '@atproto/lex-schema'
-
-/**
- * Schema for validating and parsing lexicons manifest files.
- *
- * The manifest tracks which lexicons are installed and how they were resolved.
- * This schema ensures the manifest file conforms to the expected structure.
- */
-export const lexiconsManifestSchema = l.object({
-  /** Schema version, currently always 1 */
-  version: l.literal(1),
-  /** Array of NSID strings for directly requested lexicons */
-  lexicons: l.array(l.string({ format: 'nsid' })),
-  /** Map of NSID to resolution info (AT URI and CID) for all installed lexicons */
-  resolutions: l.dict(
-    l.string({ format: 'nsid' }),
-    l.object({
-      /** AT URI where the lexicon was fetched from */
-      uri: l.string({ format: 'at-uri' }),
-      /** Content identifier (CID) of the lexicon document */
-      cid: l.string({ format: 'cid' }),
-    }),
-  ),
-})
-
-/**
- * Type representing a parsed lexicons manifest.
- */
-export type LexiconsManifest = l.Infer<typeof lexiconsManifestSchema>
-
-/**
- * Normalizes a lexicons manifest for consistent storage and comparison.
- *
- * This function:
- * - Sorts the `lexicons` array alphabetically
- * - Sorts the `resolutions` object entries by key
- * - Validates the result against the schema
- *
- * Normalization ensures that manifests with the same content produce identical
- * JSON output, making them suitable for version control and comparison.
- *
- * @param manifest - The manifest to normalize
- * @returns A new normalized manifest object
- */
-export function normalizeLexiconsManifest(
-  manifest: LexiconsManifest,
-): LexiconsManifest {
-  const normalized: LexiconsManifest = {
-    version: manifest.version,
-    lexicons: [...manifest.lexicons].sort(),
-    resolutions: Object.fromEntries(
-      Object.entries(manifest.resolutions)
-        .sort(compareObjectEntriesFn)
-        .map(([k, { uri, cid }]) => [k, { uri, cid }]),
-    ),
-  }
-  // For good measure:
-  return lexiconsManifestSchema.parse(normalized)
-}
-
-function compareObjectEntriesFn(
-  a: [string, unknown],
-  b: [string, unknown],
-): number {
-  return a[0] > b[0] ? 1 : a[0] < b[0] ? -1 : 0
-}

package/src/nsid-map.ts

@@ -1,124 +0,0 @@
-import { NSID } from '@atproto/syntax'
-
-/**
- * A Map implementation that maps keys of type K to an internal representation I.
- *
- * Key identity is determined by the {@link Object.is} comparison of the
- * encoded keys. This is useful for complex key types that can be serialized
- * to a unique primitive representation (typically strings).
- *
- * @typeParam K - The external key type
- * @typeParam V - The value type stored in the map
- * @typeParam I - The internal encoded key type used for identity comparison
- */
-class MappedMap<K, V, I = any> implements Map<K, V> {
-  private map = new Map<I, V>()
-
-  /**
-   * Creates a new MappedMap with custom key encoding/decoding functions.
-   *
-   * @param encodeKey - Function to convert external keys to internal representation
-   * @param decodeKey - Function to convert internal representation back to external keys
-   */
-  constructor(
-    private readonly encodeKey: (key: K) => I,
-    private readonly decodeKey: (enc: I) => K,
-  ) {}
-
-  get size(): number {
-    return this.map.size
-  }
-
-  clear(): void {
-    this.map.clear()
-  }
-
-  set(key: K, value: V): this {
-    this.map.set(this.encodeKey(key), value)
-    return this
-  }
-
-  get(key: K): V | undefined {
-    return this.map.get(this.encodeKey(key))
-  }
-
-  has(key: K): boolean {
-    return this.map.has(this.encodeKey(key))
-  }
-
-  delete(key: K): boolean {
-    return this.map.delete(this.encodeKey(key))
-  }
-
-  values(): IterableIterator<V> {
-    return this.map.values()
-  }
-
-  *keys(): IterableIterator<K> {
-    for (const key of this.map.keys()) {
-      yield this.decodeKey(key)
-    }
-  }
-
-  *entries(): IterableIterator<[K, V]> {
-    for (const [key, value] of this.map.entries()) {
-      yield [this.decodeKey(key), value]
-    }
-  }
-
-  forEach(
-    callbackfn: (value: V, key: K, map: MappedMap<K, V>) => void,
-    thisArg?: any,
-  ): void {
-    for (const [key, value] of this) {
-      callbackfn.call(thisArg, value, key, this)
-    }
-  }
-
-  [Symbol.iterator](): IterableIterator<[K, V]> {
-    return this.entries()
-  }
-
-  [Symbol.toStringTag]: string = 'MappedMap'
-}
-
-/**
- * A Map specialized for using NSID (Namespaced Identifier) values as keys.
- *
- * NSIDs are compared by their string representation, allowing different
- * NSID object instances with the same value to be treated as the same key.
- *
- * @typeParam T - The value type stored in the map
- *
- * @example
- * ```typescript
- * import { NsidMap } from '@atproto/lex-installer'
- * import { NSID } from '@atproto/syntax'
- * import { LexiconDocument } from '@atproto/lex-document'
- *
- * const lexicons = new NsidMap<LexiconDocument>()
- *
- * // Store lexicon documents by NSID
- * lexicons.set(NSID.from('app.bsky.feed.post'), postLexicon)
- * lexicons.set(NSID.from('app.bsky.actor.profile'), profileLexicon)
- *
- * // Retrieve by NSID (different object instance works)
- * const doc = lexicons.get(NSID.from('app.bsky.feed.post'))
- *
- * // Iterate over entries
- * for (const [nsid, lexicon] of lexicons) {
- *   console.log(`${nsid}: ${lexicon.description}`)
- * }
- * ```
- */
-export class NsidMap<T> extends MappedMap<NSID, T, string> {
-  /**
-   * Creates a new empty NsidMap.
-   */
-  constructor() {
-    super(
-      (key) => key.toString(),
-      (enc) => NSID.from(enc),
-    )
-  }
-}

package/src/nsid-set.ts

@@ -1,113 +0,0 @@
-import { NSID } from '@atproto/syntax'
-
-/**
- * A Set implementation that maps values of type K to an internal representation I.
- *
- * Value identity is determined by the {@link Object.is} comparison of the
- * encoded values. This is useful for complex types that can be serialized
- * to a unique primitive representation (typically strings).
- *
- * @typeParam K - The external value type stored in the set
- * @typeParam I - The internal encoded type used for identity comparison
- */
-export class MappedSet<K, I = any> implements Set<K> {
-  private set = new Set<I>()
-
-  /**
-   * Creates a new MappedSet with custom encoding/decoding functions.
-   *
-   * @param encodeValue - Function to convert external values to internal representation
-   * @param decodeValue - Function to convert internal representation back to external values
-   */
-  constructor(
-    private readonly encodeValue: (val: K) => I,
-    private readonly decodeValue: (enc: I) => K,
-  ) {}
-
-  get size(): number {
-    return this.set.size
-  }
-
-  clear(): void {
-    this.set.clear()
-  }
-
-  add(val: K): this {
-    this.set.add(this.encodeValue(val))
-    return this
-  }
-
-  has(val: K): boolean {
-    return this.set.has(this.encodeValue(val))
-  }
-
-  delete(val: K): boolean {
-    return this.set.delete(this.encodeValue(val))
-  }
-
-  *values(): IterableIterator<K> {
-    for (const val of this.set.values()) {
-      yield this.decodeValue(val)
-    }
-  }
-
-  keys(): SetIterator<K> {
-    return this.values()
-  }
-
-  *entries(): IterableIterator<[K, K]> {
-    for (const val of this) yield [val, val]
-  }
-
-  forEach(
-    callbackfn: (value: K, value2: K, set: Set<K>) => void,
-    thisArg?: any,
-  ): void {
-    for (const val of this) {
-      callbackfn.call(thisArg, val, val, this)
-    }
-  }
-
-  [Symbol.iterator](): IterableIterator<K> {
-    return this.values()
-  }
-
-  [Symbol.toStringTag]: string = 'MappedSet'
-}
-
-/**
- * A Set specialized for storing NSID (Namespaced Identifier) values.
- *
- * NSIDs are compared by their string representation, allowing different
- * NSID object instances with the same value to be treated as equal.
- *
- * @example
- * ```typescript
- * import { NsidSet } from '@atproto/lex-installer'
- * import { NSID } from '@atproto/syntax'
- *
- * const nsidSet = new NsidSet()
- *
- * nsidSet.add(NSID.from('app.bsky.feed.post'))
- * nsidSet.add(NSID.from('app.bsky.actor.profile'))
- *
- * // Check membership
- * nsidSet.has(NSID.from('app.bsky.feed.post')) // true
- *
- * // Iterate over NSIDs
- * for (const nsid of nsidSet) {
- *   console.log(nsid.toString())
- * }
- * ```
- */
-export class NsidSet extends MappedSet<NSID, string> {
-  /**
-   * Creates a new empty NsidSet.
-   */
-  constructor() {
-    super(
-      (val) => val.toString(),
-      (enc) => NSID.from(enc),
-    )
-  }
-}

package/tsconfig.build.json

@@ -1,13 +0,0 @@
-{
-  "extends": ["../../../tsconfig/node.json"],
-  "include": ["./src"],
-  "exclude": ["**/*.test.ts"],
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "importHelpers": true,
-    "target": "ES2023",
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "types": ["node"],
-  },
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "include": [],
-  "references": [
-    { "path": "./tsconfig.build.json" },
-    { "path": "./tsconfig.tests.json" },
-  ],
-}

package/tsconfig.tests.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig/vitest.json",
-  "include": ["./tests", "./src/**/*.test.ts"],
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "rootDir": "./",
-  },
-}