@tanstack/create-start 1.92.0

package/dist/templates/barebones/index.mjs

@@ -0,0 +1,60 @@
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+import { createModule, runWithSpinner } from "../../module.mjs";
+import { coreModule } from "../../modules/core/index.mjs";
+import { initHelpers } from "../../utils/helpers/index.mjs";
+import { createDebugger } from "../../utils/debug.mjs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const debug = createDebugger("barebones-template");
+const schema = coreModule._initSchema;
+export const barebonesTemplate = createModule(schema).init((schema2) => schema2).prompt(
+  (schema2) => schema2.transform(async (vals) => {
+    debug.verbose("Transforming prompt schema", { vals });
+    const core = await coreModule._promptSchema.parseAsync(vals);
+    debug.verbose("Core module prompt complete");
+    return {
+      ...core
+    };
+  })
+).validateAndApply({
+  validate: async ({ cfg, targetPath }) => {
+    debug.verbose("Validating barebones template", { targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    const issues = await _.getTemplateFilesThatWouldBeOverwritten({
+      file: "**/*",
+      templateFolder: "./template",
+      targetFolder: targetPath,
+      overwrite: false
+    });
+    debug.verbose("Template file conflicts found", { issues });
+    const coreIssues = await coreModule._validateFn?.({ cfg, targetPath }) ?? [];
+    debug.verbose("Core module validation issues", { coreIssues });
+    issues.push(...coreIssues);
+    return issues;
+  },
+  apply: async ({ cfg, targetPath }) => {
+    debug.info("Applying barebones template", { targetPath });
+    const _ = initHelpers(__dirname, targetPath);
+    await runWithSpinner({
+      spinnerOptions: {
+        inProgress: "Copying barebones template files",
+        error: "Failed to copy barebones template files",
+        success: "Copied barebones template files"
+      },
+      fn: async () => {
+        debug.verbose("Copying template files");
+        await _.copyTemplateFiles({
+          file: "**/*",
+          templateFolder: "./template",
+          targetFolder: ".",
+          overwrite: false
+        });
+        debug.verbose("Template files copied successfully");
+      }
+    });
+    debug.verbose("Applying core module");
+    await coreModule._applyFn({ cfg, targetPath });
+    debug.info("Barebones template applied successfully");
+  }
+});

package/dist/templates/barebones/template/app/routes/index.tsx

@@ -0,0 +1,11 @@
+// @ts-nocheck
+
+import { createFileRoute } from '@tanstack/react-router'
+
+export const Route = createFileRoute('/')({
+  component: RouteComponent,
+})
+
+function RouteComponent() {
+  return <div>Hello "/"!</div>
+}

package/dist/templates/index.d.ts

@@ -0,0 +1,13 @@
+import type { coreModule } from '../modules/core';
+import type { z } from 'zod';
+declare const templateIds: "barebones"[];
+export type TEMPLATE_NAME = (typeof templateIds)[number];
+export declare const DEFAULT_TEMPLATE: TEMPLATE_NAME;
+export declare const templateCliOption: import("@commander-js/extra-typings").Option<"--template <string>", undefined, undefined, "barebones", false, undefined>;
+export declare const templatePrompt: () => Promise<"barebones">;
+export declare const scaffoldTemplate: ({ templateId, cfg, targetPath, }: {
+    templateId: TEMPLATE_NAME;
+    cfg: z.input<typeof coreModule._baseSchema>;
+    targetPath: string;
+}) => Promise<void>;
+export {};

package/dist/templates/index.mjs

@@ -0,0 +1,60 @@
+import { select } from "@inquirer/prompts";
+import { InvalidArgumentError, createOption } from "@commander-js/extra-typings";
+import invariant from "tiny-invariant";
+import { createDebugger } from "../utils/debug.mjs";
+import { barebonesTemplate } from "./barebones/index.mjs";
+const debug = createDebugger("templates");
+const templates = [
+  {
+    id: "barebones",
+    name: "Barebones",
+    module: barebonesTemplate,
+    description: "The bare minimum"
+  }
+];
+const templateIds = templates.map((t) => t.id);
+export const DEFAULT_TEMPLATE = "barebones";
+export const templateCliOption = createOption(
+  "--template <string>",
+  "Choose the template to use"
+).argParser((value) => {
+  if (!templateIds.includes(value)) {
+    debug.error(`Invalid template specified: ${value}`);
+    throw new InvalidArgumentError(
+      `Invalid Template: ${value}. Only the following are allowed: ${templateIds.join(", ")}`
+    );
+  }
+  debug.verbose("Template validated from CLI", { template: value });
+  return value;
+});
+export const templatePrompt = async () => {
+  debug.info("Prompting for template selection");
+  const selection = await select({
+    message: "Which template would you like to use?",
+    choices: templates.map((t) => ({
+      name: t.name,
+      value: t.id,
+      description: t.description
+    })),
+    default: DEFAULT_TEMPLATE
+  });
+  debug.verbose("Template selected", { template: selection });
+  return selection;
+};
+export const scaffoldTemplate = async ({
+  templateId,
+  cfg,
+  targetPath
+}) => {
+  debug.info("Starting template scaffolding", { templateId, targetPath });
+  const template = templates[0];
+  invariant(template, `The template with ${templateId} is not valid`);
+  debug.verbose("Executing template module", { template: template.id });
+  await template.module.execute({
+    cfg,
+    targetPath,
+    type: "new-project",
+    applyingMessage: `Scaffolding the ${template.name} template`
+  });
+  debug.info("Template scaffolding complete");
+};

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import type packageJson from '../package.json';
+export type PeerDependency = keyof typeof packageJson.peerDependencies;

package/dist/utils/debug.d.ts

@@ -0,0 +1,11 @@
+type Context = string;
+export declare const debugCliOption: import("@commander-js/extra-typings").Option<`--debug <${string}>`, undefined, undefined, "debug" | "trace" | "verbose", false, undefined>;
+export declare const initDebug: (level: undefined | "debug" | "trace" | "verbose") => void;
+export declare const createDebugger: (context: Context) => {
+    info: (message: string, data?: Record<string, unknown>) => void;
+    warn: (message: string, data?: Record<string, unknown>) => void;
+    error: (message: string, error?: Error | unknown, data?: Record<string, unknown>) => void;
+    verbose: (message: string, data?: Record<string, unknown>) => void;
+    trace: (message: string, data?: Record<string, unknown>) => void;
+};
+export {};

package/dist/utils/debug.mjs

@@ -0,0 +1,71 @@
+import { InvalidArgumentError, createOption } from "@commander-js/extra-typings";
+let isDebugMode = false;
+let debugLevel = 0;
+const DEBUG_LEVELS = ["debug", "trace", "verbose"];
+export const debugCliOption = createOption(
+  `--debug <${DEBUG_LEVELS.join("|")}>`,
+  `Set a debug level (${DEBUG_LEVELS.join(", ")})`
+).argParser((value) => {
+  if (!DEBUG_LEVELS.includes(value)) {
+    throw new InvalidArgumentError(
+      `Invalid IDE: ${value}. Only the following are allowed: ${DEBUG_LEVELS.join(", ")}`
+    );
+  }
+  return value;
+});
+export const initDebug = (level) => {
+  if (level === void 0) return;
+  isDebugMode = true;
+  if (level === "debug") debugLevel = 1;
+  if (level === "trace") debugLevel = 2;
+  if (level === "verbose") debugLevel = 3;
+};
+const formatData = (data) => {
+  if (!data) return "";
+  return Object.entries(data).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join(" ");
+};
+const log = (level, message, options) => {
+  if (!isDebugMode) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const dataStr = formatData(options.data);
+  const logMessage = `[${timestamp}] [${level}] [${options.context}] ${message} ${dataStr}`;
+  switch (level) {
+    case "error":
+      console.error(logMessage);
+      break;
+    case "warn":
+      console.warn(logMessage);
+      break;
+    case "info":
+      console.log(logMessage);
+      break;
+  }
+};
+export const createDebugger = (context) => ({
+  info: (message, data) => {
+    if (debugLevel < 1) return;
+    log("info", message, { context, data });
+  },
+  warn: (message, data) => {
+    if (debugLevel < 2) return;
+    log("warn", message, { context, data });
+  },
+  error: (message, error, data) => {
+    if (debugLevel < 1) return;
+    log("error", message, {
+      context,
+      data: {
+        ...data,
+        error: error instanceof Error ? error.message : error
+      }
+    });
+  },
+  verbose: (message, data) => {
+    if (debugLevel < 2) return;
+    log("info", message, { context, data });
+  },
+  trace: (message, data) => {
+    if (debugLevel < 3) return;
+    log("info", message, { context, data });
+  }
+});

package/dist/utils/getPackageManager.d.ts

@@ -0,0 +1,2 @@
+import type { PackageManager } from '../constants';
+export declare function getPackageManager(): PackageManager | undefined;

package/dist/utils/getPackageManager.mjs

@@ -0,0 +1,11 @@
+import { SUPPORTED_PACKAGE_MANAGERS } from "../constants.mjs";
+export function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent === void 0) {
+    return void 0;
+  }
+  const packageManager = SUPPORTED_PACKAGE_MANAGERS.find(
+    (manager) => userAgent.startsWith(manager)
+  );
+  return packageManager;
+}

