@netlify/edge-bundler 10.0.0 → 10.1.1

package/README.md

@@ -9,32 +9,42 @@ Intelligently prepare Netlify Edge Functions for deployment.
 
 1. Install this module as a dependency in your project
 
-    ```
-    npm install @netlify/edge-bundler --save
-    ```
+   ```
+   npm install @netlify/edge-bundler --save
+   ```
 
 2. Import it and create a bundle from a directory of Edge Functions and a list of declarations.
 
-    ```js
-    import { bundle } from '@netlify/edge-bundler'
+   ```js
+   import { bundle } from '@netlify/edge-bundler'
 
-    // List of directories to search for Edge Functions.
-    const sourceDirectories = [
-        "/repo/netlify/edge-functions",
-        "/repo/.netlify/edge-functions"
-    ]
+   // List of directories to search for Edge Functions.
+   const sourceDirectories = ['/repo/netlify/edge-functions', '/repo/.netlify/edge-functions']
 
-    // Directory where bundle should be placed.
-    const distDirectory = "/repo/.netlify/edge-functions-dist"
+   // Directory where bundle should be placed.
+   const distDirectory = '/repo/.netlify/edge-functions-dist'
 
-    // List of Edge Functions declarations.
-    const declarations = [
-        {function: "user-1", path: "/blog/*"},
-        {function: "internal-2", path: "/"}
-    ]
+   // List of Edge Functions declarations.
+   const declarations = [
+     { function: 'user-1', path: '/blog/*' },
+     { function: 'internal-2', path: '/' },
+   ]
+
+   await bundle(sourceDirectories, distDirectory, declarations)
+   ```
+
+## Vendored modules
+
+To avoid pulling in additional dependencies at runtime, this package vendors some Deno modules in the `deno/vendor`
+directory.
+
+You can recreate this directory by running `npm run vendor`.
+
+> [!WARNING]  
+> At the time of writing, the underlying Deno CLI command doesn't correctly pull the WASM binary required by the ESZIP
+> module. If you run the command to update the list of vendores modules, please ensure you're not deleting
+> `eszip_wasm_bg.wasm`.
 
-    await bundle(sourceDirectories, distDirectory, declarations)
-    ```
 ## Contributors
 
 Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for instructions on how to set up and work on this repository. Thanks

package/deno/vendor/deno.land/x/deno_graph@0.59.2/media_type.ts

@@ -0,0 +1,20 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+export enum MediaType {
+  JavaScript = "JavaScript",
+  Mjs = "Mjs",
+  Cjs = "Cjs",
+  Jsx = "Jsx",
+  TypeScript = "TypeScript",
+  Mts = "Mts",
+  Cts = "Cts",
+  Dts = "Dts",
+  Dmts = "Dmts",
+  Dcts = "Dcts",
+  Tsx = "Tsx",
+  Json = "Json",
+  Wasm = "Wasm",
+  TsBuildInfo = "TsBuildInfo",
+  SourceMap = "SourceMap",
+  Unknown = "Unknown",
+}

package/deno/vendor/deno.land/x/deno_graph@0.59.2/types.d.ts

