@netlify/edge-bundler 1.14.1 → 2.0.0

package/deno/bundle.ts

@@ -1,6 +1,6 @@
 import { writeStage2 } from './lib/stage2.ts'
 
 const [payload] = Deno.args
-const { basePath, destPath, functions, imports } = JSON.parse(payload)
+const { basePath, destPath, functions, importMapURL } = JSON.parse(payload)
 
-await writeStage2({ basePath, destPath, functions, imports })
+await writeStage2({ basePath, destPath, functions, importMapURL })

package/deno/lib/stage2.ts

@@ -1,22 +1,11 @@
-import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.18.0/mod.ts'
+import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.28.0/mod.ts'
 
 import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
 
+import type { InputFunction, WriteStage2Options } from '../../common/stage2.ts'
 import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
-interface InputFunction {
-  name: string
-  path: string
-}
-
-interface WriteStage2Options {
-  basePath: string
-  destPath: string
-  functions: InputFunction[]
-  imports?: Record<string, string>
-}
-
 const getFunctionReference = (basePath: string, func: InputFunction, index: number) => {
   const importName = `func${index}`
   const exportLine = `"${func.name}": ${importName}`
@@ -44,7 +33,7 @@ const getVirtualPath = (basePath: string, filePath: string) => {
   return url
 }
 
-const stage2Loader = (basePath: string, functions: InputFunction[], imports: Record<string, string> = {}) => {
+const stage2Loader = (basePath: string, functions: InputFunction[]) => {
   return async (specifier: string): Promise<LoadResponse | undefined> => {
     if (specifier === STAGE2_SPECIFIER) {
       const stage2Entry = getStage2Entry(basePath, functions)
@@ -59,10 +48,6 @@ const stage2Loader = (basePath: string, functions: InputFunction[], imports: Rec
       }
     }
 
-    if (imports[specifier] !== undefined) {
-      return await loadWithRetry(imports[specifier])
-    }
-
     if (specifier.startsWith(virtualRoot)) {
       return loadFromVirtualRoot(specifier, virtualRoot, basePath)
     }
@@ -71,9 +56,9 @@ const stage2Loader = (basePath: string, functions: InputFunction[], imports: Rec
   }
 }
 
-const writeStage2 = async ({ basePath, destPath, functions, imports }: WriteStage2Options) => {
-  const loader = stage2Loader(basePath, functions, imports)
-  const bytes = await build([STAGE2_SPECIFIER], loader)
+const writeStage2 = async ({ basePath, destPath, functions, importMapURL }: WriteStage2Options) => {
+  const loader = stage2Loader(basePath, functions)
+  const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
 
   return await Deno.writeFile(destPath, bytes)
 }

package/dist/common/stage2.d.ts

@@ -0,0 +1,10 @@
+export interface InputFunction {
+    name: string;
+    path: string;
+}
+export interface WriteStage2Options {
+    basePath: string;
+    destPath: string;
+    functions: InputFunction[];
+    importMapURL?: string;
+}

package/dist/{bundler.d.ts → src/bundler.d.ts}

@@ -15,7 +15,7 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath, cacheDirectory, debug, distImportMapPath, featureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/src/edge_function.js

@@ -0,0 +1 @@
+export {};

package/dist/{formats → src/formats}/eszip.js

@@ -10,7 +10,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, func
         basePath,
         destPath,
         functions,
-        imports: importMap.imports,
+        importMapURL: importMap.toDataURL(),
     };
     const flags = ['--allow-all'];
     if (!debug) {

package/dist/src/import_map.d.ts

@@ -0,0 +1,15 @@
+interface ImportMapFile {
+    baseURL: URL;
+    imports: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+}
+declare class ImportMap {
+    imports: Record<string, URL | null>;
+    constructor(files?: ImportMapFile[]);
+    static resolve(importMapFile: ImportMapFile): import("@import-maps/resolve/types/src/types").ParsedImportMap;
+    getContents(): string;
+    toDataURL(): string;
+    writeToFile(path: string): Promise<void>;
+}
+export { ImportMap };
+export type { ImportMapFile };

package/dist/src/import_map.js

@@ -0,0 +1,44 @@
+import { Buffer } from 'buffer';
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+import { parse } from '@import-maps/resolve';
+const INTERNAL_IMPORTS = {
+    'netlify:edge': new URL('https://edge.netlify.com/v1/index.ts'),
+};
+class ImportMap {
+    constructor(files = []) {
+        let imports = {};
+        files.forEach((file) => {
+            const importMap = ImportMap.resolve(file);
+            imports = { ...imports, ...importMap.imports };
+        });
+        // Internal imports must come last, because we need to guarantee that
+        // `netlify:edge` isn't user-defined.
+        Object.entries(INTERNAL_IMPORTS).forEach((internalImport) => {
+            const [specifier, url] = internalImport;
+            imports[specifier] = url;
+        });
+        this.imports = imports;
+    }
+    static resolve(importMapFile) {
+        const { baseURL, ...importMap } = importMapFile;
+        const parsedImportMap = parse(importMap, baseURL);
+        return parsedImportMap;
+    }
+    getContents() {
+        const contents = {
+            imports: this.imports,
+        };
+        return JSON.stringify(contents);
+    }
+    toDataURL() {
+        const encodedImportMap = Buffer.from(this.getContents()).toString('base64');
+        return `data:application/json;base64,${encodedImportMap}`;
+    }
+    async writeToFile(path) {
+        await fs.mkdir(dirname(path), { recursive: true });
+        const contents = this.getContents();
+        await fs.writeFile(path, contents);
+    }
+}
+export { ImportMap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "1.14.1",
+  "version": "2.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/index.js",
@@ -79,6 +79,7 @@
     "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
   },
   "dependencies": {
+    "@import-maps/resolve": "^1.0.1",
     "common-path-prefix": "^3.0.0",
     "del": "^6.0.0",
     "env-paths": "^3.0.0",

package/dist/import_map.d.ts

@@ -1,13 +0,0 @@
-interface ImportMapFile {
-    imports: Record<string, string>;
-    scopes?: Record<string, string>;
-}
-declare class ImportMap {
-    imports: Record<string, string>;
-    constructor(input?: ImportMapFile[]);
-    getContents(): string;
-    toDataURL(): string;
-    writeToFile(path: string): Promise<void>;
-}
-export { ImportMap };
-export type { ImportMapFile };

package/dist/import_map.js

@@ -1,30 +0,0 @@
-import { Buffer } from 'buffer';
-import { promises as fs } from 'fs';
-import { dirname } from 'path';
-const INTERNAL_IMPORTS = {
-    'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
-};
-class ImportMap {
-    constructor(input = []) {
-        const inputImports = input.reduce((acc, { imports }) => ({ ...acc, ...imports }), {});
-        // `INTERNAL_IMPORTS` must come last,
-        // because we need to guarantee `netlify:edge` isn't user-defined.
-        this.imports = { ...inputImports, ...INTERNAL_IMPORTS };
-    }
-    getContents() {
-        const contents = {
-            imports: this.imports,
-        };
-        return JSON.stringify(contents);
-    }
-    toDataURL() {
-        const encodedImportMap = Buffer.from(this.getContents()).toString('base64');
-        return `data:application/json;base64,${encodedImportMap}`;
-    }
-    async writeToFile(path) {
-        await fs.mkdir(dirname(path), { recursive: true });
-        const contents = this.getContents();
-        await fs.writeFile(path, contents);
-    }
-}
-export { ImportMap };