@tanstack/create 0.49.1

package/dist/custom-add-ons/add-on.js

@@ -0,0 +1,179 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
+import { AddOnCompiledSchema } from '../types.js';
+import { createIgnore, recursivelyGatherFiles } from '../file-helpers.js';
+import { compareFilesRecursively, createAppOptionsFromPersisted, createPackageAdditions, readCurrentProjectOptions, runCreateApp, } from './shared.js';
+const ADD_ON_DIR = '.add-on';
+export const ADD_ON_IGNORE_FILES = [
+    'main.jsx',
+    'App.jsx',
+    'main.tsx',
+    'App.tsx',
+    'routeTree.gen.ts',
+];
+const INFO_FILE = '.add-on/info.json';
+const COMPILED_FILE = 'add-on.json';
+const ASSETS_DIR = 'assets';
+export function camelCase(str) {
+    return str
+        .split(/(\.|-|\/)/)
+        .filter((part) => /^[a-zA-Z]+$/.test(part))
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+export 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'
+import tailwind from '@tailwindcss/vite';
+<% } 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();
+    const jsName = camelCase(basename(path));
+    return { url: path, code, name, jsName };
+}
+export async function validateAddOnSetup(environment) {
+    const options = await readCurrentProjectOptions(environment);
+    if (options.mode === 'code-router') {
+        environment.error('This project is using code-router mode.', 'To create an add-on, the project must not use code-router mode.');
+        process.exit(1);
+    }
+    if (!options.tailwind) {
+        environment.error('This project is not using Tailwind CSS.', 'To create an add-on, the project must be created with Tailwind CSS.');
+        process.exit(1);
+    }
+    if (!options.typescript) {
+        environment.error('This project is not using TypeScript.', 'To create an add-on, the project must be created with TypeScript.');
+        process.exit(1);
+    }
+}
+export async function readOrGenerateAddOnInfo(options) {
+    const info = existsSync(INFO_FILE)
+        ? JSON.parse((await readFile(INFO_FILE)).toString())
+        : {
+            id: `${options.projectName}-add-on`,
+            name: `${options.projectName}-add-on`,
+            version: '0.0.1',
+            description: 'Add-on',
+            author: 'Jane Smith <jane.smith@example.com>',
+            tailwind: options.tailwind || true,
+            license: 'MIT',
+            link: `https://github.com/jane-smith/${options.projectName}-add-on`,
+            shadcnComponents: [],
+            framework: options.framework,
+            modes: [options.mode],
+            routes: [],
+            warning: '',
+            phase: 'add-on',
+            type: 'add-on',
+            packageAdditions: {
+                scripts: {},
+                dependencies: {},
+                devDependencies: {},
+            },
+            dependsOn: options.chosenAddOns,
+        };
+    info.tailwind = options.tailwind || true;
+    return info;
+}
+export async function generateProject(persistedOptions) {
+    const info = await readOrGenerateAddOnInfo(persistedOptions);
+    const output = await runCreateApp((await createAppOptionsFromPersisted(persistedOptions)));
+    return { info, output };
+}
+export async function buildAssetsDirectory(output, info) {
+    const assetsDir = resolve(ADD_ON_DIR, ASSETS_DIR);
+    const ignore = createIgnore(process.cwd());
+    if (!existsSync(assetsDir)) {
+        const changedFiles = {};
+        await compareFilesRecursively('.', ignore, output.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, jsName } = templatize(changedFiles[file], file);
+                info.routes || (info.routes = []);
+                if (!info.routes.find((r) => r.url === url)) {
+                    info.routes.push({
+                        url,
+                        name,
+                        jsName,
+                        path: file,
+                    });
+                }
+                writeFileSync(resolve(assetsDir, `${file}.ejs`), code);
+            }
+            else {
+                writeFileSync(resolve(assetsDir, file), changedFiles[file]);
+            }
+        }
+    }
+}
+export async function updateAddOnInfo(environment) {
+    const { info, output } = await generateProject(await readCurrentProjectOptions(environment));
+    info.packageAdditions = createPackageAdditions(JSON.parse(output.files['./package.json']), JSON.parse((await readFile('package.json')).toString()));
+    await buildAssetsDirectory(output, info);
+    mkdirSync(resolve(dirname(INFO_FILE)), { recursive: true });
+    writeFileSync(INFO_FILE, JSON.stringify(info, null, 2));
+}
+export async function compileAddOn(environment) {
+    const info = await readOrGenerateAddOnInfo(await readCurrentProjectOptions(environment));
+    const assetsDir = resolve(ADD_ON_DIR, ASSETS_DIR);
+    const compiledInfo = {
+        ...info,
+        files: await recursivelyGatherFiles(assetsDir),
+        deletedFiles: [],
+    };
+    writeFileSync(COMPILED_FILE, JSON.stringify(compiledInfo, null, 2));
+}
+export async function initAddOn(environment) {
+    await validateAddOnSetup(environment);
+    await updateAddOnInfo(environment);
+    await compileAddOn(environment);
+}
+export async function loadRemoteAddOn(url) {
+    const response = await fetch(url);
+    const jsonContent = await response.json();
+    const checked = AddOnCompiledSchema.safeParse(jsonContent);
+    if (!checked.success) {
+        throw new Error(`Invalid add-on: ${url}`);
+    }
+    const addOn = checked.data;
+    addOn.id = url;
+    const out = {
+        ...addOn,
+        getFiles: () => Promise.resolve(Object.keys(addOn.files)),
+        getFileContents: (path) => Promise.resolve(addOn.files[path]),
+        getDeletedFiles: () => Promise.resolve(addOn.deletedFiles),
+    };
+    return out;
+}