@@ -0,0 +1,182 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import type { MediaType } from "./media_type.ts";
+
+/** Additional meta data that is used to enrich the output of the module
+ * graph. */
+export interface CacheInfo {
+  /** The string path to where the local version of the content is located. For
+   * non `file:` URLs, this is the location of the cached content, otherwise it
+   * is the absolute path to the local file. */
+  local?: string;
+  /** The string path to where a transpiled version of the source content is
+   * located, if any. */
+  emit?: string;
+  /** The string path to where an external source map of the transpiled source
+   * content is located, if any. */
+  map?: string;
+}
+
+export interface TypesDependency {
+  /** The string URL to the type information for the module. */
+  types: string;
+  /** An optional range which indicates the source of the dependency. */
+  source?: Range;
+}
+
+export interface LoadResponseModule {
+  /** A module with code has been loaded. */
+  kind: "module";
+  /** The string URL of the resource. If there were redirects, the final
+   * specifier should be set here, otherwise the requested specifier. */
+  specifier: string;
+  /** For remote resources, a record of headers should be set, where the key's
+   * have been normalized to be lower case values. */
+  headers?: Record<string, string>;
+  /** The string value of the loaded resources. */
+  content: string;
+}
+
+export interface LoadResponseExternal {
+  /** The loaded module is either _external_ or _built-in_ to the runtime. */
+  kind: "external";
+  /** The strung URL of the resource. If there were redirects, the final
+   * specifier should be set here, otherwise the requested specifier. */
+  specifier: string;
+}
+
+export type LoadResponse = LoadResponseModule | LoadResponseExternal;
+
+export interface PositionJson {
+  /** The line number of a position within a source file. The number is a zero
+   * based index. */
+  line: number;
+  /** The character number of a position within a source file. The number is a
+   * zero based index. */
+  character: number;
+}
+
+export interface Range {
+  /** A string URL representing a source of a dependency. */
+  specifier: string;
+  /** The start location of a range of text in a source file. */
+  start?: PositionJson;
+  /** The end location of a range of text in a source file. */
+  end?: PositionJson;
+}
+
+export interface RangeJson {
+  /** The start location of a range of text in a source file. */
+  start: PositionJson;
+  /** The end location of a range of text in a source file. */
+  end: PositionJson;
+}
+
+export interface ResolvedDependency {
+  /** The fully resolved string URL of the dependency, which should be
+   * resolvable in the module graph. If there was an error, `error` will be set
+   * and this will be undefined. */
+  specifier?: string;
+  /** Any error encountered when trying to resolved the specifier. If this is
+   * defined, `specifier` will be undefined. */
+  error?: string;
+  /** The range within the source code where the specifier was identified. */
+  span: RangeJson;
+}
+
+export interface TypesDependencyJson {
+  /** The string specifier that was used for the dependency. */
+  specifier: string;
+  /** An object pointing to the resolved dependency. */
+  dependency: ResolvedDependency;
+}
+
+/** The kind of module.
+ *
+ * For asserted modules, the value of the `asserted` property is set to the
+ * `type` value of the import attribute.
+ *
+ * Dependency analysis is not performed for asserted or Script modules
+ * currently. Synthetic modules were injected into the graph with their own
+ * dependencies provided. */
+export type ModuleKind =
+  | "asserted"
+  | "esm"
+  | "npm"
+  | "external";
+
+export interface DependencyJson {
+  /** The string specifier that was used for the dependency. */
+  specifier: string;
+  /** An object pointing to the resolved _code_ dependency. */
+  code?: ResolvedDependency;
+  /** An object pointing to the resolved _type_ dependency of a module. This is
+   * populated when the `@deno-types` directive was used to supply a type
+   * definition file for a dependency. */
+  type?: ResolvedDependency;
+  /** A flag indicating if the dependency was dynamic. (e.g.
+   * `await import("mod.ts")`) */
+  isDynamic?: true;
+  assertionType?: string;
+}
+
+// todo(dsherret): split this up into separate types based on the "kind"
+
+export interface ModuleJson extends CacheInfo {
+  /** The string URL of the module. */
+  specifier: string;
+  /** Any error encountered when attempting to load the module. */
+  error?: string;
+  /** The module kind that was determined when the module was resolved. This is
+   * used by loaders to indicate how a module needs to be loaded at runtime. */
+  kind?: ModuleKind;
+  /** An array of dependencies that were identified in the module. */
+  dependencies?: DependencyJson[];
+  /** If the module had a types dependency, the information about that
+   * dependency. */
+  typesDependency?: TypesDependencyJson;
+  /** The resolved media type of the module, which determines how Deno will
+   * handle the module. */
+  mediaType?: MediaType;
+  /** The size of the source content of the module in bytes. */
+  size?: number;
+}
+
+export interface GraphImportJson {
+  /** The referrer (URL string) that was used as a base when resolving the
+   * imports added to the graph. */
+  referrer: string;
+  /** An array of resolved dependencies which were imported using the
+   * referrer. */
+  dependencies?: DependencyJson[];
+}
+
+/** The plain-object representation of a module graph that is suitable for
+ * serialization to JSON. */
+export interface ModuleGraphJson {
+  /** The module specifiers (URL string) of the _roots_ of the module graph of
+   * which the module graph was built for. */
+  roots: string[];
+  /** An array of modules that are part of the module graph. */
+  modules: ModuleJson[];
+  /** External imports that were added to the graph when it was being built.
+   * The key is the referrer which was used as a base to resolve the
+   * dependency. The value is the resolved dependency. */
+  imports?: GraphImportJson[];
+  /** A record/map of any redirects encountered when resolving modules. The
+   * key was the requested module specifier and the value is the redirected
+   * module specifier. */
+  redirects: Record<string, string>;
+}
+
+export interface Dependency {
+  /** An object pointing to the resolved _code_ dependency. */
+  code?: ResolvedDependency;
+  /** An object pointing to the resolved _type_ dependency of a module. This is
+   * populated when the `@deno-types` directive was used to supply a type
+   * definition file for a dependency. */
+  type?: ResolvedDependency;
+  /** A flag indicating if the dependency was dynamic. (e.g.
+   * `await import("mod.ts")`) */
+  isDynamic?: true;
+}

