@gaearon/lex-builder 0.0.13

package/dist/ts-lang.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsKeyword = isJsKeyword;
+exports.isGlobalIdentifier = isGlobalIdentifier;
+exports.isSafeLocalIdentifier = isSafeLocalIdentifier;
+exports.isValidJsIdentifier = isValidJsIdentifier;
+exports.asNamespaceExport = asNamespaceExport;
+/**
+ * JavaScript keywords
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar}
+ */
+const JS_KEYWORDS = new Set([
+    'abstract',
+    'arguments',
+    'as',
+    'async',
+    'await',
+    'boolean',
+    'break',
+    'byte',
+    'case',
+    'catch',
+    'char',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'double',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'final',
+    'finally',
+    'float',
+    'for',
+    'from',
+    'function',
+    'get',
+    'goto',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'int',
+    'interface',
+    'let',
+    'long',
+    'native',
+    'new',
+    'null',
+    'of',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'set',
+    'short',
+    'static',
+    'super',
+    'switch',
+    'synchronized',
+    'this',
+    'throw',
+    'throws',
+    'transient',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'using',
+    'var',
+    'void',
+    'volatile',
+    'while',
+    'with',
+    'yield',
+]);
+function isJsKeyword(word) {
+    return JS_KEYWORDS.has(word);
+}
+// Only important to list var/type names that are likely to be used in the
+// generated code files.
+const GLOBAL_IDENTIFIERS = new Set([
+    // import { l } from "@atproto/lex-schema"
+    'l',
+    // JS Globals
+    'self',
+    'globalThis',
+    // ESM
+    'import',
+    // CommonJS
+    '__dirname',
+    '__filename',
+    'require',
+    'module',
+    'exports',
+    // TS Primitives
+    'any',
+    'bigint',
+    'boolean',
+    'declare',
+    'never',
+    'null',
+    'number',
+    'object',
+    'string',
+    'symbol',
+    'undefined',
+    'unknown',
+    'void',
+    // TS Utility types
+    'Record',
+    'Partial',
+    'Readonly',
+    'Pick',
+    'Omit',
+    'Exclude',
+    'Extract',
+    'InstanceType',
+    'ReturnType',
+    'Required',
+    'ThisType',
+    'Uppercase',
+    'Lowercase',
+    'Capitalize',
+    'Uncapitalize',
+]);
+function isGlobalIdentifier(word) {
+    return GLOBAL_IDENTIFIERS.has(word);
+}
+function isSafeLocalIdentifier(name) {
+    return !isGlobalIdentifier(name) && isValidJsIdentifier(name);
+}
+function isValidJsIdentifier(name) {
+    return (name.length > 0 &&
+        !isJsKeyword(name) &&
+        /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name));
+}
+function asNamespaceExport(name) {
+    return isValidJsIdentifier(name) ? name : JSON.stringify(name);
+}
+//# sourceMappingURL=ts-lang.js.map

