@tanstack/cta-engine 0.10.0-alpha.25 → 0.10.0-alpha.26

package/dist/add-ons.js

@@ -1,73 +1,11 @@
-import { readFile } from 'node:fs/promises';
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { resolve } from 'node:path';
-import chalk from 'chalk';
-import { getTemplatesRoot } from './templates.js';
-import { DEFAULT_FRAMEWORK } from './constants.js';
-import { readFileHelper } from './file-helper.js';
-function isDirectory(path) {
-    return statSync(path).isDirectory();
-}
-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);
-        }
-    }
-}
-export async function getAllAddOns(framework, template) {
-    const addOns = [];
-    for (const type of ['add-on', 'example']) {
-        const addOnsBase = resolve(getTemplatesRoot(), framework, type);
-        if (!existsSync(addOnsBase)) {
-            continue;
-        }
-        for (const dir of await readdirSync(addOnsBase).filter((file) => isDirectory(resolve(addOnsBase, file)))) {
-            const filePath = resolve(addOnsBase, dir, 'info.json');
-            const fileContent = await readFile(filePath, 'utf-8');
-            const info = JSON.parse(fileContent);
-            if (!info.templates.includes(template)) {
-                continue;
-            }
-            let packageAdditions = {};
-            if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
-                packageAdditions = JSON.parse(await readFile(resolve(addOnsBase, dir, 'package.json'), 'utf-8'));
-            }
-            let readme;
-            if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
-                readme = await readFile(resolve(addOnsBase, dir, 'README.md'), 'utf-8');
-            }
-            const absoluteFiles = {};
-            const assetsDir = resolve(addOnsBase, dir, 'assets');
-            if (existsSync(assetsDir)) {
-                await findFilesRecursively(assetsDir, absoluteFiles);
-            }
-            const files = {};
-            for (const file of Object.keys(absoluteFiles)) {
-                files[file.replace(assetsDir, '.')] = absoluteFiles[file];
-            }
-            addOns.push({
-                ...info,
-                id: dir,
-                type,
-                packageAdditions,
-                readme,
-                files,
-                deletedFiles: [],
-            });
-        }
-    }
-    return addOns;
+import { loadRemoteAddOn } from './custom-add-ons/add-on.js';
+export function getAllAddOns(framework, mode) {
+    return framework.getAddOns().filter((a) => a.modes.includes(mode));
 }
 // Turn the list of chosen add-on IDs into a final list of add-ons by resolving dependencies
