@postxl/generator 1.1.0 → 1.2.0

package/dist/helpers/branded.types.d.ts

@@ -31,18 +31,18 @@
  * - `ImportPaths`: FilePath | PackageName
  */
 import z from 'zod';
-declare const zGeneratorInterfaceId: z.ZodBranded<z.ZodString, "PXL.GeneratorInterfaceId">;
+declare const zGeneratorInterfaceId: z.core.$ZodBranded<z.ZodString, "PXL.GeneratorInterfaceId", "out">;
 /**
  * A generator interface id that is used identify what interface a generator implements.
  */
 export type GeneratorInterfaceId = z.infer<typeof zGeneratorInterfaceId>;
-export declare const toGeneratorInterfaceId: (input: string) => string & z.BRAND<"PXL.GeneratorInterfaceId">;
-declare const zTypeName: z.ZodBranded<z.ZodBranded<z.ZodString, "PXL.TypeName">, "PXL.Importable">;
+export declare const toGeneratorInterfaceId: (input: string) => string & z.core.$brand<"PXL.GeneratorInterfaceId">;
+declare const zTypeName: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.TypeName", "out">, "PXL.Importable", "out">;
 /**
  * A type name that is used to refer to a type in the generated code.
  */
 export type TypeName = z.infer<typeof zTypeName>;
-export declare const toTypeName: (input: string) => string & z.BRAND<"PXL.TypeName"> & z.BRAND<"PXL.Importable">;
+export declare const toTypeName: (input: string) => string & z.core.$brand<"PXL.TypeName"> & z.core.$brand<"PXL.Importable">;
 /**
  * A TypeName that is annotated with the kind of the type.
  * Note: This is used when distinguishing between kinds is required at runtime.
@@ -59,80 +59,80 @@ export declare const toAnnotatedTypeName: (name: TypeName) => AnnotatedTypeName;
  * Type guard to check if a given type is an AnnotatedTypeName.
  */
 export declare const isAnnotatedTypeName: (t: string | AnnotatedTypeName) => t is AnnotatedTypeName;
-declare const zFunctionName: z.ZodBranded<z.ZodBranded<z.ZodString, "PXL.FunctionName">, "PXL.Importable">;
+declare const zFunctionName: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.FunctionName", "out">, "PXL.Importable", "out">;
 /**
  * A function name that is used to refer to a function in the generated code.
  */
 export type FunctionName = z.infer<typeof zFunctionName>;
-export declare const toFunctionName: (input: string) => string & z.BRAND<"PXL.FunctionName"> & z.BRAND<"PXL.Importable">;
-declare const zVariableName: z.ZodBranded<z.ZodBranded<z.ZodString, "PXL.VariableName">, "PXL.Importable">;
+export declare const toFunctionName: (input: string) => string & z.core.$brand<"PXL.FunctionName"> & z.core.$brand<"PXL.Importable">;
+declare const zVariableName: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.VariableName", "out">, "PXL.Importable", "out">;
 /**
  * A variable name that is used to refer to a variable in the generated code.
  */
 export type VariableName = z.infer<typeof zVariableName>;
-export declare const toVariableName: (input: string) => string & z.BRAND<"PXL.VariableName"> & z.BRAND<"PXL.Importable">;
-declare const zPostXlPackageName: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.PackageName">;
+export declare const toVariableName: (input: string) => string & z.core.$brand<"PXL.VariableName"> & z.core.$brand<"PXL.Importable">;
+declare const zPostXlPackageName: z.core.$ZodBranded<z.ZodString, "PXL.PackageName", "out">;
 /**
  * A package name that is used to refer to a package in the generated code.
  */
-export declare const toPostXlPackageName: (input: string) => string & z.BRAND<"PXL.PackageName">;
-export declare const toPackageName: (input: string) => string & z.BRAND<"PXL.PackageName">;
+export declare const toPostXlPackageName: (input: string) => string & z.core.$brand<"PXL.PackageName">;
+export declare const toPackageName: (input: string) => string & z.core.$brand<"PXL.PackageName">;
 /**
  * A package name that is used to refer to a package name that is provided via
  * in package.json or is a NodeJS module.
  * E.g. "fs", "random", "@nestjs/common".
  */
 export type PackageName = z.infer<typeof zPostXlPackageName>;
-declare const zClassName: z.ZodBranded<z.ZodBranded<z.ZodString, "PXL.ClassName">, "PXL.Importable">;
+declare const zClassName: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.ClassName", "out">, "PXL.Importable", "out">;
 /**
  * A class name that is used to refer to a class in the generated code.
  */
 export type ClassName = z.infer<typeof zClassName>;
