@postxl/generator 1.0.7 → 1.0.8

package/dist/helpers/import-generator.class.d.ts

@@ -1,5 +1,12 @@
 import { NonEmptyArray } from '@postxl/utils';
 import * as Brands from './branded.types';
+/**
+ * An import item that can optionally have an alias.
+ */
+export type ImportItem = Brands.ImportableTypes | {
+    name: Brands.ImportableTypes;
+    alias: string;
+};
 /**
  * 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.
@@ -12,7 +19,7 @@ import * as Brands from './branded.types';
  * }
  * ```
  */
-export type BulkImportDefinition = Record<Brands.ImportPaths, NonEmptyArray<Brands.ImportableTypes> | Brands.ImportableTypes>;
+export type BulkImportDefinition = Record<Brands.ImportPaths, NonEmptyArray<ImportItem> | ImportItem>;
 /**
  * A utility component that lets you generate TypeScript import statements
  * and makes sure every import is only added once.
@@ -29,29 +36,46 @@ export declare class ImportGenerator {
     /**
      * Convenience method to add a single import statement.
      */
-    add({ name, location }: {
+    add({ name, location, alias, }: {
         name: Brands.ImportableTypes;
         location: Brands.ImportPaths;
+        alias?: string;
     }): this;
     /**
      * Convenience method to add a single import statement.
      */
-    addType({ name, location }: {
+    addType({ name, location, alias, }: {
         name: Brands.TypeName;
         location: Brands.ImportPaths;
+        alias?: string;
     }): this;
     /**
      * Adds a given import statement to the imports list.
      */
-    addImport({ items, from: fromSource, }: {
-        items: NonEmptyArray<Brands.ImportableTypes>;
+    addImport({ items, from: fromSource }: {
+        items: NonEmptyArray<ImportItem>;
         from: Brands.ImportPaths;
     }): this;
+    /**
+     * Creates a unique key for an import based on name and alias.
+     */
+    private makeImportKey;
+    /**
+     * Validates that an alias is not an empty string.
+     */
+    private validateAlias;
+    /**
+     * Normalizes an import item to extract name and optional alias.
+     */
+    private normalizeImportItem;
     /**
      * Adds a given type import statement to the imports list.
      */
-    addTypeImport({ items, from }: {
-        items: NonEmptyArray<Brands.TypeName>;
+    addTypeImport({ items, from, }: {
+        items: NonEmptyArray<Brands.TypeName | {
+            name: Brands.TypeName;
+            alias: string;
+        }>;
         from: Brands.ImportPaths;
     }): this;
     /**

package/dist/helpers/import-generator.class.js

@@ -50,6 +50,18 @@ const Brands = __importStar(require("./branded.types"));
 //    */
 //   packageName?: Brands.PackageName
 // }
+/**
+ * Type guard to check if an import item has an alias.
+ */
+function isImportItemWithAlias(item) {
+    return typeof item === 'object' && 'name' in item && 'alias' in item && typeof item.alias === 'string';
+}
+/**
+ * Type guard to check if a type import item has an alias.
+ */
+function isTypeImportItemWithAlias(item) {
+    return typeof item === 'object' && 'name' in item && 'alias' in item && typeof item.alias === 'string';
+}
 /**
  * A utility component that lets you generate TypeScript import statements
  * and makes sure every import is only added once.
@@ -57,6 +69,7 @@ const Brands = __importStar(require("./branded.types"));
 class ImportGenerator {
     /**
      * Lists of values and types we import from a given path indexed by the path.
+     * Maps a unique key (name::alias) to the import details.
      */
     #imports = {};
     /**
@@ -75,19 +88,25 @@ class ImportGenerator {
     /**
      * Convenience method to add a single import statement.
      */
-    add({ name, location }) {
-        return this.addImport({ items: [name], from: location });
+    add({ name, location, alias, }) {
+        if (alias !== undefined) {
+            this.validateAlias(alias);
+        }
+        return this.addImport({ items: [alias ? { name, alias } : name], from: location });
     }
     /**
      * Convenience method to add a single import statement.
      */
-    addType({ name, location }) {
-        return this.addTypeImport({ items: [name], from: location });
+    addType({ name, location, alias, }) {
+        if (alias !== undefined) {
+            this.validateAlias(alias);
+        }
+        return this.addTypeImport({ items: [alias ? { name, alias } : name], from: location });
     }
     /**
      * Adds a given import statement to the imports list.
      */
-    addImport({ items, from: fromSource, }) {
+    addImport({ items, from: fromSource }) {
         if (items.length === 0) {
             throw new Error(`You cannot add an import statement without any items from ${fromSource}.`);
         }
@@ -98,24 +117,57 @@ class ImportGenerator {
         }
         const resolvedPath = ImportGenerator.getRelativePath({ from: this.#path, to: from });
         if (!this.#imports[resolvedPath]) {
-            this.#imports[resolvedPath] = { types: new Set(), nonTypes: new Set() };
+            this.#imports[resolvedPath] = { types: new Map(), nonTypes: new Map() };
         }
         items.forEach((item) => {
-            if (Brands.isAnnotatedTypeName(item)) {
-                this.#imports[resolvedPath].types.add(item.typeName);
+            const { name, alias } = this.normalizeImportItem(item);
+            const importName = Brands.isAnnotatedTypeName(name) ? name.typeName : name;
+            const key = this.makeImportKey(importName, alias);
+            if (Brands.isAnnotatedTypeName(name)) {
+                this.#imports[resolvedPath].types.set(key, { name: name.typeName, alias });
             }
             else {
-                this.#imports[resolvedPath].nonTypes.add(item);
+                this.#imports[resolvedPath].nonTypes.set(key, { name, alias });
             }
         });
         return this;
     }
+    /**
+     * Creates a unique key for an import based on name and alias.
+     */
+    makeImportKey(name, alias) {
+        return alias ? `${name}::${alias}` : name;
+    }
+    /**
+     * Validates that an alias is not an empty string.
+     */
+    validateAlias(alias) {
+        if (alias.trim() === '') {
+            throw new Error('Import alias cannot be an empty string');
+        }
+    }
+    /**
+     * Normalizes an import item to extract name and optional alias.
+     */
+    normalizeImportItem(item) {
+        if (isImportItemWithAlias(item)) {
+            this.validateAlias(item.alias);
+            return { name: item.name, alias: item.alias };
+        }
+        return { name: item, alias: undefined };
+    }
     /**
      * Adds a given type import statement to the imports list.
      */
-    addTypeImport({ items, from }) {
+    addTypeImport({ items, from, }) {
         return this.addImport({
-            items: items.map((i) => Brands.toAnnotatedTypeName(i)),
+            items: items.map((i) => {
+                if (isTypeImportItemWithAlias(i)) {
+                    this.validateAlias(i.alias);
+                    return { name: Brands.toAnnotatedTypeName(i.name), alias: i.alias };
+                }
+                return Brands.toAnnotatedTypeName(i);
+            }),
             from,
         });
     }
@@ -140,9 +192,13 @@ class ImportGenerator {
         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 nonTypes = Array.from(items.nonTypes.values())
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map(({ name, alias }) => (alias ? `${name} as ${alias}` : name));
             const nonTypesImportStatement = nonTypes.length > 0 ? `import { ${nonTypes.join(', ')} } from '${path}'\n` : '';
-            const types = Array.from(items.types).sort((a, b) => a.localeCompare(b));
+            const types = Array.from(items.types.values())
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map(({ name, alias }) => (alias ? `${name} as ${alias}` : name));
             const typesImportStatement = types.length > 0 ? `import type { ${types.join(', ')} } from '${path}'` : '';
             return `${nonTypesImportStatement}${typesImportStatement}`;
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Core package that orchestrates the code generation of a PXL project",
   "main": "./dist/index.js",
   "module": "./dist/index.js",