@vidavidorra/create-project 3.0.224 → 3.0.225

package/dist/cli.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import { input, confirm } from '@inquirer/prompts';
+import z from 'zod';
 import { createProject, options as schema } from './index.js';
 function validate(value, option) {
-    const validation = schema.shape[option].safeParse(value);
-    return validation.success
-        ? true
-        : validation.error.errors.map(({ message }) => message).join('\n> ');
+    const { success, error } = schema.shape[option].safeParse(value);
+    return success ? true : z.prettifyError(error);
 }
 const project = await input({
     message: 'Project name:',
@@ -22,7 +21,7 @@ const options = {
     }),
     public: await confirm({
         message: 'Make package public?',
-        default: schema.shape.public._def.defaultValue(),
+        default: schema.shape.public.def.defaultValue,
     }),
     description: await input({
         message: 'Description:',
@@ -50,7 +49,7 @@ if (options.typescript) {
 }
 if (options.testing) {
     options.reportCodeCoverage = await confirm({
-        message: 'Report code coverate to Codecov?',
+        message: 'Report code coverage to Codecov?',
     });
 }
 options.path = await input({

package/dist/content/ci-cd.d.ts

@@ -6,237 +6,39 @@ declare const schema: z.ZodObject<{
     on: z.ZodObject<{
         push: z.ZodObject<{
             branches: z.ZodTuple<[z.ZodLiteral<"main">, z.ZodLiteral<"beta">, z.ZodLiteral<"renovate/**">], null>;
-        }, "strip", z.ZodTypeAny, {
-            branches: ["main", "beta", "renovate/**"];
-        }, {
-            branches: ["main", "beta", "renovate/**"];
-        }>;
+        }, z.core.$strip>;
         pull_request: z.ZodNull;
-    }, "strip", z.ZodTypeAny, {
-        push: {
-            branches: ["main", "beta", "renovate/**"];
-        };
-        pull_request: null;
-    }, {
-        push: {
-            branches: ["main", "beta", "renovate/**"];
-        };
-        pull_request: null;
-    }>;
+    }, z.core.$strip>;
     jobs: z.ZodObject<{
         'lint-commit-messages': z.ZodObject<{
             uses: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            uses: string;
-        }, {
-            uses: string;
-        }>;
+        }, z.core.$strip>;
         lint: z.ZodObject<{
             uses: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            uses: string;
-        }, {
-            uses: string;
-        }>;
+        }, z.core.$strip>;
         build: z.ZodObject<{
             uses: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            uses: string;
-        }, {
-            uses: string;
-        }>;
+        }, z.core.$strip>;
         test: z.ZodObject<{
             uses: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            uses: string;
-        }, {
-            uses: string;
-        }>;
+        }, z.core.$strip>;
         'code-coverage': z.ZodObject<{
             uses: z.ZodString;
-        } & {
             needs: z.ZodTuple<[z.ZodLiteral<"lint">, z.ZodLiteral<"build">, z.ZodLiteral<"test">], null>;
             secrets: z.ZodObject<{
                 codecovToken: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                codecovToken: string;
-            }, {
-                codecovToken: string;
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            uses: string;
-            needs: ["lint", "build", "test"];
-            secrets: {
-                codecovToken: string;
-            };
-        }, {
-            uses: string;
-            needs: ["lint", "build", "test"];
-            secrets: {
-                codecovToken: string;
-            };
-        }>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
         release: z.ZodObject<{
             uses: z.ZodString;
-        } & {
-            needs: z.ZodArray<z.ZodUnion<[z.ZodLiteral<"lint-commit-messages">, z.ZodLiteral<"lint">, z.ZodLiteral<"build">, z.ZodLiteral<"test">, z.ZodLiteral<"code-coverage">]>, "many">;
+            needs: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"lint-commit-messages">, z.ZodLiteral<"lint">, z.ZodLiteral<"build">, z.ZodLiteral<"test">, z.ZodLiteral<"code-coverage">]>>;
             secrets: z.ZodObject<{
                 privateKey: z.ZodString;
                 npmToken: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                privateKey: string;
-                npmToken: string;
-            }, {
-                privateKey: string;
-                npmToken: string;
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            uses: string;
-            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
-            secrets: {
-                privateKey: string;
-                npmToken: string;
-            };
-        }, {
-            uses: string;
-            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
-            secrets: {
-                privateKey: string;
-                npmToken: string;
-            };
-        }>;
-    }, "strict", z.ZodTypeAny, {
-        'lint-commit-messages': {
-            uses: string;
-        };
-        lint: {
-            uses: string;
-        };
-        build: {
-            uses: string;
-        };
-        test: {
-            uses: string;
-        };
-        'code-coverage': {
-            uses: string;
-            needs: ["lint", "build", "test"];
-            secrets: {
-                codecovToken: string;
-            };
-        };
-        release: {
-            uses: string;
-            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
-            secrets: {
-                privateKey: string;
-                npmToken: string;
-            };
-        };
-    }, {
-        'lint-commit-messages': {
-            uses: string;
-        };
-        lint: {
-            uses: string;
-        };
-        build: {
-            uses: string;
-        };
-        test: {
-            uses: string;
-        };
-        'code-coverage': {
-            uses: string;
-            needs: ["lint", "build", "test"];
-            secrets: {
-                codecovToken: string;
-            };
-        };
-        release: {
-            uses: string;
-            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
-            secrets: {
-                privateKey: string;
-                npmToken: string;
-            };
-        };
-    }>;
-}, "strict", z.ZodTypeAny, {
-    name: "CI/CD";
-    on: {
-        push: {
-            branches: ["main", "beta", "renovate/**"];
-        };
-        pull_request: null;
-    };
-    jobs: {
-        'lint-commit-messages': {
-            uses: string;
-        };
-        lint: {
-            uses: string;
-        };
-        build: {
-            uses: string;
-        };
-        test: {
-            uses: string;
-        };
-        'code-coverage': {
-            uses: string;
-            needs: ["lint", "build", "test"];
-            secrets: {
-                codecovToken: string;
-            };
-        };
-        release: {
-            uses: string;
-            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
-            secrets: {
-                privateKey: string;
-                npmToken: string;
-            };
-        };
-    };
-}, {
-    name: "CI/CD";
-    on: {
-        push: {
-            branches: ["main", "beta", "renovate/**"];
-        };
-        pull_request: null;
-    };
-    jobs: {
-        'lint-commit-messages': {
-            uses: string;
-        };
-        lint: {
-            uses: string;
-        };
-        build: {
-            uses: string;
-        };
-        test: {
-            uses: string;
-        };
-        'code-coverage': {
-            uses: string;
-            needs: ["lint", "build", "test"];
-            secrets: {
-                codecovToken: string;
-            };
-        };
-        release: {
-            uses: string;
-            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
-            secrets: {
-                privateKey: string;
-                npmToken: string;
-            };
-        };
-    };
-}>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 type Yaml = z.infer<typeof schema>;
 declare class CiCd extends File {
     protected readonly _yaml: Yaml;

package/dist/content/ci-cd.js

@@ -7,8 +7,7 @@ const job = (action) => z.object({
         .startsWith(`vidavidorra/.github/.github/workflows/${action}@`)
         .regex(/.*?@[\da-f]{6,64}$/),
 });
-const schema = z
-    .object({
+const schema = z.strictObject({
     name: z.literal('CI/CD'),
     on: z.object({
         push: z.object({
@@ -21,8 +20,7 @@ const schema = z
         // eslint-disable-next-line @typescript-eslint/naming-convention
         pull_request: z.null(),
     }),
-    jobs: z
-        .object({
+    jobs: z.strictObject({
         'lint-commit-messages': job('lint-commit-messages.yml'),
         lint: job('node-lint.yml'),
         build: job('node-build.yml'),
@@ -50,10 +48,8 @@ const schema = z
                 npmToken: z.string(),
             }),
         }),
-    })
-        .strict(),
-})
-    .strict();
+    }),
+});
 class CiCd extends File {
     _yaml;
     constructor(path, options) {

package/dist/content/file.d.ts

@@ -13,7 +13,6 @@ declare class File {
     get options(): {
         project: string;
         package: string;
-        path: string;
         public: boolean;
         description: string;
         author: string;
@@ -22,6 +21,7 @@ declare class File {
         reportCodeCoverage: boolean;
         githubOwner: string;
         githubRepository: string;
+        path: string;
         dryRun: boolean;
     } & FileOptions;
     get content(): string;

package/dist/content/package.d.ts

@@ -5,26 +5,16 @@ declare const schema: z.ZodObject<{
     name: z.ZodString;
     version: z.ZodString;
     description: z.ZodString;
-    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
     private: z.ZodOptional<z.ZodBoolean>;
-    homepage: z.ZodString;
+    homepage: z.ZodURL;
     bugs: z.ZodObject<{
-        url: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        url: string;
-    }, {
-        url: string;
-    }>;
+        url: z.ZodURL;
+    }, z.core.$strict>;
     repository: z.ZodObject<{
         type: z.ZodLiteral<"git">;
-        url: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        type: "git";
-        url: string;
-    }, {
-        type: "git";
-        url: string;
-    }>;
+        url: z.ZodURL;
+    }, z.core.$strict>;
     license: z.ZodLiteral<"GPL-3.0-or-later">;
     author: z.ZodString;
     type: z.ZodLiteral<"module">;
@@ -40,25 +30,7 @@ declare const schema: z.ZodObject<{
         postinstall: z.ZodOptional<z.ZodString>;
         prepare: z.ZodLiteral<"husky .github/husky">;
         test: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        format: string;
-        lint: "npm run format:check && xo";
-        build: string;
-        test: string;
-        'format:check': string;
-        'lint:fix': "npm run format && xo --fix";
-        prepare: "husky .github/husky";
-        postinstall?: string | undefined;
-    }, {
-        format: string;
-        lint: "npm run format:check && xo";
-        build: string;
-        test: string;
-        'format:check': string;
-        'lint:fix': "npm run format && xo --fix";
-        prepare: "husky .github/husky";
-        postinstall?: string | undefined;
-    }>;
+    }, z.core.$strict>;
     commitlint: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     xo: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     prettier: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -69,122 +41,21 @@ declare const schema: z.ZodObject<{
     devDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
     engines: z.ZodObject<{
         node: z.ZodLiteral<">=20">;
-    }, "strict", z.ZodTypeAny, {
-        node: ">=20";
-    }, {
-        node: ">=20";
-    }>;
+    }, z.core.$strict>;
     publishConfig: z.ZodOptional<z.ZodObject<{
         access: z.ZodLiteral<"public">;
-    }, "strict", z.ZodTypeAny, {
-        access: "public";
-    }, {
-        access: "public";
-    }>>;
+    }, z.core.$strict>>;
     overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strict", z.ZodTypeAny, {
-    type: "module";
-    description: string;
-    author: string;
-    name: string;
-    release: Record<string, unknown>;
-    version: string;
-    homepage: string;
-    bugs: {
-        url: string;
-    };
-    repository: {
-        type: "git";
-        url: string;
-    };
-    license: "GPL-3.0-or-later";
-    prettier: Record<string, unknown>;
-    scripts: {
-        format: string;
-        lint: "npm run format:check && xo";
-        build: string;
-        test: string;
-        'format:check': string;
-        'lint:fix': "npm run format && xo --fix";
-        prepare: "husky .github/husky";
-        postinstall?: string | undefined;
-    };
-    commitlint: Record<string, unknown>;
-    xo: Record<string, unknown>;
-    devDependencies: Record<string, string>;
-    engines: {
-        node: ">=20";
-    };
-    files?: ["./dist/**/!(*.test).{js,d.ts,cjs}", ...string[]] | undefined;
-    ava?: Record<string, unknown> | undefined;
-    keywords?: string[] | undefined;
-    private?: boolean | undefined;
-    exports?: string | undefined;
-    bin?: Record<string, unknown> | undefined;
-    c8?: Record<string, unknown> | undefined;
-    dependencies?: Record<string, string> | undefined;
-    publishConfig?: {
-        access: "public";
-    } | undefined;
-    overrides?: Record<string, unknown> | undefined;
-}, {
-    type: "module";
-    description: string;
-    author: string;
-    name: string;
-    release: Record<string, unknown>;
-    version: string;
-    homepage: string;
-    bugs: {
-        url: string;
-    };
-    repository: {
-        type: "git";
-        url: string;
-    };
-    license: "GPL-3.0-or-later";
-    prettier: Record<string, unknown>;
-    scripts: {
-        format: string;
-        lint: "npm run format:check && xo";
-        build: string;
-        test: string;
-        'format:check': string;
-        'lint:fix': "npm run format && xo --fix";
-        prepare: "husky .github/husky";
-        postinstall?: string | undefined;
-    };
-    commitlint: Record<string, unknown>;
-    xo: Record<string, unknown>;
-    devDependencies: Record<string, string>;
-    engines: {
-        node: ">=20";
-    };
-    files?: ["./dist/**/!(*.test).{js,d.ts,cjs}", ...string[]] | undefined;
-    ava?: Record<string, unknown> | undefined;
-    keywords?: string[] | undefined;
-    private?: boolean | undefined;
-    exports?: string | undefined;
-    bin?: Record<string, unknown> | undefined;
-    c8?: Record<string, unknown> | undefined;
-    dependencies?: Record<string, string> | undefined;
-    publishConfig?: {
-        access: "public";
-    } | undefined;
-    overrides?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strict>;
 type PackageJson = z.infer<typeof schema>;
 declare class Package extends File {
     protected readonly _fullPackage: Required<PackageJson>;
     protected readonly _package: PackageJson;
     constructor(path: string, options: Options);
     get package(): {
-        type: "module";
-        description: string;
-        author: string;
         name: string;
-        release: Record<string, unknown>;
         version: string;
+        description: string;
         homepage: string;
         bugs: {
             url: string;
@@ -194,29 +65,32 @@ declare class Package extends File {
             url: string;
         };
         license: "GPL-3.0-or-later";
-        prettier: Record<string, unknown>;
+        author: string;
+        type: "module";
         scripts: {
-            format: string;
-            lint: "npm run format:check && xo";
             build: string;
-            test: string;
+            format: string;
             'format:check': string;
+            lint: "npm run format:check && xo";
             'lint:fix': "npm run format && xo --fix";
             prepare: "husky .github/husky";
+            test: string;
             postinstall?: string | undefined;
         };
         commitlint: Record<string, unknown>;
         xo: Record<string, unknown>;
+        prettier: Record<string, unknown>;
+        release: Record<string, unknown>;
         devDependencies: Record<string, string>;
         engines: {
             node: ">=20";
         };
-        files?: ["./dist/**/!(*.test).{js,d.ts,cjs}", ...string[]] | undefined;
-        ava?: Record<string, unknown> | undefined;
         keywords?: string[] | undefined;
         private?: boolean | undefined;
         exports?: string | undefined;
         bin?: Record<string, unknown> | undefined;
+        files?: ["./dist/**/!(*.test).{js,d.ts,cjs}", ...string[]] | undefined;
+        ava?: Record<string, unknown> | undefined;
         c8?: Record<string, unknown> | undefined;
         dependencies?: Record<string, string> | undefined;
         publishConfig?: {

package/dist/content/package.js

@@ -1,36 +1,25 @@
 import { z } from 'zod';
 import { sortPackageJson } from 'sort-package-json';
 import { File } from './file.js';
-const schema = z
-    .object({
+const schema = z.strictObject({
     name: z.string().min(1),
     version: z.string().min('0.0.0'.length),
     description: z.string(),
     keywords: z.array(z.string()).min(1).optional(),
     private: z.boolean().optional(),
-    homepage: z.string().url(),
-    bugs: z
-        .object({
-        url: z.string().url(),
-    })
-        .strict(),
-    repository: z
-        .object({
-        type: z.literal('git'),
-        url: z.string().url(),
-    })
-        .strict(),
+    homepage: z.url(),
+    bugs: z.strictObject({ url: z.url() }),
+    repository: z.strictObject({ type: z.literal('git'), url: z.url() }),
     license: z.literal('GPL-3.0-or-later'),
     author: z.string().min(1),
     type: z.literal('module'),
     exports: z.string().min(1).optional(),
-    bin: z.record(z.unknown()).optional(),
+    bin: z.record(z.string(), z.unknown()).optional(),
     files: z
         .tuple([z.literal('./dist/**/!(*.test).{js,d.ts,cjs}')])
         .rest(z.string().min(1))
         .optional(),
-    scripts: z
-        .object({
+    scripts: z.strictObject({
         build: z.string().min(1),
         format: z.string().startsWith('prettier'),
         // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -41,24 +30,19 @@ const schema = z
         postinstall: z.string().optional(),
         prepare: z.literal('husky .github/husky'),
         test: z.string().min(1),
-    })
-        .strict(),
-    commitlint: z.record(z.unknown()),
-    xo: z.record(z.unknown()),
-    prettier: z.record(z.unknown()),
-    release: z.record(z.unknown()),
-    ava: z.record(z.unknown()).optional(),
-    c8: z.record(z.unknown()).optional(),
-    dependencies: z.record(z.string()).optional(),
-    devDependencies: z.record(z.string()),
-    engines: z.object({ node: z.literal('>=20') }).strict(),
-    publishConfig: z
-        .object({ access: z.literal('public') })
-        .strict()
-        .optional(),
-    overrides: z.record(z.unknown()).optional(),
-})
-    .strict();
+    }),
+    commitlint: z.record(z.string(), z.unknown()),
+    xo: z.record(z.string(), z.unknown()),
+    prettier: z.record(z.string(), z.unknown()),
+    release: z.record(z.string(), z.unknown()),
+    ava: z.record(z.string(), z.unknown()).optional(),
+    c8: z.record(z.string(), z.unknown()).optional(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    devDependencies: z.record(z.string(), z.string()),
+    engines: z.strictObject({ node: z.literal('>=20') }),
+    publishConfig: z.strictObject({ access: z.literal('public') }).optional(),
+    overrides: z.record(z.string(), z.unknown()).optional(),
+});
 class Package extends File {
     _fullPackage;
     _package;

package/dist/content/ts-config.d.ts

@@ -4,36 +4,17 @@ import { File } from './file.js';
 declare const schema: z.ZodObject<{
     compilerOptions: z.ZodObject<{
         allowJs: z.ZodOptional<z.ZodBoolean>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        allowJs: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        allowJs: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">>;
-    include: z.ZodArray<z.ZodString, "many">;
-}, "strict", z.ZodTypeAny, {
-    compilerOptions: {
-        allowJs?: boolean | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-    include: string[];
-}, {
-    compilerOptions: {
-        allowJs?: boolean | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-    include: string[];
-}>;
+    }, z.core.$loose>;
+    include: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
 type TsConfigJson = z.infer<typeof schema>;
 declare class TsConfig extends File {
     protected readonly _tsConfig: TsConfigJson;
     constructor(path: string, options: Options);
     get tsConfig(): {
         compilerOptions: {
+            [x: string]: unknown;
             allowJs?: boolean | undefined;
-        } & {
-            [k: string]: unknown;
         };
         include: string[];
     };

package/dist/content/ts-config.js

@@ -1,15 +1,9 @@
 import { z } from 'zod';
 import { File } from './file.js';
-const schema = z
-    .object({
-    compilerOptions: z
-        .object({
-        allowJs: z.boolean().optional(),
-    })
-        .passthrough(),
+const schema = z.strictObject({
+    compilerOptions: z.looseObject({ allowJs: z.boolean().optional() }),
     include: z.array(z.string()).min(1),
-})
-    .strict();
+});
 class TsConfig extends File {
     _tsConfig;
     constructor(path, options) {

package/dist/options.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 declare const schema: z.ZodObject<{
     project: z.ZodString;
-    package: z.ZodEffects<z.ZodString, string, string>;
+    package: z.ZodString;
     public: z.ZodDefault<z.ZodBoolean>;
     description: z.ZodString;
     author: z.ZodString;
@@ -10,35 +10,9 @@ declare const schema: z.ZodObject<{
     reportCodeCoverage: z.ZodDefault<z.ZodBoolean>;
     githubOwner: z.ZodString;
     githubRepository: z.ZodString;
-    path: z.ZodEffects<z.ZodString, string, string>;
+    path: z.ZodString;
     dryRun: z.ZodDefault<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    project: string;
-    package: string;
-    path: string;
-    public: boolean;
-    description: string;
-    author: string;
-    typescript: boolean;
-    testing: boolean;
-    reportCodeCoverage: boolean;
-    githubOwner: string;
-    githubRepository: string;
-    dryRun: boolean;
-}, {
-    project: string;
-    package: string;
-    path: string;
-    description: string;
-    author: string;
-    typescript: boolean;
-    githubOwner: string;
-    githubRepository: string;
-    public?: boolean | undefined;
-    testing?: boolean | undefined;
-    reportCodeCoverage?: boolean | undefined;
-    dryRun?: boolean | undefined;
-}>;
+}, z.core.$strict>;
 type OptionsInput = z.input<typeof schema>;
 type Options = z.infer<typeof schema>;
 export { schema, schema as options, type Options, type OptionsInput };

package/dist/options.js

@@ -1,14 +1,17 @@
 import fs from 'node:fs';
 import { z } from 'zod';
 import validatePackageName from 'validate-npm-package-name';
-const schema = z
-    .object({
+const schema = z.strictObject({
     project: z.string().min(1),
-    package: z.string().superRefine((value, context) => {
-        const { validForNewPackages, errors, warnings } = validatePackageName(value);
+    package: z.string().check((context) => {
+        const { validForNewPackages, errors, warnings } = validatePackageName(context.value);
         if (!validForNewPackages) {
             for (const message of [...(errors ?? []), ...(warnings ?? [])]) {
-                context.addIssue({ code: z.ZodIssueCode.custom, message });
+                context.issues.push({
+                    code: 'custom',
+                    message,
+                    input: context.value,
+                });
             }
         }
     }),
@@ -23,30 +26,31 @@ const schema = z
     path: z
         .string()
         .min(1)
-        .superRefine((value, context) => {
-        const exists = fs.existsSync(value);
+        .check((context) => {
+        const exists = fs.existsSync(context.value);
         if (exists) {
-            if (!fs.statSync(value).isDirectory()) {
-                context.addIssue({
-                    code: z.ZodIssueCode.custom,
+            if (!fs.statSync(context.value).isDirectory()) {
+                context.issues.push({
+                    code: 'custom',
                     message: 'Expected an empty directory, received a file.',
+                    input: context.value,
                 });
                 return z.NEVER;
             }
-            const { files } = fs.statfsSync(value);
+            const { files } = fs.statfsSync(context.value);
             if (files !== 0) {
-                context.addIssue({
-                    code: z.ZodIssueCode.custom,
+                context.issues.push({
+                    code: 'custom',
                     message: [
                         'Expected an empty directory, received a directory with',
                         `${files} file${files === 1 ? '' : 's'}.`,
                     ].join(' '),
+                    input: context.value,
                 });
             }
         }
     }),
     dryRun: z.boolean().default(false),
-})
-    .strict();
+});
 export { schema, schema as options };
 //# sourceMappingURL=options.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidavidorra/create-project",
-  "version": "3.0.224",
+  "version": "3.0.225",
   "private": false,
   "description": "Interactively create a GitHub project",
   "keywords": [
@@ -206,7 +206,7 @@
     "typescript": "5.8.3",
     "validate-npm-package-name": "6.0.1",
     "yaml": "2.8.0",
-    "zod": "3.25.76"
+    "zod": "4.0.5"
   },
   "devDependencies": {
     "@ava/typescript": "6.0.0",