extension-create 3.1.0-next.8 → 3.2.0-next.10

package/dist/lib/package-manager.d.ts

@@ -0,0 +1,3 @@
+type PackageManagerName = 'pnpm' | 'yarn' | 'npm';
+export declare function detectPackageManagerFromEnv(): PackageManagerName;
+export {};

package/dist/lib/utils.d.ts

@@ -1,8 +1,5 @@
-export declare function copyDirectory(source: string, destination: string): Promise<void[]>;
 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<string>;
-export declare function getTemplatePath(workingDir: string): string;
+export declare function getInstallCommand(): Promise<"pnpm" | "yarn" | "npm">;
 export declare function isDirectoryWriteable(directory: string, projectName: string): Promise<boolean>;
-export declare function isExternalTemplate(_templateName: string): boolean;
 export declare function isTypeScriptTemplate(templateName: string): boolean;

package/dist/module.js

@@ -42,7 +42,18 @@ const external_path_namespaceObject = require("path");
 const external_fs_namespaceObject = require("fs");
 const external_pintor_namespaceObject = require("pintor");
 var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_namespaceObject);
-const external_package_manager_detector_namespaceObject = require("package-manager-detector");
+function detectPackageManagerFromEnv() {
+    const userAgent = process.env.npm_config_user_agent || '';
+    if (userAgent.includes('pnpm')) return 'pnpm';
+    if (userAgent.includes('yarn')) return 'yarn';
+    if (userAgent.includes('npm')) return 'npm';
+    const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
+    if (execPath.includes('pnpm')) return 'pnpm';
+    if (execPath.includes('yarn')) return 'yarn';
+    execPath.includes('npm');
+    return 'npm';
+}
+const statusPrefix = external_pintor_default().brightBlue('►►►');
 function destinationNotWriteable(workingDir) {
     const workingDirFolder = external_path_namespaceObject.basename(workingDir);
     return `${external_pintor_default().red('Error')} Couldn't write to the destination directory.\n${external_pintor_default().red('Next step: choose a writable path or update folder permissions.')}\n${external_pintor_default().red('Path')} ${external_pintor_default().underline(workingDirFolder)}`;
@@ -65,10 +76,10 @@ function noUrlAllowed() {
 }
 async function successfullInstall(projectPath, projectName, depsInstalled) {
     const relativePath = external_path_namespaceObject.relative(process.cwd(), projectPath);
-    const pm = await (0, external_package_manager_detector_namespaceObject.detect)();
+    const pm = detectPackageManagerFromEnv();
     let command = 'npm run';
     let installCmd = 'npm install';
-    switch(pm?.name){
+    switch(pm){
         case 'yarn':
             command = 'yarn dev';
             installCmd = 'yarn';
@@ -81,42 +92,37 @@ async function successfullInstall(projectPath, projectName, depsInstalled) {
             command = 'npm run dev';
             installCmd = 'npm install';
     }
-    if (process.env.npm_config_user_agent) {
-        if (process.env.npm_config_user_agent.includes('pnpm')) {
-            command = 'pnpm dev';
-            installCmd = 'pnpm install';
-        }
-    }
     const steps = depsInstalled ? `  1. ${external_pintor_default().blue('cd')} ${external_pintor_default().underline(relativePath)}\n  2. ${external_pintor_default().blue(command)} (runs a fresh browser profile with your extension loaded)\n` : `  1. ${external_pintor_default().blue('cd')} ${external_pintor_default().underline(relativePath)}\n  2. ${external_pintor_default().blue(installCmd)}\n  3. ${external_pintor_default().blue(command)} (runs a fresh browser profile with your extension loaded)\n`;
-    return `${external_pintor_default().green('Created')} ${external_pintor_default().blue(projectName)}\n\nNext steps:\n\n` + steps;
+    const depsNote = depsInstalled ? `\n${external_pintor_default().gray('Dependencies installed. You can start developing now.')}\n` : '\n';
+    return `${statusPrefix} ${external_pintor_default().green('Created')} ${external_pintor_default().blue(projectName)}\n\nNext steps:\n\n` + steps + depsNote;
 }
 function startingNewExtension(projectName) {
-    return `Creating ${external_pintor_default().blue(projectName)}...`;
+    return `${statusPrefix} Creating ${external_pintor_default().blue(projectName)}...`;
 }
 function checkingIfPathIsWriteable() {
-    return 'Checking if the destination path is writable...';
+    return `${statusPrefix} Checking if the destination path is writable...`;
 }
 function scanningPossiblyConflictingFiles() {
-    return 'Scanning for conflicting files...';
+    return `${statusPrefix} Scanning for conflicting files...`;
 }
 function createDirectoryError(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't create directory ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check the path and permissions, then try again.')}`;
 }
 function writingTypeDefinitions(projectName) {
-    return `Writing type definitions for ${external_pintor_default().blue(projectName)}...`;
+    return `${statusPrefix} Writing type definitions for ${external_pintor_default().blue(projectName)}...`;
 }
 function writingTypeDefinitionsError(error) {
     return `${external_pintor_default().red('Error')} Couldn't write the extension type definitions.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
 }
 function installingFromTemplate(projectName, templateName) {
-    if ('init' === templateName) return `Installing ${external_pintor_default().blue(projectName)}...`;
-    return `Installing ${external_pintor_default().blue(projectName)} from template ${external_pintor_default().yellow(templateName)}...`;
+    if ('init' === templateName) return `${statusPrefix} Installing ${external_pintor_default().blue(projectName)}...`;
+    return `${statusPrefix} Installing ${external_pintor_default().blue(projectName)} from template ${external_pintor_default().yellow(templateName)}...`;
 }
 function installingFromTemplateError(projectName, template, error) {
     return `${external_pintor_default().red('Error')} Couldn't find template ${external_pintor_default().yellow(template)} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: choose a valid template name or URL.')}`;
 }
 function initializingGitForRepository(projectName) {
-    return `Initializing git repository for ${external_pintor_default().blue(projectName)}...`;
+    return `${statusPrefix} Initializing git repository for ${external_pintor_default().blue(projectName)}...`;
 }
 function initializingGitForRepositoryFailed(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.')}`;
@@ -128,7 +134,7 @@ 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 'Installing dependencies (this may take a moment)...';
+    return `${statusPrefix} Installing dependencies (this may take a moment)...`;
 }
 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.')}`;
@@ -140,28 +146,28 @@ 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 `Writing ${external_pintor_default().yellow('package.json')}...`;
+    return `${statusPrefix} Writing ${external_pintor_default().yellow('package.json')}...`;
 }
 function writingPackageJsonMetadataError(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('package.json')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
 }
 function writingManifestJsonMetadata() {
-    return `Writing ${external_pintor_default().yellow('manifest.json')}...`;
+    return `${statusPrefix} Writing ${external_pintor_default().yellow('manifest.json')}...`;
 }
 function writingManifestJsonMetadataError(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('manifest.json')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
 }
 function writingReadmeMetaData() {
-    return `Writing ${external_pintor_default().yellow('README.md')}...`;
+    return `${statusPrefix} Writing ${external_pintor_default().yellow('README.md')}...`;
 }
 function writingGitIgnore() {
-    return `Writing ${external_pintor_default().yellow('.gitignore')}...`;
+    return `${statusPrefix} Writing ${external_pintor_default().yellow('.gitignore')}...`;
 }
 function writingReadmeMetaDataEError(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't write ${external_pintor_default().yellow('README.md')} for ${external_pintor_default().blue(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check file permissions, then try again.')}`;
 }
 function folderExists(projectName) {
-    return `Ensuring ${external_pintor_default().blue(projectName)} exists...`;
+    return `${statusPrefix} Ensuring ${external_pintor_default().blue(projectName)} exists...`;
 }
 function writingDirectoryError(error) {
     return `${external_pintor_default().red('Error')} Couldn't check directory writability.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: check the path and permissions, then try again.')}`;
@@ -170,9 +176,6 @@ function cantSetupBuiltInTests(projectName, error) {
     return `${external_pintor_default().red('Error')} Couldn't set up built-in tests for ${external_pintor_default().yellow(projectName)}.\n${external_pintor_default().red(String(error))}\n${external_pintor_default().red('Next step: run the setup step again or skip tests.')}`;
 }
 const promises_namespaceObject = require("fs/promises");
