@tanstack/create 0.68.2 → 0.68.3

package/dist/edge-environment.js

@@ -0,0 +1,141 @@
+import { cleanUpFileArray, cleanUpFiles } from './edge-file-helpers.js';
+import { basenamePath, dirnamePath, joinPaths, normalizePath, } from './edge-path.js';
+function hasDirectory(files, path) {
+    const directory = normalizePath(path);
+    const prefix = directory.endsWith('/') ? directory : `${directory}/`;
+    return Object.keys(files).some((file) => file.startsWith(prefix));
+}
+function createMissingDirectoryError(path) {
+    return new Error(`Directory not found: ${path}`);
+}
+export function createMemoryEnvironment(returnPathsRelativeTo = '') {
+    const output = {
+        files: {},
+        commands: [],
+        deletedFiles: [],
+    };
+    const files = {};
+    let errors = [];
+    const environment = {
+        startRun: () => {
+            errors = [];
+            output.files = {};
+            output.commands = [];
+            output.deletedFiles = [];
+        },
+        finishRun: () => {
+            output.files = Object.keys(files).reduce((acc, file) => {
+                acc[file] = files[file];
+                return acc;
+            }, {});
+            if (returnPathsRelativeTo.length) {
+                output.files = cleanUpFiles(output.files, returnPathsRelativeTo);
+                output.deletedFiles = cleanUpFileArray(output.deletedFiles, returnPathsRelativeTo);
+            }
+        },
+        getErrors: () => errors,
+        appendFile: (path, contents) => {
+            const normalized = normalizePath(path);
+            files[normalized] = `${files[normalized] ?? ''}${contents}`;
+            return Promise.resolve();
+        },
+        copyFile: (from, to) => {
+            const normalizedFrom = normalizePath(from);
+            const normalizedTo = normalizePath(to);
+            if (!(normalizedFrom in files)) {
+                throw new Error(`File not found: ${from}`);
+            }
+            files[normalizedTo] = files[normalizedFrom];
+            return Promise.resolve();
+        },
+        writeFile: (path, contents) => {
+            files[normalizePath(path)] = contents;
+            return Promise.resolve();
+        },
+        writeFileBase64: (path, base64Contents) => {
+            files[normalizePath(path)] = base64Contents;
+            return Promise.resolve();
+        },
+        execute: (command, args) => {
+            output.commands.push({
+                command,
+                args,
+            });
+            return Promise.resolve({ stdout: '' });
+        },
+        deleteFile: (path) => {
+            const normalized = normalizePath(path);
+            output.deletedFiles.push(normalized);
+            delete files[normalized];
+            return Promise.resolve();
+        },
+        exists: (path) => {
+            const normalized = normalizePath(path);
+            return normalized in files || hasDirectory(files, normalized);
+        },
+        isDirectory: (path) => hasDirectory(files, path),
+        readFile: (path) => {
+            const normalized = normalizePath(path);
+            if (!(normalized in files)) {
+                throw new Error(`File not found: ${path}`);
+            }
+            return Promise.resolve(files[normalized]);
+        },
+        readdir: (path) => {
+            const normalized = normalizePath(path);
+            const directory = normalized === '.' ? '' : normalized;
+            const prefix = directory ? `${directory}/` : '';
+            if (directory && !hasDirectory(files, directory)) {
+                throw createMissingDirectoryError(path);
+            }
+            const entries = new Set();
+            for (const file of Object.keys(files)) {
+                if (!file.startsWith(prefix)) {
+                    continue;
+                }
+                const rest = file.slice(prefix.length);
+                const entry = rest.split('/')[0];
+                if (entry) {
+                    entries.add(entry);
+                }
+            }
+            return Promise.resolve(Array.from(entries));
+        },
+        rimraf: (path) => {
+            const normalized = normalizePath(path);
+            const prefix = normalized.endsWith('/') ? normalized : `${normalized}/`;
+            for (const file of Object.keys(files)) {
+                if (file === normalized || file.startsWith(prefix)) {
+                    delete files[file];
+                }
+            }
+            return Promise.resolve();
+        },
+        appName: 'TanStack',
+        startStep: () => { },
+        finishStep: () => { },
+        intro: () => { },
+        outro: () => { },
+        info: () => { },
+        error: (_title, message) => {
+            if (message) {
+                errors.push(message);
+            }
+        },
+        warn: () => { },
+        confirm: () => Promise.resolve(true),
+        spinner: () => ({
+            start: () => { },
+            stop: () => { },
+        }),
+    };
+    return {
+        environment,
+        output,
+        paths: {
+            basename: basenamePath,
+            dirname: dirnamePath,
+            join: joinPaths,
+        },
+    };
+}

