@postxl/generator 0.74.2 → 1.0.3

package/dist/lib/exports.d.ts

@@ -1,45 +0,0 @@
-import * as Types from './schema/types';
-/**
- * A utility component that lets you generate TypeScript export statements that export all items from a given file.
- */
-export declare class ExportsGenerator {
-    private _exports;
-    /**
-     * Path of the file we're generating exports for.
-     */
-    private _path;
-    /**
-     * Tells whether this generator acts as a root.
-     */
-    private isRoot;
-    constructor({ path, isRoot }: {
-        path: string;
-        isRoot?: boolean;
-    });
-    /**
-     * Creates a new instance of the exports generator.
-     */
-    static from(path: Types.FilePath): ExportsGenerator;
-    /**
-     * Creates a new instance of the exports generator from this folder (i.e. every path is relative to this folder).
-     */
-    static fromRoot(): ExportsGenerator;
-    /**
-     * Adds a given file to the collection of files we're exporting everything from.
-     */
-    exportEverythingFromPath(from: Types.FilePath): ExportsGenerator;
-    /**
-     * Adds a given file to the collection of files we're exporting everything from.
-     *
-     * NOTE: This should only be used when the generator is a root generator.
-     */
-    exportEverythingFromFile(file: string): ExportsGenerator;
-    /**
-     * Adds a given file to the collection of files we're exporting a selection from.
-     */
-    exportSelectionFromPath(from: Types.FilePath, elements: Types.ImportableTypes[]): ExportsGenerator;
-    /**
-     * Returns the TypeScript export statements.
-     */
-    generate(): string;
-}

