@tanstack/cta-engine 0.14.3 → 0.14.4

package/dist/add.js

@@ -1,125 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { existsSync, statSync } from 'node:fs';
-import { basename, dirname, resolve } from 'node:path';
-import chalk from 'chalk';
-import { execa, execaSync } from 'execa';
-import { cancel, confirm, intro, isCancel, log, outro, spinner, } from '@clack/prompts';
-import { CONFIG_FILE } from './constants.js';
-import { createDefaultEnvironment, createMemoryEnvironment, } from './environment.js';
-import { createApp } from './create-app.js';
-import { finalizeAddOns } from './add-ons.js';
-import { sortObject } from './utils.js';
-import { readConfigFile, writeConfigFile } from './config-file.js';
-function isDirectory(path) {
-    return statSync(path).isDirectory();
-}
-async function hasPendingGitChanges() {
-    const status = await execaSync('git', ['status', '--porcelain']);
-    return status.stdout.length > 0;
-}
-async function createOptions(json, addOns) {
-    return {
-        ...json,
-        tailwind: true,
-        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [...json.existingAddOns, ...addOns]),
-    };
-}
-async function runCreateApp(options) {
-    const { environment, output } = createMemoryEnvironment();
-    await createApp(options, {
-        silent: true,
-        environment,
-        cwd: process.cwd(),
-        name: 'create-tsrouter-app',
-    });
-    return output;
-}
-export async function add(addOns, { silent = false, } = {}) {
-    const persistedOptions = await readConfigFile(process.cwd());
-    if (!persistedOptions) {
-        console.error(`${chalk.red('There is no .cta.json file in your project.')}
-
-This is probably because this was created with an older version of create-tsrouter-app.`);
-        return;
-    }
-    if (!silent) {
-        intro(`Adding ${addOns.join(', ')} to the project...`);
-    }
-    if (await hasPendingGitChanges()) {
-        log.error(`${chalk.red('You have pending git changes.')} Please commit or stash them before adding add-ons.`);
-        return;
-    }
-    const newOptions = await createOptions(persistedOptions, addOns);
-    const output = await runCreateApp(newOptions);
-    const overwrittenFiles = [];
-    const changedFiles = [];
-    const contentMap = new Map();
-    for (const file of Object.keys(output.files)) {
-        const relativeFile = file.replace(process.cwd(), '');
-        if (existsSync(file)) {
-            if (!isDirectory(file)) {
-                const contents = (await readFile(file)).toString();
-                if (['package.json', CONFIG_FILE].includes(basename(file)) ||
-                    contents !== output.files[file]) {
-                    overwrittenFiles.push(relativeFile);
-                    contentMap.set(relativeFile, output.files[file]);
-                }
-            }
-        }
-        else {
-            changedFiles.push(relativeFile);
-            contentMap.set(relativeFile, output.files[file]);
-        }
-    }
-    if (overwrittenFiles.length > 0 && !silent) {
-        log.warn(`${chalk.yellow('The following will be overwritten:')}\n${overwrittenFiles.join('\n')}`);
-        const shouldContinue = await confirm({
-            message: 'Do you want to continue?',
-        });
-        if (isCancel(shouldContinue)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-    }
-    for (const file of [...changedFiles, ...overwrittenFiles]) {
-        const targetFile = `.${file}`;
-        const fName = basename(file);
-        const contents = contentMap.get(file);
-        if (fName === 'package.json') {
-            const currentJson = JSON.parse((await readFile(resolve(fName), 'utf-8')).toString());
-            const newJson = JSON.parse(contents);
-            currentJson.scripts = newJson.scripts;
-            currentJson.dependencies = sortObject({
-                ...currentJson.dependencies,
-                ...newJson.dependencies,
-            });
-            currentJson.devDependencies = sortObject({
-                ...currentJson.devDependencies,
-                ...newJson.devDependencies,
-            });
-            await writeFile(targetFile, JSON.stringify(currentJson, null, 2));
-        }
-        else if (fName !== CONFIG_FILE) {
-            await mkdir(resolve(dirname(targetFile)), { recursive: true });
-            await writeFile(resolve(targetFile), contents);
-        }
-    }
-    // Handle commands
-    const originalOutput = await runCreateApp(await createOptions(persistedOptions, []));
-    const originalCommands = new Set(originalOutput.commands.map((c) => [c.command, ...c.args].join(' ')));
-    for (const command of output.commands) {
-        const commandString = [command.command, ...command.args].join(' ');
-        if (!originalCommands.has(commandString)) {
-            await execa(command.command, command.args);
-        }
-    }
-    const realEnvironment = createDefaultEnvironment();
-    writeConfigFile(realEnvironment, process.cwd(), newOptions);
-    const s = silent ? null : spinner();
-    s?.start(`Installing dependencies via ${newOptions.packageManager}...`);
-    await realEnvironment.execute(newOptions.packageManager, ['install'], resolve(process.cwd()));
-    s?.stop(`Installed dependencies`);
-    if (!silent) {
-        outro('Add-ons added successfully!');
-    }
-}

package/dist/cli.js

@@ -1,132 +0,0 @@
-import { Command, InvalidArgumentError } from 'commander';
-import { intro, log } from '@clack/prompts';
-import { createApp } from './create-app.js';
-import { normalizeOptions, promptForOptions } from './options.js';
-import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js';
-import { SUPPORTED_TOOLCHAINS } from './toolchain.js';
-import runServer from './mcp.js';
-import { listAddOns } from './add-ons.js';
-import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js';
-// import { initAddOn } from './custom-add-on.js'
-import { createDefaultEnvironment } from './environment.js';
-export function cli({ name, appName, forcedMode, forcedAddOns, }) {
-    const program = new Command();
-    program.name(name).description(`CLI to create a new ${appName} application`);
-    // program
-    //   .command('add')
-    //   .argument('add-on', 'Name of the add-on (or add-ons separated by commas)')
-    //   .action(async (addOn: string) => {
-    //     await add(addOn.split(',').map((addon) => addon.trim()))
-    //   })
-    // program
-    //   .command('update-add-on')
-    //   .description('Create or update an add-on from the current project')
-    //   .action(async () => {
-    //     await initAddOn('add-on')
-    //   })
-    // program
-    //   .command('update-overlay')
-    //   .description('Create or update a project overlay from the current project')
-    //   .action(async () => {
-    //     await initAddOn('overlay')
-    //   })
-    program.argument('[project-name]', 'name of the project');
-    if (!forcedMode) {
-        program.option('--template <type>', 'project template (typescript, javascript, file-router)', (value) => {
-            if (value !== 'typescript' &&
-                value !== 'javascript' &&
-                value !== 'file-router') {
-                throw new InvalidArgumentError(`Invalid template: ${value}. Only the following are allowed: typescript, javascript, file-router`);
-            }
-            return value;
-        });
-    }
-    program
-        .option('--framework <type>', 'project framework (solid, react)', (value) => {
-        if (!SUPPORTED_FRAMEWORKS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid framework: ${value}. Only the following are allowed: ${SUPPORTED_FRAMEWORKS.join(', ')}`);
-        }
-        return value;
-    }, DEFAULT_FRAMEWORK)
-        // .option('--overlay [url]', 'add an overlay from a URL', false)
-        .option(`--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`, `Explicitly tell the CLI to use this package manager`, (value) => {
-        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
-        }
-        return value;
-    })
-        .option(`--toolchain <${SUPPORTED_TOOLCHAINS.join('|')}>`, `Explicitly tell the CLI to use this toolchain`, (value) => {
-        if (!SUPPORTED_TOOLCHAINS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid toolchain: ${value}. The following are allowed: ${SUPPORTED_TOOLCHAINS.join(', ')}`);
-        }
-        return value;
-    })
-        .option('--interactive', 'interactive mode', false)
-        .option('--tailwind', 'add Tailwind CSS', false)
-        .option('--add-ons [...add-ons]', 'pick from a list of available add-ons (comma separated list)', (value) => {
-        let addOns = !!value;
-        if (typeof value === 'string') {
-            addOns = value.split(',').map((addon) => addon.trim());
-        }
-        return addOns;
-    })
-        .option('--list-add-ons', 'list all available add-ons', false)
-        .option('--no-git', 'do not create a git repository')
-        .option('--target-dir <path>', 'the target directory for the application root')
-        .option('--mcp', 'run the MCP server', false)
-        .option('--mcp-sse', 'run the MCP server in SSE mode', false);
-    program.action(async (projectName, options) => {
-        if (options.listAddOns) {
-            await listAddOns(options, {
-                forcedMode: forcedMode,
-                forcedAddOns,
-            });
-        }
-        else if (options.mcp || options.mcpSse) {
-            await runServer(!!options.mcpSse, {
-                forcedMode: forcedMode,
-                forcedAddOns,
-                appName,
-            });
-        }
-        else {
-            try {
-                const cliOptions = {
-                    projectName,
-                    ...options,
-                };
-                if (forcedMode) {
-                    cliOptions.template = forcedMode;
-                }
-                let finalOptions;
-                if (cliOptions.interactive) {
-                    cliOptions.addOns = true;
-                }
-                else {
-                    finalOptions = await normalizeOptions(cliOptions, forcedMode, forcedAddOns);
-                }
-                if (finalOptions) {
-                    intro(`Creating a new ${appName} app in ${projectName}...`);
-                }
-                else {
-                    intro(`Let's configure your ${appName} application`);
-                    finalOptions = await promptForOptions(cliOptions, {
-                        forcedMode: forcedMode,
-                        forcedAddOns,
-                    });
-                }
-                await createApp(finalOptions, {
-                    environment: createDefaultEnvironment(),
-                    cwd: options.targetDir || undefined,
-                    name,
-                    appName,
-                });
-            }
-            catch (error) {
-                log.error(error instanceof Error ? error.message : 'An unknown error occurred');
-                process.exit(1);
-            }
-        }
-    });
-    program.parse();
-}

