@tanstack/cta-engine 0.10.0-alpha.19 → 0.10.0-alpha.21

package/dist/index.js

@@ -1,10 +1,17 @@
 export { createApp } from './create-app.js';
 export { addToApp } from './add-to-app.js';
-export { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.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, getPackageManagerInstallCommand, getPackageManagerExecuteCommand, getPackageManagerScriptCommand, packageManagerInstall, packageManagerExecute, } from './package-manager.js';
+export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
 export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, } from './frameworks.js';
-export { formatCommand, jsSafeName, sortObject } from './utils.js';
-export { writeConfigFile, readConfigFile } from './config-file.js';
-export { readFileHelper, getBinaryFile, relativePath } from './file-helpers.js';
+export { writeConfigFileToEnvironment, readConfigFileFromEnvironment, } 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 { StarterCompiledSchema, AddOnCompiledSchema, AddOnInfoSchema, IntegrationSchema, } from './types.js';

package/dist/integrations/shadcn.js

@@ -1,7 +1,7 @@
 import { resolve } from 'node:path';
 import { packageManagerExecute } from '../package-manager.js';
-export async function installShadcnComponents(environment, targetDir, options, silent) {
-    const s = silent ? null : environment.spinner();
+export async function installShadcnComponents(environment, targetDir, options) {
+    const s = environment.spinner();
     if (options.chosenAddOns.find((a) => a.id === 'shadcn')) {
         const shadcnComponents = new Set();
         for (const addOn of options.chosenAddOns) {
@@ -19,9 +19,15 @@ export async function installShadcnComponents(environment, targetDir, options, s
             }
         }
         if (shadcnComponents.size > 0) {
-            s?.start(`Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`);
+            s.start(`Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`);
+            environment.startStep({
+                id: 'install-shadcn-components',
+                type: 'command',
+                message: `Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`,
+            });
             await packageManagerExecute(environment, resolve(targetDir), options.packageManager, 'shadcn@latest', ['add', '--silent', '--yes', ...Array.from(shadcnComponents)]);
-            s?.stop(`Installed additional shadcn components`);
+            environment.finishStep('install-shadcn-components', 'Shadcn components installed');
+            s.stop(`Installed additional shadcn components`);
         }
     }
 }

package/dist/options.js

@@ -0,0 +1,9 @@
+export const createSerializedOptions = (options) => {
+    const serializedOptions = {
+        ...options,
+        chosenAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+        framework: options.framework.id,
+        starter: options.starter?.id,
+    };
+    return serializedOptions;
+};

package/dist/package-json.js

@@ -1,19 +1,19 @@
 import { FILE_ROUTER } from './constants.js';
 import { sortObject } from './utils.js';
-function mergePackageJSON(packageJSON, overlayPackageJSON) {
+export function mergePackageJSON(packageJSON, overlayPackageJSON) {
     return {
         ...packageJSON,
         dependencies: {
             ...packageJSON.dependencies,
-            ...overlayPackageJSON.dependencies,
+            ...(overlayPackageJSON?.dependencies || {}),
         },
         devDependencies: {
             ...packageJSON.devDependencies,
-            ...overlayPackageJSON.devDependencies,
+            ...(overlayPackageJSON?.devDependencies || {}),
         },
         scripts: {
             ...packageJSON.scripts,
-            ...overlayPackageJSON.scripts,
+            ...(overlayPackageJSON?.scripts || {}),
         },
     };
 }
@@ -39,6 +39,9 @@ export function createPackageJSON(options) {
     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/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

@@ -11,7 +11,7 @@ function convertDotFilesAndPaths(path) {
         .map((segment) => segment.replace(/^_dot_/, '.'))
         .join('/');
 }
-export function createTemplateFile(environment, options, targetDir) {
+export function createTemplateFile(environment, options) {
     function getPackageManagerAddScript(packageName, isDev = false) {
         return formatCommand(getPackageManagerInstallCommand(options.packageManager, packageName, isDev));
     }
@@ -41,15 +41,6 @@ export function createTemplateFile(environment, options, targetDir) {
             routes.push(...addOn.routes);
         }
     }
-    const variables = {
-        ...options.variableValues,
-        ...options.chosenAddOns.reduce((acc, addOn) => {
-            return {
-                ...acc,
-                ...addOn.variables,
-            };
-        }, {}),
-    };
     const addOnEnabled = options.chosenAddOns.reduce((acc, addOn) => {
         acc[addOn.id] = true;
         return acc;
@@ -68,7 +59,6 @@ export function createTemplateFile(environment, options, targetDir) {
             addOns: options.chosenAddOns,
             integrations,
             routes,
-            variables,
             getPackageManagerAddScript,
             getPackageManagerRunScript,
             relativePath: (path) => relativePath(file, path),
@@ -113,10 +103,10 @@ export function createTemplateFile(environment, options, targetDir) {
             target = target.replace(/\.tsx$/, '.jsx').replace(/\.ts$/, '.js');
         }
         if (append) {
-            await environment.appendFile(resolve(targetDir, target), content);
+            await environment.appendFile(resolve(options.targetDir, target), content);
         }
         else {
-            await environment.writeFile(resolve(targetDir, target), content);
+            await environment.writeFile(resolve(options.targetDir, target), content);
         }
     };
 }

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

@@ -1,4 +1,3 @@
-import type { AddOn, Framework } from './types.js';
-export declare function getAllAddOns(framework: Framework, template: string): Array<AddOn>;
-export declare function finalizeAddOns(framework: Framework, template: string, chosenAddOnIDs: Array<string>): Promise<Array<AddOn>>;
-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

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

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

@@ -1,5 +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

@@ -1,4 +1,6 @@
 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;

package/dist/types/index.d.ts

@@ -1,13 +1,20 @@
 export { createApp } from './create-app.js';
 export { addToApp } from './add-to-app.js';
-export { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.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, getPackageManagerInstallCommand, getPackageManagerExecuteCommand, getPackageManagerScriptCommand, packageManagerInstall, packageManagerExecute, } from './package-manager.js';
+export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
 export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, } from './frameworks.js';
-export { formatCommand, jsSafeName, sortObject } from './utils.js';
-export { writeConfigFile, readConfigFile } from './config-file.js';
-export { readFileHelper, getBinaryFile, relativePath } from './file-helpers.js';
-export type { AddOn, Environment, FileBundleHandler, FrameworkDefinition, Mode, Options, Starter, TemplateOptions, Variable, } from './types.js';
+export { writeConfigFileToEnvironment, readConfigFileFromEnvironment, } 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 { 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/shadcn.d.ts

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

package/dist/types/options.d.ts

@@ -0,0 +1,2 @@
+import type { Options, SerializedOptions } from './types';
+export declare const createSerializedOptions: (options: Options) => SerializedOptions;

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

@@ -1,2 +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

@@ -15,5 +15,9 @@ export declare function getPackageManagerInstallCommand(packagerManager: Package
     command: "npm" | "yarn" | "pnpm" | "bun" | "deno";
     args: string[];
 };
-export declare function packageManagerInstall(environment: Environment, cwd: string, packagerManager: PackageManager, pkg?: string): Promise<void>;
-export declare function packageManagerExecute(environment: Environment, cwd: string, packagerManager: PackageManager, pkg: string, args: Array<string>): Promise<void>;
+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/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

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