package/dist/lib/exports.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExportsGenerator = void 0;
-const file_1 = require("./utils/file");
-/**
- * A utility component that lets you generate TypeScript export statements that export all items from a given file.
- */
-class ExportsGenerator {
-    constructor({ path, isRoot }) {
-        this._path = path;
-        this._exports = new Map();
-        this.isRoot = isRoot !== null && isRoot !== void 0 ? isRoot : false;
-    }
-    /**
-     * Creates a new instance of the exports generator.
-     */
-    static from(path) {
-        return new ExportsGenerator({ path });
-    }
-    /**
-     * Creates a new instance of the exports generator from this folder (i.e. every path is relative to this folder).
-     */
-    static fromRoot() {
-        return new ExportsGenerator({ path: './', isRoot: true });
-    }
-    /**
-     * Adds a given file to the collection of files we're exporting everything from.
-     */
-    exportEverythingFromPath(from) {
-        if (this.isRoot) {
-            throw new Error(`Cannot use "exportEverythingFromPath" on a root generator.`);
-        }
-        const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
-        this._exports.set(resolvedPath, { kind: 'wildcard' });
-        return this;
-    }
-    /**
-     * Adds a given file to the collection of files we're exporting everything from.
-     *
-     * NOTE: This should only be used when the generator is a root generator.
-     */
-    exportEverythingFromFile(file) {
-        if (!this.isRoot) {
-            throw new Error(`Cannot use "exportEverythingFromFile" on a non-root generator.`);
-        }
-        this._exports.set(file, { kind: 'wildcard' });
-        return this;
-    }
-    /**
-     * Adds a given file to the collection of files we're exporting a selection from.
-     */
-    exportSelectionFromPath(from, elements) {
-        if (this.isRoot) {
-            throw new Error(`Cannot use "exportSelectionFromPath" on a root generator.`);
-        }
-        const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
-        const _existing = this._exports.get(resolvedPath);
-        // NOTE: If we already export everything, we don't need to do anything.
-        if ((_existing === null || _existing === void 0 ? void 0 : _existing.kind) === 'wildcard') {
-            return this;
-        }
-        if ((_existing === null || _existing === void 0 ? void 0 : _existing.kind) === 'selection') {
-            for (const element of elements) {
-                _existing.elements.add(element);
-            }
-            return this;
-        }
-        this._exports.set(resolvedPath, { kind: 'selection', elements: new Set(elements) });
-        return this;
-    }
-    /**
-     * Returns the TypeScript export statements.
-     */
-    generate() {
-        const statements = [];
-        const exports = Array.from(this._exports.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-        for (const [_path, _export] of exports) {
-            switch (_export.kind) {
-                case 'wildcard':
-                    statements.push(`export * from '${_path}'`);
-                    break;
-                case 'selection':
-                    statements.push(`export { ${Array.from(_export.elements).join(', ')} } from '${_path}'`);
-                    break;
-            }
-        }
-        return statements.join('\n');
-    }
-}
-exports.ExportsGenerator = ExportsGenerator;

package/dist/lib/imports.d.ts

@@ -1,65 +0,0 @@
-import * as Types from './schema/types';
-/**
- * A structured definition of multiple imports: The key of the object is the "from" path,
- * the value is a list (or single item) of items to import.
- *
- * Example:
- * ```
- * {
- *   [meta.data.importPath]: meta.data.repository.className,
- *   [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
- * }
- * ```
- */
-export type BulkImportDefinition = Record<Types.ImportPaths, Types.ImportableTypes[] | Types.ImportableTypes>;
-/**
- * A utility component that lets you generate TypeScript import statements
- * and makes sure every import is only added once.
- */
-export declare class ImportsGenerator {
-    /**
-     * Lists of values and types we import from a given path indexed by the path.
-     */
-    private _imports;
-    /**
-     * Path of the file we're generating imports for.
-     */
-    private _path;
-    constructor({ path }: {
-        path: string;
-    });
-    /**
-     * Creates a new instance of the imports generator.
-     */
-    static from(path: Types.FilePath): ImportsGenerator;
-    /**
-     * Adds a given import statement to the imports list.
-     *
-     * NOTE: You should never add no items from a given path.
-     */
-    addImport({ items, from }: {
-        items: Types.ImportableTypes[];
-        from: Types.ImportPaths;
-    }): ImportsGenerator;
-    /**
-     * Adds a given type import statement to the imports list.
-     *
-     * NOTE: You should never add no items from a given path.
-     */
-    addTypeImport({ items, from }: {
-        items: Types.TypeName[];
-        from: Types.ImportPaths;
-    }): ImportsGenerator;
-    /**
-     * Adds a multiple  import statements to the imports list.
-     *
-     * @param entries - A record of items to import indexed by the path.
-     *
-     * NOTE: You should never add no items from a given path.
-     */
-    addImports(entries: BulkImportDefinition): ImportsGenerator;
-    /**
-     * Returns the TypeScript import statement.
-     */
-    generate(): string;
-}

package/dist/lib/imports.js

@@ -1,114 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportsGenerator = void 0;
-const Types = __importStar(require("./schema/types"));
-const file_1 = require("./utils/file");
-/**
- * A utility component that lets you generate TypeScript import statements
- * and makes sure every import is only added once.
- */
-class ImportsGenerator {
-    constructor({ path }) {
-        /**
-         * Lists of values and types we import from a given path indexed by the path.
-         */
-        this._imports = {};
-        this._path = path;
-    }
-    /**
-     * Creates a new instance of the imports generator.
-     */
-    static from(path) {
-        return new ImportsGenerator({ path });
-    }
-    /**
-     * Adds a given import statement to the imports list.
-     *
-     * NOTE: You should never add no items from a given path.
-     */
-    addImport({ items, from }) {
-        // NOTE: Generator relies that there's at least one import statement from a given path.
-        if (items.length === 0) {
-            throw new Error(`You cannot add an import statement without any items from ${from}.`);
-        }
-        const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
-        if (!this._imports[resolvedPath]) {
-            this._imports[resolvedPath] = { types: new Set(), nonTypes: new Set() };
-        }
-        items.forEach((item) => {
-            if (Types.isAnnotatedTypeName(item)) {
-                this._imports[resolvedPath].types.add(item.typeName);
-            }
-            else {
-                this._imports[resolvedPath].nonTypes.add(item);
-            }
-        });
-        return this;
-    }
-    /**
-     * Adds a given type import statement to the imports list.
-     *
-     * NOTE: You should never add no items from a given path.
-     */
-    addTypeImport({ items, from }) {
-        return this.addImport({ items: items.map((i) => Types.toAnnotatedTypeName(i)), from });
-    }
-    /**
-     * Adds a multiple  import statements to the imports list.
-     *
-     * @param entries - A record of items to import indexed by the path.
-     *
-     * NOTE: You should never add no items from a given path.
-     */
-    addImports(entries) {
-        for (const [key, items] of Object.entries(entries)) {
-            if (Array.isArray(items)) {
-                this.addImport({ items, from: key });
-            }
-            else {
-                this.addImport({ items: [items], from: key });
-            }
-        }
-        return this;
-    }
-    /**
-     * Returns the TypeScript import statement.
-     */
-    generate() {
-        const statements = Object.entries(this._imports)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([path, items]) => {
-            const nonTypes = Array.from(items.nonTypes).sort((a, b) => a.localeCompare(b));
-            const nonTypesImportStatement = nonTypes.length > 0 ? `import { ${nonTypes.join(', ')} } from '${path}'\n` : '';
-            const types = Array.from(items.types).sort((a, b) => a.localeCompare(b));
-            const typesImportStatement = types.length > 0 ? `import type { ${types.join(', ')} } from '${path}'` : '';
-            return `${nonTypesImportStatement}${typesImportStatement}`;
-        })
-            .join('\n');
-        return statements;
-    }
-}
-exports.ImportsGenerator = ImportsGenerator;