@tanstack/create-start 1.92.0

package/dist/index.mjs

@@ -0,0 +1,15 @@
+import { createModule } from "./module.mjs";
+import { ideModule as unstable_ideModule } from "./modules/ide.mjs";
+import { gitModule as unstable_gitModule } from "./modules/git.mjs";
+import { coreModule as unstable_coreModule } from "./modules/core/index.mjs";
+import { packageJsonModule as unstable_packageJsonModule } from "./modules/packageJson.mjs";
+import { packageManagerModule as unstable_packageManagerModule } from "./modules/packageManager.mjs";
+export { createModule as unstable_createModule };
+export { scaffoldTemplate as unstable_scaffoldTemplate } from "./templates/index.mjs";
+export const modules = {
+  unstable_ideModule,
+  unstable_gitModule,
+  unstable_coreModule,
+  unstable_packageJsonModule,
+  unstable_packageManagerModule
+};

package/dist/logo.d.ts

@@ -0,0 +1 @@
+export declare const logo: () => void;

package/dist/logo.mjs

@@ -0,0 +1,28 @@
+import gradient from "gradient-string";
+const LEFT_PADDING = 5;
+export const logo = () => {
+  const logoText = `|\u2597\u2584\u2584\u2584\u2596\u2597\u2584\u2596 \u2597\u2596  \u2597\u2596 \u2597\u2584\u2584\u2596\u2597\u2584\u2584\u2584\u2596\u2597\u2584\u2596  \u2597\u2584\u2584\u2596\u2597\u2596 \u2597\u2596
+                      |  \u2588 \u2590\u258C \u2590\u258C\u2590\u259B\u259A\u2596\u2590\u258C\u2590\u258C     \u2588 \u2590\u258C \u2590\u258C\u2590\u258C   \u2590\u258C\u2597\u259E\u2598
+                      |  \u2588 \u2590\u259B\u2580\u259C\u258C\u2590\u258C \u259D\u259C\u258C \u259D\u2580\u259A\u2596  \u2588 \u2590\u259B\u2580\u259C\u258C\u2590\u258C   \u2590\u259B\u259A\u2596
+                      |  \u2588 \u2590\u258C \u2590\u258C\u2590\u258C  \u2590\u258C\u2597\u2584\u2584\u259E\u2598  \u2588 \u2590\u258C \u2590\u258C\u259D\u259A\u2584\u2584\u2596\u2590\u258C \u2590\u258C
+                      `;
+  const startText = `|         \u2597\u2584\u2584\u2596\u2597\u2584\u2584\u2584\u2596\u2597\u2584\u2596 \u2597\u2584\u2584\u2596\u2597\u2584\u2584\u2584\u2596
+                       |        \u2590\u258C     \u2588 \u2590\u258C \u2590\u258C\u2590\u258C \u2590\u258C \u2588
+                       |         \u259D\u2580\u259A\u2596  \u2588 \u2590\u259B\u2580\u259C\u258C\u2590\u259B\u2580\u259A\u2596 \u2588
+                       |        \u2597\u2584\u2584\u259E\u2598  \u2588 \u2590\u258C \u2590\u258C\u2590\u258C \u2590\u258C \u2588
+                       `;
+  const removeLeadngChars = (str) => {
+    return str.split("\n").map((line) => line.replace(/^\s*\|/, "")).join("\n");
+  };
+  const padLeft = (str) => {
+    return str.split("\n").map((line) => " ".repeat(LEFT_PADDING) + line).join("\n");
+  };
+  const logoGradient = gradient(["#00bba6", "#8a5eec"]);
+  const startGradient = gradient(["#00bba6", "#00bba6"]);
+  const logo2 = logoGradient.multiline(padLeft(removeLeadngChars(logoText)));
+  const start = startGradient.multiline(padLeft(removeLeadngChars(startText)));
+  console.log();
+  console.log(logo2);
+  console.log(start);
+  console.log();
+};

package/dist/module.d.ts