package/dist/utils/helpers/helperFactory.d.ts

@@ -0,0 +1,15 @@
+export type Ctx = {
+    getFullModulePath: (relativePath: string) => string;
+    getFullTargetPath: (relativePath: string) => string;
+    targetFileExists: (relativePath: string) => Promise<boolean>;
+    moduleFileExists: (relativePath: string) => Promise<boolean>;
+    absoluteTargetFolder: string;
+    absoluteModuleFolder: string;
+};
+type HelperFn<T extends (...args: any) => any> = (args: {
+    modulePath: string;
+    targetPath: string;
+    ctx: Ctx;
+}) => T;
+export declare const helperFactory: <T extends (...args: any) => any>(fn: HelperFn<T>) => HelperFn<T>;
+export {};

package/dist/utils/helpers/helperFactory.mjs

@@ -0,0 +1,3 @@
+export const helperFactory = (fn) => {
+  return fn;
+};

package/dist/utils/helpers/index.d.ts

@@ -0,0 +1,51 @@
+import type { Ctx } from './helperFactory';
+export declare const initHelpers: (modulePath: string, targetPath: string) => {
+    readTargetFile: (relativePath: string) => Promise<string>;
+    writeTargetfile: (relativePath: string, content: string, overwrite?: boolean) => Promise<void>;
+    copyTemplateFiles: ({ file, templateFolder, targetFolder, overwrite, }: {
+        file: string;
+        templateFolder: string;
+        targetFolder: string;
+        overwrite: boolean;
+    }) => Promise<void>;
+    getTemplateFilesThatWouldBeOverwritten: ({ file, templateFolder, targetFolder, overwrite, }: {
+        file: string;
+        templateFolder: string;
+        targetFolder: string;
+        overwrite: boolean;
+    }) => Promise<string[]>;
+    getFullModulePath: (relativePath: string) => string;
+    getFullTargetPath: (relativePath: string) => string;
+    targetFileExists: (relativePath: string) => Promise<boolean>;
+    moduleFileExists: (relativePath: string) => Promise<boolean>;
+    absoluteTargetFolder: string;
+    absoluteModuleFolder: string;
+};
+export declare const checkFileExists: (path: string) => Promise<boolean>;
+export declare const checkFolderExists: (path: string) => Promise<boolean>;
+export declare const checkFolderIsEmpty: (path: string) => Promise<boolean>;
+export declare const createWriteTargetFile: (args: {
+    modulePath: string;
+    targetPath: string;
+    ctx: Ctx;
+}) => (relativePath: string, content: string, overwrite?: boolean) => Promise<void>;
+export declare const createGetTemplateFilesThatWouldBeOverwritten: (args: {
+    modulePath: string;
+    targetPath: string;
+    ctx: Ctx;
+}) => ({ file, templateFolder, targetFolder, overwrite, }: {
+    file: string;
+    templateFolder: string;
+    targetFolder: string;
+    overwrite: boolean;
+}) => Promise<string[]>;
+export declare const createCopyTemplateFiles: (args: {
+    modulePath: string;
+    targetPath: string;
+    ctx: Ctx;
+}) => ({ file, templateFolder, targetFolder, overwrite, }: {
+    file: string;
+    templateFolder: string;
+    targetFolder: string;
+    overwrite: boolean;
+}) => Promise<void>;