package/dist/edge-file-helpers.js

@@ -0,0 +1,88 @@
+import { basenamePath, extnamePath } from './edge-path.js';
+import { hasDrive, stripDrive } from './utils.js';
+const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico'];
+export function isBinaryFile(path) {
+    return BINARY_EXTENSIONS.includes(extnamePath(path));
+}
+export function isBase64(content) {
+    return content.startsWith('base64::');
+}
+export function toCleanPath(absolutePath, baseDir) {
+    const normalizedPath = absolutePath.replace(/\\/g, '/');
+    const normalizedBase = baseDir.replace(/\\/g, '/');
+    let cleanPath = normalizedPath;
+    if (normalizedPath.startsWith(normalizedBase)) {
+        cleanPath = normalizedPath.slice(normalizedBase.length);
+    }
+    else if (hasDrive(normalizedPath) !== hasDrive(normalizedBase)) {
+        const pathNoDrive = stripDrive(normalizedPath);
+        const baseNoDrive = stripDrive(normalizedBase);
+        if (pathNoDrive.startsWith(baseNoDrive)) {
+            cleanPath = pathNoDrive.slice(baseNoDrive.length);
+        }
+    }
+    if (cleanPath.startsWith('/')) {
+        cleanPath = cleanPath.slice(1);
+    }
+    return cleanPath;
+}
+export function relativePath(from, to, stripExtension = false) {
+    const normalized = from.replace(/\\/g, '/');
+    const cleanedFrom = normalized.startsWith('./')
+        ? normalized.slice(2)
+        : normalized;
+    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);
+    const target = stripExtension ? to.replace(extnamePath(to), '') : to;
+    if (upLevels === 0 && downLevels.length === 0) {
+        return `./${basenamePath(target)}`;
+    }
+    else if (upLevels === 0 && downLevels.length > 0) {
+        return `./${downLevels.join('/')}/${basenamePath(target)}`;
+    }
+    else {
+        const relative = [...Array(upLevels).fill('..'), ...downLevels].join('/');
+        return `${relative}/${basenamePath(target)}`;
+    }
+}
+export function isDemoFilePath(path) {
+    if (!path)
+        return false;
+    const normalized = path.replace(/\\/g, '/');
+    if (normalized.includes('/routes/demo/') ||
+        normalized.includes('/routes/example/')) {
+        return true;
+    }
+    const filename = normalized.split('/').pop() || '';
+    return (filename.startsWith('demo.') ||
+        filename.startsWith('demo-') ||
+        filename.startsWith('example.') ||
+        filename.startsWith('example-'));
+}
+export function cleanUpFiles(files, targetDir) {
+    return Object.keys(files).reduce((acc, file) => {
+        if (basenamePath(file) !== '.cta.json') {
+            acc[targetDir ? toCleanPath(file, targetDir) : file] = files[file];
+        }
+        return acc;
+    }, {});
+}
+export function cleanUpFileArray(files, targetDir) {
+    return files.reduce((acc, file) => {
+        if (basenamePath(file) !== '.cta.json') {
+            acc.push(targetDir ? toCleanPath(file, targetDir) : file);
+        }
+        return acc;
+    }, []);
+}

package/dist/edge-frameworks.js

