@netlify/zip-it-and-ship-it 4.23.3 → 4.23.5-setup-typescript-4

package/dist/runtimes/index.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { extname, basename } = require('path');
+const { getConfigForFunction } = require('../config');
+const goRuntime = require('./go');
+const jsRuntime = require('./node');
+const rustRuntime = require('./rust');
+/**
+ * Finds functions for a list of paths using a specific runtime. The return
+ * value is an object containing an array of the functions found (`functions`)
+ * and an array with the paths that haven't been recognized by the runtime
+ * (`remainingPaths`).
+ *
+ * @param   {Boolean} dedupe
+ * @param   {Object} fsCache
+ * @param   {Array<String>} paths
+ * @param   {Object} runtime
+ * @returns {Promise<Object>}
+ */
+const findFunctionsInRuntime = function ({ dedupe = false, featureFlags, fsCache, paths, runtime }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const functions = yield runtime.findFunctionsInPaths({ featureFlags, fsCache, paths });
+        // If `dedupe` is true, we use the function name (`filename`) as the map key,
+        // so that `function-1.js` will overwrite `function-1.go`. Otherwise, we use
+        // `srcPath`, so that both functions are returned.
+        const key = dedupe ? 'name' : 'srcPath';
+        // Augmenting the function objects with additional information.
+        const augmentedFunctions = functions.map((func) => [
+            func[key],
+            Object.assign(Object.assign({}, func), { extension: extname(func.mainFile), filename: basename(func.srcPath), runtime }),
+        ]);
+        const usedPaths = new Set(augmentedFunctions.map(([path]) => path));
+        const remainingPaths = paths.filter((path) => !usedPaths.has(path));
+        return { functions: augmentedFunctions, remainingPaths };
+    });
+};
+/**
+ * Gets a list of functions found in a list of paths.
+ *
+ * @param   {Object} config
+ * @param   {Boolean} dedupe
+ * @param   {String} path
+ * @returns {Promise<Map>}
+ */
+const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags } = {}) => __awaiter(this, void 0, void 0, function* () {
+    // An object to cache filesystem operations. This allows different functions
+    // to perform IO operations on the same file (i.e. getting its stats or its
+    // contents) without duplicating work.
+    const fsCache = {};
+    // The order of this array determines the priority of the runtimes. If a path
+    // is used by the first time, it won't be made available to the subsequent
+    // runtimes.
+    const runtimes = [jsRuntime, goRuntime, rustRuntime];
+    // We cycle through the ordered array of runtimes, passing each one of them
+    // through `findFunctionsInRuntime`. For each iteration, we collect all the
+    // functions found plus the list of paths that still need to be evaluated,
+    // using them as the input for the next iteration until the last runtime.
+    const { functions } = yield runtimes.reduce((aggregate, runtime) => __awaiter(this, void 0, void 0, function* () {
+        const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = yield aggregate;
+        const { functions: runtimeFunctions, remainingPaths: runtimePaths } = yield findFunctionsInRuntime({
+            dedupe,
+            featureFlags,
+            fsCache,
+            paths: aggregatePaths,
+            runtime,
+        });
+        return {
+            functions: [...aggregateFunctions, ...runtimeFunctions],
+            remainingPaths: runtimePaths,
+        };
+    }), { functions: [], remainingPaths: paths });
+    const functionsWithConfig = functions.map(([name, func]) => [
+        name,
+        Object.assign(Object.assign({}, func), { config: getConfigForFunction({ config, func }) }),
+    ]);
+    return new Map(functionsWithConfig);
+});
+module.exports = {
+    getFunctionsFromPaths,
+};

package/dist/runtimes/node/base_path.d.ts

@@ -0,0 +1 @@
+export function getBasePath(dirnames: any): any;

package/dist/runtimes/node/base_path.js

@@ -0,0 +1,8 @@
+const commonPathPrefix = require('common-path-prefix');
+const getBasePath = (dirnames) => {
+    if (dirnames.length === 1) {
+        return dirnames[0];
+    }
+    return commonPathPrefix(dirnames);
+};
+module.exports = { getBasePath };

package/dist/runtimes/node/bundler.d.ts