package/dist/custom-add-on.js

@@ -1,254 +0,0 @@
-import { readFile, readdir } from 'node:fs/promises';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { basename, dirname, resolve } from 'node:path';
-import chalk from 'chalk';
-import { createMemoryEnvironment } from './environment.js';
-import { createApp } from './create-app.js';
-import { readConfigFile } from './config-file.js';
-import { finalizeAddOns } from './add-ons.js';
-import { readFileHelper } from './file-helper.js';
-const INFO_FILE = {
-    'add-on': '.add-on/info.json',
-    overlay: 'overlay-info.json',
-};
-const COMPILED_FILE = {
-    'add-on': 'add-on.json',
-    overlay: 'overlay.json',
-};
-const ADD_ON_DIR = '.add-on';
-const ASSETS_DIR = 'assets';
-const IGNORE_FILES = [
-    ADD_ON_DIR,
-    'node_modules',
-    'dist',
-    'build',
-    '.git',
-    'pnpm-lock.yaml',
-    'package-lock.json',
-    'yarn.lock',
-    'bun.lockb',
-    'bun.lock',
-    'deno.lock',
-    'add-on.json',
-    'add-on-info.json',
-    'package.json',
-];
-const ADD_ON_IGNORE_FILES = [
-    'main.jsx',
-    'App.jsx',
-    'main.tsx',
-    'App.tsx',
-    'routeTree.gen.ts',
-];
-function templatize(routeCode, routeFile) {
-    let code = routeCode;
-    // Replace the import
-    code = code.replace(/import { createFileRoute } from '@tanstack\/react-router'/g, `import { <% if (fileRouter) { %>createFileRoute<% } else { %>createRoute<% } %> } from '@tanstack/react-router'`);
-    // Extract route path and definition, then transform the route declaration
-    const routeMatch = code.match(/export\s+const\s+Route\s*=\s*createFileRoute\(['"]([^'"]+)['"]\)\s*\(\{([^}]+)\}\)/);
-    let path = '';
-    if (routeMatch) {
-        const fullMatch = routeMatch[0];
-        path = routeMatch[1];
-        const routeDefinition = routeMatch[2];
-        code = code.replace(fullMatch, `<% if (codeRouter) { %>
-import type { RootRoute } from '@tanstack/react-router'
-<% } else { %>
-export const Route = createFileRoute('${path}')({${routeDefinition}})
-<% } %>`);
-        code += `
-<% if (codeRouter) { %>
-export default (parentRoute: RootRoute) => createRoute({
-  path: '${path}',
-  ${routeDefinition}
-  getParentRoute: () => parentRoute,
-})
-<% } %>
-`;
-    }
-    else {
-        console.error(`No route found in the file: ${routeFile}`);
-    }
-    const name = basename(path)
-        .replace('.tsx', '')
-        .replace(/^demo/, '')
-        .replace('.', ' ')
-        .trim();
-    return { url: path, code, name };
-}
-async function createOptions(json) {
-    return {
-        ...json,
-        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [...json.existingAddOns]),
-    };
-}
-async function runCreateApp(options) {
-    const { environment, output } = createMemoryEnvironment();
-    await createApp(options, {
-        silent: true,
-        environment,
-        cwd: process.cwd(),
-        name: 'create-tsrouter-app',
-    });
-    return output;
-}
-async function recursivelyGatherFiles(path, files) {
-    const dirFiles = await readdir(path, { withFileTypes: true });
-    for (const file of dirFiles) {
-        if (file.isDirectory()) {
-            await recursivelyGatherFiles(resolve(path, file.name), files);
-        }
-        else {
-            files[resolve(path, file.name)] = readFileHelper(resolve(path, file.name));
-        }
-    }
-}
-async function compareFiles(path, ignore, original, changedFiles) {
-    const files = await readdir(path, { withFileTypes: true });
-    for (const file of files) {
-        const filePath = `${path}/${file.name}`;
-        if (!ignore.includes(file.name)) {
-            if (file.isDirectory()) {
-                await compareFiles(filePath, ignore, original, changedFiles);
-            }
-            else {
-                const contents = (await readFile(filePath)).toString();
-                const absolutePath = resolve(process.cwd(), filePath);
-                if (!original[absolutePath] || original[absolutePath] !== contents) {
-                    changedFiles[filePath] = contents;
-                }
-            }
-        }
-    }
-}
-export async function initAddOn(mode) {
-    const persistedOptions = await readConfigFile(process.cwd());
-    if (!persistedOptions) {
-        console.error(`${chalk.red('There is no .cta.json file in your project.')}
-
-This is probably because this was created with an older version of create-tsrouter-app.`);
-        return;
-    }
-    if (mode === 'add-on') {
-        if (persistedOptions.mode !== 'file-router') {
-            console.error(`${chalk.red('This project is not using file-router mode.')}
-
-To create an add-on, the project must be created with the file-router mode.`);
-            return;
-        }
-        if (!persistedOptions.tailwind) {
-            console.error(`${chalk.red('This project is not using Tailwind CSS.')}
-
-To create an add-on, the project must be created with Tailwind CSS.`);
-            return;
-        }
-        if (!persistedOptions.typescript) {
-            console.error(`${chalk.red('This project is not using TypeScript.')}
-
-To create an add-on, the project must be created with TypeScript.`);
-            return;
-        }
-    }
-    const info = existsSync(INFO_FILE[mode])
-        ? JSON.parse((await readFile(INFO_FILE[mode])).toString())
-        : {
-            name: `${persistedOptions.projectName}-${mode}`,
-            version: '0.0.1',
-            description: mode === 'add-on' ? 'Add-on' : 'Project overlay',
-            author: 'Jane Smith <jane.smith@example.com>',
-            license: 'MIT',
-            link: `https://github.com/jane-smith/${persistedOptions.projectName}-${mode}`,
-            command: {},
-            shadcnComponents: [],
-            templates: [persistedOptions.mode],
-            routes: [],
-            warning: '',
-            variables: {},
-            phase: 'add-on',
-            type: mode,
-            packageAdditions: {
-                scripts: {},
-                dependencies: {},
-                devDependencies: {},
-            },
-        };
-    const compiledInfo = JSON.parse(JSON.stringify(info));
-    const originalOutput = await runCreateApp(await createOptions(persistedOptions));
-    const originalPackageJson = JSON.parse(originalOutput.files[resolve(process.cwd(), 'package.json')]);
-    const currentPackageJson = JSON.parse((await readFile('package.json')).toString());
-    for (const script of Object.keys(currentPackageJson.scripts)) {
-        if (originalPackageJson.scripts[script] !== currentPackageJson.scripts[script]) {
-            info.packageAdditions.scripts[script] = currentPackageJson.scripts[script];
-        }
-    }
-    const dependencies = {};
-    for (const dependency of Object.keys(currentPackageJson.dependencies)) {
-        if (originalPackageJson.dependencies[dependency] !==
-            currentPackageJson.dependencies[dependency]) {
-            dependencies[dependency] = currentPackageJson.dependencies[dependency];
-        }
-    }
-    info.packageAdditions.dependencies = dependencies;
-    const devDependencies = {};
-    for (const dependency of Object.keys(currentPackageJson.devDependencies)) {
-        if (originalPackageJson.devDependencies[dependency] !==
-            currentPackageJson.devDependencies[dependency]) {
-            devDependencies[dependency] =
-                currentPackageJson.devDependencies[dependency];
-        }
-    }
-    info.packageAdditions.devDependencies = devDependencies;
-    // Find altered files
-    const changedFiles = {};
-    await compareFiles('.', IGNORE_FILES, originalOutput.files, changedFiles);
-    if (mode === 'overlay') {
-        compiledInfo.files = changedFiles;
-    }
-    else {
-        const assetsDir = resolve(ADD_ON_DIR, ASSETS_DIR);
-        if (!existsSync(assetsDir)) {
-            await compareFiles('.', IGNORE_FILES, originalOutput.files, changedFiles);
-            for (const file of Object.keys(changedFiles).filter((file) => !ADD_ON_IGNORE_FILES.includes(basename(file)))) {
-                mkdirSync(dirname(resolve(assetsDir, file)), {
-                    recursive: true,
-                });
-                if (file.includes('/routes/')) {
-                    const { url, code, name } = templatize(changedFiles[file], file);
-                    info.routes.push({
-                        url,
-                        name,
-                    });
-                    writeFileSync(resolve(assetsDir, `${file}.ejs`), code);
-                }
-                else {
-                    writeFileSync(resolve(assetsDir, file), changedFiles[file]);
-                }
-            }
-        }
-        const addOnFiles = {};
-        await recursivelyGatherFiles(assetsDir, addOnFiles);
-        compiledInfo.files = Object.keys(addOnFiles).reduce((acc, file) => {
-            acc[file.replace(assetsDir, '.')] = addOnFiles[file];
-            return acc;
-        }, {});
-    }
-    compiledInfo.routes = info.routes;
-    compiledInfo.framework = persistedOptions.framework;
-    compiledInfo.addDependencies = persistedOptions.existingAddOns;
-    if (mode === 'overlay') {
-        compiledInfo.mode = persistedOptions.mode;
-        compiledInfo.typescript = persistedOptions.typescript;
-        compiledInfo.tailwind = persistedOptions.tailwind;
-        compiledInfo.deletedFiles = [];
-        for (const file of Object.keys(originalOutput.files)) {
-            if (!existsSync(file)) {
-                compiledInfo.deletedFiles.push(file.replace(process.cwd(), '.'));
-            }
-        }
-    }
-    if (!existsSync(resolve(INFO_FILE[mode]))) {
-        mkdirSync(resolve(dirname(INFO_FILE[mode])), { recursive: true });
-        writeFileSync(INFO_FILE[mode], JSON.stringify(info, null, 2));
-    }
-    writeFileSync(COMPILED_FILE[mode], JSON.stringify(compiledInfo, null, 2));
-}

package/dist/file-helper.js

@@ -1,18 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { extname } 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;
-}