extension-create 3.5.0-next.8 → 3.5.0-next.9

package/dist/lib/install-runner.d.ts

@@ -0,0 +1,10 @@
+type InstallResult = {
+    code: number | null;
+    stderr: string;
+    stdout: string;
+};
+export declare function runInstall(command: string, args: string[], opts: {
+    cwd: string;
+    stdio: 'inherit' | 'ignore' | 'pipe';
+}): Promise<InstallResult>;
+export {};

package/dist/lib/messages.d.ts

@@ -16,6 +16,8 @@ export declare function initializingGitForRepositoryFailed(gitCommand: string, g
 export declare function initializingGitForRepositoryProcessError(projectName: string, error: any): string;
 export declare function initializingGitForRepositoryError(projectName: string, error: any): string;
 export declare function installingDependencies(): string;
+export declare function installingBuildDependencies(dependencies: string[]): string;
+export declare function installingProjectIntegrations(integrations: string[]): string;
 export declare function installingDependenciesFailed(gitCommand: string, gitArgs: string[], code: number | null): string;
 export declare function installingDependenciesProcessError(projectName: string, error: any): string;
 export declare function cantInstallDependencies(projectName: string, error: any): string;

package/dist/module.cjs

@@ -143,6 +143,30 @@ function initializingGitForRepositoryProcessError(projectName, error) {
 function initializingGitForRepositoryError(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't initialize ${external_pintor_default().yellow('git')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error?.message || error))}\n${external_pintor_default().red('Next step: retry initialization or create the repository manually.')}`;
 }
+function installingDependencies() {
+    return `${statusPrefix} Installing dependencies...`;
+}
+function installingBuildDependencies(dependencies) {
+    return `${statusPrefix} Installing build tools...`;
+}
+function installingProjectIntegrations(integrations) {
+    const formatList = (items)=>{
+        if (1 === items.length) return items[0];
+        if (2 === items.length) return `${items[0]} and ${items[1]}`;
+        return `${items.slice(0, -1).join(', ')}, and ${items[items.length - 1]}`;
+    };
+    const tools = integrations.length > 0 ? formatList(integrations.map((name)=>external_pintor_default().yellow(name))) : external_pintor_default().gray('project tooling');
+    return `${statusPrefix} Installing project integrations for ${tools}...`;
+}
+function installingDependenciesFailed(gitCommand, gitArgs, code) {
+    return `${external_pintor_default().red('Error')} Command ${external_pintor_default().yellow(gitCommand)} ${external_pintor_default().yellow(gitArgs.join(' '))} failed.\n${external_pintor_default().red(`Exit code: ${external_pintor_default().yellow(String(code))}`)}\n${external_pintor_default().red('Next step: run the command manually to inspect the error.')}`;
+}
+function installingDependenciesProcessError(projectName, error) {
+    return `${external_pintor_default().red('Error')} Child process failed while installing dependencies for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: run the install command manually to inspect the error.')}`;
+}
+function cantInstallDependencies(projectName, error) {
+    return `${external_pintor_default().red('Error')} Couldn't install dependencies for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error?.message || error))}\n${external_pintor_default().red('Next step: check your package manager settings, then try again.')}`;
+}
 function writingPackageJsonMetadata() {
     return `${statusPrefix} Writing ${external_pintor_default().yellow('package.json')}...`;
 }
@@ -478,6 +502,193 @@ async function overridePackageJson(projectPath, projectName, { template: _templa
         throw error;
     }
 }
+function stripAnsi(input) {
+    return input.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function shouldShowProgress() {
+    return Boolean(process.stdout.isTTY) && !process.env.CI;
+}
+function startProgressBar(label, options) {
+    const enabled = (options?.enabled ?? true) && shouldShowProgress();
+    if (!enabled) return {
+        stop: ()=>void 0
+    };
+    const width = Math.max(10, options?.width ?? 24);
+    const intervalMs = Math.max(50, options?.intervalMs ?? 90);
+    let tick = 0;
+    let lastVisibleLength = 0;
+    const render = ()=>{
+        const filled = tick % (width + 1);
+        const empty = width - filled;
+        const bar = `[${'='.repeat(filled)}${' '.repeat(empty)}]`;
+        const line = `${label} ${bar}`;
+        lastVisibleLength = stripAnsi(line).length;
+        process.stdout.write(`\r${line}`);
+        tick = (tick + 1) % (width + 1);
+    };
+    render();
+    const timer = setInterval(render, intervalMs);
+    return {
+        stop: ()=>{
+            clearInterval(timer);
+            if (process.stdout.isTTY) process.stdout.write(`\r${' '.repeat(lastVisibleLength)}\r`);
+        }
+    };
+}
+const external_cross_spawn_namespaceObject = require("cross-spawn");
+function resolveWindowsCmdExe() {
+    const comspec = process.env.ComSpec;
+    if (comspec) return comspec;
+    const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+    return external_path_namespaceObject.join(systemRoot, 'System32', 'cmd.exe');
+}
+function formatCmdArgs(command, args) {
+    const quotedCommand = command.includes(' ') ? `"${command}"` : command;
+    const quotedArgs = args.map((arg)=>arg.includes(' ') ? `"${arg}"` : arg);
+    return `${quotedCommand} ${quotedArgs.join(' ')}`.trim();
+}
+function resolveInstallInvocation(command, args) {
+    if ('win32' !== process.platform) return {
+        command,
+        args
+    };
+    return {
+        command: resolveWindowsCmdExe(),
+        args: [
+            '/d',
+            '/s',
+            '/c',
+            formatCmdArgs(command, args)
+        ]
+    };
+}
+function buildExecEnv() {
+    if ('win32' !== process.platform) return;
+    const nodeDir = external_path_namespaceObject.dirname(process.execPath);
+    const pathSep = external_path_namespaceObject.delimiter;
+    const existing = process.env.PATH || process.env.Path || '';
+    if (existing.includes(nodeDir)) return;
+    return {
+        ...process.env,
+        PATH: `${nodeDir}${pathSep}${existing}`.trim(),
+        Path: `${nodeDir}${pathSep}${existing}`.trim()
+    };
+}
+async function runInstall(command, args, opts) {
+    const invocation = resolveInstallInvocation(command, args);
+    const env = buildExecEnv();
+    const child = (0, external_cross_spawn_namespaceObject.spawn)(invocation.command, invocation.args, {
+        stdio: opts.stdio,
+        cwd: opts.cwd,
+        env: env || process.env
+    });
+    let stdout = '';
+    let stderr = '';
+    if (child.stdout) child.stdout.on('data', (chunk)=>{
+        stdout += chunk.toString();
+    });
+    if (child.stderr) child.stderr.on('data', (chunk)=>{
+        stderr += chunk.toString();
+    });
+    return new Promise((resolve, reject)=>{
+        child.on('close', (code)=>{
+            resolve({
+                code,
+                stderr,
+                stdout
+            });
+        });
+        child.on('error', (error)=>{
+            reject(error);
+        });
+    });
+}
+function getInstallArgs() {
+    return [
+        'install',
+        '--silent'
+    ];
+}
+function getTagFallback(version) {
+    if ('*' === version || 'latest' === version || 'next' === version) return null;
+    const cleaned = version.replace(/^[~^]/, '');
+    return cleaned.includes('-') ? 'next' : 'latest';
+}
+async function updateExtensionDependencyTag(projectPath, projectName) {
+    const packageJsonPath = external_path_namespaceObject.join(projectPath, 'package.json');
+    try {
+        const raw = await external_fs_namespaceObject.promises.readFile(packageJsonPath, 'utf8');
+        const packageJson = JSON.parse(raw);
+        const currentVersion = packageJson?.devDependencies?.extension;
+        if ('string' != typeof currentVersion) return false;
+        const tag = getTagFallback(currentVersion);
+        if (!tag || currentVersion === tag) return false;
+        packageJson.devDependencies = {
+            ...packageJson.devDependencies || {},
+            extension: tag
+        };
+        await external_fs_namespaceObject.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+        return true;
+    } catch (error) {
+        console.error(cantInstallDependencies(projectName, error));
+        return false;
+    }
+}
+function shouldRetryWithTagFallback(output) {
+    const text = output.toLowerCase();
+    return text.includes('no matching version found for extension@') || text.includes('notarget') || text.includes('etarget');
+}
+async function install_dependencies_runInstall(command, args, cwd, stdio) {
+    return runInstall(command, args, {
+        cwd,
+        stdio
+    });
+}
+async function installDependencies(projectPath, projectName) {
+    const nodeModulesPath = external_path_namespaceObject.join(projectPath, 'node_modules');
+    const command = await getInstallCommand();
+    const dependenciesArgs = getInstallArgs();
+    const installMessage = installingDependencies();
+    const progressEnabled = shouldShowProgress();
+    const progress = startProgressBar(installMessage, {
+        enabled: progressEnabled
+    });
+    if (!progressEnabled) console.log(installMessage);
+    try {
+        await external_fs_namespaceObject.promises.mkdir(nodeModulesPath, {
+            recursive: true
+        });
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'pipe';
+        let firstRun;
+        try {
+            firstRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
+        } finally{
+            progress.stop();
+        }
+        if (0 !== firstRun.code) {
+            const output = `${firstRun.stdout}\n${firstRun.stderr}`;
+            const shouldRetry = shouldRetryWithTagFallback(output);
+            const didUpdate = shouldRetry ? await updateExtensionDependencyTag(projectPath, projectName) : false;
+            if (didUpdate) {
+                const retryProgress = startProgressBar(installMessage, {
+                    enabled: progressEnabled
+                });
+                let retryRun;
+                try {
+                    retryRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
+                } finally{
+                    retryProgress.stop();
+                }
+                if (0 === retryRun.code) return;
+            }
+            throw new Error(installingDependenciesFailed(command, dependenciesArgs, firstRun.code));
+        }
+    } catch (error) {
+        console.error(installingDependenciesProcessError(projectName, error));
+        console.error(cantInstallDependencies(projectName, error));
+        throw error;
+    }
+}
 const manifestSearchMaxDepth = 3;
 const ignoredManifestDirs = new Set([
     'node_modules',
@@ -703,7 +914,6 @@ async function writeGitignore(projectPath) {
         throw err;
     });
 }
-const external_cross_spawn_namespaceObject = require("cross-spawn");
 async function initializeGitRepository(projectPath, projectName) {
     const gitCommand = 'git';
     const gitArgs = [
@@ -741,7 +951,261 @@ async function setupBuiltInTests(projectPath, projectName) {
         throw error;
     }
 }
-async function extensionCreate(projectNameInput, { cliVersion, template = 'init', install: _install = false }) {
+const external_module_namespaceObject = require("module");
+const requireFromCreate = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+function resolveDevelopRoot() {
+    const override = process.env.EXTENSION_CREATE_DEVELOP_ROOT;
+    if (override) return override;
+    try {
+        const pkgPath = requireFromCreate.resolve('extension-develop/package.json', {
+            paths: [
+                process.cwd(),
+                __dirname
+            ]
+        });
+        return external_path_namespaceObject.dirname(pkgPath);
+    } catch  {
+        return null;
+    }
+}
+function resolveBuildDepsPath(developRoot) {
+    return external_path_namespaceObject.join(developRoot, 'webpack', 'webpack-lib', 'build-dependencies.json');
+}
+function loadBuildDependencies(developRoot) {
+    const metadataPath = resolveBuildDepsPath(developRoot);
+    if (!external_fs_namespaceObject.existsSync(metadataPath)) throw new Error(`Missing build-dependencies.json at ${metadataPath}`);
+    return JSON.parse(external_fs_namespaceObject.readFileSync(metadataPath, 'utf8'));
+}
+function readPackageJson(projectPath) {
+    try {
+        const raw = external_fs_namespaceObject.readFileSync(external_path_namespaceObject.join(projectPath, 'package.json'), 'utf8');
+        return JSON.parse(raw);
+    } catch  {
+        return {};
+    }
+}
+function hasDependency(pkg, name) {
+    return Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+}
+function canResolve(dependency, paths) {
+    try {
+        requireFromCreate.resolve(dependency, {
+            paths
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function findConfigFile(projectPath, candidates) {
+    return candidates.some((file)=>external_fs_namespaceObject.existsSync(external_path_namespaceObject.join(projectPath, file)));
+}
+function detectOptionalDependencies(projectPath) {
+    const pkg = readPackageJson(projectPath);
+    const usesReact = hasDependency(pkg, 'react') || hasDependency(pkg, 'react-dom');
+    const usesPreact = hasDependency(pkg, 'preact');
+    const usesVue = hasDependency(pkg, 'vue');
+    const usesSvelte = hasDependency(pkg, 'svelte');
+    const hasTsConfig = external_fs_namespaceObject.existsSync(external_path_namespaceObject.join(projectPath, 'tsconfig.json'));
+    const usesTypeScript = hasDependency(pkg, "typescript") || hasTsConfig;
+    const usesSass = hasDependency(pkg, 'sass') || hasDependency(pkg, 'sass-loader');
+    const usesLess = hasDependency(pkg, 'less') || hasDependency(pkg, 'less-loader');
+    const postCssConfigFiles = [
+        '.postcssrc',
+        '.postcssrc.json',
+        '.postcssrc.yaml',
+        '.postcssrc.yml',
+        'postcss.config.mjs',
+        '.postcssrc.js',
+        '.postcssrc.cjs',
+        'postcss.config.js',
+        'postcss.config.cjs'
+    ];
+    const tailwindConfigFiles = [
+        'tailwind.config.mjs',
+        'tailwind.config.cjs',
+        'tailwind.config.js'
+    ];
+    const usesPostCss = hasDependency(pkg, 'postcss') || hasDependency(pkg, 'postcss-loader') || findConfigFile(projectPath, postCssConfigFiles) || hasDependency(pkg, 'tailwindcss') || hasDependency(pkg, '@tailwindcss/postcss') || findConfigFile(projectPath, tailwindConfigFiles);
+    const integrations = new Set();
+    const deps = new Set();
+    if (usesTypeScript) {
+        integrations.add('TypeScript');
+        deps.add("typescript");
+    }
+    if (usesReact) {
+        integrations.add('React');
+        deps.add('react-refresh');
+        deps.add('@rspack/plugin-react-refresh');
+    }
+    if (usesPreact) {
+        integrations.add('Preact');
+        deps.add('@prefresh/core');
+        deps.add('@prefresh/utils');
+        deps.add('@rspack/plugin-preact-refresh');
+        deps.add('preact');
+    }
+    if (usesVue) {
+        integrations.add('Vue');
+        deps.add('vue-loader');
+        deps.add('@vue/compiler-sfc');
+    }
+    if (usesSvelte) {
+        integrations.add('Svelte');
+        deps.add('svelte-loader');
+        deps.add("typescript");
+    }
+    if (usesSass) {
+        integrations.add('Sass');
+        deps.add('sass-loader');
+        deps.add('postcss-loader');
+        deps.add('postcss-scss');
+        deps.add('postcss-preset-env');
+    }
+    if (usesLess) {
+        integrations.add('Less');
+        deps.add('less');
+        deps.add('less-loader');
+    }
+    if (!usesPostCss || usesSass || usesLess) {
+        if (usesPostCss) integrations.add('PostCSS');
+    } else {
+        integrations.add('PostCSS');
+        deps.add('postcss');
+        deps.add('postcss-loader');
+    }
+    return {
+        integrations: Array.from(integrations),
+        dependencies: Array.from(deps)
+    };
+}
+function buildOptionalInstallArgs(pm, dependencies, installDir) {
+    if ('yarn' === pm) return [
+        'add',
+        ...dependencies,
+        '--cwd',
+        installDir,
+        '--optional'
+    ];
+    if ('pnpm' === pm) return [
+        'add',
+        ...dependencies,
+        '--dir',
+        installDir,
+        '--save-optional'
+    ];
+    if ('bun' === pm) return [
+        'add',
+        ...dependencies,
+        '--cwd',
+        installDir,
+        '--optional'
+    ];
+    return [
+        'install',
+        ...dependencies,
+        '--prefix',
+        installDir,
+        '--save-optional'
+    ];
+}
+function buildBuildInstallArgs(pm, dependencies, dependencyMap) {
+    const depsWithVersions = dependencies.map((dep)=>`${dep}@${dependencyMap[dep]}`);
+    if ('yarn' === pm) return [
+        'add',
+        ...depsWithVersions
+    ];
+    if ('pnpm' === pm) return [
+        'add',
+        '--save',
+        ...depsWithVersions
+    ];
+    if ('bun' === pm) return [
+        'add',
+        ...depsWithVersions
+    ];
+    return [
+        'install',
+        '--save',
+        ...depsWithVersions
+    ];
+}
+function resolveMissingBuildDeps(developRoot) {
+    const dependencyMap = loadBuildDependencies(developRoot);
+    const candidates = Object.keys(dependencyMap);
+    const missing = candidates.filter((dep)=>!canResolve(dep, [
+            developRoot,
+            process.cwd()
+        ]));
+    return {
+        dependencies: missing,
+        dependencyMap
+    };
+}
+function resolveMissingOptionalDeps(developRoot, projectPath) {
+    const plan = detectOptionalDependencies(projectPath);
+    const missing = plan.dependencies.filter((dep)=>!canResolve(dep, [
+            developRoot,
+            projectPath,
+            process.cwd()
+        ]));
+    return {
+        integrations: plan.integrations,
+        dependencies: missing
+    };
+}
+async function installBuildDependencies(developRoot, plan) {
+    if (0 === plan.dependencies.length) return;
+    const pm = detectPackageManagerFromEnv();
+    const installMessage = installingBuildDependencies(plan.dependencies);
+    const progressEnabled = shouldShowProgress();
+    const progress = startProgressBar(installMessage, {
+        enabled: progressEnabled
+    });
+    if (!progressEnabled) console.log(installMessage);
+    try {
+        const args = buildBuildInstallArgs(pm, plan.dependencies, plan.dependencyMap);
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
+        const result = await runInstall(pm, args, {
+            cwd: developRoot,
+            stdio
+        });
+        if (0 !== result.code) throw new Error(installingDependenciesFailed(pm, args, result.code));
+    } finally{
+        progress.stop();
+    }
+}
+async function installOptionalDependencies(developRoot, plan) {
+    if (0 === plan.dependencies.length) return;
+    const pm = detectPackageManagerFromEnv();
+    const installMessage = installingProjectIntegrations(plan.integrations);
+    const progressEnabled = shouldShowProgress();
+    const progress = startProgressBar(installMessage, {
+        enabled: progressEnabled
+    });
+    if (!progressEnabled) console.log(installMessage);
+    try {
+        const args = buildOptionalInstallArgs(pm, plan.dependencies, developRoot);
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
+        const result = await runInstall(pm, args, {
+            cwd: developRoot,
+            stdio
+        });
+        if (0 !== result.code) throw new Error(installingDependenciesFailed(pm, args, result.code));
+    } finally{
+        progress.stop();
+    }
+}
+async function installInternalDependencies(projectPath) {
+    if ('test' === process.env.EXTENSION_ENV || 'true' === process.env.EXTENSION_SKIP_INTERNAL_INSTALL) return;
+    const developRoot = resolveDevelopRoot();
+    if (!developRoot) return;
+    const buildPlan = resolveMissingBuildDeps(developRoot);
+    await installBuildDependencies(developRoot, buildPlan);
+    const optionalPlan = resolveMissingOptionalDeps(developRoot, projectPath);
+    await installOptionalDependencies(developRoot, optionalPlan);
+}
+async function extensionCreate(projectNameInput, { cliVersion, template = 'init', install = false }) {
     if (!projectNameInput) throw new Error(noProjectName());
     if (projectNameInput.startsWith('http')) throw new Error(noUrlAllowed());
     const projectPath = external_path_namespaceObject.isAbsolute(projectNameInput) ? projectNameInput : external_path_namespaceObject.join(process.cwd(), projectNameInput);
@@ -753,13 +1217,15 @@ async function extensionCreate(projectNameInput, { cliVersion, template = 'init'
             template,
             cliVersion
         });
+        await installInternalDependencies(projectPath);
+        if (install) await installDependencies(projectPath, projectName);
         await writeReadmeFile(projectPath, projectName);
         await writeManifestJson(projectPath, projectName);
         await initializeGitRepository(projectPath, projectName);
         await writeGitignore(projectPath);
         await setupBuiltInTests(projectPath, projectName);
         if (isTypeScriptTemplate(template)) await generateExtensionTypes(projectPath, projectName);
-        const successfulInstall = await successfullInstall(projectPath, projectName, false);
+        const successfulInstall = await successfullInstall(projectPath, projectName, Boolean(install));
         console.log(successfulInstall);
     } catch (error) {
         throw error;

package/dist/module.d.ts

@@ -3,4 +3,4 @@ export interface CreateOptions {
     install?: boolean;
     cliVersion?: string;
 }
-export declare function extensionCreate(projectNameInput: string | undefined, { cliVersion, template, install: _install }: CreateOptions): Promise<void>;
+export declare function extensionCreate(projectNameInput: string | undefined, { cliVersion, template, install }: CreateOptions): Promise<void>;

package/dist/steps/install-internal-deps.d.ts

@@ -0,0 +1,20 @@
+type OptionalDepsPlan = {
+    integrations: string[];
+    dependencies: string[];
+};
+type BuildDepsPlan = {
+    dependencies: string[];
+    dependencyMap: Record<string, string>;
+};
+declare function resolveDevelopRoot(): string | null;
+declare function detectOptionalDependencies(projectPath: string): OptionalDepsPlan;
+declare function resolveMissingBuildDeps(developRoot: string): BuildDepsPlan;
+declare function resolveMissingOptionalDeps(developRoot: string, projectPath: string): OptionalDepsPlan;
+export declare function installInternalDependencies(projectPath: string): Promise<void>;
+export declare const __testing__: {
+    resolveDevelopRoot: typeof resolveDevelopRoot;
+    resolveMissingBuildDeps: typeof resolveMissingBuildDeps;
+    resolveMissingOptionalDeps: typeof resolveMissingOptionalDeps;
+    detectOptionalDependencies: typeof detectOptionalDependencies;
+};
+export {};

package/package.json

@@ -23,7 +23,7 @@
     "dist"
   ],
   "name": "extension-create",
-  "version": "3.5.0-next.8",
+  "version": "3.5.0-next.9",
   "description": "The standalone extension creation engine for Extension.js",
   "author": {
     "name": "Cezar Augusto",