@netlify/zip-it-and-ship-it 5.4.0 → 5.5.2

package/dist/runtimes/index.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -25,22 +16,25 @@ const rust_1 = __importDefault(require("./rust"));
  * and an array with the paths that haven't been recognized by the runtime
  * (`remainingPaths`).
  */
-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: (0, path_1.extname)(func.mainFile), filename: (0, path_1.basename)(func.srcPath), runtime }),
-        ]);
-        const usedPaths = new Set(augmentedFunctions.map(([path]) => path));
-        const remainingPaths = paths.filter((path) => !usedPaths.has(path));
-        return { functions: augmentedFunctions, remainingPaths };
-    });
+const findFunctionsInRuntime = async function ({ dedupe = false, featureFlags, fsCache, paths, runtime, }) {
+    const functions = await 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],
+        {
+            ...func,
+            extension: (0, path_1.extname)(func.mainFile),
+            filename: (0, path_1.basename)(func.srcPath),
+            runtime,
+        },
+    ]);
+    const usedPaths = new Set(augmentedFunctions.map(([path]) => path));
+    const remainingPaths = paths.filter((path) => !usedPaths.has(path));
+    return { functions: augmentedFunctions, remainingPaths };
 };
 // 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
@@ -53,15 +47,15 @@ const RUNTIMES = [node_1.default, go_1.default, rust_1.default];
 /**
  * Gets a list of functions found in a list of paths.
  */
-const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags = feature_flags_1.defaultFlags, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFlags = feature_flags_1.defaultFlags, } = {}) => {
     const fsCache = makeFsCache();
     // 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(void 0, void 0, void 0, function* () {
-        const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = yield aggregate;
-        const { functions: runtimeFunctions, remainingPaths: runtimePaths } = yield findFunctionsInRuntime({
+    const { functions } = await RUNTIMES.reduce(async (aggregate, runtime) => {
+        const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = await aggregate;
+        const { functions: runtimeFunctions, remainingPaths: runtimePaths } = await findFunctionsInRuntime({
             dedupe,
             featureFlags,
             fsCache,
@@ -72,27 +66,30 @@ const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags = f
             functions: [...aggregateFunctions, ...runtimeFunctions],
             remainingPaths: runtimePaths,
         };
-    }), Promise.resolve({ functions: [], remainingPaths: paths }));
+    }, Promise.resolve({ functions: [], remainingPaths: paths }));
     const functionsWithConfig = functions.map(([name, func]) => [
         name,
-        Object.assign(Object.assign({}, func), { config: (0, config_1.getConfigForFunction)({ config, func }) }),
+        { ...func, config: (0, config_1.getConfigForFunction)({ config, func }) },
     ]);
     return new Map(functionsWithConfig);
-});
+};
 exports.getFunctionsFromPaths = getFunctionsFromPaths;
 /**
  * Gets a list of functions found in a list of paths.
  */
-const getFunctionFromPath = (path, { config, featureFlags = feature_flags_1.defaultFlags } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_1.defaultFlags } = {}) => {
     const fsCache = makeFsCache();
     for (const runtime of RUNTIMES) {
-        // eslint-disable-next-line no-await-in-loop
-        const func = yield runtime.findFunctionInPath({ path, fsCache, featureFlags });
+        const func = await runtime.findFunctionInPath({ path, fsCache, featureFlags });
         if (func) {
-            return Object.assign(Object.assign({}, func), { runtime, config: (0, config_1.getConfigForFunction)({ config, func: Object.assign(Object.assign({}, func), { runtime }) }) });
+            return {
+                ...func,
+                runtime,
+                config: (0, config_1.getConfigForFunction)({ config, func: { ...func, runtime } }),
+            };
         }
     }
     return undefined;
-});
+};
 exports.getFunctionFromPath = getFunctionFromPath;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/node/bundlers/esbuild/bundler.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ESBUILD_LOG_LIMIT = exports.bundleJsFile = void 0;
 const path_1 = require("path");
@@ -27,86 +18,84 @@ exports.ESBUILD_LOG_LIMIT = ESBUILD_LOG_LIMIT;
 // 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 (0, tmp_promise_1.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 = [