@@ -0,0 +1,67 @@
+import type { ParseReturnType, SafeParseReturnType, ZodType, input, output, z } from 'zod';
+type Schema = ZodType<any, any, any>;
+declare class ModuleBase<TSchema extends Schema> {
+    private _baseSchema;
+    constructor(baseSchema: TSchema);
+    init<TInitSchema extends Schema>(fn: (baseSchema: TSchema) => TInitSchema): InitModule<TSchema, TInitSchema>;
+}
+declare class InitModule<TSchema extends Schema, TInitSchema extends Schema> {
+    private _baseSchema;
+    private _initSchema;
+    constructor(baseSchema: TSchema, initSchema: TInitSchema);
+    prompt<TPromptSchema extends Schema>(fn: (initSchema: TInitSchema) => TPromptSchema): PromptModule<TSchema, TInitSchema, TPromptSchema>;
+}
+declare class PromptModule<TSchema extends Schema, TInitSchema extends Schema, TPromptSchema extends Schema> {
+    private _baseSchema;
+    private _initSchema;
+    private _promptSchema;
+    constructor(baseSchema: TSchema, initSchema: TInitSchema, promptSchema: TPromptSchema);
+    validateAndApply<TApplyFn extends ApplyFn<TPromptSchema>, TValidateFn extends ValidateFn<TPromptSchema>>({ validate, apply, spinnerConfigFn, }: {
+        validate?: TValidateFn;
+        apply: TApplyFn;
+        spinnerConfigFn?: SpinnerConfigFn<TPromptSchema>;
+    }): FinalModule<TSchema, TInitSchema, TPromptSchema, TValidateFn, TApplyFn>;
+}
+type ApplyFn<TPromptSchema extends Schema> = (opts: {
+    targetPath: string;
+    cfg: z.output<TPromptSchema>;
+}) => void | Promise<void>;
+type ValidateFn<TPromptSchema extends Schema> = (opts: {
+    targetPath: string;
+    cfg: z.output<TPromptSchema>;
+}) => Promise<Array<string>> | Array<string>;
+type SpinnerOptions = {
+    success: string;
+    error: string;
+    inProgress: string;
+};
+type SpinnerConfigFn<TValidateSchema extends Schema> = (cfg: z.infer<TValidateSchema>) => SpinnerOptions | undefined;
+declare class FinalModule<TSchema extends Schema, TInitSchema extends Schema, TPromptSchema extends Schema, TValidateFn extends ValidateFn<TPromptSchema>, TApplyFn extends ApplyFn<TPromptSchema>> {
+    _baseSchema: TSchema;
+    _initSchema: TInitSchema;
+    _promptSchema: TPromptSchema;
+    _applyFn: TApplyFn;
+    _validateFn: TValidateFn | undefined;
+    _spinnerConfigFn: SpinnerConfigFn<TPromptSchema> | undefined;
+    constructor(baseSchema: TSchema, initSchema: TInitSchema, promptSchema: TPromptSchema, applyFn: TApplyFn, validateFn?: TValidateFn, spinnerConfigFn?: SpinnerConfigFn<TPromptSchema>);
+    init(cfg: input<TInitSchema>): Promise<ParseReturnType<TInitSchema>>;
+    initSafe(cfg: input<TInitSchema>): Promise<SafeParseReturnType<input<TInitSchema>, output<TInitSchema>>>;
+    prompt(cfg: input<TPromptSchema>): Promise<SafeParseReturnType<input<TPromptSchema>, output<TPromptSchema>>>;
+    validate(cfg: input<TPromptSchema>): Promise<SafeParseReturnType<input<TPromptSchema>, output<TPromptSchema>>>;
+    apply({ cfg, targetPath, }: {
+        cfg: output<TPromptSchema>;
+        targetPath: string;
+    }): Promise<void>;
+    execute({ cfg, targetPath, type, applyingMessage, }: {
+        cfg: input<TSchema>;
+        targetPath: string;
+        type: 'new-project' | 'update';
+        applyingMessage?: string;
+    }): Promise<void>;
+}
+export declare function createModule<TSchema extends Schema>(baseSchema: TSchema): ModuleBase<TSchema>;
+export declare const runWithSpinner: ({ spinnerOptions, fn, }: {
+    spinnerOptions: SpinnerOptions | undefined;
+    fn: () => Promise<void>;
+}) => Promise<void>;
+export {};

package/dist/module.mjs