-export declare const toClassName: (input: string) => string & z.BRAND<"PXL.ClassName"> & z.BRAND<"PXL.Importable">;
-declare const zConstantName: z.ZodBranded<z.ZodBranded<z.ZodString, "PXL.ConstantName">, "PXL.Importable">;
+export declare const toClassName: (input: string) => string & z.core.$brand<"PXL.ClassName"> & z.core.$brand<"PXL.Importable">;
+declare const zConstantName: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.ConstantName", "out">, "PXL.Importable", "out">;
 /**
  * A constant name that is used to refer to a constant in the generated code.
  */
 export type ConstantName = z.infer<typeof zConstantName>;
-export declare const toConstantName: (input: string) => string & z.BRAND<"PXL.ConstantName"> & z.BRAND<"PXL.Importable">;
-declare const zConstantValue: z.ZodBranded<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "PXL.ConstantValue">;
+export declare const toConstantName: (input: string) => string & z.core.$brand<"PXL.ConstantName"> & z.core.$brand<"PXL.Importable">;
+declare const zConstantValue: z.core.$ZodBranded<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "PXL.ConstantValue", "out">;
 /**
  * A constant value that is used in the generated code.
  */
 export type ConstantValue = z.infer<typeof zConstantValue>;
-export declare const toConstantValue: (input: string | number | boolean | null) => (string | number | boolean | null) & z.BRAND<"PXL.ConstantValue">;
-declare const zDiscriminantValue: z.ZodBranded<z.ZodString, "PXL.DiscriminantValue">;
+export declare const toConstantValue: (input: string | number | boolean | null) => (string & z.core.$brand<"PXL.ConstantValue">) | (number & z.core.$brand<"PXL.ConstantValue">) | (false & z.core.$brand<"PXL.ConstantValue">) | (true & z.core.$brand<"PXL.ConstantValue">);
+declare const zDiscriminantValue: z.core.$ZodBranded<z.ZodString, "PXL.DiscriminantValue", "out">;
 /**
  * A discriminant value, used to discriminate union types.
  */
 export type DiscriminantValue = z.infer<typeof zDiscriminantValue>;
-export declare const toDiscriminantValue: (input: string) => string & z.BRAND<"PXL.DiscriminantValue">;
-declare const zFileName: z.ZodBranded<z.ZodString, "PXL.FileName">;
+export declare const toDiscriminantValue: (input: string) => string & z.core.$brand<"PXL.DiscriminantValue">;
+declare const zFileName: z.core.$ZodBranded<z.ZodString, "PXL.FileName", "out">;
 /**
  * A file name that is used to refer to a file in the generated code.
  */
 export type FileName = z.infer<typeof zFileName>;
-export declare const toFileName: (input: string) => string & z.BRAND<"PXL.FileName">;
-declare const zFolderName: z.ZodBranded<z.ZodString, "PXL.FolderName">;
+export declare const toFileName: (input: string) => string & z.core.$brand<"PXL.FileName">;
+declare const zFolderName: z.core.$ZodBranded<z.ZodString, "PXL.FolderName", "out">;
 /**
  * A folder name that is used to refer to a folder in the generated code.
  */
 export type FolderName = z.infer<typeof zFolderName>;
-export declare const toFolderName: (input: string) => string & z.BRAND<"PXL.FolderName">;
-declare const zFilePath: z.ZodBranded<z.ZodString, "PXL.FilePath">;
+export declare const toFolderName: (input: string) => string & z.core.$brand<"PXL.FolderName">;
+declare const zFilePath: z.core.$ZodBranded<z.ZodString, "PXL.FilePath", "out">;
 /**
  * A file path that is used to refer to a file in the generated code.
  */
 export type FilePath = z.infer<typeof zFilePath>;
-export declare const toFilePath: (input: string) => string & z.BRAND<"PXL.FilePath">;
-declare const zBackendModuleName: z.ZodBranded<z.ZodString, "PXL.BackendModuleName">;
+export declare const toFilePath: (input: string) => string & z.core.$brand<"PXL.FilePath">;
+declare const zBackendModuleName: z.core.$ZodBranded<z.ZodString, "PXL.BackendModuleName", "out">;
 /**
  * A backend module name that is used to refer to a module in the backend.
  * E.g. `@actions`.
  */
 export type BackendModuleName = z.infer<typeof zBackendModuleName>;