-const external_url_namespaceObject = require("url");
-const utils_filename = (0, external_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
-const utils_dirname = external_path_namespaceObject.dirname(utils_filename);
 async function copyDirectoryWithSymlinks(source, destination) {
     const entries = await promises_namespaceObject.readdir(source, {
         withFileTypes: true
@@ -221,26 +224,7 @@ async function moveDirectoryContents(source, destination) {
     });
 }
 async function getInstallCommand() {
-    const pm = await (0, external_package_manager_detector_namespaceObject.detect)();
-    let command = 'npm';
-    if (process.env.npm_config_user_agent) {
-        if (process.env.npm_config_user_agent.includes('pnpm')) return 'pnpm';
-    }
-    switch(pm?.name){
-        case 'yarn':
-            command = 'yarn';
-            break;
-        case 'pnpm':
-            command = 'pnpm';
-            break;
-        default:
-            command = 'npm';
-    }
-    return command;
-}
-function getTemplatePath(workingDir) {
-    const templatesDir = external_path_namespaceObject.resolve(utils_dirname, '..', 'template');
-    return external_path_namespaceObject.resolve(workingDir, templatesDir);
+    return detectPackageManagerFromEnv();
 }
 async function isDirectoryWriteable(directory, projectName) {
     try {
@@ -254,9 +238,6 @@ async function isDirectoryWriteable(directory, projectName) {
         return false;
     }
 }
-function isExternalTemplate(_templateName) {
-    return true;
-}
 function isTypeScriptTemplate(templateName) {
     return templateName.includes("typescript") || templateName.includes('react') || templateName.includes('preact') || templateName.includes('svelte') || templateName.includes('solid');
 }
@@ -287,6 +268,7 @@ async function createDirectory(projectPath, projectName) {
         throw new Error(createDirectoryError(projectName, error));
     }
 }
+const external_url_namespaceObject = require("url");
 const external_os_namespaceObject = require("os");
 const external_axios_namespaceObject = require("axios");
 var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
@@ -299,7 +281,10 @@ const import_external_template_dirname = external_path_namespaceObject.dirname(i
 async function importExternalTemplate(projectPath, projectName, template) {
     const templateName = external_path_namespaceObject.basename(template);
     const examplesUrl = 'https://github.com/extension-js/examples/tree/main/examples';
-    const templateUrl = `${examplesUrl}/${template}`;
+    const resolvedTemplate = 'init' === templateName ? "javascript" : template;
+    const resolvedTemplateName = 'init' === templateName ? "javascript" : templateName;
+    const templateUrl = `${examplesUrl}/${resolvedTemplate}`;
+    const examplesZipUrl = 'https://codeload.github.com/extension-js/examples/zip/refs/heads/main';
     try {
         await promises_namespaceObject.mkdir(projectPath, {
             recursive: true
@@ -322,8 +307,7 @@ async function importExternalTemplate(projectPath, projectName, template) {
             }
             const localTemplatesRoot = await findTemplatesRoot(import_external_template_dirname);
             if (!localTemplatesRoot) throw new Error('Local templates directory not found');
-            const localTemplateName = 'init' === templateName ? "javascript" : templateName;
-            const localTemplatePath = external_path_namespaceObject.join(localTemplatesRoot, localTemplateName);
+            const localTemplatePath = external_path_namespaceObject.join(localTemplatesRoot, resolvedTemplateName);
             await copyDirectoryWithSymlinks(localTemplatePath, projectPath);
         } else {
             const tempRoot = await promises_namespaceObject.mkdtemp(external_path_namespaceObject.join(external_os_namespaceObject.tmpdir(), 'extension-js-create-'));
@@ -376,9 +360,39 @@ async function importExternalTemplate(projectPath, projectName, template) {
                 zip.extractAllTo(tempPath, true);
                 await moveDirectoryContents(tempPath, projectPath);
             } else {
-                await withFilteredOutput(()=>external_go_git_it_default()(templateUrl, tempPath, installingFromTemplate(projectName, templateName)));
-                const srcPath = external_path_namespaceObject.join(tempPath, templateName);
-                await moveDirectoryContents(srcPath, projectPath);
+                const ok = await (async ()=>{
+                    const zipExtractRoot = external_path_namespaceObject.join(tempPath, 'zip-extract');
+                    try {
+                        const { data } = await external_axios_default().get(examplesZipUrl, {
+                            responseType: 'arraybuffer',
+                            maxRedirects: 5
+                        });
+                        const zip = new (external_adm_zip_default())(Buffer.from(data));
+                        zip.extractAllTo(zipExtractRoot, true);
+                        const entries = await promises_namespaceObject.readdir(zipExtractRoot, {
+                            withFileTypes: true
+                        });
+                        const rootDir = entries.find((e)=>e.isDirectory())?.name;
+                        if (!rootDir) return false;
+                        const srcPath = external_path_namespaceObject.join(zipExtractRoot, rootDir, 'examples', resolvedTemplateName);
+                        await moveDirectoryContents(srcPath, projectPath);
+                        return true;
+                    } catch  {
+                        return false;
+                    } finally{
+                        try {
+                            await promises_namespaceObject.rm(zipExtractRoot, {
+                                recursive: true,
+                                force: true
+                            });
+                        } catch  {}
+                    }
+                })();
+                if (!ok) {
+                    await withFilteredOutput(()=>external_go_git_it_default()(templateUrl, tempPath, installingFromTemplate(projectName, templateName)));
+                    const srcPath = external_path_namespaceObject.join(tempPath, resolvedTemplateName);
+                    await moveDirectoryContents(srcPath, projectPath);
+                }
             }
             await promises_namespaceObject.rm(tempRoot, {
                 recursive: true,
@@ -397,9 +411,8 @@ const extensionJsPackageJsonScripts = {
     'build:firefox': 'development' === process.env.EXTENSION_ENV ? 'node node_modules/extension build --browser firefox' : 'extension build --browser firefox',
     'build:edge': 'development' === process.env.EXTENSION_ENV ? 'node node_modules/extension build --browser edge' : 'extension build --browser edge'
 };
-async function overridePackageJson(projectPath, projectName, { template, cliVersion }) {
-    const templatePath = getTemplatePath(process.cwd());
-    const candidatePath = isExternalTemplate(template) ? external_path_namespaceObject.join(projectPath, 'package.json') : external_path_namespaceObject.join(templatePath, 'package.json');
+async function overridePackageJson(projectPath, projectName, { template: _template, cliVersion }) {
+    const candidatePath = external_path_namespaceObject.join(projectPath, 'package.json');
     let packageJson = {};
     try {
         const packageJsonContent = await promises_namespaceObject.readFile(candidatePath);
@@ -616,17 +629,137 @@ async function writeManifestJson(projectPath, projectName) {
 }
 async function generateExtensionTypes(projectPath, projectName) {
     const extensionEnvFile = external_path_namespaceObject.join(projectPath, 'extension-env.d.ts');
-    const typePath = 'extension';
+    const { dependencies, devDependencies, peerDependencies, optionalDependencies } = await readPackageJson(projectPath);
+    const hasDependency = (name)=>Boolean(dependencies[name] || devDependencies[name] || peerDependencies[name] || optionalDependencies[name]);
+    const usesReact = hasDependency('react') || hasDependency('@types/react');
+    const usesReactDom = hasDependency('react-dom') || hasDependency('@types/react-dom');
+    const usesSvelte = hasDependency('svelte');
+    const frameworkTypeRefs = [
+        usesReact ? '/// <reference types="react" />' : '',
+        usesReactDom ? '/// <reference types="react-dom" />' : '',
+        usesSvelte ? '/// <reference types="svelte" />' : ''
+    ].filter(Boolean).join('\n');
     const fileContent = `\
 // Required Extension.js types for TypeScript projects.
 // This file is auto-generated and should not be excluded.
-// If you need additional types, consider creating a new *.d.ts file and
-// referencing it in the "include" array of your tsconfig.json file.
-// See https://www.typescriptlang.org/tsconfig#include for more information.
-/// <reference types="${typePath}/types" />
+//
+/// <reference types="webextension-polyfill" />
+/// <reference types="node" />
+/// <reference types="chrome" />
+${frameworkTypeRefs}
+
+declare global {
+  const browser: typeof import('webextension-polyfill')
+
+  type ExtensionBrowser =
+    | 'chrome'
+    | 'edge'
+    | 'firefox'
+    | 'chromium-based'
+    | 'gecko-based'
+
+  type ExtensionMode = 'development' | 'production'
+
+  interface ExtensionEnv {
+    EXTENSION_BROWSER: ExtensionBrowser
+    EXTENSION_MODE: ExtensionMode
+    EXTENSION_PUBLIC_BROWSER: ExtensionBrowser
+    EXTENSION_PUBLIC_MODE: ExtensionMode
+    EXTENSION_PUBLIC_DESCRIPTION_TEXT: string
+    EXTENSION_PUBLIC_LLM_API_KEY: string
+    EXTENSION_AUTHOR_MODE: string
+    EXTENSION_PUBLIC_AUTHOR_MODE: string
+  }
+
+  namespace NodeJS {
+    interface ProcessEnv extends ExtensionEnv {
+      [key: string]: string | undefined
+    }
+  }
+
+  interface ImportMetaEnv extends ExtensionEnv {
+    [key: string]: string | undefined
+  }
+
+  interface ImportMeta {
+    readonly env: ImportMetaEnv
+    readonly webpackHot?: {
+      accept: (module?: string | string[], callback?: () => void) => void
+      dispose: (callback: () => void) => void
+    }
+    url: string
+  }
+
+  interface Window {
+    /**
+     * @deprecated
+     * @description
+     * This is how Extension.js used to inject the shadow root into the window object.
+     * Use the shadowRoot reference from the content script instead.
+     */
+    __EXTENSION_SHADOW_ROOT__: ShadowRoot
+  }
+}
 
-// Polyfill types for browser.* APIs
-/// <reference types="${typePath}/types/polyfill" />
+type CSSContentData = Readonly<Record<string, string>>
+type CSSModuleData = Readonly<Record<string, string>>
+
+declare module '*.css' {
+  const content: CSSContentData
+  export default content
+}
+
+declare module '*.module.css' {
+  const content: CSSModuleData
+  export default content
+}
+declare module '*.module.scss' {
+  const content: CSSModuleData
+  export default content
+}
+declare module '*.module.sass' {
+  const content: CSSModuleData
+  export default content
+}
+
+declare module '*.png' {
+  const content: string
+  export default content
+}
+declare module '*.jpg' {
+  const content: string
+  export default content
+}
+declare module '*.jpeg' {
+  const content: string
+  export default content
+}
+declare module '*.gif' {
+  const content: string
+  export default content
+}
+declare module '*.webp' {
+  const content: string
+  export default content
+}
+declare module '*.avif' {
+  const content: string
+  export default content
+}
+declare module '*.ico' {
+  const content: string
+  export default content
+}
+declare module '*.bmp' {
+  const content: string
+  export default content
+}
+declare module '*.svg' {
+  const content: any
+  export default content
+}
+
+export {}
 `;
     try {
         await promises_namespaceObject.mkdir(projectPath, {
@@ -639,6 +772,26 @@ async function generateExtensionTypes(projectPath, projectName) {
         throw error;
     }
 }
+async function readPackageJson(projectPath) {
+    const packageJsonPath = external_path_namespaceObject.join(projectPath, 'package.json');
+    try {
+        const content = await promises_namespaceObject.readFile(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(content) || {};
+        return {
+            dependencies: parsed.dependencies || {},
+            devDependencies: parsed.devDependencies || {},
+            peerDependencies: parsed.peerDependencies || {},
+            optionalDependencies: parsed.optionalDependencies || {}
+        };
+    } catch  {
+        return {
+            dependencies: {},
+            devDependencies: {},
+            peerDependencies: {},
+            optionalDependencies: {}
+        };
+    }
+}
 const globalDependencies = [
     '',
     '# dependencies',
@@ -741,6 +894,15 @@ async function setupBuiltInTests(projectPath, projectName) {
         throw error;
     }
 }
+const external_module_namespaceObject = require("module");
+async function preflightOptionalDependenciesForCreate(projectPath) {
+    try {
+        const requireFromProject = (0, external_module_namespaceObject.createRequire)(external_path_namespaceObject.join(projectPath, 'package.json'));
+        const develop = requireFromProject('extension-develop');
+        const preflight = develop?.preflightOptionalDependenciesForProject;
+        if ('function' == typeof preflight) await preflight(projectPath, 'development');
+    } catch  {}
+}
 async function extensionCreate(projectNameInput, { cliVersion, template = 'init', install = false }) {
     if (!projectNameInput) throw new Error(noProjectName());
     if (projectNameInput.startsWith('http')) throw new Error(noUrlAllowed());
@@ -753,7 +915,10 @@ async function extensionCreate(projectNameInput, { cliVersion, template = 'init'
             template,
             cliVersion
         });
-        if (install) await installDependencies(projectPath, projectName);
+        if (install) {
+            await installDependencies(projectPath, projectName);
+            await preflightOptionalDependenciesForCreate(projectPath);
+        }
         await writeReadmeFile(projectPath, projectName);
         await writeManifestJson(projectPath, projectName);
         await initializeGitRepository(projectPath, projectName);

package/dist/steps/preflight-optional-deps.d.ts

@@ -0,0 +1 @@
+export declare function preflightOptionalDependenciesForCreate(projectPath: string): Promise<void>;

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

@@ -2,5 +2,5 @@ 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: _template, cliVersion }: OverridePackageJsonOptions): Promise<void>;
 export {};

package/package.json

@@ -22,7 +22,7 @@
     "dist"
   ],
   "name": "extension-create",
-  "version": "3.1.0-next.8",
+  "version": "3.2.0-next.10",
   "description": "The standalone extension creation engine for Extension.js",
   "author": {
     "name": "Cezar Augusto",
@@ -71,7 +71,6 @@
     "axios": "^1.13.2",
     "cross-spawn": "^7.0.6",
     "go-git-it": "^5.0.3",
-    "package-manager-detector": "^1.6.0",
     "pintor": "0.3.0",
     "tiny-glob": "^0.2.9"
   },

package/dist/lib/types.d.ts

@@ -1,26 +0,0 @@
-declare namespace NodeJS {
-    interface ProcessEnv {
-        EXTENSION_BROWSER: 'chrome' | 'edge' | 'firefox' | 'chromium-based' | 'gecko-based';
-        EXTENSION_MODE: 'development' | 'production';
-        EXTENSION_PUBLIC_BROWSER: 'chrome' | 'edge' | 'firefox' | 'chromium-based' | 'gecko-based';
-        EXTENSION_PUBLIC_MODE: 'development' | 'production';
-        EXTENSION_PUBLIC_DESCRIPTION_TEXT: string;
-        EXTENSION_PUBLIC_LLM_API_KEY: string;
-        EXTENSION_ENV: 'development' | 'production';
-    }
-}
-interface ImportMetaEnv {
-    EXTENSION_BROWSER: NodeJS.ProcessEnv['EXTENSION_BROWSER'];
-    EXTENSION_MODE: NodeJS.ProcessEnv['EXTENSION_MODE'];
-    EXTENSION_PUBLIC_BROWSER: NodeJS.ProcessEnv['EXTENSION_BROWSER'];
-    EXTENSION_PUBLIC_MODE: NodeJS.ProcessEnv['EXTENSION_MODE'];
-    [key: string]: string | undefined;
-}
-interface ImportMeta {
-    readonly env: ImportMetaEnv;
-    readonly webpackHot?: {
-        accept: (module?: string | string[], callback?: () => void) => void;
-        dispose: (callback: () => void) => void;
-    };
-    url: string;
-}

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

@@ -1 +0,0 @@
-export declare function importLocalTemplate(projectPath: string, projectName: string, template: string): Promise<void>;