@tanstack/cta-engine 0.14.3 → 0.14.4

package/dist/package-json.js

@@ -0,0 +1,48 @@
+import { FILE_ROUTER } from './constants.js';
+import { sortObject } from './utils.js';
+export function mergePackageJSON(packageJSON, overlayPackageJSON) {
+    return {
+        ...packageJSON,
+        dependencies: {
+            ...packageJSON.dependencies,
+            ...(overlayPackageJSON?.dependencies || {}),
+        },
+        devDependencies: {
+            ...packageJSON.devDependencies,
+            ...(overlayPackageJSON?.devDependencies || {}),
+        },
+        scripts: {
+            ...packageJSON.scripts,
+            ...(overlayPackageJSON?.scripts || {}),
+        },
+    };
+}
+export function createPackageJSON(options) {
+    let packageJSON = {
+        ...JSON.parse(JSON.stringify(options.framework.basePackageJSON)),
+        name: options.projectName,
+    };
+    const additions = [
+        options.typescript
+            ? options.framework.optionalPackages.typescript
+            : undefined,
+        options.tailwind
+            ? options.framework.optionalPackages.tailwindcss
+            : undefined,
+        options.mode === FILE_ROUTER
+            ? options.framework.optionalPackages['file-router']
+            : undefined,
+    ];
+    for (const addition of additions.filter(Boolean)) {
+        packageJSON = mergePackageJSON(packageJSON, addition);
+    }
+    for (const addOn of options.chosenAddOns.map((addOn) => addOn.packageAdditions)) {
+        packageJSON = mergePackageJSON(packageJSON, addOn);
+    }
+    if (options.starter) {
+        packageJSON = mergePackageJSON(packageJSON, options.starter.packageAdditions);
+    }
+    packageJSON.dependencies = sortObject((packageJSON.dependencies ?? {}));
+    packageJSON.devDependencies = sortObject((packageJSON.devDependencies ?? {}));
+    return packageJSON;
+}

package/dist/package-manager.js

@@ -14,17 +14,62 @@ export function getPackageManager() {
     const packageManager = SUPPORTED_PACKAGE_MANAGERS.find((manager) => userAgent.startsWith(manager));
     return packageManager;
 }
