extension-create 3.2.0-next.8 → 3.2.0

package/dist/module.js

@@ -281,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
@@ -304,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-'));
@@ -358,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,
@@ -597,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
+  }
+}
+
+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
+}
 
-// Polyfill types for browser.* APIs
-/// <reference types="${typePath}/types/polyfill" />
+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, {
@@ -620,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',

package/package.json

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