package/dist/ts-lang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-lang.js","sourceRoot":"","sources":["../src/ts-lang.ts"],"names":[],"mappings":";;AA+EA,kCAEC;AAkDD,gDAEC;AAED,sDAEC;AAED,kDAMC;AAED,8CAEC;AArJD;;;GAGG;AACH,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC;IAC1B,UAAU;IACV,WAAW;IACX,IAAI;IACJ,OAAO;IACP,OAAO;IACP,SAAS;IACT,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,OAAO;IACP,UAAU;IACV,UAAU;IACV,SAAS;IACT,QAAQ;IACR,IAAI;IACJ,QAAQ;IACR,MAAM;IACN,MAAM;IACN,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,OAAO;IACP,SAAS;IACT,OAAO;IACP,KAAK;IACL,MAAM;IACN,UAAU;IACV,KAAK;IACL,MAAM;IACN,IAAI;IACJ,YAAY;IACZ,QAAQ;IACR,IAAI;IACJ,YAAY;IACZ,KAAK;IACL,WAAW;IACX,KAAK;IACL,MAAM;IACN,QAAQ;IACR,KAAK;IACL,MAAM;IACN,IAAI;IACJ,SAAS;IACT,SAAS;IACT,WAAW;IACX,QAAQ;IACR,QAAQ;IACR,KAAK;IACL,OAAO;IACP,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,cAAc;IACd,MAAM;IACN,OAAO;IACP,QAAQ;IACR,WAAW;IACX,MAAM;IACN,KAAK;IACL,QAAQ;IACR,WAAW;IACX,OAAO;IACP,KAAK;IACL,MAAM;IACN,UAAU;IACV,OAAO;IACP,MAAM;IACN,OAAO;CACR,CAAC,CAAA;AAEF,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AAC9B,CAAC;AAED,0EAA0E;AAC1E,wBAAwB;AACxB,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,0CAA0C;IAC1C,GAAG;IACH,aAAa;IACb,MAAM;IACN,YAAY;IACZ,MAAM;IACN,QAAQ;IACR,WAAW;IACX,WAAW;IACX,YAAY;IACZ,SAAS;IACT,QAAQ;IACR,SAAS;IACT,gBAAgB;IAChB,KAAK;IACL,QAAQ;IACR,SAAS;IACT,SAAS;IACT,OAAO;IACP,MAAM;IACN,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,WAAW;IACX,SAAS;IACT,MAAM;IACN,mBAAmB;IACnB,QAAQ;IACR,SAAS;IACT,UAAU;IACV,MAAM;IACN,MAAM;IACN,SAAS;IACT,SAAS;IACT,cAAc;IACd,YAAY;IACZ,UAAU;IACV,UAAU;IACV,WAAW;IACX,WAAW;IACX,YAAY;IACZ,cAAc;CACf,CAAC,CAAA;AAEF,SAAgB,kBAAkB,CAAC,IAAY;IAC7C,OAAO,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AACrC,CAAC;AAED,SAAgB,qBAAqB,CAAC,IAAY;IAChD,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAA;AAC/D,CAAC;AAED,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,CACL,IAAI,CAAC,MAAM,GAAG,CAAC;QACf,CAAC,WAAW,CAAC,IAAI,CAAC;QAClB,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,CACxC,CAAA;AACH,CAAC;AAED,SAAgB,iBAAiB,CAAC,IAAY;IAC5C,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;AAChE,CAAC","sourcesContent":["/**\n * JavaScript keywords\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar}\n */\nconst JS_KEYWORDS = new Set([\n  'abstract',\n  'arguments',\n  'as',\n  'async',\n  'await',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'from',\n  'function',\n  'get',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'of',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'set',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'undefined',\n  'using',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n])\n\nexport function isJsKeyword(word: string) {\n  return JS_KEYWORDS.has(word)\n}\n\n// Only important to list var/type names that are likely to be used in the\n// generated code files.\nconst GLOBAL_IDENTIFIERS = new Set([\n  // import { l } from \"@atproto/lex-schema\"\n  'l',\n  // JS Globals\n  'self',\n  'globalThis',\n  // ESM\n  'import',\n  // CommonJS\n  '__dirname',\n  '__filename',\n  'require',\n  'module',\n  'exports',\n  // TS Primitives\n  'any',\n  'bigint',\n  'boolean',\n  'declare',\n  'never',\n  'null',\n  'number',\n  'object',\n  'string',\n  'symbol',\n  'undefined',\n  'unknown',\n  'void',\n  // TS Utility types\n  'Record',\n  'Partial',\n  'Readonly',\n  'Pick',\n  'Omit',\n  'Exclude',\n  'Extract',\n  'InstanceType',\n  'ReturnType',\n  'Required',\n  'ThisType',\n  'Uppercase',\n  'Lowercase',\n  'Capitalize',\n  'Uncapitalize',\n])\n\nexport function isGlobalIdentifier(word: string) {\n  return GLOBAL_IDENTIFIERS.has(word)\n}\n\nexport function isSafeLocalIdentifier(name: string) {\n  return !isGlobalIdentifier(name) && isValidJsIdentifier(name)\n}\n\nexport function isValidJsIdentifier(name: string) {\n  return (\n    name.length > 0 &&\n    !isJsKeyword(name) &&\n    /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)\n  )\n}\n\nexport function asNamespaceExport(name: string) {\n  return isValidJsIdentifier(name) ? name : JSON.stringify(name)\n}\n"]}

package/dist/util.d.ts

@@ -0,0 +1,12 @@
+export declare function memoize<T extends (arg: string) => NonNullable<unknown> | null>(fn: T): T;
+export declare function startsWithLower(str: string): boolean;
+export declare function ucFirst(str: string): string;
+export declare function lcFirst(str: string): string;
+export declare function toPascalCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function toConstantCase(str: string): string;
+export declare function toLowerCase(str: string): string;
+export declare function toUpperCase(str: string): string;
+export declare function asRelativePath(from: string, to: string): string;
+export declare function startsWithDigit(str: string): boolean;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAEA,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI,EAC5E,EAAE,EAAE,CAAC,GACJ,CAAC,CASH;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,WAG1C;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,UAElC;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,UAElC;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAeD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAKtD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,WAG1C"}