@@ -0,0 +1,168 @@
+import yoctoSpinner from "yocto-spinner";
+import { checkFolderExists, checkFolderIsEmpty } from "./utils/helpers/index.mjs";
+import { createDebugger } from "./utils/debug.mjs";
+const debug = createDebugger("module");
+class ModuleBase {
+  _baseSchema;
+  constructor(baseSchema) {
+    this._baseSchema = baseSchema;
+    debug.info("Creating new module");
+  }
+  init(fn) {
+    debug.verbose("Initializing module with schema transformer");
+    const schema = fn(this._baseSchema);
+    return new InitModule(this._baseSchema, schema);
+  }
+}
+class InitModule {
+  _baseSchema;
+  _initSchema;
+  constructor(baseSchema, initSchema) {
+    this._baseSchema = baseSchema;
+    this._initSchema = initSchema;
+    debug.verbose("Created init module");
+  }
+  prompt(fn) {
+    debug.verbose("Creating prompt module with schema transformer");
+    const schema = fn(this._initSchema);
+    return new PromptModule(
+      this._baseSchema,
+      this._initSchema,
+      schema
+    );
+  }
+}
+class PromptModule {
+  _baseSchema;
+  _initSchema;
+  _promptSchema;
+  constructor(baseSchema, initSchema, promptSchema) {
+    this._baseSchema = baseSchema;
+    this._initSchema = initSchema;
+    this._promptSchema = promptSchema;
+    debug.verbose("Created prompt module");
+  }
+  validateAndApply({
+    validate,
+    apply,
+    spinnerConfigFn
+  }) {
+    debug.verbose("Creating final module with validate and apply functions");
+    return new FinalModule(
+      this._baseSchema,
+      this._initSchema,
+      this._promptSchema,
+      apply,
+      validate,
+      spinnerConfigFn
+    );
+  }
+}
+class FinalModule {
+  _baseSchema;
+  _initSchema;
+  _promptSchema;
+  _applyFn;
+  _validateFn;
+  _spinnerConfigFn;
+  constructor(baseSchema, initSchema, promptSchema, applyFn, validateFn, spinnerConfigFn) {
+    this._baseSchema = baseSchema;
+    this._initSchema = initSchema;
+    this._promptSchema = promptSchema;
+    this._applyFn = applyFn;
+    this._validateFn = validateFn;
+    if (spinnerConfigFn) this._spinnerConfigFn = spinnerConfigFn;
+    debug.verbose("Created final module");
+  }
+  async init(cfg) {
+    debug.verbose("Running init", { cfg });
+    return await this._initSchema.parseAsync(cfg);
+  }
+  async initSafe(cfg) {
+    debug.verbose("Running safe init", { cfg });
+    return await this._initSchema.safeParseAsync(cfg);
+  }
+  async prompt(cfg) {
+    debug.verbose("Running prompt", { cfg });
+    return await this._promptSchema.parseAsync(cfg);
+  }
+  async validate(cfg) {
+    debug.verbose("Running validate", { cfg });
+    return await this._promptSchema.safeParseAsync(cfg);
+  }
+  async apply({
+    cfg,
+    targetPath
+  }) {
+    debug.verbose("Running apply", { cfg, targetPath });
+    const spinnerOptions = this._spinnerConfigFn?.(cfg);
+    await runWithSpinner({
+      fn: async () => {
+        return await this._applyFn({ cfg, targetPath });
+      },
+      spinnerOptions
+    });
+  }
+  async execute({
+    cfg,
+    targetPath,
+    type,
+    applyingMessage
+  }) {
+    debug.info("Executing module", { type, targetPath });
+    const targetExists = await checkFolderExists(targetPath);
+    const targetIsEmpty = await checkFolderIsEmpty(targetPath);
+    debug.verbose("Target directory status", { targetExists, targetIsEmpty });
+    if (type === "new-project") {
+      if (targetExists && !targetIsEmpty) {
+        debug.error("Target directory is not empty for new project");
+        console.error("The target folder isn't empty");
+        process.exit(0);
+      }
+    }
+    if (type === "update") {
+      if (!targetExists) {
+        debug.error("Target directory does not exist for update");
+        console.error("The target folder doesn't exist");
+        process.exit(0);
+      }
+    }
+    debug.verbose("Parsing init state");
+    const initState = await this._initSchema.parseAsync(cfg);
+    debug.verbose("Parsing prompt state");
+    const promptState = await this._promptSchema.parseAsync(initState);
+    if (applyingMessage) {
+      console.log();
+      console.log(applyingMessage);
+    }
+    debug.verbose("Applying module");
+    await this.apply({ cfg: promptState, targetPath });
+    debug.info("Module execution complete");
+  }
+}
+export function createModule(baseSchema) {
+  return new ModuleBase(baseSchema);
+}
+export const runWithSpinner = async ({
+  spinnerOptions,
+  fn
+}) => {
+  let spinner;
+  if (spinnerOptions != void 0) {
+    spinner = yoctoSpinner({
+      text: spinnerOptions.inProgress
+    }).start();
+  }
+  try {
+    await fn();
+    if (spinnerOptions) {
+      spinner.success(spinnerOptions.success);
+    }
+  } catch (e) {
+    if (spinnerOptions) {
+      spinner.error(spinnerOptions.error);
+    }
+    debug.error("Error in spinner operation", e);
+    throw e;
+  }
+};