-export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
+export async function finalizeAddOns(framework, mode, chosenAddOnIDs) {
     const finalAddOnIDs = new Set(chosenAddOnIDs);
-    const addOns = await getAllAddOns(framework, template);
+    const addOns = getAllAddOns(framework, mode);
     for (const addOnID of finalAddOnIDs) {
         let addOn;
         const localAddOn = addOns.find((a) => a.id === addOnID);
@@ -92,30 +30,6 @@ export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
     const finalAddOns = [...finalAddOnIDs].map((id) => addOns.find((a) => a.id === id));
     return finalAddOns;
 }
-export async function listAddOns(options, { forcedMode, forcedAddOns = [], }) {
-    let mode = forcedMode;
-    if (!mode) {
-        if (options.template) {
-            mode =
-                options.template === 'file-router'
-                    ? 'file-router'
-                    : 'code-router';
-        }
-        else {
-            mode = 'code-router';
-        }
-    }
-    const addOns = await getAllAddOns(options.framework || DEFAULT_FRAMEWORK, mode);
-    for (const addOn of addOns.filter((a) => !forcedAddOns.includes(a.id))) {
-        console.log(`${chalk.bold(addOn.id)}: ${addOn.description}`);
-    }
-}
 function loadAddOn(addOn) {
     return addOn;
 }
-export async function loadRemoteAddOn(url) {
-    const response = await fetch(url);
-    const fileContent = await response.json();
-    fileContent.id = url;
-    return fileContent;
-}

package/dist/add-to-app.js

@@ -0,0 +1,169 @@
+import { basename, resolve } from 'node:path';
+import { CONFIG_FILE } from './constants.js';
+import { finalizeAddOns } from './add-ons.js';
+import { getFrameworkById } from './frameworks.js';
+import { createMemoryEnvironment } from './environment.js';
+import { createApp } from './create-app.js';
+import { readConfigFileFromEnvironment, writeConfigFileToEnvironment, } from './config-file.js';
+import { formatCommand } from './utils.js';
+import { packageManagerInstall } from './package-manager.js';
+import { isBase64, recursivelyGatherFilesFromEnvironment, } from './file-helpers.js';
+import { mergePackageJSON } from './package-json.js';
+import { runSpecialSteps } from './special-steps/index.js';
+export async function hasPendingGitChanges(environment, cwd) {
+    const { stdout } = await environment.execute('git', ['status', '--porcelain'], cwd);
+    return stdout.length > 0;
+}
+async function createOptions(json, addOns, targetDir) {
+    const framework = getFrameworkById(json.framework);
+    // TODO: Load the starter
+    return {
+        ...json,
+        framework,
+        tailwind: true,
+        addOns: true,
+        chosenAddOns: await finalizeAddOns(framework, json.mode, [
+            ...json.existingAddOns,
+            ...addOns,
+        ]),
+        targetDir,
+    };
+}
+async function runCreateApp(options) {
+    const { environment, output } = createMemoryEnvironment(options.targetDir);
+    await createApp(environment, options);
+    return output;
+}
+export async function getCurrentConfiguration(environment, cwd) {
+    const persistedOptions = await readConfigFileFromEnvironment(environment, cwd);
+    if (!persistedOptions) {
+        environment.error('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 undefined;
+    }
+    return persistedOptions;
+}
+export async function writeFiles(environment, cwd, output, forced) {
+    const currentFiles = await recursivelyGatherFilesFromEnvironment(environment, cwd, false);
+    const overwrittenFiles = [];
+    const changedFiles = [];
+    for (const file of Object.keys(output.files)) {
+        const relativeFile = file.replace(cwd, '');
+        if (currentFiles[relativeFile]) {
+            if (currentFiles[relativeFile] !== output.files[file]) {
+                overwrittenFiles.push(relativeFile);
+            }
+        }
+        else {
+            changedFiles.push(relativeFile);
+        }
+    }
+    if (!forced && overwrittenFiles.length) {
+        environment.warn('The following will be overwritten', [...overwrittenFiles, ...output.deletedFiles].join('\n'));
+        const shouldContinue = await environment.confirm('Do you want to continue?');
+        if (!shouldContinue) {
+            throw new Error('User cancelled');
+        }
+    }
+    for (const file of output.deletedFiles) {
+        if (environment.exists(resolve(cwd, file))) {
+            await environment.deleteFile(resolve(cwd, file));
+        }
+    }
+    environment.startStep({
+        id: 'write-files',
+        type: 'file',
+        message: 'Writing add-on files...',
+    });
+    for (const file of [...changedFiles, ...overwrittenFiles]) {
+        const fName = basename(file);
+        const contents = output.files[file];
+        if (fName === 'package.json') {
+            const currentJson = JSON.parse(await environment.readFile(resolve(cwd, file)));
+            const newJSON = mergePackageJSON(currentJson, JSON.parse(contents));
+            environment.writeFile(resolve(cwd, file), JSON.stringify(newJSON, null, 2));
+        }
+        else if (fName !== CONFIG_FILE) {
+            if (isBase64(contents)) {
+                await environment.writeFileBase64(resolve(cwd, file), contents);
+            }
+            else {
+                await environment.writeFile(resolve(cwd, file), contents);
+            }
+        }
+    }
+    environment.finishStep('write-files', 'Add-on files written');
+}
+export async function runNewCommands(environment, originalOptions, cwd, output) {
+    const originalOutput = await runCreateApp({
+        ...(await createOptions(originalOptions, [], cwd)),
+    });
+    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)) {
+            environment.startStep({
+                id: 'run-commands',
+                type: 'command',
+                message: `Running ${formatCommand({ command: command.command, args: command.args })}...`,
+            });
+            await environment.execute(command.command, command.args, cwd);
+            environment.finishStep('run-commands', 'Setup commands complete');
+        }
+    }
+}
+export async function addToApp(environment, addOns, cwd, options) {
+    const persistedOptions = await getCurrentConfiguration(environment, cwd);
+    if (!persistedOptions) {
+        return;
+    }
+    if (!options?.forced && (await hasPendingGitChanges(environment, cwd))) {
+        environment.error('You have pending git changes.', 'Please commit or stash them before adding add-ons.');
+        return;
+    }
+    environment.intro(`Adding ${addOns.join(', ')} to the project...`);
+    environment.startStep({
+        id: 'processing-new-app-setup',
+        type: 'file',
+        message: 'Processing new app setup...',
+    });
+    const newOptions = await createOptions(persistedOptions, addOns, cwd);
+    const output = await runCreateApp({
+        ...newOptions,
+        targetDir: cwd,
+    });
+    await writeFiles(environment, cwd, output, !!options?.forced);
+    environment.finishStep('processing-new-app-setup', 'Application files written');
+    // Run any special steps for the new add-ons
+    const specialSteps = new Set([]);
+    for (const addOn of newOptions.chosenAddOns) {
+        for (const step of addOn.addOnSpecialSteps || []) {
+            if (addOns.includes(addOn.id)) {
+                specialSteps.add(step);
+            }
+        }
+    }
+    if (specialSteps.size) {
+        await runSpecialSteps(environment, newOptions, Array.from(specialSteps));
+    }
+    // Install dependencies
+    environment.startStep({
+        id: 'install-dependencies',
+        type: 'package-manager',
+        message: `Installing dependencies via ${newOptions.packageManager}...`,
+    });
+    const s = environment.spinner();
+    s.start(`Installing dependencies via ${newOptions.packageManager}...`);
+    await packageManagerInstall(environment, newOptions.targetDir, newOptions.packageManager);
+    s.stop(`Installed dependencies`);
+    environment.finishStep('install-dependencies', 'Dependencies installed');
+    // Handle new commands
+    await runNewCommands(environment, persistedOptions, cwd, output);
+    environment.startStep({
+        id: 'write-config-file',
+        type: 'file',
+        message: 'Writing config file...',
+    });
+    writeConfigFileToEnvironment(environment, newOptions);
+    environment.finishStep('write-config-file', 'Config file written');
+    environment.outro('Add-ons added successfully!');
+}