package/dist/util.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = memoize;
+exports.startsWithLower = startsWithLower;
+exports.ucFirst = ucFirst;
+exports.lcFirst = lcFirst;
+exports.toPascalCase = toPascalCase;
+exports.toCamelCase = toCamelCase;
+exports.toConstantCase = toConstantCase;
+exports.toLowerCase = toLowerCase;
+exports.toUpperCase = toUpperCase;
+exports.asRelativePath = asRelativePath;
+exports.startsWithDigit = startsWithDigit;
+const node_path_1 = require("node:path");
+function memoize(fn) {
+    const cache = new Map();
+    return ((arg) => {
+        const cached = cache.get(arg);
+        if (cached !== undefined)
+            return cached;
+        const result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    });
+}
+function startsWithLower(str) {
+    const code = str.charCodeAt(0);
+    return code >= 97 && code <= 122; // 'a' to 'z'
+}
+function ucFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function lcFirst(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function toPascalCase(str) {
+    return extractWords(str).map(toLowerCase).map(ucFirst).join('');
+}
+function toCamelCase(str) {
+    return lcFirst(toPascalCase(str));
+}
+function toConstantCase(str) {
+    return extractWords(str).map(toUpperCase).join('_');
+}
+function toLowerCase(str) {
+    return str.toLowerCase();
+}
+function toUpperCase(str) {
+    return str.toUpperCase();
+}
+function extractWords(str) {
+    const processedStr = str
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // split camelCase
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2') // split ALLCAPSWords
+        .replace(/([0-9])([A-Za-z])/g, '$1 $2') // split number followed by letter
+        .replace(/[^a-zA-Z0-9]+/g, ' ') // replace non-alphanumeric with space
+        .trim(); // trim leading/trailing spaces
+    return processedStr
+        ? processedStr.split(/\s+/) // split by spaces
+        : []; // Avoid returning [''] for empty strings
+}
+function asRelativePath(from, to) {
+    const relPath = (0, node_path_1.relative)(from, to);
+    return relPath.startsWith('./') || relPath.startsWith('../')
+        ? relPath
+        : `./${relPath}`;
+}
+function startsWithDigit(str) {
+    const code = str.charCodeAt(0);
+    return code >= 48 && code <= 57; // '0' to '9'
+}
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative } from 'node:path'\n\nexport function memoize<T extends (arg: string) => NonNullable<unknown> | null>(\n  fn: T,\n): T {\n  const cache = new Map<string, NonNullable<unknown> | null>()\n  return ((arg: string) => {\n    const cached = cache.get(arg)\n    if (cached !== undefined) return cached\n    const result = fn(arg)\n    cache.set(arg, result)\n    return result\n  }) as T\n}\n\nexport function startsWithLower(str: string) {\n  const code = str.charCodeAt(0)\n  return code >= 97 && code <= 122 // 'a' to 'z'\n}\n\nexport function ucFirst(str: string) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n}\n\nexport function lcFirst(str: string) {\n  return str.charAt(0).toLowerCase() + str.slice(1)\n}\n\nexport function toPascalCase(str: string): string {\n  return extractWords(str).map(toLowerCase).map(ucFirst).join('')\n}\n\nexport function toCamelCase(str: string): string {\n  return lcFirst(toPascalCase(str))\n}\n\nexport function toConstantCase(str: string): string {\n  return extractWords(str).map(toUpperCase).join('_')\n}\n\nexport function toLowerCase(str: string): string {\n  return str.toLowerCase()\n}\n\nexport function toUpperCase(str: string): string {\n  return str.toUpperCase()\n}\n\nfunction extractWords(str: string): string[] {\n  const processedStr = str\n    .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // split camelCase\n    .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2') // split ALLCAPSWords\n    .replace(/([0-9])([A-Za-z])/g, '$1 $2') // split number followed by letter\n    .replace(/[^a-zA-Z0-9]+/g, ' ') // replace non-alphanumeric with space\n    .trim() // trim leading/trailing spaces\n\n  return processedStr\n    ? processedStr.split(/\\s+/) // split by spaces\n    : [] // Avoid returning [''] for empty strings\n}\n\nexport function asRelativePath(from: string, to: string) {\n  const relPath = relative(from, to)\n  return relPath.startsWith('./') || relPath.startsWith('../')\n    ? relPath\n    : `./${relPath}`\n}\n\nexport function startsWithDigit(str: string) {\n  const code = str.charCodeAt(0)\n  return code >= 48 && code <= 57 // '0' to '9'\n}\n"]}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@gaearon/lex-builder",
+  "version": "0.0.13",
+  "license": "MIT",
+  "description": "TypeScript schema builder for AT Lexicons",
+  "keywords": [
+    "atproto",
+    "lexicon",
+    "build",
+    "lex"
+  ],
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/lex/lex-builder"
+  },
+  "files": [
+    "./src",
+    "./tsconfig.build.json",
+    "./tsconfig.tests.json",
+    "./tsconfig.json",
+    "./dist",
+    "./CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/index.js",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@atproto/lex-document": "workspace:^",
+    "@atproto/lex-schema": "workspace:^",
+    "prettier": "^3.2.5",
+    "ts-morph": "^27.0.0",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@ts-morph/common": "^0.28.0",
+    "vitest": "^4.0.16"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "test": "vitest run"
+  }
+}