@@ -0,0 +1,20 @@
+export function bundleJsFile({ additionalModulePaths, basePath, config, externalModules, ignoredModules, name, srcDir, srcFile, }: {
+    additionalModulePaths: any;
+    basePath: any;
+    config: any;
+    externalModules?: any[];
+    ignoredModules?: any[];
+    name: any;
+    srcDir: any;
+    srcFile: any;
+}): Promise<{
+    additionalPaths: any[];
+    bundlePaths: Map<any, any>;
+    cleanTempFiles: () => Promise<void>;
+    inputs: string[];
+    nativeNodeModules: {};
+    nodeModulesWithDynamicImports: any[];
+    warnings: esbuild.Message[];
+}>;
+export const ESBUILD_LOG_LIMIT: 10;
+import esbuild = require("@netlify/esbuild");

package/dist/runtimes/node/bundler.js

@@ -0,0 +1,135 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { basename, dirname, extname, resolve, join } = require('path');
+const esbuild = require('@netlify/esbuild');
+const { tmpName } = require('tmp-promise');
+const { JS_BUNDLER_ESBUILD, RUNTIME_JS } = require('../../utils/consts');
+const { getPathWithExtension, safeUnlink } = require('../../utils/fs');
+const { getBundlerTarget } = require('./bundler_target');
+const { getDynamicImportsPlugin } = require('./dynamic_imports/plugin');
+const { getNativeModulesPlugin } = require('./native_modules/plugin');
+// Maximum number of log messages that an esbuild instance will produce. This
+// limit is important to avoid out-of-memory errors due to too much data being
+// sent in the Go<>Node IPC channel.
+const ESBUILD_LOG_LIMIT = 10;
+// When resolving imports with no extension (e.g. require('./foo')), these are
+// the extensions that esbuild will look for, in this order.
+const RESOLVE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.json'];
+// eslint-disable-next-line max-statements
+const bundleJsFile = function ({ additionalModulePaths, basePath, config, externalModules = [], ignoredModules = [], name, srcDir, srcFile, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // We use a temporary directory as the destination for esbuild files to avoid
+        // any naming conflicts with files generated by other functions.
+        const targetDirectory = yield tmpName();
+        // De-duping external and ignored modules.
+        const external = [...new Set([...externalModules, ...ignoredModules])];
+        // To be populated by the native modules plugin with the names, versions and
+        // paths of any Node modules with native dependencies.
+        const nativeNodeModules = {};
+        // To be populated by the dynamic imports plugin with the names of the Node
+        // modules that include imports with dynamic expressions.
+        const nodeModulesWithDynamicImports = new Set();
+        // To be populated by the dynamic imports plugin with any paths (in a glob
+        // format) to be included in the bundle in order to make a dynamic import
+        // work at runtime.
+        const dynamicImportsIncludedPaths = new Set();
+        // The list of esbuild plugins to enable for this build.
+        const plugins = [
+            getNativeModulesPlugin(nativeNodeModules),
+            getDynamicImportsPlugin({
+                basePath,
+                includedPaths: dynamicImportsIncludedPaths,
+                moduleNames: nodeModulesWithDynamicImports,
+                processImports: config.processDynamicNodeImports !== false,
+                srcDir,
+            }),
+        ];
+        // The version of ECMAScript to use as the build target. This will determine
+        // whether certain features are transpiled down or left untransformed.
+        const nodeTarget = getBundlerTarget(config.nodeVersion);
+        // esbuild will format `sources` relative to the sourcemap file, which lives
+        // in `destFolder`. We use `sourceRoot` to establish that relation. They are
+        // URLs, not paths, so even on Windows they should use forward slashes.
+        const sourceRoot = targetDirectory.replace(/\\/g, '/');
+        try {
+            const { metafile, warnings } = yield esbuild.build({
+                bundle: true,
+                entryPoints: [srcFile],
+                external,
+                logLevel: 'warning',
+                logLimit: ESBUILD_LOG_LIMIT,
+                metafile: true,
+                nodePaths: additionalModulePaths,
+                outdir: targetDirectory,
+                platform: 'node',
+                plugins,
+                resolveExtensions: RESOLVE_EXTENSIONS,
+                sourcemap: Boolean(config.nodeSourcemap),
+                sourceRoot,
+                target: [nodeTarget],
+            });
+            const bundlePaths = getBundlePaths({
+                destFolder: targetDirectory,
+                outputs: metafile.outputs,
+                srcFile,
+            });
+            const inputs = Object.keys(metafile.inputs).map((path) => resolve(path));
+            const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()]);
+            return {
+                additionalPaths: [...dynamicImportsIncludedPaths],
+                bundlePaths,
+                cleanTempFiles,
+                inputs,
+                nativeNodeModules,
+                nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
+                warnings,
+            };
+        }
+        catch (error) {
+            error.customErrorInfo = {
+                type: 'functionsBundling',
+                location: { bundler: JS_BUNDLER_ESBUILD, functionName: name, runtime: RUNTIME_JS },
+            };
+            throw error;
+        }
+    });
+};
+// Takes the `outputs` object produced by esbuild and returns a Map with the
+// absolute paths of the generated files as keys, and the paths that those
+// files should take in the generated bundle as values. This is compatible
+// with the `aliases` format used upstream.
+const getBundlePaths = ({ destFolder, outputs, srcFile }) => {
+    const bundleFilename = `${basename(srcFile, extname(srcFile))}.js`;
+    const mainFileDirectory = dirname(srcFile);
+    const bundlePaths = new Map();
+    // The paths returned by esbuild are relative to the current directory, which
+    // is a problem on Windows if the target directory is in a different drive
+    // letter. To get around that, instead of using `path.resolve`, we compute
+    // the absolute path by joining `destFolder` with the `basename` of each
+    // entry of the `outputs` object.
+    Object.entries(outputs).forEach(([path, output]) => {
+        const filename = basename(path);
+        const extension = extname(path);
+        const absolutePath = join(destFolder, filename);
+        if (output.entryPoint && basename(output.entryPoint) === basename(srcFile)) {
+            // Ensuring the main file has a `.js` extension.
+            const normalizedSrcFile = getPathWithExtension(srcFile, '.js');
+            bundlePaths.set(absolutePath, normalizedSrcFile);
+        }
+        else if (extension === '.js' || filename === `${bundleFilename}.map`) {
+            bundlePaths.set(absolutePath, join(mainFileDirectory, filename));
+        }
+    });
+    return bundlePaths;
+};
+const getCleanupFunction = (paths) => () => __awaiter(this, void 0, void 0, function* () {
+    yield Promise.all(paths.filter(Boolean).map(safeUnlink));
+});
+module.exports = { bundleJsFile, ESBUILD_LOG_LIMIT };

