extension-create 4.0.30 → 4.0.33

package/dist/module.cjs

@@ -439,10 +439,9 @@ async function generateExtensionTypes(projectPath, projectName, logger) {
     }
 }
 const external_node_os_namespaceObject = require("node:os");
-const external_adm_zip_namespaceObject = require("adm-zip");
-var external_adm_zip_default = /*#__PURE__*/ __webpack_require__.n(external_adm_zip_namespaceObject);
 const external_axios_namespaceObject = require("axios");
 var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
+const external_fflate_namespaceObject = require("fflate");
 const external_go_git_it_namespaceObject = require("go-git-it");
 var external_go_git_it_default = /*#__PURE__*/ __webpack_require__.n(external_go_git_it_namespaceObject);
 function _define_property(obj, key, value) {
@@ -455,12 +454,38 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
+async function extractZipBufferTo(zipBuffer, destinationDir) {
+    const root = external_node_path_namespaceObject.resolve(destinationDir);
+    const entries = (0, external_fflate_namespaceObject.unzipSync)(new Uint8Array(zipBuffer));
+    await promises_namespaceObject.mkdir(root, {
+        recursive: true
+    });
+    for (const [name, data] of Object.entries(entries)){
+        const normalized = name.replace(/\\/g, '/');
+        const target = external_node_path_namespaceObject.resolve(root, normalized);
+        const relative = external_node_path_namespaceObject.relative(root, target);
+        if (!relative || relative.startsWith('..') || external_node_path_namespaceObject.isAbsolute(relative)) throw new Error(`Refusing to extract zip entry outside the destination: ${name}`);
+        if (normalized.endsWith('/')) {
+            await promises_namespaceObject.mkdir(target, {
+                recursive: true
+            });
+            continue;
+        }
+        await promises_namespaceObject.mkdir(external_node_path_namespaceObject.dirname(target), {
+            recursive: true
+        });
+        await promises_namespaceObject.writeFile(target, data);
+    }
+}
 const NETWORK_TIMEOUT_MS = (()=>{
     const raw = parseInt(String(process.env.EXTENSION_CREATE_TIMEOUT_MS || ''), 10);
     return Number.isFinite(raw) && raw > 0 ? raw : 60000;
 })();
 const CODELOAD_BASE = 'https://codeload.github.com/extension-js/examples/zip';
-const DEFAULT_TEMPLATES_REF = '52c0d871c433d9c54878767175ce8ffc9a951756';
+const DEFAULT_TEMPLATES_REF = 'f7f4e6efb56a7e5ae08d58dbff3972d94af7d021';
+const BUNDLED_TEMPLATES = [
+    "javascript"
+];
 function resolveCatalogUrls(ref, overrideUrl) {
     if (overrideUrl) return [
         overrideUrl
@@ -516,22 +541,24 @@ async function downloadArchive(url, timeoutMs, attempts = 2) {
     throw lastError;
 }
 async function extractExamplesTemplateFromZip(zipBuffer, templateName, projectPath) {
-    const zip = new (external_adm_zip_default())(zipBuffer);
-    const entries = zip.getEntries();
+    const entries = Object.entries((0, external_fflate_namespaceObject.unzipSync)(new Uint8Array(zipBuffer)));
     if (!entries.length) throw new TemplateNotFoundError(templateName, new Error('empty archive'));
-    const archiveRoot = entries[0].entryName.split('/')[0];
+    const archiveRoot = entries[0][0].split('/')[0];
     const wanted = `${archiveRoot}/examples/${templateName}/`;
-    const files = entries.filter((e)=>!e.isDirectory && e.entryName.startsWith(wanted));
+    const files = entries.filter(([name])=>!name.endsWith('/') && name.startsWith(wanted));
     if (!files.length) throw new TemplateNotFoundError(templateName);
+    const root = external_node_path_namespaceObject.resolve(projectPath);
     let written = 0;
-    for (const entry of files){
-        const rel = entry.entryName.slice(wanted.length);
+    for (const [name, data] of files){
+        const rel = name.slice(wanted.length);
         if (!rel) continue;
-        const dest = external_node_path_namespaceObject.join(projectPath, rel);
+        const dest = external_node_path_namespaceObject.resolve(root, rel);
+        const relative = external_node_path_namespaceObject.relative(root, dest);
+        if (!relative || relative.startsWith('..') || external_node_path_namespaceObject.isAbsolute(relative)) throw new Error(`Refusing to extract zip entry outside the destination: ${name}`);
         await promises_namespaceObject.mkdir(external_node_path_namespaceObject.dirname(dest), {
             recursive: true
         });
-        await promises_namespaceObject.writeFile(dest, entry.getData());
+        await promises_namespaceObject.writeFile(dest, data);
         written++;
     }
     return written;
@@ -677,8 +704,8 @@ async function importExternalTemplate(projectPath, projectName, template, logger
         await promises_namespaceObject.mkdir(projectPath, {
             recursive: true
         });
-        if (!isHttp && !isGithub && "javascript" === resolvedTemplate) {
-            const localTemplate = bundledTemplateDir("javascript");
+        if (!isHttp && !isGithub && BUNDLED_TEMPLATES.includes(resolvedTemplate)) {
+            const localTemplate = bundledTemplateDir(resolvedTemplate);
             if ((0, external_node_fs_namespaceObject.existsSync)(localTemplate)) {
                 await copyDirectoryWithSymlinks(localTemplate, projectPath);
                 await removeTemplateScaffoldingFiles(projectPath);
@@ -735,8 +762,7 @@ async function importExternalTemplate(projectPath, projectName, template, logger
             const contentType = String(headers?.['content-type'] || '');
             const looksZip = /zip|octet-stream/i.test(contentType) || template.toLowerCase().endsWith('.zip');
             if (!looksZip) throw new Error(`Remote template does not appear to be a ZIP archive: ${template}`);
-            const zip = new (external_adm_zip_default())(Buffer.from(data));
-            zip.extractAllTo(tempPath, true);
+            await extractZipBufferTo(Buffer.from(data), tempPath);
             const sourcePath = await getZipSourcePath(tempPath, template);
             await moveDirectoryContents(sourcePath, projectPath);
             provenance = {
@@ -862,134 +888,6 @@ async function initializeGitRepository(projectPath, projectName, templateName, l
     ], projectPath);
     if (!committed.ok) logger.log(firstCommitSkipped(projectName, committed.reason || ''));
 }
-function buildExecEnv() {
-    if ('win32' !== process.platform) return;
-    const nodeDir = external_node_path_namespaceObject.dirname(process.execPath);
-    const pathSep = external_node_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 env = buildExecEnv();
-    const child = (0, external_cross_spawn_namespaceObject.spawn)(command, 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(packageManager) {
-    if ('bun' === packageManager) return [
-        'install'
-    ];
-    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, logger) {
-    const packageJsonPath = external_node_path_namespaceObject.join(projectPath, 'package.json');
-    try {
-        const raw = await external_node_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_node_fs_namespaceObject.promises.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
-        return true;
-    } catch (error) {
-        logger.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 hasDependenciesToInstall(projectPath) {
-    try {
-        const raw = await external_node_fs_namespaceObject.promises.readFile(external_node_path_namespaceObject.join(projectPath, 'package.json'), 'utf8');
-        const packageJson = JSON.parse(raw);
-        const depsCount = Object.keys(packageJson?.dependencies || {}).length;
-        const devDepsCount = Object.keys(packageJson?.devDependencies || {}).length;
-        return depsCount + devDepsCount > 0;
-    } catch (error) {
-        return true;
-    }
-}
-async function installDependencies(projectPath, projectName, logger) {
-    const nodeModulesPath = external_node_path_namespaceObject.join(projectPath, 'node_modules');
-    const shouldInstall = await hasDependenciesToInstall(projectPath);
-    if (!shouldInstall) return;
-    const command = isDenoRuntime() ? 'deno' : await getInstallCommand();
-    const dependenciesArgs = 'deno' === command ? [
-        'install'
-    ] : getInstallArgs(command);
-    const installMessage = installingDependencies();
-    logger.log(installMessage);
-    try {
-        await external_node_fs_namespaceObject.promises.mkdir(nodeModulesPath, {
-            recursive: true
-        });
-        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'pipe';
-        const firstRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
-        if (0 !== firstRun.code) {
-            const output = `${firstRun.stdout}\n${firstRun.stderr}`;
-            const shouldRetry = shouldRetryWithTagFallback(output);
-            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;
-            }
-            throw new Error(installingDependenciesFailed(command, dependenciesArgs, firstRun.code));
-        }
-    } catch (error) {
-        logger.error(installingDependenciesProcessError(projectName, error));
-        logger.error(cantInstallDependencies(projectName, error));
-        throw error;
-    }
-}
-const external_node_module_namespaceObject = require("node:module");
 function stripJsoncExtensions(text) {
     let out = '';
     let i = 0;
@@ -1104,6 +1002,200 @@ function readDenoConfigDependencies(projectPath) {
     }
     return dependencies;
 }
+function buildExecEnv() {
+    if ('win32' !== process.platform) return;
+    const nodeDir = external_node_path_namespaceObject.dirname(process.execPath);
+    const pathSep = external_node_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 env = buildExecEnv();
+    const child = (0, external_cross_spawn_namespaceObject.spawn)(command, 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(packageManager) {
+    if ('bun' === packageManager) return [
+        'install'
+    ];
+    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 pathExists(target) {
+    try {
+        await external_node_fs_namespaceObject.promises.access(target);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function resolveDenoConfigPath(projectPath) {
+    for (const candidate of [
+        'deno.json',
+        'deno.jsonc'
+    ]){
+        const full = external_node_path_namespaceObject.join(projectPath, candidate);
+        if (await pathExists(full)) return full;
+    }
+}
+async function updatePackageJsonExtensionTag(projectPath) {
+    const packageJsonPath = external_node_path_namespaceObject.join(projectPath, 'package.json');
+    if (!await pathExists(packageJsonPath)) return false;
+    const packageJson = JSON.parse(await external_node_fs_namespaceObject.promises.readFile(packageJsonPath, 'utf8'));
+    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_node_fs_namespaceObject.promises.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+    return true;
+}
+function replaceExtensionSpecifierInDenoConfig(raw, currentSpecifier, nextSpecifier) {
+    if (currentSpecifier === nextSpecifier) return;
+    const quoted = `"${currentSpecifier}"`;
+    let from = 0;
+    while(from < raw.length){
+        const at = raw.indexOf(quoted, from);
+        if (-1 === at) break;
+        const lineStart = raw.lastIndexOf('\n', at) + 1;
+        const lineBefore = raw.slice(lineStart, at);
+        if (/:\s*$/.test(lineBefore) && !lineBefore.includes('//')) {
+            const index = at + 1;
+            return raw.slice(0, index) + nextSpecifier + raw.slice(index + currentSpecifier.length);
+        }
+        from = at + quoted.length;
+    }
+}
+async function updateDenoConfigExtensionTag(projectPath) {
+    const configPath = await resolveDenoConfigPath(projectPath);
+    if (!configPath) return false;
+    const raw = await external_node_fs_namespaceObject.promises.readFile(configPath, 'utf8');
+    const config = parseJsoncSafe(raw);
+    const imports = config?.imports;
+    if (!imports || 'object' != typeof imports) return false;
+    let next = raw;
+    let updated = false;
+    for (const specifier of Object.values(imports)){
+        if ('string' != typeof specifier) continue;
+        const parsed = parseNpmSpecifier(specifier);
+        if (!parsed || 'extension' !== parsed.name) continue;
+        const tag = getTagFallback(parsed.version);
+        if (!tag || parsed.version === tag) continue;
+        const rewritten = replaceExtensionSpecifierInDenoConfig(next, specifier, `npm:extension@${tag}`);
+        if (void 0 !== rewritten) {
+            next = rewritten;
+            updated = true;
+        }
+    }
+    if (!updated) return false;
+    await external_node_fs_namespaceObject.promises.writeFile(configPath, next);
+    return true;
+}
+async function updateExtensionDependencyTag(projectPath, projectName, logger) {
+    try {
+        const updatedPackageJson = await updatePackageJsonExtensionTag(projectPath);
+        const updatedDenoConfig = await updateDenoConfigExtensionTag(projectPath);
+        return updatedPackageJson || updatedDenoConfig;
+    } catch (error) {
+        logger.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('extension@') || text.includes('etarget') && text.includes('extension@') || /could not find version of npm package ['"]?extension['"]?/.test(text);
+}
+async function install_dependencies_runInstall(command, args, cwd, stdio) {
+    return runInstall(command, args, {
+        cwd,
+        stdio
+    });
+}
+async function hasDependenciesToInstall(projectPath) {
+    const packageJsonPath = external_node_path_namespaceObject.join(projectPath, 'package.json');
+    let raw;
+    try {
+        raw = await external_node_fs_namespaceObject.promises.readFile(packageJsonPath, 'utf8');
+    } catch (error) {
+        if (error?.code === 'ENOENT') return Object.keys(readDenoConfigDependencies(projectPath)).length > 0;
+        throw error;
+    }
+    const packageJson = JSON.parse(raw);
+    const depsCount = Object.keys(packageJson?.dependencies || {}).length;
+    const devDepsCount = Object.keys(packageJson?.devDependencies || {}).length;
+    return depsCount + devDepsCount > 0;
+}
+async function installDependencies(projectPath, projectName, logger) {
+    const nodeModulesPath = external_node_path_namespaceObject.join(projectPath, 'node_modules');
+    const shouldInstall = await hasDependenciesToInstall(projectPath);
+    if (!shouldInstall) return;
+    const command = isDenoRuntime() ? 'deno' : await getInstallCommand();
+    const dependenciesArgs = 'deno' === command ? [
+        'install'
+    ] : getInstallArgs(command);
+    const installMessage = installingDependencies();
+    logger.log(installMessage);
+    try {
+        await external_node_fs_namespaceObject.promises.mkdir(nodeModulesPath, {
+            recursive: true
+        });
+        const stdio = 'development' === process.env.EXTENSION_ENV ? 'inherit' : 'pipe';
+        const firstRun = await install_dependencies_runInstall(command, dependenciesArgs, projectPath, stdio);
+        if (0 !== firstRun.code) {
+            const output = `${firstRun.stdout}\n${firstRun.stderr}`;
+            const shouldRetry = shouldRetryWithTagFallback(output);
+            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;
+            }
+            throw new Error(installingDependenciesFailed(command, dependenciesArgs, firstRun.code));
+        }
+    } catch (error) {
+        logger.error(installingDependenciesProcessError(projectName, error));
+        logger.error(cantInstallDependencies(projectName, error));
+        throw error;
+    }
+}
+const external_node_module_namespaceObject = require("node:module");
 const requireFromCreate = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
 function resolveDevelopRoot(projectPath) {
     try {
@@ -1485,7 +1577,7 @@ async function overridePackageJson(projectPath, { template = "javascript", cliVe
         throw error;
     }
 }
-async function pathExists(target) {
+async function write_deno_jsonc_pathExists(target) {
     try {
         await promises_namespaceObject.access(target);
         return true;
@@ -1531,7 +1623,7 @@ async function writeDenoJsonc(projectPath, { template = "javascript", cliVersion
     for (const candidate of [
         'deno.json',
         'deno.jsonc'
-    ])if (await pathExists(external_node_path_namespaceObject.join(projectPath, candidate))) {
+    ])if (await write_deno_jsonc_pathExists(external_node_path_namespaceObject.join(projectPath, candidate))) {
         existingConfig = candidate;
         break;
     }
@@ -1548,8 +1640,12 @@ async function writeDenoJsonc(projectPath, { template = "javascript", cliVersion
                 ...imports || {},
                 ...config.imports || {}
             };
-            if (void 0 === config.nodeModulesDir) config.nodeModulesDir = 'auto';
-            if (!config.tasks) config.tasks = tasks;
+            if (imports?.extension) config.imports.extension = imports.extension;
+            config.nodeModulesDir = 'auto';
+            config.tasks = {
+                ...tasks,
+                ...config.tasks || {}
+            };
             await promises_namespaceObject.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
         } else await promises_namespaceObject.writeFile(external_node_path_namespaceObject.join(projectPath, 'deno.jsonc'), renderDenoJsonc(tasks, imports));
         if (primary) await promises_namespaceObject.rm(external_node_path_namespaceObject.join(projectPath, 'package.json'), {

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

@@ -1,4 +1,5 @@
-export declare const DEFAULT_TEMPLATES_REF = "52c0d871c433d9c54878767175ce8ffc9a951756";
+export declare const DEFAULT_TEMPLATES_REF = "f7f4e6efb56a7e5ae08d58dbff3972d94af7d021";
+export declare const BUNDLED_TEMPLATES: readonly string[];
 export declare function resolveCatalogUrls(ref: string, overrideUrl?: string): string[];
 export interface TemplateProvenance {
     template: string;

package/dist/test-template-javascript/.extension-create.json

@@ -1,5 +1,5 @@
 {
-  "createdWith": "extension-create@4.0.29",
+  "createdWith": "extension-create@4.0.32",
   "template": "javascript",
   "source": "bundled"
 }

package/dist/test-template-javascript/STORE.md

@@ -9,7 +9,7 @@ Packaging your extension is local and free. Submitting the result to a
 store is what [extension.dev](https://docs.extension.dev/publish/overview?utm_source=store-md)
 does, and it sponsors Extension.js.
 
-Last updated: 2026-08-04
+Last updated: 2026-08-17
 
 ## Listing
 

package/dist/test-template-javascript/package.json

@@ -16,7 +16,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "extension": "^4.0.29"
+    "extension": "^4.0.32"
   },
   "packageManager": "pnpm@10.28.0",
   "pnpm": {

package/package.json

@@ -25,7 +25,7 @@
     "templates"
   ],
   "name": "extension-create",
-  "version": "4.0.30",
+  "version": "4.0.33",
   "description": "The standalone extension creation engine for Extension.js",
   "author": {
     "name": "Cezar Augusto",
@@ -75,9 +75,9 @@
     "edge-extension"
   ],
   "dependencies": {
-    "adm-zip": "^0.6.0",
     "axios": "^1.18.0",
     "cross-spawn": "^7.0.6",
+    "fflate": "^0.8.3",
     "go-git-it": "^5.1.5",
     "pintor": "0.3.0",
     "prefers-yarn": "2.0.1"
@@ -86,7 +86,6 @@
     "@biomejs/biome": "^2.2.4",
     "@changesets/cli": "^2.29.8",
     "@rslib/core": "^0.23.1",
-    "@types/adm-zip": "^0.5.7",
     "@types/chrome": "^0.1.33",
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^26",