@@ -0,0 +1,33 @@
+import { createManifestFrameworks } from './generated/create-manifest.js';
+function createAddOn(addOn) {
+    return {
+        ...addOn,
+        getFiles: () => Promise.resolve(Object.keys(addOn.files)),
+        getFileContents: (path) => Promise.resolve(addOn.files[path]),
+        getDeletedFiles: () => Promise.resolve(addOn.deletedFiles),
+    };
+}
+export function createFrameworkFromManifest(framework) {
+    const addOns = framework.addOns.map(createAddOn);
+    const { addOns: _addOns, base, ...rest } = framework;
+    return {
+        ...rest,
+        getFiles: () => Promise.resolve(Object.keys(base)),
+        getFileContents: (path) => Promise.resolve(base[path]),
+        getDeletedFiles: () => Promise.resolve([]),
+        getAddOns: () => addOns,
+    };
+}
+const frameworks = createManifestFrameworks().map(createFrameworkFromManifest);
+export function getFrameworkById(id) {
+    if (id === 'react-cra') {
+        return frameworks.find((framework) => framework.id === 'react');
+    }
+    return frameworks.find((framework) => framework.id === id);
+}
+export function getFrameworkByName(name) {
+    return frameworks.find((framework) => framework.name.toLowerCase() === name.toLowerCase());
+}
+export function getFrameworks() {
+    return frameworks;
+}

package/dist/edge-package-json.js

