@tanstack/cta-engine 0.10.0-alpha.15 → 0.10.0-alpha.16

package/dist/file-helpers.js

@@ -0,0 +1,59 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, extname, resolve } from 'node:path';
+const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico'];
+export function readFileHelper(path) {
+    if (BINARY_EXTENSIONS.includes(extname(path))) {
+        return `base64::${readFileSync(path).toString('base64')}`;
+    }
+    else {
+        return readFileSync(path, 'utf-8').toString();
+    }
+}
+export function getBinaryFile(content) {
+    if (content.startsWith('base64::')) {
+        const binaryContent = Buffer.from(content.replace('base64::', ''), 'base64');
+        return binaryContent;
+    }
+    return null;
+}
+export function relativePath(from, to) {
+    const cleanedFrom = from.startsWith('./') ? from.slice(2) : from;
+    const cleanedTo = to.startsWith('./') ? to.slice(2) : to;
+    const fromSegments = cleanedFrom.split('/');
+    const toSegments = cleanedTo.split('/');
+    fromSegments.pop();
+    toSegments.pop();
+    let commonIndex = 0;
+    while (commonIndex < fromSegments.length &&
+        commonIndex < toSegments.length &&
+        fromSegments[commonIndex] === toSegments[commonIndex]) {
+        commonIndex++;
+    }
+    const upLevels = fromSegments.length - commonIndex;
+    const downLevels = toSegments.slice(commonIndex);
+    if (upLevels === 0 && downLevels.length === 0) {
+        return `./${basename(to)}`;
+    }
+    else if (upLevels === 0 && downLevels.length > 0) {
+        return `./${downLevels.join('/')}/${basename(to)}`;
+    }
+    else {
+        const relativePath = [...Array(upLevels).fill('..'), ...downLevels].join('/');
+        return `${relativePath}/${basename(to)}`;
+    }
+}
+export function isDirectory(path) {
+    return statSync(path).isDirectory();
+}
+export function findFilesRecursively(path, files) {
+    const dirFiles = readdirSync(path);
+    for (const file of dirFiles) {
+        const filePath = resolve(path, file);
+        if (isDirectory(filePath)) {
+            findFilesRecursively(filePath, files);
+        }
+        else {
+            files[filePath] = readFileHelper(filePath);
+        }
+    }
+}

package/dist/frameworks.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { findFilesRecursively, isDirectory, readFileHelper, } from './file-helpers.js';
+const frameworks = [];
+function getAddOns(framework) {
+    const addOns = [];
+    for (const addOnsBase of framework.addOnsDirectories) {
+        for (const dir of readdirSync(addOnsBase).filter((file) => isDirectory(resolve(addOnsBase, file)))) {
+            const filePath = resolve(addOnsBase, dir, 'info.json');
+            const fileContent = readFileSync(filePath, 'utf-8');
+            const info = JSON.parse(fileContent);
+            let packageAdditions = {};
+            if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
+                packageAdditions = JSON.parse(readFileSync(resolve(addOnsBase, dir, 'package.json'), 'utf-8'));
+            }
+            let readme;
+            if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
+                readme = readFileSync(resolve(addOnsBase, dir, 'README.md'), 'utf-8');
+            }
+            const absoluteFiles = {};
+            const assetsDir = resolve(addOnsBase, dir, 'assets');
+            if (existsSync(assetsDir)) {
+                findFilesRecursively(assetsDir, absoluteFiles);
+            }
+            const files = {};
+            for (const file of Object.keys(absoluteFiles)) {
+                files[file.replace(assetsDir, '.')] = readFileHelper(file);
+            }
+            const getFiles = () => {
+                return Promise.resolve(Object.keys(files));
+            };
+            const getFileContents = (path) => {
+                return Promise.resolve(files[path]);
+            };
+            addOns.push({
+                ...info,
+                id: dir,
+                packageAdditions,
+                readme,
+                files,
+                deletedFiles: [],
+                getFiles,
+                getFileContents,
+            });
+        }
+    }
+    return addOns;
+}
+export function registerFramework(framework) {
+    const baseAssetsDirectory = resolve(framework.baseDirectory, 'base');
+    const basePackageJSON = JSON.parse(readFileSync(resolve(baseAssetsDirectory, 'package.json'), 'utf8'));
+    const optionalPackages = JSON.parse(readFileSync(resolve(framework.baseDirectory, 'packages.json'), 'utf8'));
+    const addOns = getAddOns(framework);
+    const frameworkWithBundler = {
+        ...framework,
+        getFiles: () => {
+            const files = {};
+            findFilesRecursively(baseAssetsDirectory, files);
+            return Promise.resolve(Object.keys(files).map((path) => path.replace(baseAssetsDirectory, '.')));
+        },
+        getFileContents: (path) => {
+            return Promise.resolve(readFileHelper(resolve(baseAssetsDirectory, path)));
+        },
+        basePackageJSON,
+        optionalPackages,
+        getAddOns: () => addOns,
+    };
+    frameworks.push(frameworkWithBundler);
+}
+export function getFrameworkById(id) {
+    return frameworks.find((framework) => framework.id === id);
+}
+export function getFrameworkByName(name) {
+    return frameworks.find((framework) => framework.name === name);
+}
+export function getFrameworks() {
+    return frameworks;
+}

