@tanstack/create-start 1.92.0

package/dist/modules/core/index.mjs

@@ -0,0 +1,218 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { packageJsonModule } from "../packageJson.mjs";
+import { createModule, runWithSpinner } from "../../module.mjs";
+import { ideModule } from "../ide.mjs";
+import packageJson from "../../../package.json" assert { type: "json" };
+import { packageManagerModule } from "../packageManager.mjs";
+import { initHelpers } from "../../utils/helpers/index.mjs";
+import { gitModule } from "../git.mjs";
+import { createDebugger } from "../../utils/debug.mjs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const debug = createDebugger("core-module");
+export const coreModule = createModule(
+  z.object({
+    packageJson: packageJsonModule._initSchema.optional(),
+    ide: ideModule._initSchema.optional(),
+    packageManager: packageManagerModule._initSchema.optional(),
+    git: gitModule._initSchema.optional()
+  })
+).init(
+  (schema) => schema.transform(async (vals, ctx) => {
+    debug.verbose("Initializing core module schema", { vals });
+    const gitignore = [
+      {
+        sectionName: "Dependencies",
+        lines: ["node_modules/"]
+      },
+      {
+        sectionName: "Env",
+        lines: [
+          ".env",
+          ".env.local",
+          ".env.development",
+          ".env.test",
+          ".env.production",
+          ".env.staging"
+        ]
+      },
+      {
+        sectionName: "System Files",
+        lines: [".DS_Store", "Thumbs.db"]
+      }
+    ];
+    vals.git = {
+      ...vals.git,
+      gitIgnore: [...vals.git?.gitIgnore ?? [], ...gitignore]
+    };
+    const packageJson2 = {
+      type: "new",
+      dependencies: await deps([
+        "@tanstack/react-router",
+        "@tanstack/start",
+        "react",
+        "react-dom",
+        "vinxi"
+      ]),
+      devDependencies: await deps(["@types/react", "@types/react"]),
+      scripts: [
+        {
+          name: "dev",
+          script: "vinxi dev"
+        },
+        {
+          name: "build",
+          script: "vinxi build"
+        },
+        {
+          name: "start",
+          script: "vinxi start"
+        }
+      ],
+      ...vals.packageJson
+    };
+    debug.verbose("Parsing package manager schema");
+    const packageManager = await packageManagerModule._initSchema.safeParseAsync(
+      vals.packageManager,
+      {
+        path: ["packageManager"]
+      }
+    );
+    debug.verbose("Parsing IDE schema");
+    const ide = await ideModule._initSchema.safeParseAsync(vals.ide, {
+      path: ["ide"]
+    });
+    debug.verbose("Parsing git schema");
+    const git = await gitModule._initSchema.safeParseAsync(vals.git, {
+      path: ["git"]
+    });
+    if (!ide.success || !packageManager.success || !git.success) {
+      debug.error("Schema validation failed", null, {
+        ide: ide.success,
+        packageManager: packageManager.success,
+        git: git.success
+      });
+      ide.error?.issues.forEach((i) => ctx.addIssue(i));
+      packageManager.error?.issues.forEach((i) => ctx.addIssue(i));
+      git.error?.issues.forEach((i) => ctx.addIssue(i));
+      throw Error("Failed validation");
+    }
+    debug.verbose("Schema transformation complete");
+    return {
+      ...vals,
+      packageManager: packageManager.data,
+      ide: ide.data,
+      git: git.data,
+      packageJson: packageJson2
+    };
+  })
+).prompt(
+  (schema) => schema.transform(async (vals, ctx) => {
+    debug.verbose("Running prompt transformations", { vals });
+    debug.verbose("Parsing IDE prompt schema");
+    const ide = await ideModule._promptSchema.safeParseAsync(vals.ide, {
+      path: ["ide"]
+    });
+    debug.verbose("Parsing package manager prompt schema");
+    const packageManager = await packageManagerModule._promptSchema.safeParseAsync(
+      vals.packageManager,
+      { path: ["packageManager"] }
+    );
+    debug.verbose("Parsing git prompt schema");
+    const git = await gitModule._promptSchema.safeParseAsync(vals.git, {
+      path: ["git"]
+    });
+    debug.verbose("Parsing package.json prompt schema");
+    const packageJson2 = await packageJsonModule._promptSchema.safeParseAsync(
+      vals.packageJson,
+      {
+        path: ["packageJson"]
+      }
+    );
+    if (!ide.success || !packageManager.success || !git.success || !packageJson2.success) {
+      debug.error("Prompt validation failed", null, {
+        ide: ide.success,
+        packageManager: packageManager.success,
+        git: git.success,
+        packageJson: packageJson2.success
+      });
+      ide.error?.issues.forEach((i) => ctx.addIssue(i));
+      packageManager.error?.issues.forEach((i) => ctx.addIssue(i));
+      git.error?.issues.forEach((i) => ctx.addIssue(i));
+      throw Error("Failed validation");
+    }
+    debug.verbose("Prompt transformations complete");
+    return {
+      packageJson: packageJson2.data,
+      ide: ide.data,
+      packageManager: packageManager.data,
+      git: git.data
+    };
+  })
+).validateAndApply({
+  validate: async ({ cfg, targetPath }) => {
+    debug.verbose("Validating core module", { targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    const issues = await _.getTemplateFilesThatWouldBeOverwritten({
+      file: "**/*",
+      templateFolder: "./template",
+      targetFolder: targetPath,
+      overwrite: false
+    });
+    if (ideModule._validateFn) {
+      debug.verbose("Running IDE validation");
+      const ideIssues = await ideModule._validateFn({
+        cfg: cfg.ide,
+        targetPath
+      });
+      issues.push(...ideIssues);
+    }
+    debug.info("Validation complete", { issueCount: issues.length });
+    return issues;
+  },
+  apply: async ({ cfg, targetPath }) => {
+    debug.info("Applying core module", { targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    debug.verbose("Copying core template files");
+    await runWithSpinner({
+      spinnerOptions: {
+        inProgress: "Copying core template files",
+        error: "Failed to copy core template files",
+        success: "Copied core template files"
+      },
+      fn: async () => await _.copyTemplateFiles({
+        file: "**/*",
+        templateFolder: "./template",
+        targetFolder: ".",
+        overwrite: false
+      })
+    });
+    debug.verbose("Applying package.json module");
+    await packageJsonModule.apply({ cfg: cfg.packageJson, targetPath });
+    debug.verbose("Applying IDE module");
+    await ideModule.apply({ cfg: cfg.ide, targetPath });
+    debug.verbose("Applying git module");
+    await gitModule._applyFn({ cfg: cfg.git, targetPath });
+    debug.verbose("Applying package manager module");
+    await packageManagerModule.apply({
+      cfg: cfg.packageManager,
+      targetPath
+    });
+    debug.info("Core module application complete");
+  }
+});
+const deps = async (depsArray) => {
+  debug.verbose("Resolving dependencies", { deps: depsArray });
+  const result = await Promise.all(
+    depsArray.map((d) => {
+      const version = packageJson["peerDependencies"][d] === "workspace:^" ? "latest" : packageJson["peerDependencies"][d];
+      return {
+        name: d,
+        version
+      };
+    })
+  );
+  return result;
+};

package/dist/modules/core/template/app/client.tsx

@@ -0,0 +1,10 @@
+// @ts-nocheck
+
+/// <reference types="vinxi/types/client" />
+import { hydrateRoot } from 'react-dom/client'
+import { StartClient } from '@tanstack/start'
+import { createRouter } from './router'
+
+const router = createRouter()
+
+hydrateRoot(document, <StartClient router={router} />)

package/dist/modules/core/template/app/router.tsx

@@ -0,0 +1,18 @@
+// @ts-nocheck
+
+import { createRouter as createTanStackRouter } from '@tanstack/react-router'
+import { routeTree } from './routeTree.gen'
+
+export function createRouter() {
+  const router = createTanStackRouter({
+    routeTree,
+  })
+
+  return router
+}
+
+declare module '@tanstack/react-router' {
+  interface Register {
+    router: ReturnType<typeof createRouter>
+  }
+}

package/dist/modules/core/template/app/routes/__root.tsx

@@ -0,0 +1,50 @@
+// @ts-nocheck
+
+import {
+  Outlet,
+  ScrollRestoration,
+  createRootRoute,
+} from '@tanstack/react-router'
+import { Meta, Scripts } from '@tanstack/start'
+import type { ReactNode } from 'react'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      {
+        charSet: 'utf-8',
+      },
+      {
+        name: 'viewport',
+        content: 'width=device-width, initial-scale=1',
+      },
+      {
+        title: 'TanStack Start Starter',
+      },
+    ],
+  }),
+  component: RootComponent,
+})
+
+function RootComponent() {
+  return (
+    <RootDocument>
+      <Outlet />
+    </RootDocument>
+  )
+}
+
+function RootDocument({ children }: Readonly<{ children: ReactNode }>) {
+  return (
+    <html>
+      <head>
+        <Meta />
+      </head>
+      <body>
+        {children}
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  )
+}