-            (0, plugin_node_builtin_1.getNodeBuiltinPlugin)(),
-            (0, plugin_native_modules_1.getNativeModulesPlugin)(nativeNodeModules),
-            (0, plugin_dynamic_imports_1.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 = (0, bundler_target_1.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 = { inputs: {}, outputs: {} }, warnings } = yield (0, esbuild_1.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) => (0, path_1.resolve)(path));
-            const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()]);
-            return {
-                additionalPaths: [...dynamicImportsIncludedPaths],
-                bundlePaths,
-                cleanTempFiles,
-                inputs,
-                nativeNodeModules,
-                nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
-                warnings,
-            };
-        }
-        catch (error) {
-            const bundler = 'esbuild';
-            const runtime = 'js';
-            error.customErrorInfo = {
-                type: 'functionsBundling',
-                location: { bundler, functionName: name, runtime },
-            };
-            throw error;
-        }
-    });
+const bundleJsFile = async function ({ additionalModulePaths, basePath, config, externalModules = [], ignoredModules = [], name, srcDir, srcFile, }) {
+    // We use a temporary directory as the destination for esbuild files to avoid
+    // any naming conflicts with files generated by other functions.
+    const targetDirectory = await (0, tmp_promise_1.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 = [
+        (0, plugin_node_builtin_1.getNodeBuiltinPlugin)(),
+        (0, plugin_native_modules_1.getNativeModulesPlugin)(nativeNodeModules),
+        (0, plugin_dynamic_imports_1.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 = (0, bundler_target_1.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 = { inputs: {}, outputs: {} }, warnings } = await (0, esbuild_1.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) => (0, path_1.resolve)(path));
+        const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()]);
+        return {
+            additionalPaths: [...dynamicImportsIncludedPaths],
+            bundlePaths,
+            cleanTempFiles,
+            inputs,
+            nativeNodeModules,
+            nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
+            warnings,
+        };
+    }
+    catch (error) {
+        const bundler = 'esbuild';
+        const runtime = 'js';
+        error.customErrorInfo = {
+            type: 'functionsBundling',
+            location: { bundler, functionName: name, runtime },
+        };
+        throw error;
+    }
 };
 exports.bundleJsFile = bundleJsFile;
 // Takes the `outputs` object produced by esbuild and returns a Map with the
@@ -137,7 +126,7 @@ const getBundlePaths = ({ destFolder, outputs, srcFile, }) => {
     });
     return bundlePaths;
 };
-const getCleanupFunction = (paths) => () => __awaiter(void 0, void 0, void 0, function* () {
-    yield Promise.all(paths.filter(Boolean).map(fs_1.safeUnlink));
-});
+const getCleanupFunction = (paths) => async () => {
+    await Promise.all(paths.filter(Boolean).map(fs_1.safeUnlink));
+};
 //# sourceMappingURL=bundler.js.map