@@ -0,0 +1,146 @@
+import { render } from './edge-render.js';
+import { formatCommand, sortObject } from './utils.js';
+import { getPackageManagerExecuteCommand } from './package-manager.js';
+export function mergePackageJSON(packageJSON, overlayPackageJSON) {
+    const packageDependencies = packageJSON.dependencies && typeof packageJSON.dependencies === 'object'
+        ? packageJSON.dependencies
+        : {};
+    const overlayDependencies = overlayPackageJSON?.dependencies &&
+        typeof overlayPackageJSON.dependencies === 'object'
+        ? overlayPackageJSON.dependencies
+        : {};
+    const packageDevDependencies = packageJSON.devDependencies && typeof packageJSON.devDependencies === 'object'
+        ? packageJSON.devDependencies
+        : {};
+    const overlayDevDependencies = overlayPackageJSON?.devDependencies &&
+        typeof overlayPackageJSON.devDependencies === 'object'
+        ? overlayPackageJSON.devDependencies
+        : {};
+    const packageScripts = packageJSON.scripts && typeof packageJSON.scripts === 'object'
+        ? packageJSON.scripts
+        : {};
+    const overlayScripts = overlayPackageJSON?.scripts && typeof overlayPackageJSON.scripts === 'object'
+        ? overlayPackageJSON.scripts
+        : {};
+    const mergedPackageJSON = {
+        ...packageJSON,
+        ...(overlayPackageJSON || {}),
+        dependencies: {
+            ...packageDependencies,
+            ...overlayDependencies,
+        },
+        devDependencies: {
+            ...packageDevDependencies,
+            ...overlayDevDependencies,
+        },
+        scripts: {
+            ...packageScripts,
+            ...overlayScripts,
+        },
+    };
+    const packagePnpm = packageJSON.pnpm && typeof packageJSON.pnpm === 'object'
+        ? packageJSON.pnpm
+        : undefined;
+    const overlayPnpm = overlayPackageJSON?.pnpm && typeof overlayPackageJSON.pnpm === 'object'
+        ? overlayPackageJSON.pnpm
+        : undefined;
+    const baseOnlyBuiltDependencies = Array.isArray(packagePnpm?.onlyBuiltDependencies)
+        ? packagePnpm.onlyBuiltDependencies
+        : [];
+    const overlayOnlyBuiltDependencies = Array.isArray(overlayPnpm?.onlyBuiltDependencies)
+        ? overlayPnpm.onlyBuiltDependencies
+        : [];
+    const onlyBuiltDependencies = [
+        ...new Set([
+            ...baseOnlyBuiltDependencies,
+            ...overlayOnlyBuiltDependencies,
+        ]),
+    ];
+    if (packagePnpm || overlayPnpm) {
+        mergedPackageJSON.pnpm = {
+            ...packagePnpm,
+            ...overlayPnpm,
+        };
+        if (onlyBuiltDependencies.length) {
+            const mergedPnpm = mergedPackageJSON.pnpm;
+            mergedPnpm.onlyBuiltDependencies = onlyBuiltDependencies;
+        }
+    }
+    return mergedPackageJSON;
+}
+export function createPackageJSON(options) {
+    const packageManager = options.packageManager;
+    function getPackageManagerExecuteScript(pkg, args = []) {
+        return formatCommand(getPackageManagerExecuteCommand(packageManager, pkg, args));
+    }
+    let packageJSON = {
+        ...JSON.parse(JSON.stringify(options.framework.basePackageJSON)),
+        name: options.projectName,
+    };
+    const additions = [
+        options.framework.optionalPackages.typescript,
+        options.framework.optionalPackages.tailwindcss,
+        options.mode ? options.framework.optionalPackages[options.mode] : undefined,
+    ];
+    for (const addition of additions.filter((addition) => Boolean(addition))) {
+        packageJSON = mergePackageJSON(packageJSON, addition);
+    }
+    for (const addOn of options.chosenAddOns) {
+        let addOnPackageJSON = addOn.packageAdditions;
+        if (addOn.packageTemplate) {
+            const templateValues = {
+                packageManager: options.packageManager,
+                projectName: options.projectName,
+                typescript: true,
+                tailwind: true,
+                js: 'ts',
+                jsx: 'tsx',
+                fileRouter: options.mode === 'file-router',
+                codeRouter: options.mode === 'code-router',
+                routerOnly: options.routerOnly === true,
+                addOnEnabled: options.chosenAddOns.reduce((acc, addon) => {
+                    acc[addon.id] = true;
+                    return acc;
+                }, {}),
+                addOnOption: options.addOnOptions,
+                addOns: options.chosenAddOns,
+                getPackageManagerExecuteScript,
+            };
+            try {
+                addOnPackageJSON = JSON.parse(render(addOn.packageTemplate, templateValues));
+            }
+            catch (error) {
+                console.error(`Error processing package.json.ejs for add-on ${addOn.id}:`, error);
+            }
+        }
+        packageJSON = mergePackageJSON(packageJSON, addOnPackageJSON);
+    }
+    if (options.starter) {
+        packageJSON = mergePackageJSON(packageJSON, options.starter.packageAdditions);
+    }
+    const dependencies = packageJSON.dependencies;
+    const devDependencies = packageJSON.devDependencies;
+    const scripts = packageJSON.scripts;
+    if (options.routerOnly) {
+        if (options.framework.id === 'react') {
+            delete dependencies?.['@tanstack/react-start'];
+            delete dependencies?.['@tanstack/react-router-ssr-query'];
+            packageJSON.devDependencies = {
+                ...(devDependencies ?? {}),
+                '@tanstack/router-plugin': devDependencies?.['@tanstack/router-plugin'] ?? 'latest',
+            };
+        }
+        if (options.framework.id === 'solid') {
+            delete dependencies?.['@tanstack/solid-start'];
+            delete dependencies?.['@tanstack/solid-router-ssr-query'];
+            delete scripts?.start;
+            packageJSON.devDependencies = {
+                ...(devDependencies ?? {}),
+                '@tanstack/router-plugin': devDependencies?.['@tanstack/router-plugin'] ?? 'latest',
+            };
+        }
+    }
+    packageJSON.dependencies = sortObject((packageJSON.dependencies ?? {}));
+    packageJSON.devDependencies = sortObject((packageJSON.devDependencies ?? {}));
+    return packageJSON;
+}

package/dist/edge-path.js