package/dist/runtimes/node/bundler_target.d.ts

@@ -0,0 +1 @@
+export function getBundlerTarget(suppliedVersion: any): any;

package/dist/runtimes/node/bundler_target.js

@@ -0,0 +1,16 @@
+const DEFAULT_VERSION = 'node12';
+const versionMap = {
+    '8.x': 'node8',
+    '10.x': 'node10',
+    '12.x': 'node12',
+    '14.x': 'node14',
+};
+const getBundlerTarget = (suppliedVersion) => {
+    const version = normalizeVersion(suppliedVersion);
+    return versionMap[version] || DEFAULT_VERSION;
+};
+const normalizeVersion = (version) => {
+    const match = version && version.match(/^nodejs(.*)$/);
+    return match ? match[1] : version;
+};
+module.exports = { getBundlerTarget };

package/dist/runtimes/node/detect_es_module.d.ts

@@ -0,0 +1,3 @@
+export function detectEsModule({ mainFile }: {
+    mainFile: any;
+}): Promise<boolean>;

package/dist/runtimes/node/detect_es_module.js

@@ -0,0 +1,28 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { readFile } = require('fs');
+const { promisify } = require('util');
+const pReadFile = promisify(readFile);
+const { init, parse } = require('es-module-lexer');
+const detectEsModule = ({ mainFile }) => __awaiter(this, void 0, void 0, function* () {
+    if (!mainFile) {
+        return false;
+    }
+    try {
+        const [mainFileContents] = yield Promise.all([pReadFile(mainFile, 'utf8'), init]);
+        const [imports, exports] = parse(mainFileContents);
+        return imports.length !== 0 || exports.length !== 0;
+    }
+    catch (_a) {
+        // If there are any problems with init or parsing, assume it's not an ES module
+        return false;
+    }
+});
+module.exports = { detectEsModule };

package/dist/runtimes/node/dynamic_imports/parser.d.ts

@@ -0,0 +1,8 @@
+export function parseExpression({ basePath, expression: rawExpression, resolveDir }: {
+    basePath: any;
+    expression: any;
+    resolveDir: any;
+}): {
+    includedPathsGlob: string;
+    type: any;
+};

package/dist/runtimes/node/dynamic_imports/parser.js