-export function packageManagerExecute(environment, packagerManager, pkg, args, cwd) {
+export function getPackageManagerScriptCommand(packagerManager, args = []) {
     switch (packagerManager) {
         case 'yarn':
-            return environment.execute('yarn', ['dlx', pkg, ...args], cwd);
+            return { command: 'yarn', args: ['run', ...args] };
         case 'pnpm':
-            return environment.execute('pnpx', [pkg, ...args], cwd);
+            return { command: 'pnpm', args: [...args] };
         case 'bun':
-            return environment.execute('bunx', ['--bun', pkg, ...args], cwd);
+            return { command: 'bunx', args: ['--bun', 'run', ...args] };
         case 'deno':
-            return environment.execute('deno', ['run', `npm:${pkg}`, ...args], cwd);
+            return { command: 'deno', args: ['task', ...args] };
         default:
-            return environment.execute('npx', [pkg, ...args], cwd);
+            return { command: 'npm', args: ['run', ...args] };
     }
 }
+export function getPackageManagerExecuteCommand(packagerManager, pkg, args = []) {
+    switch (packagerManager) {
+        case 'yarn':
+            return { command: 'yarn', args: ['dlx', pkg, ...args] };
+        case 'pnpm':
+            return { command: 'pnpx', args: [pkg, ...args] };
+        case 'bun':
+            return { command: 'bunx', args: ['--bun', pkg, ...args] };
+        case 'deno':
+            return { command: 'deno', args: ['run', `npm:${pkg}`, ...args] };
+        default:
+            return { command: 'npx', args: [pkg, ...args] };
+    }
+}
+export function getPackageManagerInstallCommand(packagerManager, pkg, isDev = false) {
+    if (pkg) {
+        switch (packagerManager) {
+            case 'yarn':
+            case 'pnpm':
+                return {
+                    command: packagerManager,
+                    args: ['add', pkg, isDev ? '--dev' : ''],
+                };
+            default:
+                return {
+                    command: packagerManager,
+                    args: ['install', pkg, isDev ? '-D' : ''],
+                };
+        }
+    }
+    else {
+        return {
+            command: packagerManager,
+            args: ['install'],
+        };
+    }
+}
+export function packageManagerInstall(environment, cwd, packagerManager, pkg) {
+    const { command, args: commandArgs } = getPackageManagerInstallCommand(packagerManager, pkg);
+    return environment.execute(command, commandArgs, cwd);
+}
+export function packageManagerExecute(environment, cwd, packagerManager, pkg, args) {
+    const { command, args: commandArgs } = getPackageManagerExecuteCommand(packagerManager, pkg, args);
+    return environment.execute(command, commandArgs, cwd);
+}

package/dist/registry.js

@@ -0,0 +1,56 @@
+import { loadRemoteAddOn } from './custom-add-ons/add-on.js';
+import { loadStarter } from './custom-add-ons/starter.js';
+function absolutizeUrl(originalUrl, relativeUrl) {
+    if (relativeUrl.startsWith('http') || relativeUrl.startsWith('https')) {
+        return relativeUrl;
+    }
+    const baseUrl = originalUrl.replace(/registry.json$/, '');
+    return `${baseUrl}${relativeUrl.replace(/^\.\//, '')}`;
+}
+export async function getRawRegistry(registryUrl) {
+    const regUrl = registryUrl || process.env.CTA_REGISTRY;
+    if (regUrl) {
+        const registry = (await fetch(regUrl).then((res) => res.json()));
+        for (const addOn of registry['add-ons']) {
+            addOn.url = absolutizeUrl(regUrl, addOn.url);
+        }
+        for (const starter of registry.starters) {
+            starter.url = absolutizeUrl(regUrl, starter.url);
+            if (starter.banner) {
+                starter.banner = absolutizeUrl(regUrl, starter.banner);
+            }
+        }
+        return registry;
+    }
+}
+async function getAddOns(registry) {
+    const addOns = [];
+    for (const addOnInfo of registry['add-ons']) {
+        const addOn = await loadRemoteAddOn(addOnInfo.url);
+        addOns.push(addOn);
+    }
+    return addOns;
+}
+export async function getRegistryAddOns(registryUrl) {
+    const registry = await getRawRegistry(registryUrl);
+    return registry ? await getAddOns(registry) : [];
+}
+async function getStarters(registry) {
+    const starters = [];
+    for (const starterInfo of registry.starters) {
+        const starter = await loadStarter(starterInfo.url);
+        starters.push(starter);
+    }
+    return starters;
+}
+export async function getRegistryStarters(registryUrl) {
+    const registry = await getRawRegistry(registryUrl);
+    return registry ? await getStarters(registry) : [];
+}
+export async function getRegistry(registryUrl) {
+    const registry = await getRawRegistry(registryUrl);
+    return {
+        addOns: registry ? await getAddOns(registry) : [],
+        starters: registry ? await getStarters(registry) : [],
+    };
+}

package/dist/special-steps/index.js

@@ -0,0 +1,24 @@
+import { rimrafNodeModules } from './rimraf-node-modules.js';
+const specialStepsLookup = {
+    'rimraf-node-modules': rimrafNodeModules,
+};
+export async function runSpecialSteps(environment, options, specialSteps) {
+    if (specialSteps.length) {
+        environment.startStep({
+            id: 'special-steps',
+            type: 'command',
+            message: 'Removing node_modules...',
+        });
+        for (const step of specialSteps) {
+            const stepFunction = specialStepsLookup[step];
+            /* eslint-disable @typescript-eslint/no-unnecessary-condition */
+            if (stepFunction) {
+                await stepFunction(environment, options);
+            }
+            else {
+                environment.error(`Special step ${step} not found`);
+            }
+        }
+        environment.finishStep('special-steps', 'Special steps complete');
+    }
+}

package/dist/special-steps/rimraf-node-modules.js

@@ -0,0 +1,16 @@
+import { resolve } from 'node:path';
+const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+export async function rimrafNodeModules(environment, options) {
+    environment.startStep({
+        id: 'special-steps',
+        type: 'command',
+        message: 'Removing node_modules...',
+    });
+    await environment.rimraf(resolve(options.targetDir, 'node_modules'));
+    for (const lockFile of lockFiles) {
+        const lockFilePath = resolve(options.targetDir, lockFile);
+        if (environment.exists(lockFilePath)) {
+            await environment.deleteFile(lockFilePath);
+        }
+    }
+}

package/dist/template-file.js

@@ -0,0 +1,112 @@
+import { resolve, sep } from 'node:path';
+import { render } from 'ejs';
+import { format } from 'prettier';
+import { CODE_ROUTER, FILE_ROUTER } from './constants.js';
+import { formatCommand } from './utils.js';
+import { getPackageManagerInstallCommand, getPackageManagerScriptCommand, } from './package-manager.js';
+import { relativePath } from './file-helpers.js';
+function convertDotFilesAndPaths(path) {
+    return path
+        .split(sep)
+        .map((segment) => segment.replace(/^_dot_/, '.'))
+        .join(sep);
+}
+export function createTemplateFile(environment, options) {
+    function getPackageManagerAddScript(packageName, isDev = false) {
+        return formatCommand(getPackageManagerInstallCommand(options.packageManager, packageName, isDev));
+    }
+    function getPackageManagerRunScript(scriptName, args = []) {
+        return formatCommand(getPackageManagerScriptCommand(options.packageManager, [
+            scriptName,
+            ...args,
+        ]));
+    }
+    class IgnoreFileError extends Error {
+        constructor() {
+            super('ignoreFile');
+            this.name = 'IgnoreFileError';
+        }
+    }
+    const integrations = [];
+    for (const addOn of options.chosenAddOns) {
+        if (addOn.integrations) {
+            for (const integration of addOn.integrations) {
+                integrations.push(integration);
+            }
+        }
+    }
+    const routes = [];
+    for (const addOn of options.chosenAddOns) {
+        if (addOn.routes) {
+            routes.push(...addOn.routes);
+        }
+    }
+    const addOnEnabled = options.chosenAddOns.reduce((acc, addOn) => {
+        acc[addOn.id] = true;
+        return acc;
+    }, {});
+    return async function templateFile(file, content) {
+        const templateValues = {
+            packageManager: options.packageManager,
+            projectName: options.projectName,
+            typescript: options.typescript,
+            tailwind: options.tailwind,
+            js: options.typescript ? 'ts' : 'js',
+            jsx: options.typescript ? 'tsx' : 'jsx',
+            fileRouter: options.mode === FILE_ROUTER,
+            codeRouter: options.mode === CODE_ROUTER,
+            addOnEnabled,
+            addOns: options.chosenAddOns,
+            integrations,
+            routes,
+            getPackageManagerAddScript,
+            getPackageManagerRunScript,
+            relativePath: (path) => relativePath(file, path),
+            ignoreFile: () => {
+                throw new IgnoreFileError();
+            },
+        };
+        let ignoreFile = false;
+        if (file.endsWith('.ejs')) {
+            try {
+                content = render(content, templateValues);
+            }
+            catch (error) {
+                if (error instanceof IgnoreFileError) {
+                    ignoreFile = true;
+                }
+                else {
+                    console.error(file, error);
+                    environment.error(`EJS error in file ${file}`, error?.toString());
+                    process.exit(1);
+                }
+            }
+        }
+        if (ignoreFile) {
+            return;
+        }
+        let target = convertDotFilesAndPaths(file.replace('.ejs', ''));
+        let append = false;
+        if (target.endsWith('.append')) {
+            append = true;
+            target = target.replace('.append', '');
+        }
+        if (target.endsWith('.ts') || target.endsWith('.tsx')) {
+            content = await format(content, {
+                semi: false,
+                singleQuote: true,
+                trailingComma: 'all',
+                parser: 'typescript',
+            });
+        }
+        if (!options.typescript) {
+            target = target.replace(/\.tsx$/, '.jsx').replace(/\.ts$/, '.js');
+        }
+        if (append) {
+            await environment.appendFile(resolve(options.targetDir, target), content);
+        }
+        else {
+            await environment.writeFile(resolve(options.targetDir, target), content);
+        }
+    };
+}

package/dist/types/add-ons.d.ts

@@ -1,8 +1,3 @@
-import type { AddOn, CliOptions, Framework, TemplateOptions } from './types.js';
-export declare function getAllAddOns(framework: Framework, template: string): Promise<Array<AddOn>>;
-export declare function finalizeAddOns(framework: Framework, template: string, chosenAddOnIDs: Array<string>): Promise<Array<AddOn>>;
-export declare function listAddOns(options: CliOptions, { forcedMode, forcedAddOns, }: {
-    forcedMode?: TemplateOptions;
-    forcedAddOns?: Array<string>;
-}): Promise<void>;
-export declare function loadRemoteAddOn(url: string): Promise<AddOn>;
+import type { AddOn, Framework, Mode } from './types.js';
+export declare function getAllAddOns(framework: Framework, mode: Mode): Array<AddOn>;
+export declare function finalizeAddOns(framework: Framework, mode: Mode, chosenAddOnIDs: Array<string>): Promise<Array<AddOn>>;

package/dist/types/add-to-app.d.ts

@@ -0,0 +1,17 @@
+import type { Environment } from './types.js';
+import type { PersistedOptions } from './config-file.js';
+export declare function hasPendingGitChanges(environment: Environment, cwd: string): Promise<boolean>;
+export declare function getCurrentConfiguration(environment: Environment, cwd: string): Promise<PersistedOptions | undefined>;
+export declare function writeFiles(environment: Environment, cwd: string, output: {
+    files: Record<string, string>;
+    deletedFiles: Array<string>;
+}, forced: boolean): Promise<void>;
+export declare function runNewCommands(environment: Environment, originalOptions: PersistedOptions, cwd: string, output: {
+    commands: Array<{
+        command: string;
+        args: Array<string>;
+    }>;
+}): Promise<void>;
+export declare function addToApp(environment: Environment, addOns: Array<string>, cwd: string, options?: {
+    forced?: boolean;
+}): Promise<void>;

package/dist/types/config-file.d.ts

@@ -1,7 +1,10 @@
-import type { Environment, Options } from './types';
-export type PersistedOptions = Exclude<Partial<Options>, 'addOns' | 'chosenAddOns'> & {
+import type { Environment, Options } from './types.js';
+export type PersistedOptions = Omit<Partial<Options>, 'addOns' | 'chosenAddOns' | 'framework' | 'starter' | 'targetDir'> & {
+    framework: string;
     version: number;
-    existingAddOns: Array<string>;
+    chosenAddOns: Array<string>;
+    starter?: string;
 };
-export declare function writeConfigFile(environment: Environment, targetDir: string, options: Options): Promise<void>;
+export declare function writeConfigFileToEnvironment(environment: Environment, options: Options): Promise<void>;
+export declare function readConfigFileFromEnvironment(environment: Environment, targetDir: string): Promise<PersistedOptions | null>;
 export declare function readConfigFile(targetDir: string): Promise<PersistedOptions | null>;

package/dist/types/constants.d.ts

@@ -1,6 +1,3 @@
-import type { Framework } from './types.js';
 export declare const CODE_ROUTER = "code-router";
 export declare const FILE_ROUTER = "file-router";
-export declare const SUPPORTED_FRAMEWORKS: Array<Framework>;
-export declare const DEFAULT_FRAMEWORK: Framework;
 export declare const CONFIG_FILE = ".cta.json";

package/dist/types/create-app.d.ts

@@ -1,8 +1,2 @@
 import type { Environment, Options } from './types.js';
-export declare function createApp(options: Options, { silent, environment, cwd, appName, }: {
-    silent?: boolean;
-    environment: Environment;
-    cwd?: string;
-    name?: string;
-    appName?: string;
-}): Promise<void>;
+export declare function createApp(environment: Environment, options: Options): Promise<void>;

package/dist/types/custom-add-ons/add-on.d.ts

@@ -0,0 +1,69 @@
+import type { PersistedOptions } from '../config-file';
+import type { AddOn, AddOnInfo, Environment } from '../types';
+export declare const ADD_ON_IGNORE_FILES: Array<string>;
+export declare function camelCase(str: string): string;
+export declare function templatize(routeCode: string, routeFile: string): {
+    url: string;
+    code: string;
+    name: string;
+    jsName: string;
+};
+export declare function validateAddOnSetup(environment: Environment): Promise<void>;
+export declare function readOrGenerateAddOnInfo(options: PersistedOptions): Promise<AddOnInfo>;
+export declare function generateProject(persistedOptions: PersistedOptions): Promise<{
+    info: {
+        id: string;
+        name: string;
+        description: string;
+        type: "add-on" | "example" | "starter" | "toolchain";
+        modes: string[];
+        phase: "add-on" | "setup";
+        command?: {
+            command: string;
+            args?: string[] | undefined;
+        } | undefined;
+        author?: string | undefined;
+        version?: string | undefined;
+        link?: string | undefined;
+        license?: string | undefined;
+        warning?: string | undefined;
+        routes?: {
+            path: string;
+            jsName: string;
+            name?: string | undefined;
+            url?: string | undefined;
+        }[] | undefined;
+        packageAdditions?: {
+            dependencies?: Record<string, string> | undefined;
+            devDependencies?: Record<string, string> | undefined;
+            scripts?: Record<string, string> | undefined;
+        } | undefined;
+        shadcnComponents?: string[] | undefined;
+        dependsOn?: string[] | undefined;
+        smallLogo?: string | undefined;
+        logo?: string | undefined;
+        addOnSpecialSteps?: string[] | undefined;
+        createSpecialSteps?: string[] | undefined;
+        integrations?: {
+            type: string;
+            path: string;
+            jsName: string;
+        }[] | undefined;
+        readme?: string | undefined;
+    };
+    output: {
+        files: Record<string, string>;
+        deletedFiles: Array<string>;
+        commands: Array<{
+            command: string;
+            args: Array<string>;
+        }>;
+    };
+}>;
+export declare function buildAssetsDirectory(output: {
+    files: Record<string, string>;
+}, info: AddOnInfo): Promise<void>;
+export declare function updateAddOnInfo(environment: Environment): Promise<void>;
+export declare function compileAddOn(environment: Environment): Promise<void>;
+export declare function initAddOn(environment: Environment): Promise<void>;
+export declare function loadRemoteAddOn(url: string): Promise<AddOn>;

package/dist/types/custom-add-ons/shared.d.ts

@@ -0,0 +1,15 @@
+import type { Environment, Options, SerializedOptions } from '../types.js';
+import type { PersistedOptions } from '../config-file.js';
+export declare function createPackageAdditions(originalPackageJson: Record<string, any>, currentPackageJson: Record<string, any>): Record<string, any>;
+export declare function createAppOptionsFromPersisted(json: PersistedOptions): Promise<Options>;
+export declare function createSerializedOptionsFromPersisted(json: PersistedOptions): SerializedOptions;
+export declare function runCreateApp(options: Required<Options>): Promise<{
+    files: Record<string, string>;
+    deletedFiles: Array<string>;
+    commands: Array<{
+        command: string;
+        args: Array<string>;
+    }>;
+}>;
+export declare function compareFilesRecursively(path: string, ignore: (filePath: string) => boolean, original: Record<string, string>, changedFiles: Record<string, string>): Promise<void>;
+export declare function readCurrentProjectOptions(environment: Environment): Promise<PersistedOptions>;

package/dist/types/custom-add-ons/starter.d.ts

@@ -0,0 +1,7 @@
+import type { PersistedOptions } from '../config-file';
+import type { Environment, Starter, StarterInfo } from '../types';
+export declare function readOrGenerateStarterInfo(options: PersistedOptions): Promise<StarterInfo>;
+export declare function updateStarterInfo(environment: Environment): Promise<void>;
+export declare function compileStarter(environment: Environment): Promise<void>;
+export declare function initStarter(environment: Environment): Promise<void>;
+export declare function loadStarter(url: string): Promise<Starter>;

package/dist/types/environment.d.ts

@@ -1,9 +1,10 @@
 import type { Environment } from './types.js';
 export declare function createDefaultEnvironment(): Environment;
-export declare function createMemoryEnvironment(): {
+export declare function createMemoryEnvironment(returnPathsRelativeTo?: string): {
     environment: Environment;
     output: {
         files: Record<string, string>;
+        deletedFiles: Array<string>;
         commands: Array<{
             command: string;
             args: Array<string>;

package/dist/types/file-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { Environment } from './types';
+export declare function readFileHelper(path: string): string;
+export declare function isBinaryFile(path: string): boolean;
+export declare function convertBinaryContentsToBase64(contents: any): string;
+export declare function isBase64(content: string): boolean;
+export declare function getBinaryFile(content: string): string | null;
+export declare function relativePath(from: string, to: string): string;
+export declare function isDirectory(path: string): boolean;
+export declare function findFilesRecursively(path: string, files: Record<string, string>): void;
+export declare function recursivelyGatherFiles(path: string, includeProjectFiles?: boolean): Promise<Record<string, string>>;
+export declare function recursivelyGatherFilesFromEnvironment(environment: Environment, path: string, includeProjectFiles?: boolean): Promise<Record<string, string>>;
+export declare const IGNORE_FILES: string[];
+export declare function createIgnore(path: string, includeProjectFiles?: boolean): (filePath: string) => boolean;
+export declare function cleanUpFiles(files: Record<string, string>, targetDir?: string): Record<string, string>;
+export declare function cleanUpFileArray(files: Array<string>, targetDir?: string): string[];

package/dist/types/frameworks.d.ts

@@ -0,0 +1,7 @@
+import type { Framework, FrameworkDefinition } from './types.js';
+export declare function __testRegisterFramework(framework: Framework): void;
+export declare function __testClearFrameworks(): void;
+export declare function registerFramework(framework: FrameworkDefinition): void;
+export declare function getFrameworkById(id: string): Framework | undefined;
+export declare function getFrameworkByName(name: string): Framework | undefined;
+export declare function getFrameworks(): Framework[];

package/dist/types/index.d.ts

@@ -1 +1,21 @@
-export { cli } from './cli.js';
+export { createApp } from './create-app.js';
+export { addToApp } from './add-to-app.js';
+export { finalizeAddOns, getAllAddOns } from './add-ons.js';
+export { loadRemoteAddOn } from './custom-add-ons/add-on.js';
+export { loadStarter } from './custom-add-ons/starter.js';
+export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
+export { CODE_ROUTER, CONFIG_FILE, FILE_ROUTER } from './constants.js';
+export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
+export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, } from './frameworks.js';
+export { writeConfigFileToEnvironment, readConfigFileFromEnvironment, readConfigFile, } from './config-file.js';
+export { cleanUpFiles, cleanUpFileArray, readFileHelper, getBinaryFile, recursivelyGatherFiles, relativePath, } from './file-helpers.js';
+export { formatCommand } from './utils.js';
+export { initStarter, compileStarter } from './custom-add-ons/starter.js';
+export { initAddOn, compileAddOn } from './custom-add-ons/add-on.js';
+export { createAppOptionsFromPersisted, createSerializedOptionsFromPersisted, } from './custom-add-ons/shared.js';
+export { createSerializedOptions } from './options.js';
+export { getRawRegistry, getRegistry, getRegistryAddOns, getRegistryStarters, } from './registry.js';
+export { StarterCompiledSchema, StatusEvent, StatusStepType, StopEvent, AddOnCompiledSchema, AddOnInfoSchema, IntegrationSchema, } from './types.js';
+export type { AddOn, Environment, FileBundleHandler, Framework, FrameworkDefinition, Mode, Options, SerializedOptions, Starter, StarterCompiled, } from './types.js';
+export type { PersistedOptions } from './config-file.js';
+export type { PackageManager } from './package-manager.js';

package/dist/types/integrations/git.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from '../types.js';
+export declare function setupGit(environment: Environment, targetDir: string): Promise<void>;

package/dist/types/integrations/shadcn.d.ts

@@ -0,0 +1,2 @@
+import type { Environment, Options } from '../types.js';
+export declare function installShadcnComponents(environment: Environment, targetDir: string, options: Options): Promise<void>;

package/dist/types/options.d.ts

@@ -1,6 +1,2 @@
-import type { CliOptions, Mode, Options, TemplateOptions } from './types.js';
-export declare function normalizeOptions(cliOptions: CliOptions, forcedMode?: Mode, forcedAddOns?: Array<string>): Promise<Options | undefined>;
-export declare function promptForOptions(cliOptions: CliOptions, { forcedAddOns, forcedMode, }: {
-    forcedAddOns?: Array<string>;
-    forcedMode?: TemplateOptions;
-}): Promise<Required<Options> | undefined>;
+import type { Options, SerializedOptions } from './types';
+export declare const createSerializedOptions: (options: Options) => SerializedOptions;

package/dist/types/package-json.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from './types.js';
+export declare function mergePackageJSON(packageJSON: Record<string, any>, overlayPackageJSON?: Record<string, any>): {
+    dependencies: any;
+    devDependencies: any;
+    scripts: any;
+};
+export declare function createPackageJSON(options: Options): any;

package/dist/types/package-manager.d.ts

@@ -3,4 +3,21 @@ export declare const SUPPORTED_PACKAGE_MANAGERS: readonly ["npm", "yarn", "pnpm"
 export type PackageManager = (typeof SUPPORTED_PACKAGE_MANAGERS)[number];
 export declare const DEFAULT_PACKAGE_MANAGER: PackageManager;
 export declare function getPackageManager(): PackageManager | undefined;
-export declare function packageManagerExecute(environment: Environment, packagerManager: PackageManager, pkg: string, args: Array<string>, cwd: string): Promise<void>;
+export declare function getPackageManagerScriptCommand(packagerManager: PackageManager, args?: Array<string>): {
+    command: string;
+    args: string[];
+};
+export declare function getPackageManagerExecuteCommand(packagerManager: PackageManager, pkg: string, args?: Array<string>): {
+    command: string;
+    args: string[];
+};
+export declare function getPackageManagerInstallCommand(packagerManager: PackageManager, pkg?: string, isDev?: boolean): {
+    command: "npm" | "yarn" | "pnpm" | "bun" | "deno";
+    args: string[];
+};
+export declare function packageManagerInstall(environment: Environment, cwd: string, packagerManager: PackageManager, pkg?: string): Promise<{
+    stdout: string;
+}>;
+export declare function packageManagerExecute(environment: Environment, cwd: string, packagerManager: PackageManager, pkg: string, args: Array<string>): Promise<{
+    stdout: string;
+}>;

package/dist/types/registry.d.ts

@@ -0,0 +1,25 @@
+import type { AddOn, Mode, Starter } from './types';
+export type Registry = {
+    starters: Array<{
+        name: string;
+        description: string;
+        url: string;
+        banner?: string;
+        mode: Mode;
+        framework: string;
+    }>;
+    'add-ons': Array<{
+        name: string;
+        description: string;
+        url: string;
+        modes: Array<Mode>;
+        framework: string;
+    }>;
+};
+export declare function getRawRegistry(registryUrl?: string): Promise<Registry | undefined>;
+export declare function getRegistryAddOns(registryUrl?: string): Promise<Array<AddOn>>;
+export declare function getRegistryStarters(registryUrl?: string): Promise<Array<Starter>>;
+export declare function getRegistry(registryUrl?: string): Promise<{
+    addOns: Array<AddOn>;
+    starters: Array<Starter>;
+}>;

package/dist/types/special-steps/index.d.ts

@@ -0,0 +1,2 @@
+import type { Environment, Options } from '../types.js';
+export declare function runSpecialSteps(environment: Environment, options: Options, specialSteps: Array<string>): Promise<void>;

package/dist/types/special-steps/rimraf-node-modules.d.ts

@@ -0,0 +1,2 @@
+import type { Environment, Options } from '../types.js';
+export declare function rimrafNodeModules(environment: Environment, options: Options): Promise<void>;

package/dist/types/template-file.d.ts

@@ -0,0 +1,2 @@
+import type { Environment, Options } from './types.js';
+export declare function createTemplateFile(environment: Environment, options: Options): (file: string, content: string) => Promise<void>;