package/dist/runtimes/node/bundlers/esbuild/index.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const fs_1 = require("../../../../utils/fs");
@@ -30,16 +21,16 @@ const getFunctionBasePath = ({ basePathFromConfig, mainFile, repositoryRoot, sup
 };
 // Convenience method for retrieving external and ignored modules from
 // different places and merging them together.
-const getExternalAndIgnoredModules = ({ config, srcDir }) => __awaiter(void 0, void 0, void 0, function* () {
+const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
     const { externalNodeModules: externalModulesFromConfig = [], ignoredNodeModules: ignoredModulesFromConfig = [] } = config;
-    const { externalModules: externalModulesFromSpecialCases, ignoredModules: ignoredModulesFromSpecialCases } = yield (0, special_cases_1.getExternalAndIgnoredModulesFromSpecialCases)({ srcDir });
+    const { externalModules: externalModulesFromSpecialCases, ignoredModules: ignoredModulesFromSpecialCases } = await (0, special_cases_1.getExternalAndIgnoredModulesFromSpecialCases)({ srcDir });
     const externalModules = [...new Set([...externalModulesFromConfig, ...externalModulesFromSpecialCases])];
     const ignoredModules = [...ignoredModulesFromConfig, ...ignoredModulesFromSpecialCases];
     return { externalModules, ignoredModules };
-});
-const bundle = ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { externalModules, ignoredModules } = yield getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = yield (0, bundler_1.bundleJsFile)({
+};
+const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => {
+    const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir });
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await (0, bundler_1.bundleJsFile)({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
         basePath,
         config,
@@ -50,9 +41,14 @@ const bundle = ({ basePath, config = {}, extension, featureFlags, filename, main
         srcFile: mainFile,
     });
     const bundlerWarnings = warnings.length === 0 ? undefined : warnings;
-    const srcFiles = yield (0, src_files_1.getSrcFiles)({
+    const srcFiles = await (0, src_files_1.getSrcFiles)({
         basePath,
-        config: Object.assign(Object.assign({}, config), { externalNodeModules: [...externalModules, ...Object.keys(nativeNodeModules)], includedFiles: [...(config.includedFiles || []), ...additionalPaths], includedFilesBasePath: config.includedFilesBasePath || basePath }),
+        config: {
+            ...config,
+            externalNodeModules: [...externalModules, ...Object.keys(nativeNodeModules)],
+            includedFiles: [...(config.includedFiles || []), ...additionalPaths],
+            includedFilesBasePath: config.includedFilesBasePath || basePath,
+        },
         extension,
         featureFlags,
         filename,
@@ -86,7 +82,7 @@ const bundle = ({ basePath, config = {}, extension, featureFlags, filename, main
         nodeModulesWithDynamicImports,
         srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],
     };
-});
+};
 const bundler = { bundle, getSrcFiles: src_files_1.getSrcFiles };
 exports.default = bundler;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/node/bundlers/esbuild/plugin_dynamic_imports.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,7 +21,7 @@ const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, process
     setup(build) {
         const cache = new Map();
         // eslint-disable-next-line complexity
-        build.onDynamicImport({ filter: /.*/ }, (args) => __awaiter(this, void 0, void 0, function* () {
+        build.onDynamicImport({ filter: /.*/ }, async (args) => {
             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.
@@ -56,27 +47,27 @@ const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, process
             // 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 });
-        }));
+            await registerModuleWithDynamicImports({ cache, moduleNames, resolveDir, srcDir });
+        });
     },
 });
 exports.getDynamicImportsPlugin = getDynamicImportsPlugin;
-const getPackageName = ({ resolveDir, srcDir }) => __awaiter(void 0, void 0, void 0, function* () {
-    const packageJsonPath = yield (0, find_up_1.default)((directory) => __awaiter(void 0, void 0, void 0, function* () {
+const getPackageName = async ({ resolveDir, srcDir }) => {
+    const packageJsonPath = await (0, find_up_1.default)(async (directory) => {
         // We stop traversing if we're about to leave the boundaries of the
         // function directory or any node_modules directory.
         if (directory === srcDir || (0, path_1.basename)(directory) === 'node_modules') {
             return find_up_1.default.stop;
         }
         const path = (0, path_1.join)(directory, 'package.json');
-        const hasPackageJson = yield find_up_1.default.exists(path);
+        const hasPackageJson = await find_up_1.default.exists(path);
         return hasPackageJson ? path : undefined;
-    }), { cwd: resolveDir });
+    }, { cwd: resolveDir });
     if (packageJsonPath !== undefined) {
-        const { name } = yield (0, read_package_json_fast_1.default)(packageJsonPath);
+        const { name } = await (0, read_package_json_fast_1.default)(packageJsonPath);
         return name;
     }
-});
+};
 const getPackageNameCached = ({ cache, resolveDir, srcDir, }) => {
     if (!cache.has(resolveDir)) {
         cache.set(resolveDir, getPackageName({ resolveDir, srcDir }));
@@ -95,15 +86,15 @@ const getShimContents = ({ expressionType, resolveDir, srcDir, }) => {
         return `module.exports = args => require(${requireArg})`;
     }
 };
-const registerModuleWithDynamicImports = ({ cache, moduleNames, resolveDir, srcDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+const registerModuleWithDynamicImports = async ({ cache, moduleNames, resolveDir, srcDir, }) => {
     try {
-        const packageName = yield getPackageNameCached({ cache, resolveDir, srcDir });
+        const packageName = await getPackageNameCached({ cache, resolveDir, srcDir });
         if (packageName !== undefined) {
             moduleNames.add(packageName);
         }
     }
-    catch (_) {
+    catch {
         // no-op
     }
-});
+};
 //# sourceMappingURL=plugin_dynamic_imports.js.map

package/dist/runtimes/node/bundlers/esbuild/plugin_native_modules.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -32,7 +23,7 @@ const getNativeModulesPlugin = (externalizedModules) => ({
     setup(build) {
         const cache = {};
         // eslint-disable-next-line complexity, max-statements
-        build.onResolve({ filter: packageFilter }, (args) => __awaiter(this, void 0, void 0, function* () {
+        build.onResolve({ filter: packageFilter }, async (args) => {
             const pkg = packageName.exec(args.path);
             if (!pkg)
                 return;
@@ -41,8 +32,7 @@ const getNativeModulesPlugin = (externalizedModules) => ({
                 if (path_1.default.basename(directory) !== 'node_modules') {
                     const modulePath = path_1.default.join(directory, 'node_modules', pkg[1]);
                     const packageJsonPath = path_1.default.join(modulePath, 'package.json');
-                    // eslint-disable-next-line no-await-in-loop
-                    const [isNative, packageJsonData] = yield findNativeModule(packageJsonPath, cache);
+                    const [isNative, packageJsonData] = await findNativeModule(packageJsonPath, cache);
                     // eslint-disable-next-line max-depth
                     if (isNative === true) {
                         // eslint-disable-next-line max-depth
@@ -65,7 +55,7 @@ const getNativeModulesPlugin = (externalizedModules) => ({
                 }
                 directory = parentDirectory;
             }
-        }));
+        });
     },
 });
 exports.getNativeModulesPlugin = getNativeModulesPlugin;

package/dist/runtimes/node/bundlers/esbuild/special_cases.js

@@ -1,29 +1,20 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExternalAndIgnoredModulesFromSpecialCases = void 0;
 const package_json_1 = require("../../utils/package_json");
 const EXTERNAL_MODULES = ['@prisma/client'];
 const IGNORED_MODULES = ['aws-sdk'];
-const getPackageJsonIfAvailable = (srcDir) => __awaiter(void 0, void 0, void 0, function* () {
+const getPackageJsonIfAvailable = async (srcDir) => {
     try {
-        const packageJson = yield (0, package_json_1.getPackageJson)(srcDir);
+        const packageJson = await (0, package_json_1.getPackageJson)(srcDir);
         return packageJson;
     }
-    catch (_) {
+    catch {
         return {};
     }
-});
+};
 const getModulesForNextJs = ({ dependencies, devDependencies }) => {
-    const allDependencies = Object.assign(Object.assign({}, dependencies), devDependencies);
+    const allDependencies = { ...dependencies, ...devDependencies };
     const externalModules = allDependencies.next ? ['critters', 'nanoid'] : [];
     const ignoredModules = [];
     return {
@@ -31,8 +22,8 @@ const getModulesForNextJs = ({ dependencies, devDependencies }) => {
         ignoredModules,
     };
 };
-const getExternalAndIgnoredModulesFromSpecialCases = ({ srcDir }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { dependencies = {}, devDependencies = {} } = yield getPackageJsonIfAvailable(srcDir);
+const getExternalAndIgnoredModulesFromSpecialCases = async ({ srcDir }) => {
+    const { dependencies = {}, devDependencies = {} } = await getPackageJsonIfAvailable(srcDir);
     const { externalModules: nextJsExternalModules, ignoredModules: nextJsIgnoredModules } = getModulesForNextJs({
         dependencies,
         devDependencies,
@@ -43,6 +34,6 @@ const getExternalAndIgnoredModulesFromSpecialCases = ({ srcDir }) => __awaiter(v
         externalModules,
         ignoredModules,
     };
-});
+};
 exports.getExternalAndIgnoredModulesFromSpecialCases = getExternalAndIgnoredModulesFromSpecialCases;
 //# sourceMappingURL=special_cases.js.map