@@ -0,0 +1,135 @@
+const { join, relative, resolve } = require('path');
+const babel = require('@babel/parser');
+const GLOB_WILDCARD = '**';
+// Transforms an array of glob nodes into a glob string including an absolute
+// path.
+//
+// Example: ["./files/", "*", ".json"] => "/home/ntl/files/*.json"
+const getAbsoluteGlob = ({ basePath, globNodes, resolveDir }) => {
+    if (!validateGlobNodes(globNodes)) {
+        return null;
+    }
+    const globStarIndex = globNodes.indexOf(GLOB_WILDCARD);
+    const [staticPath, dynamicPath] = globStarIndex === -1
+        ? [globNodes.join(''), '']
+        : [globNodes.slice(0, globStarIndex).join(''), globNodes.slice(globStarIndex).join('')];
+    const absoluteStaticPath = resolve(resolveDir, staticPath);
+    const relativeStaticPath = relative(basePath, absoluteStaticPath);
+    const absoluteGlob = join(relativeStaticPath, dynamicPath);
+    return absoluteGlob;
+};
+// Returns GLOB_WILDCARD for AST nodes that are accepted as part of a dynamic
+// expression and convertable to a wildcard character. This determines whether
+// we convert an expression or leave it alone. For example:
+//
+// - `./files/${someVariable}`: Convert `someVariable` to GLOB_WILDCARD
+// - `./files/${[some, array]}`: Don't convert expression
+//
+// The following AST nodes are converted to a wildcard:
+//
+// - CallExpression: `someFunction()`
+// - ConditionalExpression: `someCond ? someValue : otherValue`
+// - Identifier: `someVariable`
+// - MemberExpression: `someArray[index]` or `someObject.property`
+const getWildcardFromASTNode = (node) => {
+    switch (node.type) {
+        case 'CallExpression':
+        case 'ConditionalExpression':
+        case 'Identifier':
+        case 'MemberExpression':
+            return GLOB_WILDCARD;
+        default:
+            throw new Error('Expression member not supported');
+    }
+};
+// Tries to parse an expression, returning an object with:
+// - `includedPathsGlob`: A glob with the files to be included in the bundle
+// - `type`: The expression type (e.g. "require", "import")
+const parseExpression = ({ basePath, expression: rawExpression, resolveDir }) => {
+    const { program } = babel.parse(rawExpression, {
+        sourceType: 'module',
+    });
+    const [topLevelExpression] = program.body;
+    const { expression } = topLevelExpression;
+    if (expression.type === 'CallExpression' && expression.callee.name === 'require') {
+        try {
+            const includedPathsGlob = parseRequire({ basePath, expression, resolveDir });
+            return {
+                includedPathsGlob,
+                type: expression.callee.name,
+            };
+        }
+        catch (_) {
+            // no-op
+        }
+    }
+};
+// Parses a `require()` and returns a glob string with an absolute path.
+const parseRequire = ({ basePath, expression, resolveDir }) => {
+    const { arguments: args = [] } = expression;
+    const argType = args.length === 0 ? null : args[0].type;
+    if (argType === 'BinaryExpression') {
+        try {
+            const globNodes = parseBinaryExpression(args[0]);
+            return getAbsoluteGlob({ basePath, globNodes, resolveDir });
+        }
+        catch (_) {
+            // no-op
+        }
+    }
+    if (argType === 'TemplateLiteral') {
+        const globNodes = parseTemplateLiteral(args[0]);
+        return getAbsoluteGlob({ basePath, globNodes, resolveDir });
+    }
+};
+// Transforms a binary expression AST node into an array of glob nodes, where
+// static parts will be left untouched and identifiers will be replaced by
+// `GLOB_WILDCARD`.
+//
+// Example: './files/' + lang + '.json' => ["./files/", "**", ".json"]
+const parseBinaryExpression = (expression) => {
+    const { left, operator, right } = expression;
+    if (operator !== '+') {
+        throw new Error('Expression operator not supported');
+    }
+    const operands = [left, right].flatMap((operand) => {
+        switch (operand.type) {
+            case 'BinaryExpression':
+                return parseBinaryExpression(operand);
+            case 'StringLiteral':
+                return operand.value;
+            default:
+                return getWildcardFromASTNode(operand);
+        }
+    });
+    return operands;
+};
+// Transforms a template literal AST node into an array of glob nodes, where
+// static parts will be left untouched and identifiers will be replaced by
+// `GLOB_WILDCARD`.
+//
+// Example: `./files/${lang}.json` => ["./files/", "**", ".json"]
+const parseTemplateLiteral = (expression) => {
+    const { expressions, quasis } = expression;
+    const parts = [...expressions, ...quasis].sort((partA, partB) => partA.start - partB.start);
+    const globNodes = parts.map((part) => {
+        switch (part.type) {
+            case 'TemplateElement':
+                return part.value.cooked;
+            default:
+                return getWildcardFromASTNode(part);
+        }
+    });
+    return globNodes.filter(Boolean);
+};
+// For our purposes, we consider a glob to be valid if all the nodes are
+// strings and the first node is static (i.e. not a wildcard character).
+const validateGlobNodes = (globNodes) => {
+    if (!globNodes) {
+        return false;
+    }
+    const hasStrings = globNodes.every((node) => typeof node === 'string');
+    const hasStaticHead = globNodes[0] !== GLOB_WILDCARD;
+    return hasStrings && hasStaticHead;
+};
+module.exports = { parseExpression };