package/dist/index.js

@@ -1,5 +1,10 @@
-export { cli } from './cli.js';
-export { getAllAddOns } from './add-ons.js';
 export { createApp } from './create-app.js';
-export { createAppOptionsFromPersisted } from './custom-add-on.js';
+export { addToApp } from './add-to-app.js';
+export { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.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 { 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';

package/dist/integrations/git.js

@@ -0,0 +1,4 @@
+import { resolve } from 'node:path';
+export async function setupGit(environment, targetDir) {
+    await environment.execute('git', ['init'], resolve(targetDir));
+}

package/dist/integrations/shadcn.js

@@ -0,0 +1,27 @@
+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();
+    if (options.chosenAddOns.find((a) => a.id === 'shadcn')) {
+        const shadcnComponents = new Set();
+        for (const addOn of options.chosenAddOns) {
+            if (addOn.shadcnComponents) {
+                for (const component of addOn.shadcnComponents) {
+                    shadcnComponents.add(component);
+                }
+            }
+        }
+        if (options.starter) {
+            if (options.starter.shadcnComponents) {
+                for (const component of options.starter.shadcnComponents) {
+                    shadcnComponents.add(component);
+                }
+            }
+        }
+        if (shadcnComponents.size > 0) {
+            s?.start(`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`);
+        }
+    }
+}

package/dist/package-json.js

@@ -0,0 +1,46 @@
+import { FILE_ROUTER } from './constants.js';
+import { sortObject } from './utils.js';
+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) {
+    const addOns = options.chosenAddOns.map((addOn) => addOn.packageAdditions);
+    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 addOns) {
+        packageJSON = mergePackageJSON(packageJSON, addOn);
+    }
+    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/template-file.js

@@ -0,0 +1,108 @@
+import { resolve } 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 { getPackageManagerExecuteCommand, getPackageManagerInstallCommand, } from './package-manager.js';
+import { relativePath } from './file-helpers.js';
+function convertDotFilesAndPaths(path) {
+    return path
+        .split('/')
+        .map((segment) => segment.replace(/^_dot_/, '.'))
+        .join('/');
+}
+export function createTemplateFile(environment, options, targetDir) {
+    function getPackageManagerAddScript(packageName, isDev = false) {
+        return formatCommand(getPackageManagerInstallCommand(options.packageManager, packageName, isDev));
+    }
+    function getPackageManagerRunScript(scriptName) {
+        return formatCommand(getPackageManagerExecuteCommand(options.packageManager, scriptName));
+    }
+    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);
+        }
+    }
+    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: options.chosenAddOns.reduce((acc, addOn) => {
+                acc[addOn.id] = true;
+                return acc;
+            }, {}),
+            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(targetDir, target), content);
+        }
+        else {
+            await environment.writeFile(resolve(targetDir, target), content);
+        }
+    };
+}

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

@@ -1,8 +1,4 @@
-import type { AddOn, CliOptions, Framework, TemplateOptions } from './types.js';
-export declare function getAllAddOns(framework: Framework, template: string): Promise<Array<AddOn>>;
+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 listAddOns(options: CliOptions, { forcedMode, forcedAddOns, }: {
-    forcedMode?: TemplateOptions;
-    forcedAddOns?: Array<string>;
-}): Promise<void>;
 export declare function loadRemoteAddOn(url: string): Promise<AddOn>;

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

@@ -0,0 +1,4 @@
+import type { Environment } from './types.js';
+export declare function addToApp(addOns: Array<string>, { silent, }: {
+    silent?: boolean;
+} | undefined, environment: Environment): Promise<void>;

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

@@ -1,5 +1,6 @@
-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'> & {
+    framework: string;
     version: number;
     existingAddOns: Array<string>;
 };

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/file-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function readFileHelper(path: string): string;
+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;

package/dist/types/frameworks.d.ts

@@ -0,0 +1,5 @@
+import type { Framework, FrameworkDefinition } from './types.js';
+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,7 +1,13 @@
-export { cli } from './cli.js';
-export { getAllAddOns } from './add-ons.js';
 export { createApp } from './create-app.js';
-export { createAppOptionsFromPersisted } from './custom-add-on.js';
+export { addToApp } from './add-to-app.js';
+export { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.js';
 export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
-export type { AddOn, Framework, Mode } from './types.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 { 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 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, silent: boolean): Promise<void>;

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

@@ -0,0 +1,2 @@
+import type { Options } from './types.js';
+export declare function createPackageJSON(options: Options): any;

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

@@ -3,4 +3,17 @@ 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<void>;
+export declare function packageManagerExecute(environment: Environment, cwd: string, packagerManager: PackageManager, pkg: string, args: Array<string>): 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, targetDir: string): (file: string, content: string) => Promise<void>;