package/dist/config-file.js

@@ -1,20 +1,25 @@
-import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { CONFIG_FILE } from './constants.js';
-export async function writeConfigFile(environment, targetDir, options) {
-    const persistedOptions = {
-        ...options,
+function createPersistedOptions(options) {
+    /* eslint-disable unused-imports/no-unused-vars */
+    const { chosenAddOns, framework, targetDir, ...rest } = options;
+    /* eslint-enable unused-imports/no-unused-vars */
+    return {
+        ...rest,
         version: 1,
+        framework: options.framework.id,
         existingAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+        starter: options.starter?.id ?? undefined,
     };
-    delete persistedOptions.addOns;
-    delete persistedOptions.chosenAddOns;
-    await environment.writeFile(resolve(targetDir, CONFIG_FILE), JSON.stringify(persistedOptions, null, 2));
 }
-export async function readConfigFile(targetDir) {
+export async function writeConfigFileToEnvironment(environment, options) {
+    await environment.writeFile(resolve(options.targetDir, CONFIG_FILE), JSON.stringify(createPersistedOptions(options), null, 2));
+}
+export async function readConfigFileFromEnvironment(environment, targetDir) {
     try {
         const configFile = resolve(targetDir, CONFIG_FILE);
-        const config = await readFile(configFile, 'utf8');
+        const config = await environment.readFile(configFile);
+        // TODO: Look for old config files and convert them to the new format
         return JSON.parse(config);
     }
     catch {

package/dist/constants.js

@@ -1,5 +1,3 @@
 export const CODE_ROUTER = 'code-router';
 export const FILE_ROUTER = 'file-router';
-export const SUPPORTED_FRAMEWORKS = ['solid', 'react'];
-export const DEFAULT_FRAMEWORK = 'react';
 export const CONFIG_FILE = '.cta.json';