package/dist/deno/vendor/deno.land/x/deno_graph@0.59.2/media_type.d.ts

@@ -0,0 +1,18 @@
+export declare enum MediaType {
+    JavaScript = "JavaScript",
+    Mjs = "Mjs",
+    Cjs = "Cjs",
+    Jsx = "Jsx",
+    TypeScript = "TypeScript",
+    Mts = "Mts",
+    Cts = "Cts",
+    Dts = "Dts",
+    Dmts = "Dmts",
+    Dcts = "Dcts",
+    Tsx = "Tsx",
+    Json = "Json",
+    Wasm = "Wasm",
+    TsBuildInfo = "TsBuildInfo",
+    SourceMap = "SourceMap",
+    Unknown = "Unknown"
+}

package/dist/deno/vendor/deno.land/x/deno_graph@0.59.2/media_type.js

@@ -0,0 +1,20 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export var MediaType;
+(function (MediaType) {
+    MediaType["JavaScript"] = "JavaScript";
+    MediaType["Mjs"] = "Mjs";
+    MediaType["Cjs"] = "Cjs";
+    MediaType["Jsx"] = "Jsx";
+    MediaType["TypeScript"] = "TypeScript";
+    MediaType["Mts"] = "Mts";
+    MediaType["Cts"] = "Cts";
+    MediaType["Dts"] = "Dts";
+    MediaType["Dmts"] = "Dmts";
+    MediaType["Dcts"] = "Dcts";
+    MediaType["Tsx"] = "Tsx";
+    MediaType["Json"] = "Json";
+    MediaType["Wasm"] = "Wasm";
+    MediaType["TsBuildInfo"] = "TsBuildInfo";
+    MediaType["SourceMap"] = "SourceMap";
+    MediaType["Unknown"] = "Unknown";
+})(MediaType || (MediaType = {}));

package/dist/node/bundler.js

@@ -156,7 +156,7 @@ const safelyVendorNPMSpecifiers = async ({ basePath, functions, importMap, logge
             functions: functions.map(({ path }) => path),
             importMap,
             logger,
-            referenceTypes: false,
+            environment: 'production',
             rootPath,
         });
     }

package/dist/node/bundler.test.js

@@ -1,3 +1,4 @@
+import { Buffer } from 'buffer';
 import { access, readdir, readFile, rm, writeFile } from 'fs/promises';
 import { join, resolve } from 'path';
 import process from 'process';
@@ -430,3 +431,27 @@ test('Loads JSON modules', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
+test('Supports TSX and process.env', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('tsx');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        vendorDirectory: vendorDirectory.path,
+    });
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    process.env.FOO = 'bar';
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(Buffer.from(func1, 'base64').toString()).toBe(`hippedy hoppedy, createElement is now a production property. Here, take this env var: FOO=bar`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+    delete process.env.FOO;
+});

package/dist/node/index.d.ts

@@ -6,5 +6,5 @@ export type { EdgeFunction } from './edge_function.js';
 export { findFunctions as find } from './finder.js';
 export { generateManifest } from './manifest.js';
 export type { EdgeFunctionConfig, Manifest } from './manifest.js';
-export { serve } from './server/server.js';
+export { ModuleGraph, serve } from './server/server.js';
 export { validateManifest, ManifestValidationError } from './validation/manifest/index.js';

package/dist/node/npm_dependencies.d.ts

@@ -7,10 +7,10 @@ interface VendorNPMSpecifiersOptions {
     functions: string[];
     importMap: ImportMap;
     logger: Logger;
-    referenceTypes: boolean;
+    environment: 'production' | 'development';
     rootPath?: string;
 }