@@ -0,0 +1,62 @@
+export function normalizePath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    const isAbsolute = normalized.startsWith('/');
+    const parts = [];
+    for (const part of normalized.split('/')) {
+        if (!part || part === '.') {
+            continue;
+        }
+        if (part === '..') {
+            if (parts.length && parts[parts.length - 1] !== '..') {
+                parts.pop();
+            }
+            else if (!isAbsolute) {
+                parts.push(part);
+            }
+            continue;
+        }
+        parts.push(part);
+    }
+    const joined = parts.join('/');
+    if (isAbsolute) {
+        return joined ? `/${joined}` : '/';
+    }
+    return joined || '.';
+}
+export function joinPaths(...paths) {
+    const filtered = paths.filter((path) => typeof path === 'string' && path.length > 0);
+    if (!filtered.length) {
+        return '.';
+    }
+    return normalizePath(filtered.join('/'));
+}
+export function basenamePath(path) {
+    const normalized = normalizePath(path);
+    if (normalized === '/') {
+        return '';
+    }
+    return normalized.split('/').pop() ?? '';
+}
+export function dirnamePath(path) {
+    const normalized = normalizePath(path);
+    if (normalized === '/') {
+        return '/';
+    }
+    const parts = normalized.split('/');
+    parts.pop();
+    if (!parts.length) {
+        return '.';
+    }
+    if (parts.length === 1 && parts[0] === '') {
+        return '/';
+    }
+    return parts.join('/') || '.';
+}
+export function extnamePath(path) {
+    const basename = basenamePath(path);
+    const index = basename.lastIndexOf('.');
+    if (index <= 0) {
+        return '';
+    }
+    return basename.slice(index);
+}

package/dist/edge-render.js

@@ -0,0 +1,31 @@
+import { renderManifestTemplate } from './generated/create-manifest.js';
+export function render(template, data) {
+    return renderManifestTemplate(template, {
+        packageManager: undefined,
+        projectName: undefined,
+        typescript: undefined,
+        tailwind: undefined,
+        js: undefined,
+        jsx: undefined,
+        fileRouter: undefined,
+        codeRouter: undefined,
+        routerOnly: undefined,
+        includeExamples: undefined,
+        addOnEnabled: {},
+        addOnOption: {},
+        addOns: [],
+        integrations: [],
+        routes: [],
+        getPackageManagerAddScript: () => '',
+        getPackageManagerRunScript: () => '',
+        getPackageManagerExecuteScript: () => '',
+        relativePath: () => '',
+        integrationImportContent: () => '',
+        integrationImportCode: () => '',
+        renderTemplate: () => '',
+        ignoreFile: () => {
+            throw new Error('ignoreFile');
+        },
+        ...(data ?? {}),
+    });
+}

package/dist/edge-template-file.js