package/dist/runtimes/node/dynamic_imports/plugin.d.ts

@@ -0,0 +1,10 @@
+export function getDynamicImportsPlugin({ basePath, includedPaths, moduleNames, processImports, srcDir }: {
+    basePath: any;
+    includedPaths: any;
+    moduleNames: any;
+    processImports: any;
+    srcDir: any;
+}): {
+    name: string;
+    setup(build: any): void;
+};

package/dist/runtimes/node/dynamic_imports/plugin.js

@@ -0,0 +1,102 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { basename, join, relative } = require('path');
+const findUp = require('find-up');
+const readPackageJson = require('read-package-json-fast');
+const unixify = require('unixify');
+const { parseExpression } = require('./parser');
+// This plugin intercepts module imports using dynamic expressions and does a
+// couple of things with them. First of all, it figures out whether the call
+// is being made from within a Node module, and if so it adds the name of the
+// module to `moduleNames`, so that we can warn the user of potential runtime
+// issues. Secondly, it parses the dynamic expressions and tries to include in
+// the bundle all the files that are possibly needed to make the import work at
+// runtime. This is not always possible, but we do our best.
+const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, processImports, srcDir }) => ({
+    name: 'dynamic-imports',
+    setup(build) {
+        const cache = new Map();
+        // eslint-disable-next-line complexity
+        build.onDynamicImport({}, (args) => __awaiter(this, void 0, void 0, function* () {
+            const { expression, resolveDir } = args;
+            // Don't attempt to parse the expression if the base path isn't defined,
+            // since we won't be able to generate the globs for the included paths.
+            // Also don't parse the expression if we're not interested in processing
+            // the dynamic import expressions.
+            if (basePath && processImports) {
+                const { includedPathsGlob, type: expressionType } = parseExpression({ basePath, expression, resolveDir }) || {};
+                if (includedPathsGlob) {
+                    // The parser has found a glob of paths that should be included in the
+                    // bundle to make this import work, so we add it to `includedPaths`.
+                    includedPaths.add(includedPathsGlob);
+                    // Create the shim that will handle the import at runtime.
+                    const contents = getShimContents({ expressionType, resolveDir, srcDir });
+                    // This is the only branch where we actually solve a dynamic import.
+                    // eslint-disable-next-line max-depth
+                    if (contents) {
+                        return {
+                            contents,
+                        };
+                    }
+                }
+            }
+            // If we're here, it means we weren't able to solve the dynamic import.
+            // We add it to the list of modules with dynamic imports, which allows
+            // consumers like Netlify Build or CLI to advise users on how to proceed.
+            yield registerModuleWithDynamicImports({ cache, moduleNames, resolveDir, srcDir });
+        }));
+    },
+});
+const getPackageName = ({ resolveDir, srcDir }) => __awaiter(this, void 0, void 0, function* () {
+    const packageJsonPath = yield findUp((directory) => __awaiter(this, void 0, void 0, function* () {
+        // We stop traversing if we're about to leave the boundaries of the
+        // function directory or any node_modules directory.
+        if (directory === srcDir || basename(directory) === 'node_modules') {
+            return findUp.stop;
+        }
+        const path = join(directory, 'package.json');
+        const hasPackageJson = yield findUp.exists(path);
+        return hasPackageJson ? path : false;
+    }), { cwd: resolveDir });
+    if (packageJsonPath !== undefined) {
+        const { name } = yield readPackageJson(packageJsonPath);
+        return name;
+    }
+});
+const getPackageNameCached = ({ cache, resolveDir, srcDir }) => {
+    if (!cache.has(resolveDir)) {
+        cache.set(resolveDir, getPackageName({ resolveDir, srcDir }));
+    }
+    return cache.get(resolveDir);
+};
+const getShimContents = ({ expressionType, resolveDir, srcDir }) => {
+    // The shim needs to modify the path of the import, since originally it was
+    // relative to wherever the importer sat in the file tree (i.e. anywhere in
+    // the user space or inside `node_modules`), but at runtime paths must be
+    // relative to the main bundle file, since esbuild will flatten everything
+    // into a single file.
+    const relativeResolveDir = relative(srcDir, resolveDir);
+    const requireArg = relativeResolveDir ? `\`./${unixify(relativeResolveDir)}/$\{args}\`` : 'args';
+    if (expressionType === 'require') {
+        return `module.exports = args => require(${requireArg})`;
+    }
+};
+const registerModuleWithDynamicImports = ({ cache, moduleNames, resolveDir, srcDir }) => __awaiter(this, void 0, void 0, function* () {
+    try {
+        const packageName = yield getPackageNameCached({ cache, resolveDir, srcDir });
+        if (packageName !== undefined) {
+            moduleNames.add(packageName);
+        }
+    }
+    catch (_) {
+        // no-op
+    }
+});
+module.exports = { getDynamicImportsPlugin };