-export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, referenceTypes, rootPath, }: VendorNPMSpecifiersOptions) => Promise<{
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, environment, rootPath, }: VendorNPMSpecifiersOptions) => Promise<{
     cleanup: () => Promise<void>;
     directory: string;
     importMap: {

package/dist/node/npm_dependencies.js

@@ -9,7 +9,7 @@ import { findUp } from 'find-up';
 import getPackageName from 'get-package-name';
 import tmp from 'tmp-promise';
 import { pathsBetween } from './utils/fs.js';
-const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.cts', '.mts']);
+const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.ctsx', '.mts', '.mtsx']);
 const slugifyPackageName = (specifier) => {
     if (!specifier.startsWith('@'))
         return specifier;
@@ -66,6 +66,10 @@ const safelyDetectTypes = async (packageJsonPath) => {
 // Workaround for https://github.com/evanw/esbuild/issues/1921.
 const banner = {
     js: `
+  import process from "node:process";
+  import {setImmediate, clearImmediate} from "node:timers";
+  import {Buffer} from "node:buffer";
+
   import {createRequire as ___nfyCreateRequire} from "node:module";
   import {fileURLToPath as ___nfyFileURLToPath} from "node:url";
   import {dirname as ___nfyPathDirname} from "node:path";
@@ -78,7 +82,7 @@ const banner = {
  * Parses a set of functions and returns a list of specifiers that correspond
  * to npm modules.
  */
-const getNPMSpecifiers = async ({ basePath, functions, importMap, referenceTypes, rootPath, }) => {
+const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, rootPath }) => {
     const baseURL = pathToFileURL(basePath);
     const { reasons } = await nodeFileTrace(functions, {
         base: rootPath,
@@ -153,7 +157,7 @@ const getNPMSpecifiers = async ({ basePath, functions, importMap, referenceTypes
         if (isDirectDependency) {
             npmSpecifiers.push({
                 specifier: packageName,
-                types: referenceTypes ? await safelyDetectTypes(path.join(basePath, filePath)) : undefined,
+                types: environment === 'development' ? await safelyDetectTypes(path.join(basePath, filePath)) : undefined,
             });
         }
     }
@@ -162,7 +166,7 @@ const getNPMSpecifiers = async ({ basePath, functions, importMap, referenceTypes
         npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
     };
 };
-export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, referenceTypes, rootPath = basePath, }) => {
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, environment, rootPath = basePath, }) => {
     // The directories that esbuild will use when resolving Node modules. We must
     // set these manually because esbuild will be operating from a temporary
     // directory that will not live inside the project root, so the normal
@@ -176,7 +180,7 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         basePath,
         functions,
         importMap: importMap.getContentsWithURLObjects(),
-        referenceTypes,
+        environment,
         rootPath,
     });
     // If we found no specifiers, there's nothing left to do here.
@@ -210,6 +214,11 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         splitting: true,
         target: 'es2020',
         write: false,
+        define: environment === 'production'
+            ? {
+                'process.env.NODE_ENV': '"production"',
+            }
+            : undefined,
     });
     await Promise.all(outputFiles.map(async (file) => {
         var _a;

package/dist/node/server/server.d.ts

@@ -1,9 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ModuleGraphJson } from '../../deno/vendor/deno.land/x/deno_graph@0.59.2/types.d.js';
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
 import type { FeatureFlags } from '../feature_flags.js';
 import { LogFunction } from '../logger.js';
 export type FormatFunction = (name: string) => string;
+export type ModuleGraph = ModuleGraphJson;
 interface StartServerOptions {
     getFunctionsConfig?: boolean;
 }
@@ -34,7 +41,7 @@ interface ServeOptions {
 export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, rootPath, servePath, userLogger, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
     features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
-    graph: any;
+    graph: ModuleGraphJson;
     npmSpecifiersWithExtraneousFiles: string[];
     success: boolean;
 }>>;

package/dist/node/server/server.js

@@ -24,7 +24,11 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
             await killProcess(processRef.ps);
         }
-        let graph;
+        let graph = {
+            roots: [],
+            modules: [],
+            redirects: {},
+        };
         const stage2Path = await generateStage2({
             bootstrapURL,
             distDirectory,
@@ -44,7 +48,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             functions: functions.map(({ path }) => path),
             importMap,
             logger,
-            referenceTypes: true,
+            environment: 'development',
             rootPath,
         });
         if (vendor) {

package/dist/node/server/server.test.js

@@ -48,9 +48,7 @@ test('Starts a server and serves requests for edge functions', async () => {
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
     expect(npmSpecifiersWithExtraneousFiles).toEqual(['dictionary']);
     for (const key in functions) {
-        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
-        // @ts-expect-error TODO: Module graph is currently not typed
-        ({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
+        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
         expect(graphEntry).toBe(true);
     }
     const response1 = await fetch(`http://0.0.0.0:${port}/foo`, {
@@ -121,9 +119,7 @@ test('Serves edge functions in a monorepo setup', async () => {
     expect(functionsConfig).toEqual([{ path: '/func1' }]);
     expect(npmSpecifiersWithExtraneousFiles).toEqual(['child-1']);
     for (const key in functions) {
-        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
-        // @ts-expect-error TODO: Module graph is currently not typed
-        ({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
+        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
         expect(graphEntry).toBe(true);
     }
     const response1 = await fetch(`http://0.0.0.0:${port}/func1`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "10.0.0",
+  "version": "10.1.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -34,7 +34,8 @@
     "test:dev:deno": "deno test --allow-all deno",
     "test:ci:vitest": "vitest run --coverage",
     "test:ci:deno": "deno test --allow-all deno",
-    "test:integration": "node --experimental-modules test/integration/test.js"
+    "test:integration": "node --experimental-modules test/integration/test.js",
+    "vendor": "deno vendor --force --output deno/vendor https://deno.land/x/deno_graph@0.59.2/types.d.ts https://deno.land/x/eszip@v0.55.2/mod.ts https://deno.land/x/retry@v2.0.0/mod.ts https://deno.land/x/std@0.177.0/path/mod.ts"
   },
   "config": {
     "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{node,scripts,.github}/**/*.{js,ts,md,html}\" \"*.{js,ts,md,html}\"",

package/deno/lib/stage2.test.ts

@@ -1,58 +0,0 @@
-import { assertEquals, assertStringIncludes } from 'https://deno.land/std@0.177.0/testing/asserts.ts'
-
-import { join } from 'https://deno.land/std@0.177.0/path/mod.ts'
-import { pathToFileURL } from 'https://deno.land/std@0.177.0/node/url.ts'
-
-import { getStage2Entry } from './stage2.ts'
-import { virtualRoot } from './consts.ts'
-
-Deno.test('`getStage2Entry` returns a valid stage 2 file', async () => {
-  const directory = await Deno.makeTempDir()
-  const functions = [
-    {
-      name: 'func1',
-      path: join(directory, 'func1.ts'),
-      response: 'Hello from function 1',
-    },
-    {
-      name: 'func2',
-      path: join(directory, 'func2.ts'),
-      response: 'Hello from function 2',
-    },
-  ]
-
-  for (const func of functions) {
-    const contents = `export default async () => new Response(${JSON.stringify(func.response)})`
-
-    await Deno.writeTextFile(func.path, contents)
-  }
-
-  const baseURL = pathToFileURL(directory)
-  const stage2 = getStage2Entry(
-    directory,
-    functions.map(({ name, path }) => ({ name, path })),
-  )
-
-  // Ensuring that the stage 2 paths have the virtual root before we strip it.
-  assertStringIncludes(stage2, virtualRoot)
-
-  // Replacing the virtual root with the URL of the temporary directory so that
-  // we can actually import the module.
-  const normalizedStage2 = stage2.replaceAll(virtualRoot, `${baseURL.href}/`)
-
-  const stage2Path = join(directory, 'stage2.ts')
-  const stage2URL = pathToFileURL(stage2Path)
-
-  await Deno.writeTextFile(stage2Path, normalizedStage2)
-
-  const mod = await import(stage2URL.href)
-
-  await Deno.remove(directory, { recursive: true })
-
-  for (const func of functions) {
-    const result = await mod.functions[func.name]()
-
-    assertEquals(await result.text(), func.response)
-    assertEquals(mod.metadata.functions[func.name].url, pathToFileURL(func.path).toString())
-  }
-})

package/dist/node/bootstrap.test.d.ts

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

package/dist/node/bootstrap.test.js

@@ -1,26 +0,0 @@
-import { Buffer } from 'buffer';
-import { env } from 'process';
-import fetch, { Headers } from 'node-fetch';
-import { test, expect } from 'vitest';
-import { getBootstrapURL } from './formats/javascript.js';
-test('Imports the bootstrap layer from a valid URL', async () => {
-    const importURL = new URL(getBootstrapURL());
-    const headers = new Headers();
-    // `node-fetch` doesn't let us send credentials as part of the URL, so we
-    // have to transform them into an `Authorization` header.
-    if (importURL.username) {
-        const auth = Buffer.from(`${importURL.username}:${importURL.password}`);
-        importURL.username = '';
-        importURL.password = '';
-        headers.set('Authorization', `Basic ${auth.toString('base64')}`);
-    }
-    const canonicalURL = importURL.toString();
-    const { status } = await fetch(canonicalURL, { headers });
-    expect(status).toBe(200);
-});
-test('Imports the bootstrap layer from the URL present in the `NETLIFY_EDGE_BOOTSTRAP` environment variable, if present', () => {
-    const mockURL = 'https://example.com/boot.ts';
-    env.NETLIFY_EDGE_BOOTSTRAP = mockURL;
-    expect(getBootstrapURL()).toBe(mockURL);
-    env.NETLIFY_EDGE_BOOTSTRAP = undefined;
-});

package/dist/node/deno_config.d.ts

@@ -1,5 +0,0 @@
-interface DenoConfigFile {
-    importMap?: string;
-}
-export declare const getConfig: (basePath?: string) => Promise<DenoConfigFile | undefined>;
-export {};

package/dist/node/deno_config.js

@@ -1,40 +0,0 @@
-import { promises as fs } from 'fs';
-import { join, resolve } from 'path';
-import { parse as parseJSONC } from 'jsonc-parser';
-import { isNodeError } from './utils/error.js';
-const filenames = ['deno.json', 'deno.jsonc'];
-export const getConfig = async (basePath) => {
-    if (basePath === undefined) {
-        return;
-    }
-    for (const filename of filenames) {
-        const candidatePath = join(basePath, filename);
-        const config = await getConfigFromFile(candidatePath);
-        if (config !== undefined) {
-            return normalizeConfig(config, basePath);
-        }
-    }
-};
-const getConfigFromFile = async (filePath) => {
-    try {
-        const data = await fs.readFile(filePath, 'utf8');
-        const config = parseJSONC(data);
-        return config;
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return;
-        }
-        return {};
-    }
-};
-const normalizeConfig = (rawConfig, basePath) => {
-    const config = {};
-    if (rawConfig.importMap) {
-        if (typeof rawConfig.importMap !== 'string') {
-            throw new TypeError(`'importMap' property in Deno config must be a string`);
-        }
-        config.importMap = resolve(basePath, rawConfig.importMap);
-    }
-    return config;
-};

package/dist/node/deno_config.test.d.ts

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

package/dist/node/deno_config.test.js

@@ -1,37 +0,0 @@
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import tmp from 'tmp-promise';
-import { expect, test } from 'vitest';
-import { getConfig } from './deno_config.js';
-test('Returns `undefined` if no config file is found', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const config = await getConfig(path);
-    expect(config).toBeUndefined();
-    await cleanup();
-});
-test('Returns an empty object if the config file cannot be parsed', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.json');
-    await fs.writeFile(configPath, '{');
-    const config = await getConfig(path);
-    expect(config).toEqual({});
-    await cleanup();
-});
-test('Resolves `importMap` into an absolute path', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.json');
-    const data = JSON.stringify({ importMap: 'import_map.json' });
-    await fs.writeFile(configPath, data);
-    const config = await getConfig(path);
-    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
-    await cleanup();
-});
-test('Supports JSONC', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.jsonc');
-    const data = JSON.stringify({ importMap: 'import_map.json' });
-    await fs.writeFile(configPath, `// This is a comment\n${data}`);
-    const config = await getConfig(path);
-    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
-    await cleanup();
-});

package/dist/node/serving.test.d.ts

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

package/dist/node/serving.test.js

@@ -1,31 +0,0 @@
-import { join } from 'path';
-import getPort from 'get-port';
-import fetch from 'node-fetch';
-import { test, expect } from 'vitest';
-import { fixturesDir } from '../test/util.js';
-import { serve } from './index.js';
-test('bundler serving functionality', async () => {
-    const port = await getPort();
-    const server = await serve({
-        port,
-    });
-    const { success } = await server([
-        {
-            name: 'echo_env',
-            path: join(fixturesDir, 'serve_test', 'echo_env.ts'),
-        },
-    ], {
-        very_secret_secret: 'i love netlify',
-    });
-    expect(success).toBe(true);
-    const response = await fetch(`http://0.0.0.0:${port}/foo`, {
-        headers: {
-            'x-deno-functions': 'echo_env',
-            'x-deno-pass': 'passthrough',
-            'X-NF-Request-ID': 'foo',
-        },
-    });
-    expect(response.status).toBe(200);
-    const body = (await response.json());
-    expect(body.very_secret_secret).toBe('i love netlify');
-});