@gaearon/lex-builder 0.0.13

package/dist/filtered-indexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-indexer.d.ts","sourceRoot":"","sources":["../src/filtered-indexer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC;;;;;GAKG;AACH,qBAAa,eAAgB,YAAW,cAAc,EAAE,eAAe;IAInE,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,CAAC,eAAe,CAAC;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM;IAJzB,SAAS,CAAC,QAAQ,CAAC,QAAQ,cAAoB;gBAGpC,OAAO,EAAE,cAAc,GAAG,aAAa,CAAC,eAAe,CAAC,EACxD,MAAM,EAAE,MAAM;IAGnB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAKxC,CAAC,MAAM,CAAC,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkCvB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7C"}

package/dist/filtered-indexer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilteredIndexer = void 0;
+/**
+ * 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.
+ */
+class FilteredIndexer {
+    indexer;
+    filter;
+    returned = new Set();
+    constructor(indexer, filter) {
+        this.indexer = indexer;
+        this.filter = filter;
+    }
+    async get(id) {
+        this.returned.add(id);
+        return this.indexer.get(id);
+    }
+    async *[Symbol.asyncIterator]() {
+        const returned = new Set();
+        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;
+        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]() {
+        await this.indexer[Symbol.asyncDispose]?.();
+    }
+}
+exports.FilteredIndexer = FilteredIndexer;
+//# sourceMappingURL=filtered-indexer.js.map