package/dist/runtimes/node/finder.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export function findFunctionsInPaths({ paths }: {
+    paths: any;
+}): Promise<any[]>;
+export function getFunctionAtPath(srcPath: any): Promise<{
+    extension: string;
+    mainFile: any;
+    name: string;
+    srcDir: any;
+    srcPath: any;
+    stat: import("fs").Stats;
+}>;

package/dist/runtimes/node/finder.js

@@ -0,0 +1,82 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { lstat } = require('fs');
+const { join, dirname, basename, extname } = require('path');
+const { promisify } = require('util');
+const locatePath = require('locate-path');
+const pLstat = promisify(lstat);
+// List of extensions that this runtime will look for, in order of precedence.
+const allowedExtensions = ['.js', '.zip', '.cjs', '.mjs', '.ts'];
+// Sorting function, compatible with the callback of Array.sort, which sorts
+// entries by extension according to their position in `allowedExtensions`.
+// It places extensions with a higher precedence last in the array, so that
+// they "win" when the array is flattened into a Map.
+const sortByExtension = (fA, fB) => {
+    const indexA = allowedExtensions.indexOf(fA.extension);
+    const indexB = allowedExtensions.indexOf(fB.extension);
+    return indexB - indexA;
+};
+const findFunctionsInPaths = function ({ paths }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const functions = yield Promise.all(paths.map(getFunctionAtPath));
+        // It's fine to mutate the array since its scope is local to this function.
+        const sortedFunctions = functions.filter(Boolean).sort((fA, fB) => {
+            // We first sort the functions array to put directories first. This is so
+            // that `{name}/{name}.js` takes precedence over `{name}.js`.
+            const directorySort = Number(fA.stat.isDirectory()) - Number(fB.stat.isDirectory());
+            if (directorySort !== 0) {
+                return directorySort;
+            }
+            // If the functions have the same name, we sort them according to the order
+            // defined in `allowedExtensions`.
+            if (fA.name === fB.name) {
+                return sortByExtension(fA, fB);
+            }
+            return 0;
+        });
+        return sortedFunctions;
+    });
+};
+const getFunctionAtPath = function (srcPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filename = basename(srcPath);
+        if (filename === 'node_modules') {
+            return;
+        }
+        const stat = yield pLstat(srcPath);
+        const mainFile = yield getMainFile(srcPath, filename, stat);
+        if (mainFile === undefined) {
+            return;
+        }
+        const extension = extname(srcPath);
+        const srcDir = stat.isDirectory() ? srcPath : dirname(srcPath);
+        const name = basename(srcPath, extname(srcPath));
+        return { extension, mainFile, name, srcDir, srcPath, stat };
+    });
+};
+// Each `srcPath` can also be a directory with an `index` file or a file using
+// the same filename as its directory.
+const getMainFile = function (srcPath, filename, stat) {
+    if (stat.isDirectory()) {
+        return locatePath([
+            join(srcPath, `${filename}.js`),
+            join(srcPath, 'index.js'),
+            join(srcPath, `${filename}.mjs`),
+            join(srcPath, 'index.mjs'),
+            join(srcPath, `${filename}.ts`),
+            join(srcPath, 'index.ts'),
+        ], { type: 'file' });
+    }
+    const extension = extname(srcPath);
+    if (allowedExtensions.includes(extension)) {
+        return srcPath;
+    }
+};
+module.exports = { findFunctionsInPaths, getFunctionAtPath };