package/src/filter.ts

@@ -0,0 +1,41 @@
+export type BuildFilterOptions = {
+  include?: string | string[]
+  exclude?: string | string[]
+}
+
+export type Filter = (input: string) => boolean
+
+export function buildFilter(options: BuildFilterOptions): Filter {
+  const include = createMatcher(options.include, () => true)
+  const exclude = createMatcher(options.exclude, () => false)
+
+  return (id) => include(id) && !exclude(id)
+}
+
+function createMatcher(
+  pattern: undefined | string | string[],
+  fallback: Filter,
+): Filter {
+  if (!pattern?.length) {
+    return fallback
+  } else if (Array.isArray(pattern)) {
+    return pattern.map(buildMatcher).reduce(combineFilters)
+  } else {
+    return buildMatcher(pattern)
+  }
+}
+
+function combineFilters(a: Filter, b: Filter): Filter {
+  return (input: string) => a(input) || b(input)
+}
+
+function buildMatcher(pattern: string): Filter {
+  if (pattern.includes('*')) {
+    const regex = new RegExp(
+      `^${pattern.replaceAll('.', '\\.').replaceAll('*', '.+')}$`,
+    )
+    return (input: string) => regex.test(input)
+  }
+
+  return (input: string) => pattern === input
+}

package/src/filtered-indexer.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import { LexiconDocument, LexiconIndexer } from '@atproto/lex-document'
+import { FilteredIndexer } from './filtered-indexer.js'
+
+class DummyIndexer implements LexiconIndexer, AsyncIterable<LexiconDocument> {
+  readonly docs: Map<string, LexiconDocument>
+
+  constructor(docs: LexiconDocument[]) {
+    this.docs = new Map(docs.map((doc) => [doc.id, doc]))
+  }
+
+  async get(id: string): Promise<LexiconDocument> {
+    const doc = this.docs.get(id)
+    if (!doc) {
+      throw new Error(`Document not found: ${id}`)
+    }
+    return doc
+  }
+
+  async *[Symbol.asyncIterator]() {
+    for (const doc of this.docs.values()) {
+      yield doc
+    }
+  }
+}
+
+describe('FilteredIndexer', () => {
+  const docs: LexiconDocument[] = [
+    {
+      lexicon: 1,
+      id: 'com.example.alpha',
+      defs: {},
+    },
+    {
+      lexicon: 1,
+      id: 'com.example.beta',
+      defs: {},
+    },
+    {
+      lexicon: 1,
+      id: 'org.sample.gamma',
+      defs: {},
+    },
+  ]
+
+  it('yields only filtered documents', async () => {
+    const indexer = new DummyIndexer(docs)
+    const filter = (id: string) => id.startsWith('com.example.')
+    const filteredIndexer = new FilteredIndexer(indexer, filter)
+
+    const yieldedDocs = []
+    for await (const doc of filteredIndexer) {
+      yieldedDocs.push(doc)
+    }
+
+    expect(yieldedDocs).toHaveLength(2)
+    expect(yieldedDocs.map((d) => d.id)).toEqual([
+      'com.example.alpha',
+      'com.example.beta',
+    ])
+  })
+
+  it('bypasses filter for requested documents', async () => {
+    const indexer = new DummyIndexer(docs)
+    const filter = (id: string) => id.startsWith('com.example.')
+    const filteredIndexer = new FilteredIndexer(indexer, filter)
+
+    // Request a document that would normally be filtered out
+    const requestedDoc = await filteredIndexer.get('org.sample.gamma')
+    expect(requestedDoc.id).toBe('org.sample.gamma')
+
+    const yieldedDocs = []
+    for await (const doc of filteredIndexer) {
+      yieldedDocs.push(doc)
+    }
+
+    expect(yieldedDocs).toHaveLength(3)
+    expect(yieldedDocs.map((d) => d.id)).toEqual([
+      'com.example.alpha',
+      'com.example.beta',
+      'org.sample.gamma',
+    ])
+  })
+})