package/dist/custom-add-ons/shared.js

@@ -0,0 +1,120 @@
+import { readdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { createApp } from '../create-app.js';
+import { createMemoryEnvironment } from '../environment.js';
+import { finalizeAddOns, populateAddOnOptionsDefaults } from '../add-ons.js';
+import { getFrameworkById } from '../frameworks.js';
+import { readConfigFileFromEnvironment } from '../config-file.js';
+import { readFileHelper, toCleanPath } from '../file-helpers.js';
+import { loadStarter } from '../custom-add-ons/starter.js';
+export function createPackageAdditions(originalPackageJson, currentPackageJson) {
+    const packageAdditions = {};
+    const scripts = {};
+    for (const script of Object.keys(currentPackageJson.scripts || {})) {
+        if (originalPackageJson.scripts[script] !== currentPackageJson.scripts[script]) {
+            scripts[script] = currentPackageJson.scripts[script];
+        }
+    }
+    packageAdditions.scripts = Object.keys(scripts).length ? scripts : undefined;
+    const dependencies = {};
+    for (const dependency of Object.keys(currentPackageJson.dependencies || {})) {
+        if (originalPackageJson.dependencies[dependency] !==
+            currentPackageJson.dependencies[dependency]) {
+            dependencies[dependency] = currentPackageJson.dependencies[dependency];
+        }
+    }
+    packageAdditions.dependencies = Object.keys(dependencies).length
+        ? dependencies
+        : undefined;
+    const devDependencies = {};
+    for (const dependency of Object.keys(currentPackageJson.devDependencies || {})) {
+        if (originalPackageJson.devDependencies[dependency] !==
+            currentPackageJson.devDependencies[dependency]) {
+            devDependencies[dependency] =
+                currentPackageJson.devDependencies[dependency];
+        }
+    }
+    packageAdditions.devDependencies = Object.keys(devDependencies).length
+        ? devDependencies
+        : undefined;
+    return packageAdditions;
+}
+export async function createAppOptionsFromPersisted(json) {
+    /* eslint-disable unused-imports/no-unused-vars */
+    const { version, ...rest } = json;
+    /* eslint-enable unused-imports/no-unused-vars */
+    const framework = getFrameworkById(rest.framework);
+    const chosenAddOns = await finalizeAddOns(framework, json.mode, [
+        ...json.chosenAddOns,
+    ]);
+    return {
+        ...rest,
+        mode: json.mode,
+        projectName: json.projectName,
+        typescript: json.typescript,
+        tailwind: json.tailwind,
+        git: json.git,
+        packageManager: json.packageManager,
+        targetDir: '',
+        framework: framework,
+        starter: json.starter ? await loadStarter(json.starter) : undefined,
+        chosenAddOns,
+        addOnOptions: populateAddOnOptionsDefaults(chosenAddOns),
+    };
+}
+export function createSerializedOptionsFromPersisted(json) {
+    /* eslint-disable unused-imports/no-unused-vars */
+    const { version, ...rest } = json;
+    /* eslint-enable unused-imports/no-unused-vars */
+    return {
+        ...rest,
+        mode: json.mode,
+        projectName: json.projectName,
+        typescript: json.typescript,
+        tailwind: json.tailwind,
+        git: json.git,
+        packageManager: json.packageManager,
+        targetDir: '',
+        framework: json.framework,
+        starter: json.starter,
+        addOnOptions: {},
+    };
+}
+export async function runCreateApp(options) {
+    const { environment, output } = createMemoryEnvironment();
+    const targetDir = resolve(process.cwd());
+    await createApp(environment, {
+        ...options,
+        targetDir,
+    });
+    output.files = Object.fromEntries(Object.entries(output.files).map(([key, value]) => [
+        toCleanPath(key, targetDir),
+        value,
+    ]));
+    return output;
+}
+export async function compareFilesRecursively(path, ignore, original, changedFiles) {
+    const files = await readdir(path, { withFileTypes: true });
+    for (const file of files) {
+        const filePath = `${path}/${file.name}`;
+        if (!ignore(file.name)) {
+            if (file.isDirectory()) {
+                await compareFilesRecursively(filePath, ignore, original, changedFiles);
+            }
+            else {
+                const contents = await readFileHelper(filePath);
+                if (!original[filePath] || original[filePath] !== contents) {
+                    changedFiles[filePath] = contents;
+                }
+            }
+        }
+    }
+}
+export async function readCurrentProjectOptions(environment) {
+    const persistedOptions = await readConfigFileFromEnvironment(environment, process.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.`);
+        process.exit(1);
+    }
+    return persistedOptions;
+}

package/dist/custom-add-ons/starter.js

@@ -0,0 +1,84 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { StarterCompiledSchema } from '../types.js';
+import { createIgnore } from '../file-helpers.js';
+import { compareFilesRecursively, createAppOptionsFromPersisted, createPackageAdditions, readCurrentProjectOptions, runCreateApp, } from './shared.js';
+const INFO_FILE = 'starter-info.json';
+const COMPILED_FILE = 'starter.json';
+export async function readOrGenerateStarterInfo(options) {
+    return existsSync(INFO_FILE)
+        ? JSON.parse((await readFile(INFO_FILE)).toString())
+        : {
+            id: `${options.projectName}-starter`,
+            name: `${options.projectName}-starter`,
+            version: '0.0.1',
+            description: 'Project starter',
+            author: 'Jane Smith <jane.smith@example.com>',
+            license: 'MIT',
+            link: `https://github.com/jane-smith/${options.projectName}-starter`,
+            shadcnComponents: [],
+            framework: options.framework,
+            mode: options.mode,
+            routes: [],
+            warning: '',
+            type: 'starter',
+            packageAdditions: {
+                scripts: {},
+                dependencies: {},
+                devDependencies: {},
+            },
+            dependsOn: options.chosenAddOns,
+            typescript: options.typescript,
+            tailwind: options.tailwind,
+        };
+}
+async function loadCurrentStarterInfo(environment) {
+    const persistedOptions = await readCurrentProjectOptions(environment);
+    const info = await readOrGenerateStarterInfo(persistedOptions);
+    const output = await runCreateApp((await createAppOptionsFromPersisted(persistedOptions)));
+    return { info, output };
+}
+export async function updateStarterInfo(environment) {
+    const { info, output } = await loadCurrentStarterInfo(environment);
+    info.packageAdditions = createPackageAdditions(JSON.parse(output.files['./package.json']), JSON.parse((await readFile('package.json')).toString()));
+    writeFileSync(INFO_FILE, JSON.stringify(info, null, 2));
+}
+export async function compileStarter(environment) {
+    const { info, output } = await loadCurrentStarterInfo(environment);
+    const ignore = createIgnore(process.cwd());
+    const changedFiles = {};
+    await compareFilesRecursively('.', ignore, output.files, changedFiles);
+    const deletedFiles = [];
+    for (const file of Object.keys(output.files)) {
+        if (!existsSync(resolve(process.cwd(), file))) {
+            deletedFiles.push(file);
+        }
+    }
+    const compiledInfo = {
+        ...info,
+        files: changedFiles,
+        deletedFiles,
+    };
+    writeFileSync(COMPILED_FILE, JSON.stringify(compiledInfo, null, 2));
+}
+export async function initStarter(environment) {
+    await updateStarterInfo(environment);
+    await compileStarter(environment);
+}
+export async function loadStarter(url) {
+    const response = await fetch(url);
+    const jsonContent = await response.json();
+    const checked = StarterCompiledSchema.safeParse(jsonContent);
+    if (!checked.success) {
+        throw new Error(`Invalid starter: ${url}`);
+    }
+    const starter = checked.data;
+    starter.id = url;
+    return {
+        ...starter,
+        getFiles: () => Promise.resolve(Object.keys(starter.files)),
+        getFileContents: (path) => Promise.resolve(starter.files[path]),
+        getDeletedFiles: () => Promise.resolve(starter.deletedFiles),
+    };
+}

package/dist/environment.js

@@ -0,0 +1,153 @@
+import { appendFile, copyFile, mkdir, readFile, readdir, unlink, writeFile, } from 'node:fs/promises';
+import { existsSync, statSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { execa } from 'execa';
+import { memfs } from 'memfs';
+import { rimraf } from 'rimraf';
+import { cleanUpFileArray, cleanUpFiles, getBinaryFile, } from './file-helpers.js';
+export function createDefaultEnvironment() {
+    let errors = [];
+    return {
+        startRun: () => {
+            errors = [];
+        },
+        finishRun: () => { },
+        getErrors: () => errors,
+        appendFile: async (path, contents) => {
+            await mkdir(dirname(path), { recursive: true });
+            return appendFile(path, contents);
+        },
+        copyFile: async (from, to) => {
+            await mkdir(dirname(to), { recursive: true });
+            return copyFile(from, to);
+        },
+        writeFile: async (path, contents) => {
+            await mkdir(dirname(path), { recursive: true });
+            return writeFile(path, contents);
+        },
+        writeFileBase64: async (path, base64Contents) => {
+            await mkdir(dirname(path), { recursive: true });
+            return writeFile(path, getBinaryFile(base64Contents));
+        },
+        execute: async (command, args, cwd, options) => {
+            try {
+                if (options?.inherit) {
+                    // For commands that should show output directly to the user
+                    await execa(command, args, {
+                        cwd,
+                        stdio: 'inherit',
+                    });
+                    return { stdout: '' };
+                }
+                else {
+                    // For commands where we need to capture output
+                    const result = await execa(command, args, {
+                        cwd,
+                    });
+                    return { stdout: result.stdout };
+                }
+            }
+            catch {
+                errors.push(`Command "${command} ${args.join(' ')}" did not run successfully. Please run this manually in your project.`);
+                return { stdout: '' };
+            }
+        },
+        deleteFile: async (path) => {
+            if (existsSync(path)) {
+                await unlink(path);
+            }
+        },
+        readFile: async (path) => {
+            return (await readFile(path)).toString();
+        },
+        exists: (path) => existsSync(path),
+        isDirectory: (path) => statSync(path).isDirectory(),
+        readdir: async (path) => readdir(path),
+        rimraf: async (path) => {
+            await rimraf(path);
+        },
+        appName: 'TanStack',
+        startStep: () => { },
+        finishStep: () => { },
+        intro: () => { },
+        outro: () => { },
+        info: () => { },
+        error: () => { },
+        warn: () => { },
+        confirm: () => Promise.resolve(true),
+        spinner: () => ({
+            start: () => { },
+            stop: () => { },
+        }),
+    };
+}
+export function createMemoryEnvironment(returnPathsRelativeTo = '') {
+    const environment = createDefaultEnvironment();
+    const output = {
+        files: {},
+        commands: [],
+        deletedFiles: [],
+    };
+    const { fs, vol } = memfs({});
+    environment.appendFile = async (path, contents) => {
+        fs.mkdirSync(dirname(path), { recursive: true });
+        await fs.appendFileSync(path, contents);
+    };
+    environment.copyFile = async (from, to) => {
+        fs.mkdirSync(dirname(to), { recursive: true });
+        fs.copyFileSync(from, to);
+        return Promise.resolve();
+    };
+    environment.execute = async (command, args) => {
+        output.commands.push({
+            command,
+            args,
+        });
+        return Promise.resolve({ stdout: '' });
+    };
+    environment.readFile = async (path) => {
+        return Promise.resolve(fs.readFileSync(path, 'utf-8').toString());
+    };
+    environment.writeFile = async (path, contents) => {
+        fs.mkdirSync(dirname(path), { recursive: true });
+        await fs.writeFileSync(path, contents);
+    };
+    environment.writeFileBase64 = async (path, contents) => {
+        // For the in-memory file system, we are not converting the base64 to binary
+        // because it's not needed.
+        fs.mkdirSync(dirname(path), { recursive: true });
+        await fs.writeFileSync(path, contents);
+    };
+    environment.deleteFile = async (path) => {
+        output.deletedFiles.push(path);
+        if (fs.existsSync(path)) {
+            await fs.unlinkSync(path);
+        }
+    };
+    environment.finishRun = () => {
+        output.files = vol.toJSON();
+        for (const file of Object.keys(output.files)) {
+            if (fs.statSync(file).isDirectory()) {
+                delete output.files[file];
+            }
+        }
+        if (returnPathsRelativeTo.length) {
+            output.files = cleanUpFiles(output.files, returnPathsRelativeTo);
+            output.deletedFiles = cleanUpFileArray(output.deletedFiles, returnPathsRelativeTo);
+        }
+    };
+    environment.exists = (path) => {
+        return fs.existsSync(path);
+    };
+    environment.isDirectory = (path) => {
+        return fs.statSync(path).isDirectory();
+    };
+    environment.readdir = async (path) => {
+        return Promise.resolve(fs.readdirSync(path).map((d) => d.toString()));
+    };
+    environment.rimraf = async () => { };
+    return {
+        environment,
+        output,
+    };
+}