package/dist/filtered-indexer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-indexer.js","sourceRoot":"","sources":["../src/filtered-indexer.ts"],"names":[],"mappings":";;;AAGA;;;;;GAKG;AACH,MAAa,eAAe;IAIf;IACA;IAJQ,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAA;IAE/C,YACW,OAAwD,EACxD,MAAc;QADd,YAAO,GAAP,OAAO,CAAiD;QACxD,WAAM,GAAN,MAAM,CAAQ;IACtB,CAAC;IAEJ,KAAK,CAAC,GAAG,CAAC,EAAU;QAClB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;QACrB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAC7B,CAAC;IAED,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAA;QAElC,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACrC,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;gBACzB,sBAAsB;gBACtB,MAAM,IAAI,KAAK,CAAC,kCAAkC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAA;YAC7D,CAAC;YAED,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;gBACrD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;gBACzB,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;gBACpB,MAAM,GAAG,CAAA;YACX,CAAC;QACH,CAAC;QAED,2EAA2E;QAC3E,wEAAwE;QACxE,4EAA4E;QAC5E,uDAAuD;QAEvD,IAAI,WAAoB,CAAA;QACxB,GAAG,CAAC;YACF,WAAW,GAAG,KAAK,CAAA;YACnB,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC/B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;oBACtB,MAAM,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;oBAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;oBAChB,WAAW,GAAG,IAAI,CAAA;gBACpB,CAAC;YACH,CAAC;QACH,CAAC,QAAQ,WAAW,EAAC;IACvB,CAAC;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;QACzB,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,CAAA;IAC7C,CAAC;CACF;AAlDD,0CAkDC","sourcesContent":["import { LexiconDocument, LexiconIndexer } from '@atproto/lex-document'\nimport { Filter } from './filter.js'\n\n/**\n * A lexicon indexer that filters documents based on a provided filter.\n *\n * If a document was filtered out but later requested via `get()`, the filter\n * will be bypassed for that document.\n */\nexport class FilteredIndexer implements LexiconIndexer, AsyncDisposable {\n  protected readonly returned = new Set<string>()\n\n  constructor(\n    readonly indexer: LexiconIndexer & AsyncIterable<LexiconDocument>,\n    readonly filter: Filter,\n  ) {}\n\n  async get(id: string): Promise<LexiconDocument> {\n    this.returned.add(id)\n    return this.indexer.get(id)\n  }\n\n  async *[Symbol.asyncIterator]() {\n    const returned = new Set<string>()\n\n    for await (const doc of this.indexer) {\n      if (returned.has(doc.id)) {\n        // Should never happen\n        throw new Error(`Duplicate lexicon document id: ${doc.id}`)\n      }\n\n      if (this.returned.has(doc.id) || this.filter(doc.id)) {\n        this.returned.add(doc.id)\n        returned.add(doc.id)\n        yield doc\n      }\n    }\n\n    // When we yield control back to the caller, there may be requests (.get())\n    // for documents that were initially ignored (filtered out). We won't be\n    // done iterating until every document that may have been requested when the\n    // control was yielded to the caller has been returned.\n\n    let returnedAny: boolean\n    do {\n      returnedAny = false\n      for (const id of this.returned) {\n        if (!returned.has(id)) {\n          yield await this.indexer.get(id)\n          returned.add(id)\n          returnedAny = true\n        }\n      }\n    } while (returnedAny)\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.indexer[Symbol.asyncDispose]?.()\n  }\n}\n"]}

package/dist/formatter.d.ts

@@ -0,0 +1,13 @@
+import { Options as PrettierOptions } from 'prettier';
+export type FormatterOptions = {
+    /** @default false */
+    pretty?: boolean | PrettierOptions;
+    banner?: string;
+};
+export declare class Formatter {
+    readonly banner: string;
+    readonly prettierOptions: PrettierOptions | null;
+    constructor(options?: FormatterOptions);
+    format(code: string): Promise<string>;
+}
+//# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAA4B,MAAM,UAAU,CAAA;AAc/E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qBAAqB;IACrB,MAAM,CAAC,EAAE,OAAO,GAAG,eAAe,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,qBAAa,SAAS;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAA;gBAEpC,OAAO,GAAE,gBAAqB;IASpC,MAAM,CAAC,IAAI,EAAE,MAAM;CAQ1B"}

package/dist/formatter.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+const prettier_1 = require("prettier");
+const DEFAULT_FORMAT_OPTIONS = {
+    parser: 'typescript',
+    tabWidth: 2,
+    semi: false,
+    singleQuote: true,
+    trailingComma: 'all',
+};
+const DEFAULT_BANNER = `/*
+ * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT.
+ */`;
+class Formatter {
+    banner;
+    prettierOptions;
+    constructor(options = {}) {
+        this.banner = options?.banner ?? DEFAULT_BANNER;
+        this.prettierOptions =
+            options?.pretty === true
+                ? DEFAULT_FORMAT_OPTIONS
+                : options?.pretty || null;
+    }
+    async format(code) {
+        const bannerPadding = this.banner && !this.banner.endsWith('\n') ? '\n\n' : '';
+        const codePretty = this.prettierOptions
+            ? await (0, prettier_1.format)(code, this.prettierOptions)
+            : code;
+        return `${this.banner}${bannerPadding}${codePretty}`;
+    }
+}
+exports.Formatter = Formatter;
+//# sourceMappingURL=formatter.js.map

package/dist/formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.js","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":";;;AAAA,uCAA+E;AAE/E,MAAM,sBAAsB,GAAoB;IAC9C,MAAM,EAAE,YAAY;IACpB,QAAQ,EAAE,CAAC;IACX,IAAI,EAAE,KAAK;IACX,WAAW,EAAE,IAAI;IACjB,aAAa,EAAE,KAAK;CACrB,CAAA;AAED,MAAM,cAAc,GAAG;;IAEnB,CAAA;AAQJ,MAAa,SAAS;IACX,MAAM,CAAQ;IACd,eAAe,CAAwB;IAEhD,YAAY,UAA4B,EAAE;QACxC,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,cAAc,CAAA;QAE/C,IAAI,CAAC,eAAe;YAClB,OAAO,EAAE,MAAM,KAAK,IAAI;gBACtB,CAAC,CAAC,sBAAsB;gBACxB,CAAC,CAAC,OAAO,EAAE,MAAM,IAAI,IAAI,CAAA;IAC/B,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,IAAY;QACvB,MAAM,aAAa,GACjB,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAA;QAC1D,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe;YACrC,CAAC,CAAC,MAAM,IAAA,iBAAc,EAAC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC;YAClD,CAAC,CAAC,IAAI,CAAA;QACR,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,aAAa,GAAG,UAAU,EAAE,CAAA;IACtD,CAAC;CACF;AArBD,8BAqBC","sourcesContent":["import { Options as PrettierOptions, format as prettierFormat } from 'prettier'\n\nconst DEFAULT_FORMAT_OPTIONS: PrettierOptions = {\n  parser: 'typescript',\n  tabWidth: 2,\n  semi: false,\n  singleQuote: true,\n  trailingComma: 'all',\n}\n\nconst DEFAULT_BANNER = `/*\n * THIS FILE WAS GENERATED BY \"@atproto/lex\". DO NOT EDIT.\n */`\n\nexport type FormatterOptions = {\n  /** @default false */\n  pretty?: boolean | PrettierOptions\n  banner?: string\n}\n\nexport class Formatter {\n  readonly banner: string\n  readonly prettierOptions: PrettierOptions | null\n\n  constructor(options: FormatterOptions = {}) {\n    this.banner = options?.banner ?? DEFAULT_BANNER\n\n    this.prettierOptions =\n      options?.pretty === true\n        ? DEFAULT_FORMAT_OPTIONS\n        : options?.pretty || null\n  }\n\n  async format(code: string) {\n    const bannerPadding =\n      this.banner && !this.banner.endsWith('\\n') ? '\\n\\n' : ''\n    const codePretty = this.prettierOptions\n      ? await prettierFormat(code, this.prettierOptions)\n      : code\n    return `${this.banner}${bannerPadding}${codePretty}`\n  }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import './polyfill.js';
+import { 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 declare function build(options: TsProjectBuildOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,eAAe,CAAA;AAEtB,OAAO,EAEL,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,kBAAkB,CAAA;AAEzB,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,gCAAgC,CAAA;AAE9C,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,GACnD,qBAAqB,GACrB,qBAAqB,CAAA;AAEvB,wBAAsB,KAAK,CAAC,OAAO,EAAE,qBAAqB,iBAIzD"}

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const tslib_1 = require("tslib");
+// Must be first
+require("./polyfill.js");
+const lex_builder_js_1 = require("./lex-builder.js");
+tslib_1.__exportStar(require("./lex-builder.js"), exports);
+tslib_1.__exportStar(require("./lex-def-builder.js"), exports);
+tslib_1.__exportStar(require("./lexicon-directory-indexer.js"), exports);
+async function build(options) {
+    const builder = new lex_builder_js_1.LexBuilder(options);
+    await builder.load(options);
+    await builder.save(options);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAkBA,sBAIC;;AAtBD,gBAAgB;AAChB,yBAAsB;AAEtB,qDAKyB;AAEzB,2DAAgC;AAChC,+DAAoC;AACpC,yEAA8C;AAMvC,KAAK,UAAU,KAAK,CAAC,OAA8B;IACxD,MAAM,OAAO,GAAG,IAAI,2BAAU,CAAC,OAAO,CAAC,CAAA;IACvC,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC3B,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;AAC7B,CAAC","sourcesContent":["// Must be first\nimport './polyfill.js'\n\nimport {\n  LexBuilder,\n  LexBuilderLoadOptions,\n  LexBuilderOptions,\n  LexBuilderSaveOptions,\n} from './lex-builder.js'\n\nexport * from './lex-builder.js'\nexport * from './lex-def-builder.js'\nexport * from './lexicon-directory-indexer.js'\n\nexport type TsProjectBuildOptions = LexBuilderOptions &\n  LexBuilderLoadOptions &\n  LexBuilderSaveOptions\n\nexport async function build(options: TsProjectBuildOptions) {\n  const builder = new LexBuilder(options)\n  await builder.load(options)\n  await builder.save(options)\n}\n"]}

package/dist/lex-builder.d.ts

@@ -0,0 +1,36 @@
+import { BuildFilterOptions } from './filter.js';
+import { FormatterOptions } from './formatter.js';
+import { LexDefBuilderOptions } from './lex-def-builder.js';
+import { LexiconDirectoryIndexerOptions } from './lexicon-directory-indexer.js';
+export type LexBuilderOptions = LexDefBuilderOptions & {
+    /**
+     * Whether to generate an index file at the root exporting all top-level
+     * namespaces.
+     *
+     * @note This could theoretically cause name conflicts if a
+     * @default false
+     */
+    indexFile?: boolean;
+    importExt?: string;
+    fileExt?: string;
+};
+export type LexBuilderLoadOptions = LexiconDirectoryIndexerOptions & BuildFilterOptions;
+export type LexBuilderSaveOptions = FormatterOptions & {
+    out: string;
+    clear?: boolean;
+    override?: boolean;
+};
+export declare class LexBuilder {
+    #private;
+    private readonly options;
+    constructor(options?: LexBuilderOptions);
+    get fileExt(): string;
+    get importExt(): string;
+    load(options: LexBuilderLoadOptions): Promise<void>;
+    save(options: LexBuilderSaveOptions): Promise<void>;
+    private createFile;
+    private getFile;
+    private createExportTree;
+    private createDefsFile;
+}
+//# sourceMappingURL=lex-builder.d.ts.map

package/dist/lex-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-builder.d.ts","sourceRoot":"","sources":["../src/lex-builder.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAe,MAAM,aAAa,CAAA;AAE7D,OAAO,EAAa,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,EAAiB,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAC1E,OAAO,EAEL,8BAA8B,EAC/B,MAAM,gCAAgC,CAAA;AAGvC,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,GAAG;IACrD;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,8BAA8B,GAChE,kBAAkB,CAAA;AAEpB,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,qBAAa,UAAU;;IAOT,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,GAAE,iBAAsB;IAE5D,IAAI,OAAO,WAEV;IAED,IAAI,SAAS,WAEZ;IAEY,IAAI,CAAC,OAAO,EAAE,qBAAqB;IAkBnC,IAAI,CAAC,OAAO,EAAE,qBAAqB;IA4BhD,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,OAAO;YAID,gBAAgB;YAyDhB,cAAc;CAU7B"}

package/dist/lex-builder.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexBuilder = void 0;
+const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const ts_morph_1 = require("ts-morph");
+const filter_js_1 = require("./filter.js");
+const filtered_indexer_js_1 = require("./filtered-indexer.js");
+const formatter_js_1 = require("./formatter.js");
+const lex_def_builder_js_1 = require("./lex-def-builder.js");
+const lexicon_directory_indexer_js_1 = require("./lexicon-directory-indexer.js");
+const ts_lang_js_1 = require("./ts-lang.js");
+class LexBuilder {
+    options;
+    #imported = new Set();
+    #project = new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+        manipulationSettings: { indentationText: ts_morph_1.IndentationText.TwoSpaces },
+    });
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get fileExt() {
+        return this.options.fileExt ?? '.ts';
+    }
+    get importExt() {
+        return this.options.importExt ?? '.js';
+    }
+    async load(options) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const indexer = tslib_1.__addDisposableResource(env_1, new filtered_indexer_js_1.FilteredIndexer(new lexicon_directory_indexer_js_1.LexiconDirectoryIndexer(options), (0, filter_js_1.buildFilter)(options)), true);
+            for await (const doc of indexer) {
+                if (!this.#imported.has(doc.id)) {
+                    this.#imported.add(doc.id);
+                }
+                else {
+                    throw new Error(`Duplicate lexicon document id: ${doc.id}`);
+                }
+                await this.createDefsFile(doc, indexer);
+                await this.createExportTree(doc);
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = tslib_1.__disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async save(options) {
+        const files = this.#project.getSourceFiles();
+        const destination = (0, node_path_1.resolve)(options.out);
+        if (options.clear) {
+            await (0, promises_1.rm)(destination, { recursive: true, force: true });
+        }
+        else if (!options.override) {
+            await Promise.all(files.map(async (f) => assertNotFileExists((0, node_path_1.join)(destination, f.getFilePath()))));
+        }
+        const formatter = new formatter_js_1.Formatter(options);
+        await Promise.all(Array.from(files, async (file) => {
+            const filePath = (0, node_path_1.join)(destination, file.getFilePath());
+            const content = await formatter.format(file.getFullText());
+            await (0, promises_1.mkdir)((0, node_path_1.join)(filePath, '..'), { recursive: true });
+            await (0, promises_1.rm)(filePath, { recursive: true, force: true });
+            await (0, promises_1.writeFile)(filePath, content, 'utf8');
+        }));
+    }
+    createFile(path) {
+        return this.#project.createSourceFile(path);
+    }
+    getFile(path) {
+        return this.#project.getSourceFile(path) || this.createFile(path);
+    }
+    async createExportTree(doc) {
+        const namespaces = doc.id.split('.');
+        if (this.options.indexFile) {
+            const indexFile = this.getFile(`/index${this.fileExt}`);
+            const tldNs = namespaces[0];
+            (0, node_assert_1.default)(tldNs !== 'index', 'The "indexFile" options cannot be used with namespaces using a ".index" tld.');
+            const tldNsSpecifier = `./${tldNs}${this.importExt}`;
+            if (!indexFile.getExportDeclaration(tldNsSpecifier)) {
+                indexFile.addExportDeclaration({
+                    moduleSpecifier: tldNsSpecifier,
+                    namespaceExport: (0, ts_lang_js_1.asNamespaceExport)(tldNs),
+                });
+            }
+        }
+        // First create the parent namespaces
+        for (let i = 0; i < namespaces.length - 1; i++) {
+            const currentNs = namespaces[i];
+            const childNs = namespaces[i + 1];
+            const path = (0, node_path_1.join)('/', ...namespaces.slice(0, i + 1));
+            const file = this.getFile(`${path}${this.fileExt}`);
+            const childModuleSpecifier = `./${currentNs}/${childNs}${this.importExt}`;
+            const dec = file.getExportDeclaration(childModuleSpecifier);
+            if (!dec) {
+                file.addExportDeclaration({
+                    moduleSpecifier: childModuleSpecifier,
+                    namespaceExport: (0, ts_lang_js_1.asNamespaceExport)(childNs),
+                });
+            }
+        }
+        // The child file exports the schemas (as *)
+        const path = (0, node_path_1.join)('/', ...namespaces);
+        const file = this.getFile(`${path}${this.fileExt}`);
+        file.addExportDeclaration({
+            moduleSpecifier: `./${namespaces.at(-1)}.defs${this.importExt}`,
+        });
+        // @NOTE Individual exports exports from the defs file might conflict with
+        // child namespaces. For this reason, we also add a namespace export for the
+        // defs (export * as $defs from './xyz.defs'). This is an escape hatch
+        // allowing to still access the definitions if a hash get shadowed by a
+        // child namespace.
+        file.addExportDeclaration({
+            moduleSpecifier: `./${namespaces.at(-1)}.defs${this.importExt}`,
+            namespaceExport: '$defs',
+        });
+    }
+    async createDefsFile(doc, indexer) {
+        const path = (0, node_path_1.join)('/', ...doc.id.split('.'));
+        const file = this.createFile(`${path}.defs${this.fileExt}`);
+        const fileBuilder = new lex_def_builder_js_1.LexDefBuilder(this.options, file, doc, indexer);
+        await fileBuilder.build();
+    }
+}
+exports.LexBuilder = LexBuilder;
+async function assertNotFileExists(file) {
+    try {
+        await (0, promises_1.stat)(file);
+        throw new Error(`File already exists: ${file}`);
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT')
+            return;
+        throw err;
+    }
+}
+//# sourceMappingURL=lex-builder.js.map

package/dist/lex-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-builder.js","sourceRoot":"","sources":["../src/lex-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'node:assert'\nimport { mkdir, rm, stat, writeFile } from 'node:fs/promises'\nimport { join, resolve } from 'node:path'\nimport { IndentationText, Project } from 'ts-morph'\nimport { LexiconDocument, LexiconIndexer } from '@atproto/lex-document'\nimport { BuildFilterOptions, buildFilter } from './filter.js'\nimport { FilteredIndexer } from './filtered-indexer.js'\nimport { Formatter, FormatterOptions } from './formatter.js'\nimport { LexDefBuilder, LexDefBuilderOptions } from './lex-def-builder.js'\nimport {\n  LexiconDirectoryIndexer,\n  LexiconDirectoryIndexerOptions,\n} from './lexicon-directory-indexer.js'\nimport { asNamespaceExport } from './ts-lang.js'\n\nexport type LexBuilderOptions = LexDefBuilderOptions & {\n  /**\n   * Whether to generate an index file at the root exporting all top-level\n   * namespaces.\n   *\n   * @note This could theoretically cause name conflicts if a\n   * @default false\n   */\n  indexFile?: boolean\n  importExt?: string\n  fileExt?: string\n}\n\nexport type LexBuilderLoadOptions = LexiconDirectoryIndexerOptions &\n  BuildFilterOptions\n\nexport type LexBuilderSaveOptions = FormatterOptions & {\n  out: string\n  clear?: boolean\n  override?: boolean\n}\n\nexport class LexBuilder {\n  readonly #imported = new Set<string>()\n  readonly #project = new Project({\n    useInMemoryFileSystem: true,\n    manipulationSettings: { indentationText: IndentationText.TwoSpaces },\n  })\n\n  constructor(private readonly options: LexBuilderOptions = {}) {}\n\n  get fileExt() {\n    return this.options.fileExt ?? '.ts'\n  }\n\n  get importExt() {\n    return this.options.importExt ?? '.js'\n  }\n\n  public async load(options: LexBuilderLoadOptions) {\n    await using indexer = new FilteredIndexer(\n      new LexiconDirectoryIndexer(options),\n      buildFilter(options),\n    )\n\n    for await (const doc of indexer) {\n      if (!this.#imported.has(doc.id)) {\n        this.#imported.add(doc.id)\n      } else {\n        throw new Error(`Duplicate lexicon document id: ${doc.id}`)\n      }\n\n      await this.createDefsFile(doc, indexer)\n      await this.createExportTree(doc)\n    }\n  }\n\n  public async save(options: LexBuilderSaveOptions) {\n    const files = this.#project.getSourceFiles()\n\n    const destination = resolve(options.out)\n\n    if (options.clear) {\n      await rm(destination, { recursive: true, force: true })\n    } else if (!options.override) {\n      await Promise.all(\n        files.map(async (f) =>\n          assertNotFileExists(join(destination, f.getFilePath())),\n        ),\n      )\n    }\n\n    const formatter = new Formatter(options)\n\n    await Promise.all(\n      Array.from(files, async (file) => {\n        const filePath = join(destination, file.getFilePath())\n        const content = await formatter.format(file.getFullText())\n        await mkdir(join(filePath, '..'), { recursive: true })\n        await rm(filePath, { recursive: true, force: true })\n        await writeFile(filePath, content, 'utf8')\n      }),\n    )\n  }\n\n  private createFile(path: string) {\n    return this.#project.createSourceFile(path)\n  }\n\n  private getFile(path: string) {\n    return this.#project.getSourceFile(path) || this.createFile(path)\n  }\n\n  private async createExportTree(doc: LexiconDocument) {\n    const namespaces = doc.id.split('.')\n\n    if (this.options.indexFile) {\n      const indexFile = this.getFile(`/index${this.fileExt}`)\n\n      const tldNs = namespaces[0]!\n      assert(\n        tldNs !== 'index',\n        'The \"indexFile\" options cannot be used with namespaces using a \".index\" tld.',\n      )\n      const tldNsSpecifier = `./${tldNs}${this.importExt}`\n      if (!indexFile.getExportDeclaration(tldNsSpecifier)) {\n        indexFile.addExportDeclaration({\n          moduleSpecifier: tldNsSpecifier,\n          namespaceExport: asNamespaceExport(tldNs),\n        })\n      }\n    }\n\n    // First create the parent namespaces\n    for (let i = 0; i < namespaces.length - 1; i++) {\n      const currentNs = namespaces[i]\n      const childNs = namespaces[i + 1]\n\n      const path = join('/', ...namespaces.slice(0, i + 1))\n      const file = this.getFile(`${path}${this.fileExt}`)\n\n      const childModuleSpecifier = `./${currentNs}/${childNs}${this.importExt}`\n      const dec = file.getExportDeclaration(childModuleSpecifier)\n      if (!dec) {\n        file.addExportDeclaration({\n          moduleSpecifier: childModuleSpecifier,\n          namespaceExport: asNamespaceExport(childNs),\n        })\n      }\n    }\n\n    // The child file exports the schemas (as *)\n    const path = join('/', ...namespaces)\n    const file = this.getFile(`${path}${this.fileExt}`)\n\n    file.addExportDeclaration({\n      moduleSpecifier: `./${namespaces.at(-1)}.defs${this.importExt}`,\n    })\n\n    // @NOTE Individual exports exports from the defs file might conflict with\n    // child namespaces. For this reason, we also add a namespace export for the\n    // defs (export * as $defs from './xyz.defs'). This is an escape hatch\n    // allowing to still access the definitions if a hash get shadowed by a\n    // child namespace.\n    file.addExportDeclaration({\n      moduleSpecifier: `./${namespaces.at(-1)}.defs${this.importExt}`,\n      namespaceExport: '$defs',\n    })\n  }\n\n  private async createDefsFile(\n    doc: LexiconDocument,\n    indexer: LexiconIndexer,\n  ): Promise<void> {\n    const path = join('/', ...doc.id.split('.'))\n    const file = this.createFile(`${path}.defs${this.fileExt}`)\n\n    const fileBuilder = new LexDefBuilder(this.options, file, doc, indexer)\n    await fileBuilder.build()\n  }\n}\n\nasync function assertNotFileExists(file: string): Promise<void> {\n  try {\n    await stat(file)\n    throw new Error(`File already exists: ${file}`)\n  } catch (err) {\n    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return\n    throw err\n  }\n}\n"]}

package/dist/lex-def-builder.d.ts

@@ -0,0 +1,69 @@
+import { SourceFile } from 'ts-morph';
+import { LexiconDocument, LexiconIndexer, LexiconProcedure, LexiconQuery, LexiconSubscription } from '@atproto/lex-document';
+import { RefResolverOptions, ResolvedRef } from './ref-resolver.js';
+export type LexDefBuilderOptions = RefResolverOptions & {
+    lib?: string;
+    allowLegacyBlobs?: boolean;
+    pureAnnotations?: boolean;
+};
+/**
+ * Utility class to build a TypeScript source file from a lexicon document.
+ */
+export declare class LexDefBuilder {
+    private readonly options;
+    private readonly file;
+    private readonly doc;
+    private readonly refResolver;
+    constructor(options: LexDefBuilderOptions, file: SourceFile, doc: LexiconDocument, indexer: LexiconIndexer);
+    private pure;
+    build(): Promise<void>;
+    private addUtils;
+    private addDef;
+    private addPermissionSet;
+    private addProcedure;
+    private addQuery;
+    private addSubscription;
+    addMethodTypeUtils(ref: ResolvedRef, def: LexiconProcedure | LexiconQuery | LexiconSubscription): void;
+    private addRecord;
+    private addObject;
+    private addToken;
+    private addArray;
+    private addSchema;
+    private compilePayload;
+    private compileBodySchema;
+    private compileParamsSchema;
+    private compileErrors;
+    private compileObjectSchema;
+    private compilePropertiesSchemas;
+    private compilePropertiesTypes;
+    private compilePropertyEntrySchema;
+    private compilePropertyEntryType;
+    private compileContainedSchema;
+    private compileContainedType;
+    private compileArraySchema;
+    private compileArrayType;
+    private compileUnknownSchema;
+    private compileUnknownType;
+    private withDefault;
+    private compileBooleanSchema;
+    private compileBooleanType;
+    private compileIntegerSchema;
+    private compileIntegerType;
+    private compileStringSchema;
+    private compileStringType;
+    private compileBytesSchema;
+    private compileBytesType;
+    private compileBlobSchema;
+    private compileBlobType;
+    private compileCidLinkSchema;
+    private compileCidLinkType;
+    private compileRefSchema;
+    private compileRefType;
+    private compileRefUnionSchema;
+    private compileRefUnionType;
+    private compileConstSchema;
+    private compileConstType;
+    private compileEnumSchema;
+    private compileEnumType;
+}
+//# sourceMappingURL=lex-def-builder.d.ts.map

package/dist/lex-def-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-def-builder.d.ts","sourceRoot":"","sources":["../src/lex-def-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,UAAU,EAEX,MAAM,UAAU,CAAA;AACjB,OAAO,EAOL,eAAe,EAEf,cAAc,EAMd,gBAAgB,EAChB,YAAY,EAKZ,mBAAmB,EAGpB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAEL,kBAAkB,EAClB,WAAW,EAEZ,MAAM,mBAAmB,CAAA;AAG1B,MAAM,MAAM,oBAAoB,GAAG,kBAAkB,GAAG;IACtD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;GAEG;AACH,qBAAa,aAAa;IAItB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IALtB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;gBAGtB,OAAO,EAAE,oBAAoB,EAC7B,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,EACrC,OAAO,EAAE,cAAc;IAKzB,OAAO,CAAC,IAAI;IAIN,KAAK;IAyBX,OAAO,CAAC,QAAQ;YAgBF,MAAM;YA8BN,gBAAgB;YAsBhB,YAAY;YA4BZ,QAAQ;YA0BR,eAAe;IA0B7B,kBAAkB,CAChB,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,gBAAgB,GAAG,YAAY,GAAG,mBAAmB;YAmD9C,SAAS;YAsBT,SAAS;YAiBT,QAAQ;YAQR,QAAQ;YAuBR,SAAS;YA2FT,cAAc;YAkBd,iBAAiB;YAQjB,mBAAmB;YAWnB,aAAa;YAKb,mBAAmB;YAKnB,wBAAwB;YAsBxB,sBAAsB;YAYtB,0BAA0B;YAuB1B,wBAAwB;YAoBxB,sBAAsB;YA8BtB,oBAAoB;YA8BpB,kBAAkB;YASlB,gBAAgB;YAIhB,oBAAoB;YAIpB,kBAAkB;IAIhC,OAAO,CAAC,WAAW;YAQL,oBAAoB;YAYpB,kBAAkB;YAKlB,oBAAoB;YA0BpB,kBAAkB;YAOlB,mBAAmB;YA6BnB,iBAAiB;YA2CjB,kBAAkB;YAQlB,gBAAgB;YAIhB,iBAAiB;YAUjB,eAAe;YAMf,oBAAoB;YAIpB,kBAAkB;YAIlB,gBAAgB;YAOhB,cAAc;YAKd,qBAAqB;YAmBrB,mBAAmB;YAWnB,kBAAkB;YAYlB,gBAAgB;YAShB,iBAAiB;YAgBjB,eAAe;CAK9B"}