@postxl/generator 0.44.3 → 0.44.5

package/dist/lib/imports.d.ts

@@ -11,7 +11,7 @@ import * as Types from './schema/types';
  * }
  * ```
  */
-export type BulkImportDefinition = Record<Types.Path, Types.ImportableTypes[] | Types.ImportableTypes>;
+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.
@@ -31,7 +31,7 @@ export declare class ImportsGenerator {
     /**
      * Creates a new instance of the imports generator.
      */
-    static from(path: Types.Path): ImportsGenerator;
+    static from(path: Types.FilePath): ImportsGenerator;
     /**
      * Adds a given import statement to the imports list.
      *
@@ -39,7 +39,16 @@ export declare class ImportsGenerator {
      */
     addImport({ items, from }: {
         items: Types.ImportableTypes[];
-        from: Types.Path;
+        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.

package/dist/lib/imports.js

@@ -1,6 +1,30 @@
 "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
@@ -32,11 +56,26 @@ class ImportsGenerator {
         }
         const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
         if (!this._imports[resolvedPath]) {
-            this._imports[resolvedPath] = new Set();
+            this._imports[resolvedPath] = { types: new Set(), nonTypes: new Set() };
         }
-        items.forEach((item) => this._imports[resolvedPath].add(item));
+        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.
      *
@@ -60,20 +99,13 @@ class ImportsGenerator {
      */
     generate() {
         const statements = Object.entries(this._imports)
-            .sort(([a], [b]) => {
-            // //in case a or b start with "@", they will be sorted first
-            // if (a.startsWith('@') && !b.startsWith('@')) {
-            //   return -1
-            // }
-            // if (!a.startsWith('@') && b.startsWith('@')) {
-            //   return 1
-            // }
-            return a.localeCompare(b);
-        })
+            .sort(([a], [b]) => a.localeCompare(b))
             .map(([path, items]) => {
-            const alphabeticallySortedItems = Array.from(items).sort((a, b) => a.localeCompare(b));
-            // NOTE: You cannot remove imports and we check that there's at least one imported item for every path.
-            return `import { ${alphabeticallySortedItems.join(', ')} } from '${path}'`;
+            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;