-export declare const toBackendModuleName: (input: string) => string & z.BRAND<"PXL.BackendModuleName">;
-declare const zBackendModuleLocation: z.ZodBranded<z.ZodString, "PXL.BackendModuleLocation">;
+export declare const toBackendModuleName: (input: string) => string & z.core.$brand<"PXL.BackendModuleName">;
+declare const zBackendModuleLocation: z.core.$ZodBranded<z.ZodString, "PXL.BackendModuleLocation", "out">;
 /**
  * A module location is a reference to a file in a locale backend module.
  * E.g. `@actions/actions.types`.
@@ -143,7 +143,7 @@ declare const zBackendModuleLocation: z.ZodBranded<z.ZodString, "PXL.BackendModu
  * Therefore, we need to reference the actual file together with the package name.
  */
 export type BackendModuleLocation = z.infer<typeof zBackendModuleLocation>;
-export declare const toBackendModuleLocation: (input: `@${string}`) => string & z.BRAND<"PXL.BackendModuleLocation">;
+export declare const toBackendModuleLocation: (input: `@${string}`) => string & z.core.$brand<"PXL.BackendModuleLocation">;
 export type ImportableTypes = TypeName | FunctionName | ClassName | ConstantName | AnnotatedTypeName;
 export type ImportPaths = FilePath | PackageName | BackendModuleLocation;
 export {};

package/dist/helpers/branded.types.js

@@ -64,7 +64,9 @@ const toVariableName = (input) => zVariableName.parse(input);
 exports.toVariableName = toVariableName;
 const zPostXlPackageName = zod_1.default
     .string()
-    .refine((name) => name.startsWith('@postxl/'), (name) => ({ message: `Package name must start with "@postxl/", got "${name}"!` }))
+    .refine((name) => name.startsWith('@postxl/'), {
+    error: (issue) => `Package name must start with "@postxl/", got "${issue.input}"!`,
+})
     .brand('PXL.PackageName');
 /**
  * A package name that is used to refer to a package in the generated code.

package/dist/utils/checksum.d.ts

@@ -1,5 +1,5 @@
 import z from 'zod';
-export declare const zChecksum: z.ZodBranded<z.ZodString, "PXL.Checksum">;
+export declare const zChecksum: z.core.$ZodBranded<z.ZodString, "PXL.Checksum", "out">;
 /**
  * Branded Id type that should be used to identify checksum strings.
  */

package/dist/utils/lockfile.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { VirtualFileSystem } from './vfs.class';
-declare const zLockFile: z.ZodEffects<z.ZodRecord<z.ZodBranded<z.ZodString, "PXL.PosixPath">, z.ZodBranded<z.ZodString, "PXL.Checksum">>, Map<string & z.BRAND<"PXL.PosixPath">, string & z.BRAND<"PXL.Checksum">>, Record<string, string>>;
+declare const zLockFile: z.ZodPipe<z.ZodRecord<z.core.$ZodBranded<z.ZodString, "PXL.PosixPath", "out">, z.core.$ZodBranded<z.ZodString, "PXL.Checksum", "out">>, z.ZodTransform<Map<string & z.core.$brand<"PXL.PosixPath">, string & z.core.$brand<"PXL.Checksum">>, Record<string & z.core.$brand<"PXL.PosixPath">, string & z.core.$brand<"PXL.Checksum">>>>;
 type LockFile = z.infer<typeof zLockFile>;
 export declare function writeLockFile(lockFilePath: string, vfs: VirtualFileSystem): Promise<void>;
 export declare function readLockFile(lockFilePath: string): Promise<LockFile | undefined>;

package/dist/utils/path.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-export declare const zPosixPath: z.ZodBranded<z.ZodString, "PXL.PosixPath">;
+export declare const zPosixPath: z.core.$ZodBranded<z.ZodString, "PXL.PosixPath", "out">;
 /**
  * A path string that has been normalized to use the unix path separator.
  */
 export type PosixPath = z.infer<typeof zPosixPath>;