package/src/filtered-indexer.ts

@@ -0,0 +1,60 @@
+import { LexiconDocument, LexiconIndexer } from '@atproto/lex-document'
+import { Filter } from './filter.js'
+
+/**
+ * A lexicon indexer that filters documents based on a provided filter.
+ *
+ * If a document was filtered out but later requested via `get()`, the filter
+ * will be bypassed for that document.
+ */
+export class FilteredIndexer implements LexiconIndexer, AsyncDisposable {
+  protected readonly returned = new Set<string>()
+
+  constructor(
+    readonly indexer: LexiconIndexer & AsyncIterable<LexiconDocument>,
+    readonly filter: Filter,
+  ) {}
+
+  async get(id: string): Promise<LexiconDocument> {
+    this.returned.add(id)
+    return this.indexer.get(id)
+  }
+
+  async *[Symbol.asyncIterator]() {
+    const returned = new Set<string>()
+
+    for await (const doc of this.indexer) {
+      if (returned.has(doc.id)) {
+        // Should never happen
+        throw new Error(`Duplicate lexicon document id: ${doc.id}`)
+      }
+
+      if (this.returned.has(doc.id) || this.filter(doc.id)) {
+        this.returned.add(doc.id)
+        returned.add(doc.id)
+        yield doc
+      }
+    }
+
+    // When we yield control back to the caller, there may be requests (.get())
+    // for documents that were initially ignored (filtered out). We won't be
+    // done iterating until every document that may have been requested when the
+    // control was yielded to the caller has been returned.
+
+    let returnedAny: boolean
+    do {
+      returnedAny = false
+      for (const id of this.returned) {
+        if (!returned.has(id)) {
+          yield await this.indexer.get(id)
+          returned.add(id)
+          returnedAny = true
+        }
+      }
+    } while (returnedAny)
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.indexer[Symbol.asyncDispose]?.()
+  }
+}

package/src/formatter.ts

@@ -0,0 +1,42 @@
+import { Options as PrettierOptions, format as prettierFormat } from 'prettier'
+
+const DEFAULT_FORMAT_OPTIONS: PrettierOptions = {
+  parser: 'typescript',
+  tabWidth: 2,
+  semi: false,
+  singleQuote: true,
+  trailingComma: 'all',
+}
+
+const DEFAULT_BANNER = `/*
+ * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT.
+ */`
+
+export type FormatterOptions = {
+  /** @default false */
+  pretty?: boolean | PrettierOptions
+  banner?: string
+}
+
+export class Formatter {
+  readonly banner: string
+  readonly prettierOptions: PrettierOptions | null
+
+  constructor(options: FormatterOptions = {}) {
+    this.banner = options?.banner ?? DEFAULT_BANNER
+
+    this.prettierOptions =
+      options?.pretty === true
+        ? DEFAULT_FORMAT_OPTIONS
+        : options?.pretty || null
+  }
+
+  async format(code: string) {
+    const bannerPadding =
+      this.banner && !this.banner.endsWith('\n') ? '\n\n' : ''
+    const codePretty = this.prettierOptions
+      ? await prettierFormat(code, this.prettierOptions)
+      : code
+    return `${this.banner}${bannerPadding}${codePretty}`
+  }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+// Must be first
+import './polyfill.js'
+
+import {
+  LexBuilder,
+  LexBuilderLoadOptions,
+  LexBuilderOptions,
+  LexBuilderSaveOptions,
+} from './lex-builder.js'
+
+export * from './lex-builder.js'
+export * from './lex-def-builder.js'
+export * from './lexicon-directory-indexer.js'
+
+export type TsProjectBuildOptions = LexBuilderOptions &
+  LexBuilderLoadOptions &
+  LexBuilderSaveOptions
+
+export async function build(options: TsProjectBuildOptions) {
+  const builder = new LexBuilder(options)
+  await builder.load(options)
+  await builder.save(options)
+}