extension-create 3.12.0 → 3.12.2

package/dist/lib/messages.d.ts

@@ -16,7 +16,6 @@ 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 foundSpecializedDependencies(count: number): string;
 export declare function installingProjectIntegrations(integrations: string[]): string;
 export declare function installingDependenciesFailed(gitCommand: string, gitArgs: string[], code: number | null): string;

package/dist/lib/utils.d.ts

@@ -1,5 +1,8 @@
 export declare function copyDirectoryWithSymlinks(source: string, destination: string): Promise<void>;
 export declare function moveDirectoryContents(source: string, destination: string): Promise<void>;
 export declare function getInstallCommand(): Promise<"pnpm" | "yarn" | "npm">;
-export declare function isDirectoryWriteable(directory: string, projectName: string): Promise<boolean>;
+export declare function isDirectoryWriteable(directory: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<boolean>;
 export declare function isTypeScriptTemplate(templateName: string): boolean;

package/dist/module.cjs

@@ -146,9 +146,6 @@ function initializingGitForRepositoryError(projectName, error) {
 function installingDependencies() {
     return `${statusPrefix} Installing project-specific dependencies... ${external_pintor_default().gray('(This may take a moment)')}`;
 }
-function installingBuildDependencies(dependencies) {
-    return `${statusPrefix} Installing general build dependencies... ${external_pintor_default().gray('(This may take a moment)')}`;
-}
 function foundSpecializedDependencies(count) {
     return `${statusPrefix} Found ${external_pintor_default().yellow(String(count))} specialized integration${1 === count ? '' : 's'} needing installation...`;
 }
@@ -243,15 +240,15 @@ async function moveDirectoryContents(source, destination) {
 async function getInstallCommand() {
     return detectPackageManagerFromEnv();
 }
-async function isDirectoryWriteable(directory, projectName) {
+async function isDirectoryWriteable(directory, projectName, logger) {
     try {
-        console.log(folderExists(projectName));
+        logger.log(folderExists(projectName));
         await promises_namespaceObject.mkdir(directory, {
             recursive: true
         });
         return true;
     } catch (err) {
-        console.log(writingDirectoryError(err));
+        logger.log(writingDirectoryError(err));
         return false;
     }
 }
@@ -262,17 +259,17 @@ const allowlist = [
     'LICENSE',
     'node_modules'
 ];
-async function createDirectory(projectPath, projectName) {
-    console.log(startingNewExtension(projectName));
+async function createDirectory(projectPath, projectName, logger) {
+    logger.log(startingNewExtension(projectName));
     try {
-        const isCurrentDirWriteable = await isDirectoryWriteable(projectPath, projectName);
-        console.log(checkingIfPathIsWriteable());
+        const isCurrentDirWriteable = await isDirectoryWriteable(projectPath, projectName, logger);
+        logger.log(checkingIfPathIsWriteable());
         if (!isCurrentDirWriteable) {
-            console.error(destinationNotWriteable(projectPath));
+            logger.error(destinationNotWriteable(projectPath));
             throw new Error(destinationNotWriteable(projectPath));
         }
         const currentDir = await promises_namespaceObject.readdir(projectPath);
-        console.log(scanningPossiblyConflictingFiles());
+        logger.log(scanningPossiblyConflictingFiles());
         const conflictingFiles = await Promise.all(currentDir.filter((file)=>!file.startsWith('.')).filter((file)=>!file.endsWith('.log')).filter((file)=>!allowlist.includes(file)).map(async (file)=>{
             const stats = await promises_namespaceObject.lstat(external_path_namespaceObject.join(projectPath, file));
             return stats.isDirectory() ? `${file}/` : `${file}`;
@@ -326,7 +323,7 @@ async function getZipSourcePath(tempPath, templateUrl) {
     if (onlyDir.name === archiveBase) return external_path_namespaceObject.join(tempPath, onlyDir.name);
     return tempPath;
 }
-async function importExternalTemplate(projectPath, projectName, template) {
+async function importExternalTemplate(projectPath, projectName, template, logger) {
     const templateName = external_path_namespaceObject.basename(template);
     const examplesUrl = 'https://github.com/extension-js/examples/tree/main/examples';
     const resolvedTemplate = 'init' === templateName ? "javascript" : template;
@@ -376,7 +373,7 @@ async function importExternalTemplate(projectPath, projectName, template) {
             force: true
         });
     } catch (error) {
-        console.error(installingFromTemplateError(projectName, templateName, error));
+        logger.error(installingFromTemplateError(projectName, templateName, error));
         throw error;
     }
 }
@@ -422,7 +419,7 @@ function resolveExtensionDevDependencyVersion(cliVersion) {
     if (!cliVersion) return 'latest';
     return cliVersion.includes('-') ? cliVersion : `^${cliVersion}`;
 }
-async function overridePackageJson(projectPath, projectName, { template = "javascript", cliVersion }) {
+async function overridePackageJson(projectPath, projectName, { template = "javascript", cliVersion }, logger) {
     const extensionBinary = await resolveExtensionBinary();
     const candidatePath = external_path_namespaceObject.join(projectPath, 'package.json');
     let packageJson = {};
@@ -465,10 +462,10 @@ async function overridePackageJson(projectPath, projectName, { template = "javas
         }
     };
     try {
-        console.log(writingPackageJsonMetadata());
+        logger.log(writingPackageJsonMetadata());
         await promises_namespaceObject.writeFile(external_path_namespaceObject.join(projectPath, 'package.json'), JSON.stringify(packageMetadata, null, 2));
     } catch (error) {
-        console.error(writingPackageJsonMetadataError(projectName, error));
+        logger.error(writingPackageJsonMetadataError(projectName, error));
         throw error;
     }
 }
@@ -524,7 +521,7 @@ function getTagFallback(version) {
     const cleaned = version.replace(/^[~^]/, '');
     return cleaned.includes('-') ? 'next' : 'latest';
 }
-async function updateExtensionDependencyTag(projectPath, projectName) {
+async function updateExtensionDependencyTag(projectPath, projectName, logger) {
     const packageJsonPath = external_path_namespaceObject.join(projectPath, 'package.json');
     try {
         const raw = await external_fs_namespaceObject.promises.readFile(packageJsonPath, 'utf8');
@@ -540,7 +537,7 @@ async function updateExtensionDependencyTag(projectPath, projectName) {
         await external_fs_namespaceObject.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
         return true;
     } catch (error) {
-        console.error(cantInstallDependencies(projectName, error));
+        logger.error(cantInstallDependencies(projectName, error));
         return false;
     }
 }
@@ -565,14 +562,14 @@ async function hasDependenciesToInstall(projectPath) {
         return true;
     }
 }
-async function installDependencies(projectPath, projectName) {
+async function installDependencies(projectPath, projectName, logger) {
     const nodeModulesPath = external_path_namespaceObject.join(projectPath, 'node_modules');
     const shouldInstall = await hasDependenciesToInstall(projectPath);
     if (!shouldInstall) return;
     const command = await getInstallCommand();
     const dependenciesArgs = getInstallArgs();
     const installMessage = installingDependencies();
-    console.log(installMessage);
+    logger.log(installMessage);
     try {
         await external_fs_namespaceObject.promises.mkdir(nodeModulesPath, {
             recursive: true
@@ -582,7 +579,7 @@ async function installDependencies(projectPath, projectName) {
         if (0 !== firstRun.code) {
             const output = `${firstRun.stdout}\n${firstRun.stderr}`;
             const shouldRetry = shouldRetryWithTagFallback(output);
-            const didUpdate = shouldRetry ? await updateExtensionDependencyTag(projectPath, projectName) : false;
+            const didUpdate = shouldRetry ? await updateExtensionDependencyTag(projectPath, projectName, logger) : false;
             if (didUpdate) {
                 const retryRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
                 if (0 === retryRun.code) return;
@@ -590,8 +587,8 @@ async function installDependencies(projectPath, projectName) {
             throw new Error(installingDependenciesFailed(command, dependenciesArgs, firstRun.code));
         }
     } catch (error) {
-        console.error(installingDependenciesProcessError(projectName, error));
-        console.error(cantInstallDependencies(projectName, error));
+        logger.error(installingDependenciesProcessError(projectName, error));
+        logger.error(cantInstallDependencies(projectName, error));
         throw error;
     }
 }
@@ -638,7 +635,7 @@ async function findManifestJsonPath(projectPath) {
     }
     throw new Error(`Could not locate manifest.json under ${projectPath}. Checked common paths and searched up to depth ${manifestSearchMaxDepth}.`);
 }
-async function writeReadmeFile(projectPath, projectName) {
+async function writeReadmeFile(projectPath, projectName, logger) {
     try {
         await promises_namespaceObject.access(external_path_namespaceObject.join(projectPath, 'README.md'));
         return;
@@ -705,17 +702,17 @@ Learn more in the [Extension.js docs](https://extension.js.org).
     const manifestJson = JSON.parse(await promises_namespaceObject.readFile(manifestJsonPath, 'utf-8'));
     const readmeFileEdited = initTemplateReadme.replaceAll('[projectName]', projectName).replaceAll("[templateDescription]", manifestJson.description).replaceAll('[runCommand]', installCommand);
     try {
-        console.log(writingReadmeMetaData());
+        logger.log(writingReadmeMetaData());
         await promises_namespaceObject.mkdir(projectPath, {
             recursive: true
         });
         await promises_namespaceObject.writeFile(external_path_namespaceObject.join(projectPath, 'README.md'), readmeFileEdited);
     } catch (error) {
-        console.error(writingReadmeMetaDataEError(projectName, error));
+        logger.error(writingReadmeMetaDataEError(projectName, error));
         throw error;
     }
 }
-async function writeManifestJson(projectPath, projectName) {
+async function writeManifestJson(projectPath, projectName, logger) {
     const manifestJsonPath = await findManifestJsonPath(projectPath);
     const manifestJsonContent = await promises_namespaceObject.readFile(manifestJsonPath);
     const manifestJson = JSON.parse(manifestJsonContent.toString());
@@ -725,14 +722,14 @@ async function writeManifestJson(projectPath, projectName) {
         author: 'Your Name'
     };
     try {
-        console.log(writingManifestJsonMetadata());
+        logger.log(writingManifestJsonMetadata());
         await promises_namespaceObject.writeFile(manifestJsonPath, JSON.stringify(manifestMetadata, null, 2));
     } catch (error) {
-        console.error(writingManifestJsonMetadataError(projectName, error));
+        logger.error(writingManifestJsonMetadataError(projectName, error));
         throw error;
     }
 }
-async function generateExtensionTypes(projectPath, projectName) {
+async function generateExtensionTypes(projectPath, projectName, logger) {
     const extensionEnvFile = external_path_namespaceObject.join(projectPath, 'extension-env.d.ts');
     const typePath = 'extension';
     const fileContent = `\
@@ -750,10 +747,10 @@ async function generateExtensionTypes(projectPath, projectName) {
         await promises_namespaceObject.mkdir(projectPath, {
             recursive: true
         });
-        console.log(writingTypeDefinitions(projectName));
+        logger.log(writingTypeDefinitions(projectName));
         await promises_namespaceObject.writeFile(extensionEnvFile, fileContent);
     } catch (error) {
-        console.error(writingTypeDefinitionsError(error));
+        logger.error(writingTypeDefinitionsError(error));
         throw error;
     }
 }
@@ -801,13 +798,13 @@ const globalLines = [
     ...envFiles,
     ...debugFiles
 ];
-async function writeGitignore(projectPath) {
+async function writeGitignore(projectPath, logger) {
     const gitIgnorePath = external_path_namespaceObject.join(projectPath, '.gitignore');
     const paths = new Set();
     let currentContents = '';
     currentContents = await promises_namespaceObject.readFile(gitIgnorePath, 'utf8').catch((err)=>{
         if ('ENOENT' === err.code) return '';
-        console.error(err);
+        logger.error(err);
         throw err;
     });
     for (const rawLine of currentContents.split(/\r?\n/)){
@@ -817,21 +814,21 @@ async function writeGitignore(projectPath) {
     const linesToAdd = globalLines.filter((line)=>!paths.has(line));
     while('' === linesToAdd[linesToAdd.length - 1])linesToAdd.pop();
     if (0 === linesToAdd.length) return;
-    console.log(writingGitIgnore());
+    logger.log(writingGitIgnore());
     const shouldPrefixWithNewline = currentContents.length > 0 && !currentContents.endsWith('\n');
     const contentToAppend = `${shouldPrefixWithNewline ? '\n' : ''}${linesToAdd.join('\n')}`;
     await promises_namespaceObject.appendFile(gitIgnorePath, contentToAppend).catch((err)=>{
-        console.error(err);
+        logger.error(err);
         throw err;
     });
 }
-async function initializeGitRepository(projectPath, projectName) {
+async function initializeGitRepository(projectPath, projectName, logger) {
     const gitCommand = 'git';
     const gitArgs = [
         'init',
         '--quiet'
     ];
-    console.log(initializingGitForRepository(projectName));
+    logger.log(initializingGitForRepository(projectName));
     try {
         const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
         const child = (0, external_cross_spawn_namespaceObject.spawn)(gitCommand, gitArgs, {
@@ -844,21 +841,21 @@ async function initializeGitRepository(projectPath, projectName) {
                 else resolve();
             });
             child.on('error', (error)=>{
-                console.error(initializingGitForRepositoryProcessError(projectName, error));
+                logger.error(initializingGitForRepositoryProcessError(projectName, error));
                 reject(error);
             });
         });
     } catch (error) {
-        console.error(initializingGitForRepositoryError(projectName, error));
+        logger.error(initializingGitForRepositoryError(projectName, error));
         throw error;
     }
 }
-async function setupBuiltInTests(projectPath, projectName) {
+async function setupBuiltInTests(projectPath, projectName, logger) {
     try {
         const testSpecPath = external_path_namespaceObject.join(projectPath, 'tests', 'templates.spec.ts');
         if (external_fs_namespaceObject.existsSync(testSpecPath)) external_fs_namespaceObject.unlinkSync(testSpecPath);
     } catch (error) {
-        console.error(cantSetupBuiltInTests(projectName, error));
+        logger.error(cantSetupBuiltInTests(projectName, error));
         throw error;
     }
 }
@@ -884,17 +881,6 @@ function resolveDevelopRoot(projectPath) {
         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)) {
-        console.warn(`${installingBuildDependencies([])} (build-dependencies.json missing; skipping build deps install)`);
-        return {};
-    }
-    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');
@@ -1029,39 +1015,6 @@ function buildOptionalInstallArgs(pm, dependencies, installDir) {
         '--legacy-peer-deps'
     ];
 }
-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 dependenciesByIntegration = {};
@@ -1086,31 +1039,18 @@ function resolveMissingOptionalDeps(developRoot, projectPath) {
         dependenciesByIntegration
     };
 }
-async function installBuildDependencies(developRoot, plan) {
+async function installOptionalDependencies(developRoot, projectPath, plan, logger) {
     if (0 === plan.dependencies.length) return;
     const pm = detectPackageManagerFromEnv();
-    const installMessage = installingBuildDependencies(plan.dependencies);
-    console.log(installMessage);
-    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));
-}
-async function installOptionalDependencies(developRoot, projectPath, plan) {
-    if (0 === plan.dependencies.length) return;
-    const pm = detectPackageManagerFromEnv();
-    const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'ignore';
-    console.log(foundSpecializedDependencies(plan.integrations.length));
+    logger.log(foundSpecializedDependencies(plan.integrations.length));
     for (const [index, integration] of plan.integrations.entries()){
         const missingDeps = plan.dependenciesByIntegration[integration] || [];
         const baseMessage = installingProjectIntegrations([
             integration
         ]);
         const installMessage = baseMessage.replace('⏵⏵⏵ ', `⏵⏵⏵ [${index + 1}/${plan.integrations.length}] `);
-        console.log(installMessage);
+        logger.log(installMessage);
         if (0 === missingDeps.length) continue;
         const args = buildOptionalInstallArgs(pm, missingDeps, developRoot);
         const result = await runInstall(pm, args, {
@@ -1120,39 +1060,43 @@ async function installOptionalDependencies(developRoot, projectPath, plan) {
         if (0 !== result.code) throw new Error(installingDependenciesFailed(pm, args, result.code));
     }
 }
-async function installInternalDependencies(projectPath) {
+async function installInternalDependencies(projectPath, logger) {
     if ('test' === process.env.EXTENSION_ENV || 'true' === process.env.EXTENSION_SKIP_INTERNAL_INSTALL) return;
     const developRoot = resolveDevelopRoot(projectPath);
     if (!developRoot) return;
-    const buildPlan = resolveMissingBuildDeps(developRoot);
-    if (buildPlan.dependencies.length > 0) await installBuildDependencies(developRoot, buildPlan);
     const optionalPlan = resolveMissingOptionalDeps(developRoot, projectPath);
-    if (optionalPlan.dependencies.length > 0) await installOptionalDependencies(developRoot, projectPath, optionalPlan);
+    if (optionalPlan.dependencies.length > 0) await installOptionalDependencies(developRoot, projectPath, optionalPlan, logger);
 }
-async function extensionCreate(projectNameInput, { cliVersion, template = "javascript", install = false }) {
+async function extensionCreate(projectNameInput, { cliVersion, template = "javascript", install = false, logger = console }) {
     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);
     const projectName = external_path_namespaceObject.basename(projectPath);
     try {
-        await createDirectory(projectPath, projectName);
-        await importExternalTemplate(projectPath, projectName, template);
+        await createDirectory(projectPath, projectName, logger);
+        await importExternalTemplate(projectPath, projectName, template, logger);
         await overridePackageJson(projectPath, projectName, {
             template,
             cliVersion
-        });
+        }, logger);
         if (install) {
-            await installDependencies(projectPath, projectName);
-            await installInternalDependencies(projectPath);
+            await installDependencies(projectPath, projectName, logger);
+            await installInternalDependencies(projectPath, logger);
         }
-        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);
+        await writeReadmeFile(projectPath, projectName, logger);
+        await writeManifestJson(projectPath, projectName, logger);
+        await initializeGitRepository(projectPath, projectName, logger);
+        await writeGitignore(projectPath, logger);
+        await setupBuiltInTests(projectPath, projectName, logger);
+        if (isTypeScriptTemplate(template)) await generateExtensionTypes(projectPath, projectName, logger);
         const successfulInstall = await successfullInstall(projectPath, projectName, Boolean(install));
-        console.log(successfulInstall);
+        logger.log(successfulInstall);
+        return {
+            projectPath,
+            projectName,
+            template,
+            depsInstalled: install
+        };
     } catch (error) {
         throw error;
     }

package/dist/module.d.ts

@@ -1,6 +1,17 @@
+export interface CreateLogger {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
 export interface CreateOptions {
     template?: string;
     install?: boolean;
     cliVersion?: string;
+    logger?: CreateLogger;
+}
+export interface CreateResult {
+    projectPath: string;
+    projectName: string;
+    template: string;
+    depsInstalled: boolean;
 }
-export declare function extensionCreate(projectNameInput: string | undefined, { cliVersion, template, install }: CreateOptions): Promise<void>;
+export declare function extensionCreate(projectNameInput: string | undefined, { cliVersion, template, install, logger }: CreateOptions): Promise<CreateResult>;

package/dist/steps/create-directory.d.ts

@@ -1 +1,4 @@
-export declare function createDirectory(projectPath: string, projectName: string): Promise<void>;
+export declare function createDirectory(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/generate-extension-types.d.ts

@@ -1 +1,4 @@
-export declare function generateExtensionTypes(projectPath: string, projectName: string): Promise<void>;
+export declare function generateExtensionTypes(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/import-external-template.d.ts

@@ -1 +1,4 @@
-export declare function importExternalTemplate(projectPath: string, projectName: string, template: string): Promise<void>;
+export declare function importExternalTemplate(projectPath: string, projectName: string, template: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/initialize-git-repository.d.ts

@@ -1 +1,4 @@
-export declare function initializeGitRepository(projectPath: string, projectName: string): Promise<void>;
+export declare function initializeGitRepository(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/install-dependencies.d.ts

@@ -1 +1,4 @@
-export declare function installDependencies(projectPath: string, projectName: string): Promise<void>;
+export declare function installDependencies(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

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

@@ -3,18 +3,15 @@ type OptionalDepsPlan = {
     dependencies: string[];
     dependenciesByIntegration: Record<string, string[]>;
 };
-type BuildDepsPlan = {
-    dependencies: string[];
-    dependencyMap: Record<string, string>;
-};
 declare function resolveDevelopRoot(projectPath: string): 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 function installInternalDependencies(projectPath: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;
 export declare const __testing__: {
     resolveDevelopRoot: typeof resolveDevelopRoot;
-    resolveMissingBuildDeps: typeof resolveMissingBuildDeps;
     resolveMissingOptionalDeps: typeof resolveMissingOptionalDeps;
     detectOptionalDependencies: typeof detectOptionalDependencies;
 };

package/dist/steps/setup-built-in-tests.d.ts

@@ -1 +1,4 @@
-export declare function setupBuiltInTests(projectPath: string, projectName: string): Promise<void>;
+export declare function setupBuiltInTests(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/write-gitignore.d.ts

@@ -1 +1,4 @@
-export declare function writeGitignore(projectPath: string): Promise<void>;
+export declare function writeGitignore(projectPath: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/write-manifest-json.d.ts

@@ -1 +1,4 @@
-export declare function writeManifestJson(projectPath: string, projectName: string): Promise<void>;
+export declare function writeManifestJson(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/dist/steps/write-package-json.d.ts

@@ -3,5 +3,8 @@ interface OverridePackageJsonOptions {
     template?: string;
     cliVersion?: string;
 }
-export declare function overridePackageJson(projectPath: string, projectName: string, { template, cliVersion }: OverridePackageJsonOptions): Promise<void>;
+export declare function overridePackageJson(projectPath: string, projectName: string, { template, cliVersion }: OverridePackageJsonOptions, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;
 export {};

package/dist/steps/write-readme-file.d.ts

@@ -1 +1,4 @@
-export declare function writeReadmeFile(projectPath: string, projectName: string): Promise<void>;
+export declare function writeReadmeFile(projectPath: string, projectName: string, logger: {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}): Promise<void>;

package/package.json

@@ -24,7 +24,7 @@
     "dist"
   ],
   "name": "extension-create",
-  "version": "3.12.0",
+  "version": "3.12.2",
   "description": "The standalone extension creation engine for Extension.js",
   "author": {
     "name": "Cezar Augusto",
@@ -73,11 +73,10 @@
   ],
   "dependencies": {
     "adm-zip": "^0.5.16",
-    "axios": "^1.13.5",
+    "axios": "^1.15.0",
     "cross-spawn": "^7.0.6",
     "go-git-it": "^5.1.5",
-    "pintor": "0.3.0",
-    "tiny-glob": "^0.2.9"
+    "pintor": "0.3.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.4",