-export declare const POSIX_ROOT: string & z.BRAND<"PXL.PosixPath">;
+export declare const POSIX_ROOT: string & z.core.$brand<"PXL.PosixPath">;
 /**
  * Normalizes a unix or Windows path to use the unix path separator. Additionally,
  * it normalizes the path so that every path is considered absolute.

package/dist/utils/string-functions.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-export declare const zTypescript: z.ZodBranded<z.ZodString, "PXL.Typescript">;
+export declare const zTypescript: z.core.$ZodBranded<z.ZodString, "PXL.Typescript", "out">;
 export type Typescript = z.infer<typeof zTypescript>;
-export declare function ts(input: string): string & z.BRAND<"PXL.Typescript">;
+export declare function ts(input: string): string & z.core.$brand<"PXL.Typescript">;
 export declare function trimLines(input: string): string;
 /**
  * Removes leading and trailing newlines from the input string.

package/dist/utils/vfs.class.js

@@ -34,8 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VirtualFileSystem = void 0;
-const fs = __importStar(require("fs/promises"));
 const minimatch_1 = require("minimatch");
+const fs = __importStar(require("node:fs/promises"));
 const utils_1 = require("@postxl/utils");
 const fs_utils_1 = require("./fs-utils");
 const Path = __importStar(require("./path"));
@@ -186,33 +186,54 @@ class VirtualFileSystem {
         this.#files.set(basePath, content.unwrap());
     }
     async #readDirectory({ diskPath, targetPath, filter, recursive, }) {
-        const entries = await utils_1.Result.fromPromise(() => fs.readdir(diskPath, { withFileTypes: true }), () => `Folder "${diskPath}" does not exist`);
-        if (entries.isErr()) {
-            throw new Error(entries.unwrapErr());
-        }
-        for (const entry of entries.unwrap()) {
+        const entries = await this.#readDirEntries(diskPath);
+        for (const entry of entries) {
             const entryName = Path.normalize(entry.name);
             const entryPath = Path.join(diskPath, entryName);
             const relativePath = Path.join(targetPath, entryName);
-            if (filter && !filter(relativePath)) {
+            if (this.#shouldSkipEntry(relativePath, filter)) {
                 continue;
             }
             if (recursive && entry.isDirectory()) {
-                await this.#readDirectory({ diskPath: entryPath, targetPath: relativePath, filter, recursive });
+                await this.#processDirectory(entryPath, relativePath, filter, recursive);
             }
             else if (entry.isFile()) {
-                // Skip files that don't match the pattern
-                if (!this.matchesPattern(relativePath)) {
-                    continue;
-                }
-                const content = await (0, fs_utils_1.readFile)(entryPath);
-                if (content.isErr()) {
-                    throw content.unwrapErr();
-                }
-                this.#files.set(relativePath, content.unwrap());
+                await this.#processFile(entryPath, relativePath);
             }
         }
     }
+    async #readDirEntries(diskPath) {
+        const entries = await utils_1.Result.fromPromise(() => fs.readdir(diskPath, { withFileTypes: true }), () => `Folder "${diskPath}" does not exist`);
+        if (entries.isErr()) {
+            throw new Error(entries.unwrapErr());
+        }
+        return entries.unwrap();
+    }
+    #shouldSkipEntry(relativePath, filter) {
+        return filter ? !filter(relativePath) : false;
+    }
+    async #processDirectory(diskPath, relativePath, filter, recursive) {
+        await this.#readDirectory({ diskPath, targetPath: relativePath, filter, recursive });
+    }
+    async #processFile(entryPath, relativePath) {
+        if (!this.matchesPattern(relativePath)) {
+            return;
+        }
+        const content = await (0, fs_utils_1.readFile)(entryPath);
+        if (content.isErr()) {
+            throw content.unwrapErr();
+        }
+        const finalPath = this.#resolveFinalPath(relativePath);
+        this.#files.set(finalPath, content.unwrap());
+    }
+    #resolveFinalPath(relativePath) {
+        // Handle .gitignore.template files: rename them to .gitignore
+        // This is necessary because npm/pnpm exclude .gitignore files from published packages
+        if (relativePath.endsWith('.gitignore.template')) {
+            return relativePath.replace(/\.gitignore\.template$/, '.gitignore');
+        }
+        return relativePath;
+    }
     /**
      * Transforms the content of all files using the provided function.
      * An optional filter function can be provided to select specific files.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Core package that orchestrates the code generation of a PXL project",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -46,8 +46,8 @@
     "jszip": "3.10.1",
     "minimatch": "^10.1.1",
     "p-limit": "3.1.0",
-    "@postxl/schema": "^1.1.0",
-    "@postxl/utils": "^1.1.0"
+    "@postxl/schema": "^1.2.0",
+    "@postxl/utils": "^1.2.0"
   },
   "devDependencies": {
     "@types/diff": "8.0.0"