@tanstack/create-start 1.92.0

package/dist/modules/packageJson.mjs

@@ -0,0 +1,153 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { input } from "@inquirer/prompts";
+import { InvalidArgumentError, createOption } from "@commander-js/extra-typings";
+import { initHelpers } from "../utils/helpers/index.mjs";
+import { createModule } from "../module.mjs";
+import { validateProjectName } from "../utils/validateProjectName.mjs";
+import { createDebugger } from "../utils/debug.mjs";
+const debug = createDebugger("package-json");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const packageNameCliOption = createOption(
+  "--package-name <string>",
+  "The name to use in the package.json"
+).argParser((name) => {
+  const validation = validateProjectName(name);
+  if (!validation.valid) {
+    debug.error("Invalid package name", { name, validation });
+    throw new InvalidArgumentError(`The project name ${name} is invalid`);
+  }
+  debug.verbose("Validated package name", { name });
+  return name;
+});
+const dependencies = z.array(
+  z.object({
+    name: z.string(),
+    version: z.string()
+  })
+);
+const script = z.object({
+  name: z.string(),
+  script: z.string()
+});
+const schema = z.object({
+  type: z.enum(["new", "update"]),
+  name: z.string().optional(),
+  dependencies: dependencies.optional(),
+  devDependencies: dependencies.optional(),
+  scripts: z.array(script).optional()
+});
+export const packageJsonModule = createModule(schema).init((schema2) => schema2).prompt((schema2) => {
+  return schema2.transform(async (vals) => {
+    debug.verbose("Transforming prompt schema", vals);
+    if (vals.type === "new") {
+      const name = vals.name ? vals.name : await input({
+        message: "Enter the project name",
+        default: "tanstack-start",
+        validate: (name2) => {
+          const validation = validateProjectName(name2);
+          if (validation.valid) {
+            debug.verbose("Valid project name entered", { name: name2 });
+            return true;
+          }
+          debug.warn("Invalid project name entered", {
+            name: name2,
+            problems: validation.problems
+          });
+          return "Invalid project name: " + validation.problems[0];
+        }
+      });
+      return {
+        ...vals,
+        name
+      };
+    } else {
+      return vals;
+    }
+  });
+}).validateAndApply({
+  validate: async ({ cfg, targetPath }) => {
+    debug.verbose("Validating package.json", { cfg, targetPath });
+    const issues = [];
+    const _ = initHelpers(__dirname, targetPath);
+    const packageJsonExists = await _.targetFileExists("./package.json");
+    debug.verbose("Package.json exists check", { exists: packageJsonExists });
+    if (cfg.type === "new") {
+      if (packageJsonExists) {
+        debug.warn("Package.json already exists for new project");
+        issues.push("Package.json already exists");
+      }
+    } else {
+      if (!packageJsonExists) {
+        debug.warn("Package.json missing for update");
+        issues.push("Package.json doesn't exist to update");
+      }
+    }
+    return issues;
+  },
+  apply: async ({ cfg, targetPath }) => {
+    debug.verbose("Applying package.json changes", { cfg, targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    if (cfg.type === "new") {
+      const packageJson2 = {
+        name: cfg.name,
+        version: "0.0.0",
+        private: true,
+        type: "module"
+      };
+      debug.verbose("Creating new package.json", packageJson2);
+      await _.writeTargetfile(
+        "./package.json",
+        JSON.stringify(packageJson2, null, 2),
+        false
+      );
+    }
+    let packageJson = JSON.parse(await _.readTargetFile("./package.json"));
+    debug.verbose("Current package.json contents", packageJson);
+    const dependenciesRecord = createDepsRecord(cfg.dependencies ?? []);
+    const devDependenciesRecord = createDepsRecord(cfg.devDependencies ?? []);
+    const scriptsRecord = createScriptsRecord(cfg.scripts ?? []);
+    packageJson = {
+      ...packageJson,
+      scripts: {
+        ...packageJson.scripts,
+        ...scriptsRecord
+      },
+      dependencies: {
+        ...packageJson.dependencies,
+        ...dependenciesRecord
+      },
+      devDependencies: {
+        ...packageJson.devDependencies,
+        ...devDependenciesRecord
+      }
+    };
+    debug.verbose("Updated package.json contents", packageJson);
+    await _.writeTargetfile(
+      "./package.json",
+      JSON.stringify(packageJson, null, 2),
+      true
+    );
+  },
+  spinnerConfigFn: (cfg) => ({
+    success: `${cfg.type === "new" ? "Created" : "Updated"} package.json`,
+    error: `Failed to ${cfg.type === "new" ? "create" : "update"} package.json`,
+    inProgress: `${cfg.type === "new" ? "Creating" : "Updating"} package.json`
+  })
+});
+const createDepsRecord = (deps) => deps.reduce(
+  (acc, dep) => ({
+    ...acc,
+    [dep.name]: dep.version
+  }),
+  {}
+);
+const createScriptsRecord = (scripts) => scripts.reduce(
+  (acc, script2) => ({
+    ...acc,
+    [script2.name]: script2.script
+  }),
+  {}
+);

package/dist/modules/packageManager.d.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+export declare const packageManagerOption: import("@commander-js/extra-typings").Option<`--package-manager <${string}>`, undefined, undefined, "bun" | "pnpm" | "npm" | "yarn", false, undefined>;
+export declare const packageManagerModule: {
+    _baseSchema: z.ZodObject<{
+        packageManager: z.ZodOptional<z.ZodEnum<["bun", "pnpm", "npm", "yarn"]>>;
+        installDeps: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>;
+    _initSchema: z.ZodEffects<z.ZodObject<{
+        packageManager: z.ZodOptional<z.ZodEnum<["bun", "pnpm", "npm", "yarn"]>>;
+        installDeps: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>, {
+        packageManager: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>;
+    _promptSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        packageManager: z.ZodOptional<z.ZodEnum<["bun", "pnpm", "npm", "yarn"]>>;
+        installDeps: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>, {
+        packageManager: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>, {
+        installDeps: boolean;
+        packageManager: "bun" | "pnpm" | "npm" | "yarn";
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>;
+    _applyFn: ({ cfg, targetPath }: {
+        targetPath: string;
+        cfg: {
+            installDeps: boolean;
+            packageManager: "bun" | "pnpm" | "npm" | "yarn";
+        };
+    }) => Promise<void>;
+    _validateFn: ((opts: {
+        targetPath: string;
+        cfg: {
+            installDeps: boolean;
+            packageManager: "bun" | "pnpm" | "npm" | "yarn";
+        };
+    }) => Promise<Array<string>> | Array<string>) | undefined;
+    _spinnerConfigFn: ((cfg: {
+        installDeps: boolean;
+        packageManager: "bun" | "pnpm" | "npm" | "yarn";
+    }) => {
+        success: string;
+        error: string;
+        inProgress: string;
+    } | undefined) | undefined;
+    init(cfg: {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }): Promise<z.ParseReturnType<z.ZodEffects<z.ZodObject<{
+        packageManager: z.ZodOptional<z.ZodEnum<["bun", "pnpm", "npm", "yarn"]>>;
+        installDeps: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>, {
+        packageManager: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps: boolean | undefined;
+    }, {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }>>>;
+    initSafe(cfg: {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }): Promise<z.SafeParseReturnType<{
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        packageManager: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps: boolean | undefined;
+    }>>;
+    prompt(cfg: {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }): Promise<z.SafeParseReturnType<{
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        installDeps: boolean;
+        packageManager: "bun" | "pnpm" | "npm" | "yarn";
+    }>>;
+    validate(cfg: {
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }): Promise<z.SafeParseReturnType<{
+        packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+        installDeps?: boolean | undefined;
+    }, {
+        installDeps: boolean;
+        packageManager: "bun" | "pnpm" | "npm" | "yarn";
+    }>>;
+    apply({ cfg, targetPath, }: {
+        cfg: {
+            installDeps: boolean;
+            packageManager: "bun" | "pnpm" | "npm" | "yarn";
+        };
+        targetPath: string;
+    }): Promise<void>;
+    execute({ cfg, targetPath, type, applyingMessage, }: {
+        cfg: {
+            packageManager?: "bun" | "pnpm" | "npm" | "yarn" | undefined;
+            installDeps?: boolean | undefined;
+        };
+        targetPath: string;
+        type: "new-project" | "update";
+        applyingMessage?: string;
+    }): Promise<void>;
+};

package/dist/modules/packageManager.mjs

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { InvalidArgumentError, createOption } from "@commander-js/extra-typings";
+import { select } from "@inquirer/prompts";
+import { createModule } from "../module.mjs";
+import { SUPPORTED_PACKAGE_MANAGERS } from "../constants.mjs";
+import { getPackageManager } from "../utils/getPackageManager.mjs";
+import { install } from "../utils/runPackageManagerCommand.mjs";
+import { createDebugger } from "../utils/debug.mjs";
+const debug = createDebugger("packageManager");
+const schema = z.object({
+  packageManager: z.enum(SUPPORTED_PACKAGE_MANAGERS),
+  installDeps: z.boolean()
+});
+const DEFAULT_PACKAGE_MANAGER = "npm";
+const options = schema.shape.packageManager.options;
+export const packageManagerOption = createOption(
+  `--package-manager <${options.join("|")}>`,
+  `use this Package Manager (${options.join(", ")})`
+).argParser((value) => {
+  if (!options.includes(value)) {
+    debug.error("Invalid package manager provided", { value, allowed: options });
+    throw new InvalidArgumentError(
+      `Invalid Package Manager: ${value}. Only the following are allowed: ${options.join(", ")}`
+    );
+  }
+  return value;
+});
+export const packageManagerModule = createModule(
+  z.object({
+    packageManager: z.enum(SUPPORTED_PACKAGE_MANAGERS).optional(),
+    installDeps: z.boolean().optional()
+  })
+).init(
+  (schema2) => schema2.transform((vals) => {
+    debug.verbose("Initializing package manager", vals);
+    const detectedPM = getPackageManager();
+    debug.verbose("Detected package manager", { detectedPM });
+    return {
+      packageManager: vals.packageManager ?? detectedPM,
+      installDeps: vals.installDeps
+    };
+  })
+).prompt(
+  (schema2) => schema2.transform(async (vals) => {
+    debug.verbose("Prompting for package manager options", vals);
+    const packageManager = vals.packageManager != void 0 ? vals.packageManager : await select({
+      message: "Select a package manager",
+      choices: options.map((pm) => ({ value: pm })),
+      default: getPackageManager() ?? DEFAULT_PACKAGE_MANAGER
+    });
+    const installDeps = vals.installDeps != void 0 ? vals.installDeps : await select({
+      message: "Install dependencies",
+      choices: [
+        { name: "yes", value: true },
+        { name: "no", value: false }
+      ],
+      default: "yes"
+    });
+    debug.verbose("Package manager options selected", {
+      packageManager,
+      installDeps
+    });
+    return {
+      installDeps,
+      packageManager
+    };
+  })
+).validateAndApply({
+  spinnerConfigFn: (cfg) => {
+    debug.verbose("Configuring spinner", cfg);
+    return cfg.installDeps ? {
+      error: `Failed to install dependencies with ${cfg.packageManager}`,
+      inProgress: `Installing dependencies with ${cfg.packageManager}`,
+      success: `Installed dependencies with ${cfg.packageManager}`
+    } : void 0;
+  },
+  apply: async ({ cfg, targetPath }) => {
+    if (cfg.installDeps) {
+      debug.info("Installing dependencies", {
+        packageManager: cfg.packageManager,
+        targetPath
+      });
+      await install(cfg.packageManager, targetPath);
+      debug.info("Dependencies installed successfully");
+    } else {
+      debug.info("Skipping dependency installation");
+    }
+  }
+});

package/dist/modules/vscode/index.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const vsCodeModule: {
+    _baseSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    _initSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    _promptSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    _applyFn: ({ targetPath }: {
+        targetPath: string;
+        cfg: {};
+    }) => Promise<void>;
+    _validateFn: (({ targetPath }: {
+        targetPath: string;
+        cfg: {};
+    }) => Promise<string[]>) | undefined;
+    _spinnerConfigFn: ((cfg: {}) => {
+        success: string;
+        error: string;
+        inProgress: string;
+    } | undefined) | undefined;
+    init(cfg: {}): Promise<z.ParseReturnType<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>>;
+    initSafe(cfg: {}): Promise<z.SafeParseReturnType<{}, {}>>;
+    prompt(cfg: {}): Promise<z.SafeParseReturnType<{}, {}>>;
+    validate(cfg: {}): Promise<z.SafeParseReturnType<{}, {}>>;
+    apply({ cfg, targetPath, }: {
+        cfg: {};
+        targetPath: string;
+    }): Promise<void>;
+    execute({ cfg, targetPath, type, applyingMessage, }: {
+        cfg: {};
+        targetPath: string;
+        type: "new-project" | "update";
+        applyingMessage?: string;
+    }): Promise<void>;
+};

package/dist/modules/vscode/index.mjs

@@ -0,0 +1,35 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { initHelpers } from "../../utils/helpers/index.mjs";
+import { createModule } from "../../module.mjs";
+import { createDebugger } from "../../utils/debug.mjs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const debug = createDebugger("vscode");
+export const vsCodeModule = createModule(z.object({})).init((schema) => schema).prompt((schema) => schema).validateAndApply({
+  validate: async ({ targetPath }) => {
+    debug.verbose("Validating vscode module", { targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    const issues = await _.getTemplateFilesThatWouldBeOverwritten({
+      file: "**/*",
+      templateFolder: "./template",
+      targetFolder: targetPath,
+      overwrite: false
+    });
+    debug.verbose("Validation complete", { issueCount: issues.length });
+    return issues;
+  },
+  apply: async ({ targetPath }) => {
+    debug.info("Applying vscode module", { targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    debug.verbose("Copying template files");
+    await _.copyTemplateFiles({
+      file: "**/*",
+      templateFolder: "./template",
+      targetFolder: ".",
+      overwrite: false
+    });
+    debug.info("VSCode module applied successfully");
+  }
+});

package/dist/modules/vscode/template/_dot_vscode/settings.json

@@ -0,0 +1,11 @@
+{
+  "files.watcherExclude": {
+    "**/routeTree.gen.ts": true
+  },
+  "search.exclude": {
+    "**/routeTree.gen.ts": true
+  },
+  "files.readonlyInclude": {
+    "**/routeTree.gen.ts": true
+  }
+}