package/dist/utils/helpers/index.mjs

@@ -0,0 +1,227 @@
+import path, { resolve } from "node:path";
+import fs, {
+  access,
+  copyFile,
+  mkdir,
+  readFile,
+  readdir,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import invariant from "tiny-invariant";
+import fastGlob from "fast-glob";
+import { createDebugger } from "../debug.mjs";
+import { helperFactory } from "./helperFactory.mjs";
+const debug = createDebugger("helpers");
+export const initHelpers = (modulePath, targetPath) => {
+  debug.info("Initializing helpers", { modulePath, targetPath });
+  const getFullModulePath = (relativePath) => {
+    const fullPath = path.join(modulePath, relativePath);
+    debug.trace("Getting full module path", { relativePath, fullPath });
+    return fullPath;
+  };
+  const getFullTargetPath = (relativePath) => {
+    const fullPath = path.join(targetPath, relativePath);
+    debug.trace("Getting full target path", { relativePath, fullPath });
+    return fullPath;
+  };
+  const targetFileExists = async (relativePath) => {
+    const path2 = resolve(targetPath, relativePath);
+    debug.trace("Checking if target file exists", { path: path2 });
+    return await checkFileExists(path2);
+  };
+  const moduleFileExists = async (relativePath) => {
+    const path2 = resolve(modulePath, relativePath);
+    debug.trace("Checking if module file exists", { path: path2 });
+    return await checkFileExists(path2);
+  };
+  const ctx = {
+    targetFileExists,
+    moduleFileExists,
+    absoluteModuleFolder: getFullModulePath(modulePath),
+    absoluteTargetFolder: getFullTargetPath(targetPath),
+    getFullModulePath,
+    getFullTargetPath
+  };
+  debug.verbose("Created helper context", ctx);
+  return {
+    ...ctx,
+    readTargetFile: createReadTargetFile({
+      ctx,
+      modulePath,
+      targetPath
+    }),
+    writeTargetfile: createWriteTargetFile({
+      ctx,
+      modulePath,
+      targetPath
+    }),
+    copyTemplateFiles: createCopyTemplateFiles({
+      ctx,
+      modulePath,
+      targetPath
+    }),
+    getTemplateFilesThatWouldBeOverwritten: createGetTemplateFilesThatWouldBeOverwritten({
+      ctx,
+      modulePath,
+      targetPath
+    })
+  };
+};
+export const checkFileExists = async (path2) => {
+  debug.trace("Checking if file exists", { path: path2 });
+  try {
+    await access(path2, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export const checkFolderExists = async (path2) => {
+  debug.trace("Checking if folder exists", { path: path2 });
+  try {
+    await access(path2, fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export const checkFolderIsEmpty = async (path2) => {
+  debug.trace("Checking if folder is empty", { path: path2 });
+  try {
+    const files = await readdir(path2);
+    return files.length === 0;
+  } catch {
+    return false;
+  }
+};
+const createReadTargetFile = helperFactory(
+  ({ ctx, targetPath }) => async (relativePath) => {
+    debug.trace("Reading target file", { relativePath, targetPath });
+    invariant(
+      await ctx.targetFileExists(relativePath),
+      `The file ${relativePath} doesn't exist`
+    );
+    const path2 = resolve(targetPath, relativePath);
+    return await readFile(path2, "utf-8");
+  }
+);
+export const createWriteTargetFile = helperFactory(
+  ({ targetPath }) => async (relativePath, content, overwrite = false) => {
+    debug.trace("Writing target file", {
+      relativePath,
+      targetPath,
+      overwrite
+    });
+    const path2 = resolve(targetPath, relativePath);
+    invariant(
+      !(!overwrite && await checkFileExists(path2)),
+      `File ${relativePath} already exists and overwrite is false`
+    );
+    await writeFile(path2, content);
+  }
+);
+const DOT_PREFIX = "_dot_";
+const removeTsNoCheckHeader = async (filePath) => {
+  debug.trace("Removing ts-nocheck header", { filePath });
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.split("\n");
+  let newContent = content;
+  if (lines[0]?.trim() === "// @ts-nocheck") {
+    newContent = lines.slice(1).join("\n").trimStart();
+  }
+  await writeFile(filePath, newContent);
+};
+async function copyDir(srcDir, destDir) {
+  debug.trace("Copying directory", { srcDir, destDir });
+  await mkdir(destDir, { recursive: true });
+  const files = await readdir(srcDir);
+  for (const file of files) {
+    const srcFile = resolve(srcDir, file);
+    const destFile = resolve(destDir, file);
+    await copy(srcFile, destFile);
+  }
+}
+async function copy(src, dest) {
+  debug.trace("Copying file", { src, dest });
+  const statResult = await stat(src);
+  const replacedDest = dest.replaceAll(DOT_PREFIX, ".");
+  if (statResult.isDirectory()) {
+    await copyDir(src, replacedDest);
+  } else {
+    await copyFile(src, replacedDest);
+    await removeTsNoCheckHeader(replacedDest);
+  }
+}
+export const createGetTemplateFilesThatWouldBeOverwritten = helperFactory(
+  ({ ctx }) => async ({
+    file,
+    templateFolder,
+    targetFolder,
+    overwrite
+  }) => {
+    debug.verbose("Checking for files that would be overwritten", {
+      file,
+      templateFolder,
+      targetFolder,
+      overwrite
+    });
+    const overwrittenFiles = [];
+    if (overwrite) [];
+    const absoluteTemplateFolder = ctx.getFullModulePath(templateFolder);
+    const absoluteTargetFolder = ctx.getFullTargetPath(targetFolder);
+    const files = await fastGlob.glob(file, {
+      cwd: absoluteTemplateFolder,
+      onlyFiles: false
+    });
+    for (const file2 of files) {
+      const exists = await checkFileExists(
+        resolve(absoluteTargetFolder, file2)
+      );
+      if (exists) {
+        debug.verbose("Found file that would be overwritten", { file: file2 });
+        overwrittenFiles.push(file2);
+      }
+    }
+    return overwrittenFiles;
+  }
+);
+export const createCopyTemplateFiles = helperFactory(
+  ({ ctx }) => async ({
+    file,
+    templateFolder,
+    targetFolder,
+    overwrite
+  }) => {
+    debug.verbose("Copying template files", {
+      file,
+      templateFolder,
+      targetFolder,
+      overwrite
+    });
+    const absoluteTemplateFolder = ctx.getFullModulePath(templateFolder);
+    const absoluteTargetFolder = ctx.getFullTargetPath(targetFolder);
+    const templateFolderExists = checkFolderExists(absoluteTemplateFolder);
+    invariant(
+      templateFolderExists,
+      `The template folder ${templateFolder} doesn't exist`
+    );
+    const files = await fastGlob.glob(file, {
+      cwd: absoluteTemplateFolder,
+      onlyFiles: false
+    });
+    for (const file2 of files) {
+      if (overwrite) {
+        invariant(
+          await checkFileExists(resolve(absoluteTargetFolder, file2)),
+          `The file ${file2} couldn't be created because it would overwrite an existing file`
+        );
+      }
+      debug.trace("Copying template file", { file: file2 });
+      await copy(
+        resolve(absoluteTemplateFolder, file2),
+        resolve(absoluteTargetFolder, file2)
+      );
+    }
+  }
+);

package/dist/utils/runCmd.d.ts

@@ -0,0 +1 @@
+export declare function runCmd(command: string, args: Array<string>, env?: NodeJS.ProcessEnv, cwd?: string): Promise<void>;

package/dist/utils/runCmd.mjs

@@ -0,0 +1,4 @@
+import { spawnCommand } from "./spawnCmd.mjs";
+export async function runCmd(command, args, env = {}, cwd) {
+  return spawnCommand(command, args, env, cwd);
+}

package/dist/utils/runPackageManagerCommand.d.ts

@@ -0,0 +1,4 @@
+import type { PackageManager } from '../constants';
+export declare function runPackageManagerCommand(packageManager: PackageManager, args: Array<string>, env?: NodeJS.ProcessEnv, cwd?: string): Promise<void>;
+export declare function install(packageManager: PackageManager, cwd?: string): Promise<void>;
+export declare function build(packageManager: PackageManager, cwd?: string): Promise<void>;

package/dist/utils/runPackageManagerCommand.mjs

@@ -0,0 +1,17 @@
+import { spawnCommand } from "./spawnCmd.mjs";
+export async function runPackageManagerCommand(packageManager, args, env = {}, cwd) {
+  return spawnCommand(packageManager, args, env, cwd);
+}
+export async function install(packageManager, cwd) {
+  return runPackageManagerCommand(
+    packageManager,
+    ["install"],
+    {
+      NODE_ENV: "development"
+    },
+    cwd
+  );
+}
+export async function build(packageManager, cwd) {
+  return runPackageManagerCommand(packageManager, ["run", "build"], {}, cwd);
+}

package/dist/utils/spawnCmd.d.ts

@@ -0,0 +1 @@
+export declare function spawnCommand(command: string, args: Array<string>, env?: NodeJS.ProcessEnv, cwd?: string): Promise<void>;

package/dist/utils/spawnCmd.mjs

@@ -0,0 +1,30 @@
+import spawn from "cross-spawn";
+export async function spawnCommand(command, args, env = {}, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env: {
+        ...process.env,
+        ...env
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd
+    });
+    let stderrBuffer = "";
+    let stdoutBuffer = "";
+    child.stderr?.on("data", (data) => {
+      stderrBuffer += data;
+    });
+    child.stdout?.on("data", (data) => {
+      stdoutBuffer += data;
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(
+          `"${command} ${args.join(" ")}" failed ${stdoutBuffer} ${stderrBuffer}`
+        );
+        return;
+      }
+      resolve();
+    });
+  });
+}

package/dist/utils/validateProjectName.d.ts

@@ -0,0 +1,8 @@
+type ValidatationResult = {
+    valid: true;
+} | {
+    valid: false;
+    problems: Array<string>;
+};
+export declare function validateProjectName(name: string): ValidatationResult;
+export {};

package/dist/utils/validateProjectName.mjs

@@ -0,0 +1,14 @@
+import validate from "validate-npm-package-name";
+export function validateProjectName(name) {
+  const nameValidation = validate(name);
+  if (nameValidation.validForNewPackages) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    problems: [
+      ...nameValidation.errors || [],
+      ...nameValidation.warnings || []
+    ]
+  };
+}

package/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import './dist/cli-entry.mjs'