package/dist/modules/core/template/app/ssr.tsx

@@ -0,0 +1,15 @@
+// @ts-nocheck
+
+/// <reference types="vinxi/types/server" />
+import {
+  createStartHandler,
+  defaultStreamHandler,
+} from '@tanstack/start/server'
+import { getRouterManifest } from '@tanstack/start/router-manifest'
+
+import { createRouter } from './router'
+
+export default createStartHandler({
+  createRouter,
+  getRouterManifest,
+})(defaultStreamHandler)

package/dist/modules/core/template/app.config.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+
+import { defineConfig } from '@tanstack/start/config'
+
+export default defineConfig({})

package/dist/modules/core/template/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "target": "ES2022",
+    "skipLibCheck": true,
+    "strictNullChecks": true
+  }
+}

package/dist/modules/git.d.ts

@@ -0,0 +1,231 @@
+import { z } from 'zod';
+export declare const gitModule: {
+    _baseSchema: z.ZodObject<{
+        setupGit: z.ZodOptional<z.ZodBoolean>;
+        gitIgnore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            sectionName: z.ZodString;
+            lines: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            sectionName: string;
+            lines: string[];
+        }, {
+            sectionName: string;
+            lines: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>;
+    _initSchema: z.ZodObject<{
+        setupGit: z.ZodOptional<z.ZodBoolean>;
+        gitIgnore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            sectionName: z.ZodString;
+            lines: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            sectionName: string;
+            lines: string[];
+        }, {
+            sectionName: string;
+            lines: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>;
+    _promptSchema: z.ZodEffects<z.ZodObject<{
+        setupGit: z.ZodOptional<z.ZodBoolean>;
+        gitIgnore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            sectionName: z.ZodString;
+            lines: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            sectionName: string;
+            lines: string[];
+        }, {
+            sectionName: string;
+            lines: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>, {
+        setupGit: boolean;
+        gitIgnore: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>;
+    _applyFn: ({ cfg, targetPath }: {
+        targetPath: string;
+        cfg: {
+            setupGit: boolean;
+            gitIgnore: {
+                sectionName: string;
+                lines: string[];
+            }[] | undefined;
+        };
+    }) => Promise<void>;
+    _validateFn: ((opts: {
+        targetPath: string;
+        cfg: {
+            setupGit: boolean;
+            gitIgnore: {
+                sectionName: string;
+                lines: string[];
+            }[] | undefined;
+        };
+    }) => Promise<Array<string>> | Array<string>) | undefined;
+    _spinnerConfigFn: ((cfg: {
+        setupGit: boolean;
+        gitIgnore: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }) => {
+        success: string;
+        error: string;
+        inProgress: string;
+    } | undefined) | undefined;
+    init(cfg: {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }): Promise<z.ParseReturnType<z.ZodObject<{
+        setupGit: z.ZodOptional<z.ZodBoolean>;
+        gitIgnore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            sectionName: z.ZodString;
+            lines: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            sectionName: string;
+            lines: string[];
+        }, {
+            sectionName: string;
+            lines: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>>>;
+    initSafe(cfg: {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }): Promise<z.SafeParseReturnType<{
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>>;
+    prompt(cfg: {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }): Promise<z.SafeParseReturnType<{
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit: boolean;
+        gitIgnore: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>>;
+    validate(cfg: {
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }): Promise<z.SafeParseReturnType<{
+        setupGit?: boolean | undefined;
+        gitIgnore?: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }, {
+        setupGit: boolean;
+        gitIgnore: {
+            sectionName: string;
+            lines: string[];
+        }[] | undefined;
+    }>>;
+    apply({ cfg, targetPath, }: {
+        cfg: {
+            setupGit: boolean;
+            gitIgnore: {
+                sectionName: string;
+                lines: string[];
+            }[] | undefined;
+        };
+        targetPath: string;
+    }): Promise<void>;
+    execute({ cfg, targetPath, type, applyingMessage, }: {
+        cfg: {
+            setupGit?: boolean | undefined;
+            gitIgnore?: {
+                sectionName: string;
+                lines: string[];
+            }[] | undefined;
+        };
+        targetPath: string;
+        type: "new-project" | "update";
+        applyingMessage?: string;
+    }): Promise<void>;
+};

package/dist/modules/git.mjs

@@ -0,0 +1,114 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { z } from "zod";
+import { select } from "@inquirer/prompts";
+import { createModule } from "../module.mjs";
+import { runCmd } from "../utils/runCmd.mjs";
+import { createDebugger } from "../utils/debug.mjs";
+import { checkFileExists, initHelpers } from "../utils/helpers/index.mjs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const debug = createDebugger("git-module");
+async function appendToGitignore(targetPath, newEntries, sectionName) {
+  const gitignorePath = resolve(targetPath, ".gitignore");
+  debug.verbose("Handling gitignore", { gitignorePath });
+  let existingContent = "";
+  const exists = await checkFileExists(gitignorePath);
+  if (exists) {
+    existingContent = await readFile(gitignorePath, "utf-8");
+    const lines = existingContent.split("\n");
+    const sectionStart = lines.findIndex(
+      (line) => line.trim() === `# ${sectionName}`
+    );
+    if (sectionStart !== -1) {
+      let sectionEnd = lines.findIndex(
+        (line, i) => i > sectionStart && line.trim().startsWith("#")
+      );
+      if (sectionEnd === -1) sectionEnd = lines.length;
+      const sectionEntries = lines.slice(sectionStart + 1, sectionEnd).map((line) => line.trim()).filter((line) => line !== "");
+      newEntries = newEntries.filter(
+        (entry) => !sectionEntries.some(
+          (existing) => existing.toLowerCase() === entry.trim().toLowerCase()
+        )
+      );
+      if (newEntries.length > 0) {
+        lines.splice(sectionEnd, 0, ...newEntries);
+        await writeFile(gitignorePath, lines.join("\n"));
+        debug.info("Updated existing section in gitignore file");
+      }
+    } else {
+      const newContent = `${existingContent}
+
+# ${sectionName}
+${newEntries.join("\n")}`;
+      await writeFile(gitignorePath, newContent);
+      debug.info("Added new section to gitignore file");
+    }
+  } else {
+    const content = `# ${sectionName}
+${newEntries.join("\n")}`;
+    await writeFile(gitignorePath, content);
+    debug.info("Created new gitignore file");
+  }
+}
+export const gitModule = createModule(
+  z.object({
+    setupGit: z.boolean().optional(),
+    gitIgnore: z.object({
+      sectionName: z.string(),
+      lines: z.string().array()
+    }).array().optional()
+  })
+).init((schema) => schema).prompt(
+  (schema) => schema.transform(async (vals) => {
+    debug.verbose("Transforming git prompt schema", { vals });
+    const setupGit = vals.setupGit != void 0 ? vals.setupGit : await select({
+      message: "Initialize git",
+      choices: [
+        { name: "yes", value: true },
+        { name: "no", value: false }
+      ],
+      default: "yes"
+    });
+    debug.info("Git initialization choice made", { setupGit });
+    return {
+      setupGit,
+      gitIgnore: vals.gitIgnore
+    };
+  })
+).validateAndApply({
+  apply: async ({ cfg, targetPath }) => {
+    const _ = initHelpers(__dirname, targetPath);
+    debug.verbose("Applying git module", { cfg, targetPath });
+    if (cfg.gitIgnore && cfg.gitIgnore.length > 0) {
+      for (const gitIgnore of cfg.gitIgnore) {
+        await appendToGitignore(
+          _.getFullTargetPath(""),
+          gitIgnore.lines,
+          gitIgnore.sectionName
+        );
+      }
+      debug.info("Created / updated .gitignore");
+    }
+    if (cfg.setupGit) {
+      debug.info("Initializing git repository");
+      try {
+        await runCmd("git", ["init"], {}, targetPath);
+        debug.info("Git repository initialized successfully");
+      } catch (error) {
+        debug.error("Failed to initialize git repository", error);
+        throw error;
+      }
+    } else {
+      debug.info("Skipping git initialization");
+    }
+  },
+  spinnerConfigFn: () => {
+    return {
+      success: "Git initalized",
+      error: "Failed to initialize git",
+      inProgress: "Initializing git"
+    };
+  }
+});