@@ -0,0 +1,141 @@
+import { render } from './edge-render.js';
+import { relativePath } from './edge-file-helpers.js';
+import { joinPaths } from './edge-path.js';
+import { formatCommand } from './utils.js';
+import { getPackageManagerExecuteCommand, getPackageManagerInstallCommand, getPackageManagerScriptCommand, } from './package-manager.js';
+function convertDotFilesAndPaths(path) {
+    return path
+        .split('/')
+        .map((segment) => segment.replace(/^_dot_/, '.'))
+        .join('/');
+}
+function normalizeSourceExtension(target, typescript) {
+    if (!typescript) {
+        return target;
+    }
+    const normalizedTarget = target.replace(/\\/g, '/');
+    if (!normalizedTarget.startsWith('src/')) {
+        return target;
+    }
+    if (normalizedTarget.endsWith('.js')) {
+        return `${target.slice(0, -3)}.ts`;
+    }
+    if (normalizedTarget.endsWith('.jsx')) {
+        return `${target.slice(0, -4)}.tsx`;
+    }
+    return target;
+}
+export function createTemplateFile(environment, options) {
+    function getPackageManagerAddScript(packageName, isDev = false) {
+        return formatCommand(getPackageManagerInstallCommand(options.packageManager, packageName, isDev));
+    }
+    function getPackageManagerRunScript(scriptName, args = []) {
+        return formatCommand(getPackageManagerScriptCommand(options.packageManager, [
+            scriptName,
+            ...args,
+        ]));
+    }
+    function getPackageManagerExecuteScript(pkg, args = []) {
+        return formatCommand(getPackageManagerExecuteCommand(options.packageManager, pkg, args));
+    }
+    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,
+                    _sourceId: addOn.id,
+                    _sourceName: addOn.name,
+                });
+            }
+        }
+    }
+    const routes = [];
+    for (const addOn of options.chosenAddOns) {
+        if (addOn.routes) {
+            routes.push(...addOn.routes);
+        }
+    }
+    const addOnEnabled = options.chosenAddOns.reduce((acc, addOn) => {
+        acc[addOn.id] = true;
+        return acc;
+    }, {});
+    return async function templateFile(file, content) {
+        const localRelativePath = (path, stripExtension = false) => relativePath(file, path, stripExtension);
+        const integrationImportContent = (integration) => integration.import ||
+            `import ${integration.jsName} from '${localRelativePath(integration.path || '')}'`;
+        const integrationImportCode = (integration) => integration.code || integration.jsName;
+        const templateValues = {
+            packageManager: options.packageManager,
+            projectName: options.projectName,
+            typescript: true,
+            tailwind: true,
+            js: 'ts',
+            jsx: 'tsx',
+            fileRouter: options.mode === 'file-router',
+            codeRouter: options.mode === 'code-router',
+            routerOnly: options.routerOnly === true,
+            includeExamples: options.includeExamples !== false,
+            addOnEnabled,
+            addOnOption: options.addOnOptions,
+            addOns: options.chosenAddOns,
+            integrations,
+            routes,
+            getPackageManagerAddScript,
+            getPackageManagerRunScript,
+            getPackageManagerExecuteScript,
+            relativePath: (path, stripExtension = false) => relativePath(file, path, stripExtension),
+            integrationImportContent,
+            integrationImportCode,
+            renderTemplate: (templateContent) => {
+                return render(templateContent, templateValues);
+            },
+            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 {
+                    const message = error instanceof Error ? error.message : String(error);
+                    environment.error(`EJS error in file ${file}`, message);
+                    throw error;
+                }
+            }
+        }
+        if (ignoreFile) {
+            return;
+        }
+        let target = convertDotFilesAndPaths(file.replace('.ejs', ''));
+        target = normalizeSourceExtension(target, options.typescript);
+        const prefixMatch = target.match(/^(.+\/)?__([^_]+)__(.+)$/);
+        if (prefixMatch) {
+            const [, directory, , filename] = prefixMatch;
+            target = (directory || '') + filename;
+        }
+        let append = false;
+        if (target.endsWith('.append')) {
+            append = true;
+            target = target.replace('.append', '');
+        }
+        if (append) {
+            await environment.appendFile(joinPaths(options.targetDir, target), content);
+        }
+        else {
+            await environment.writeFile(joinPaths(options.targetDir, target), content);
+        }
+    };
+}

package/dist/edge.js

@@ -0,0 +1,7 @@
+export { createApp } from './edge-create-app.js';
+export { createMemoryEnvironment, } from './edge-environment.js';
+export { getFrameworkById, getFrameworkByName, getFrameworks, } from './edge-frameworks.js';
+export { finalizeAddOns, getAllAddOns, loadRemoteAddOn, populateAddOnOptionsDefaults, } from './edge-add-ons.js';
+export { createSerializedOptions } from './options.js';
+export { CONFIG_FILE } from './constants.js';
+export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManagerExecuteCommand, getPackageManagerInstallCommand, getPackageManagerScriptCommand, translateExecuteCommand, } from './package-manager.js';

package/dist/frameworks/react/add-ons/storybook/info.json

@@ -7,14 +7,9 @@
   "type": "add-on",
   "category": "tooling",
   "color": "#FF4785",
-  "priority": 18,
-  "routes": [
-    {
-      "icon": "BookOpen",
-      "url": "/demo/storybook",
-      "name": "Storybook",
-      "path": "src/routes/demo.storybook.tsx",
-      "jsName": "StorybookDemo"
-    }
-  ]
+  "priority": 1,
+  "command": {
+    "command": "npx",
+    "args": ["storybook", "init", "-y", "--no-dev"]
+  }
 }