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

package/dist/archive.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export function startZip(destPath: any): {
+    archive: any;
+    output: import("fs").WriteStream;
+};
+export function addZipFile(archive: any, file: any, name: any, stat: any): void;
+export function addZipContent(archive: any, content: any, name: any): void;
+export function endZip(archive: any, output: any): Promise<void>;

package/dist/archive.js

@@ -0,0 +1,39 @@
+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 { createWriteStream } = require('fs');
+const { promisify } = require('util');
+const archiver = require('archiver');
+const endOfStream = require('end-of-stream');
+const pEndOfStream = promisify(endOfStream);
+// Start zipping files
+const startZip = function (destPath) {
+    const output = createWriteStream(destPath);
+    const archive = archiver('zip', { level: ZIP_LEVEL });
+    archive.pipe(output);
+    return { archive, output };
+};
+const ZIP_LEVEL = 9;
+// Add new file to zip
+const addZipFile = function (archive, file, name, stat) {
+    // Ensure sha256 stability regardless of mtime
+    archive.file(file, { name, mode: stat.mode, date: new Date(0), stats: stat });
+};
+// Add new file content to zip
+const addZipContent = function (archive, content, name) {
+    archive.append(content, { name, date: new Date(0) });
+};
+// End zipping files
+const endZip = function (archive, output) {
+    return __awaiter(this, void 0, void 0, function* () {
+        archive.finalize();
+        yield pEndOfStream(output);
+    });
+};
+module.exports = { startZip, addZipFile, addZipContent, endZip };

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+const { exit } = require('process');
+const yargs = require('yargs');
+const zipIt = require('./main');
+const { ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP } = require('./utils/consts');
+// CLI entry point
+const runCli = function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const _a = parseArgs(), { destFolder, srcFolder } = _a, options = __rest(_a, ["destFolder", "srcFolder"]);
+        try {
+            const zipped = yield zipIt.zipFunctions(srcFolder, destFolder, options);
+            console.log(JSON.stringify(zipped, null, 2));
+        }
+        catch (error) {
+            console.error(error.toString());
+            exit(1);
+        }
+    });
+};
+const parseArgs = function () {
+    return yargs.command('* <srcFolder> <destFolder>').options(OPTIONS).usage(USAGE).strict().parse();
+};
+const OPTIONS = {
+    'archive-format': {
+        string: true,
+        choices: [ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP],
+        default: ARCHIVE_FORMAT_ZIP,
+        describe: 'Format of the archive created for each function',
+    },
+    config: {
+        default: {},
+        describe: 'An object matching glob-like expressions to objects containing configuration properties. Whenever a function name matches one of the expressions, it inherits the configuration properties',
+    },
+    manifest: {
+        string: true,
+        describe: 'If a manifest file is to be created, specifies its path',
+    },
+    'parallel-limit': {
+        number: true,
+        describe: 'Maximum number of Functions to bundle at the same time',
+    },
+};
+const USAGE = `$0 [OPTIONS...] FUNCTIONS_DIRECTORY OUTPUT_DIRECTORY
+
+Zip all function files inside FUNCTIONS_DIRECTORY so that they can be uploaded
+to AWS Lambda.`;
+runCli();

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+export function getConfigForFunction({ config, func }: {
+    config: any;
+    func: any;
+}): any;

package/dist/config.js

@@ -0,0 +1,26 @@
+const mergeOptions = require('merge-options');
+const minimatch = require('minimatch');
+const getConfigForFunction = ({ config, func }) => {
+    if (!config) {
+        return {};
+    }
+    // It's safe to mutate the array because it's local to this function.
+    const matches = Object.keys(config)
+        .filter((expression) => minimatch(func.name, expression))
+        .map((expression) => {
+        const wildcardCount = [...expression].filter((char) => char === '*').length;
+        // The weight increases with the number of hardcoded (i.e. non-wildcard)
+        // characters — e.g. "netlify" has a higher weight than "net*". We do a
+        // subtraction of 1 if there is at least one wildcard character, so that
+        // "netlify" has a higher weight than "netlify*".
+        const weight = expression.length - wildcardCount - (wildcardCount === 0 ? 0 : 1);
+        return {
+            expression,
+            weight,
+        };
+    })
+        .sort(({ weight: weightA }, { weight: weightB }) => weightA - weightB)
+        .map(({ expression }) => config[expression]);
+    return mergeOptions.apply({ concatArrays: true, ignoreUndefined: true }, matches);
+};
+module.exports = { getConfigForFunction };

package/dist/feature_flags.d.ts

@@ -0,0 +1,12 @@
+export namespace FLAGS {
+    const buildGoSource: boolean;
+    const buildRustSource: boolean;
+    const defaultEsModulesToEsbuild: boolean;
+    const parseWithEsbuild: boolean;
+}
+export function getFlags(input?: {}, flags?: {
+    buildGoSource: boolean;
+    buildRustSource: boolean;
+    defaultEsModulesToEsbuild: boolean;
+    parseWithEsbuild: boolean;
+}): {};

package/dist/feature_flags.js

@@ -0,0 +1,10 @@
+const { env } = require('process');
+// List of supported flags and their default value.
+const FLAGS = {
+    buildGoSource: Boolean(env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
+    buildRustSource: Boolean(env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
+    defaultEsModulesToEsbuild: Boolean(env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
+    parseWithEsbuild: false,
+};
+const getFlags = (input = {}, flags = FLAGS) => Object.entries(flags).reduce((result, [key, defaultValue]) => (Object.assign(Object.assign({}, result), { [key]: input[key] === undefined ? defaultValue : input[key] })), {});
+module.exports = { FLAGS, getFlags };

package/dist/main.d.ts

@@ -0,0 +1,15 @@
+import { zipFunctions } from "./zip";
+import { zipFunction } from "./zip";
+export function listFunctions(relativeSrcFolders: any, { featureFlags: inputFeatureFlags }?: {
+    featureFlags: any;
+}): Promise<{
+    name: any;
+    mainFile: any;
+    runtime: any;
+    extension: any;
+}[]>;
+export function listFunctionsFiles(relativeSrcFolders: any, { config, featureFlags: inputFeatureFlags }?: {
+    config: any;
+    featureFlags: any;
+}): Promise<any[]>;
+export { zipFunctions, zipFunction };

package/dist/main.js

@@ -0,0 +1,80 @@
+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 } = require('path');
+require('./utils/polyfills');
+const { getFlags } = require('./feature_flags');
+const { getPluginsModulesPath } = require('./node_dependencies');
+const { getFunctionsFromPaths } = require('./runtimes');
+const { listFunctionsDirectories, resolveFunctionsDirectories } = require('./utils/fs');
+const { zipFunction, zipFunctions } = require('./zip');
+// List all Netlify Functions main entry files for a specific directory
+const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const featureFlags = getFlags(inputFeatureFlags);
+        const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
+        const paths = yield listFunctionsDirectories(srcFolders);
+        const functions = yield getFunctionsFromPaths(paths, { featureFlags });
+        const listedFunctions = [...functions.values()].map(getListedFunction);
+        return listedFunctions;
+    });
+};
+// List all Netlify Functions files for a specific directory
+const listFunctionsFiles = function (relativeSrcFolders, { config, featureFlags: inputFeatureFlags } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const featureFlags = getFlags(inputFeatureFlags);
+        const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
+        const paths = yield listFunctionsDirectories(srcFolders);
+        const [functions, pluginsModulesPath] = yield Promise.all([
+            getFunctionsFromPaths(paths, { config, featureFlags }),
+            getPluginsModulesPath(srcFolders[0]),
+        ]);
+        const listedFunctionsFiles = yield Promise.all([...functions.values()].map((func) => getListedFunctionFiles(func, { featureFlags, pluginsModulesPath })));
+        // TODO: switch to Array.flat() once we drop support for Node.js < 11.0.0
+        // eslint-disable-next-line unicorn/prefer-spread
+        return [].concat(...listedFunctionsFiles);
+    });
+};
+const getListedFunction = function ({ runtime, name, mainFile, extension }) {
+    return { name, mainFile, runtime: runtime.name, extension };
+};
+const getListedFunctionFiles = function ({ config, runtime, name, stat, mainFile, extension, srcPath, srcDir }, { featureFlags, pluginsModulesPath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const srcFiles = yield getSrcFiles({
+            featureFlags,
+            runtime,
+            stat,
+            mainFile,
+            extension,
+            srcPath,
+            srcDir,
+            pluginsModulesPath,
+            config,
+        });
+        return srcFiles.map((srcFile) => ({ srcFile, name, mainFile, runtime: runtime.name, extension: extname(srcFile) }));
+    });
+};
+const getSrcFiles = function ({ bundler, config, featureFlags, runtime, stat, mainFile, extension, srcPath, srcDir, pluginsModulesPath, }) {
+    const { getSrcFiles: getRuntimeSrcFiles } = runtime;
+    if (extension === '.zip' || typeof getRuntimeSrcFiles !== 'function') {
+        return [srcPath];
+    }
+    return getRuntimeSrcFiles({
+        bundler,
+        config,
+        extension,
+        featureFlags,
+        srcPath,
+        mainFile,
+        srcDir,
+        stat,
+        pluginsModulesPath,
+    });
+};
+module.exports = { zipFunctions, zipFunction, listFunctions, listFunctionsFiles };

package/dist/manifest.d.ts

@@ -0,0 +1,4 @@
+export function createManifest({ functions, path }: {
+    functions: any;
+    path: any;
+}): Promise<void>;

package/dist/manifest.js

@@ -0,0 +1,25 @@
+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 { resolve } = require('path');
+const { arch, platform } = require('process');
+const { writeFile } = require('./utils/fs');
+const MANIFEST_VERSION = 1;
+const createManifest = ({ functions, path }) => __awaiter(this, void 0, void 0, function* () {
+    const formattedFunctions = functions.map(formatFunction);
+    const payload = {
+        functions: formattedFunctions,
+        system: { arch, platform },
+        timestamp: Date.now(),
+        version: MANIFEST_VERSION,
+    };
+    yield writeFile(path, JSON.stringify(payload));
+});
+const formatFunction = ({ mainFile, name, path, runtime }) => ({ mainFile, name, path: resolve(path), runtime });
+module.exports = { createManifest };

package/dist/node_dependencies/index.d.ts

@@ -0,0 +1,15 @@
+import { getDependencyPathsForDependency } from "./traverse";
+import { getDependencyNamesAndPathsForDependencies } from "./traverse";
+import { getDependencyNamesAndPathsForDependency } from "./traverse";
+import { getExternalAndIgnoredModulesFromSpecialCases } from "./special_cases";
+export function getPluginsModulesPath(srcDir: any): Promise<string>;
+export function listFilesUsingLegacyBundler({ featureFlags, srcPath, mainFile, name, srcDir, stat, pluginsModulesPath, }: {
+    featureFlags: any;
+    srcPath: any;
+    mainFile: any;
+    name: any;
+    srcDir: any;
+    stat: any;
+    pluginsModulesPath: any;
+}): Promise<string[]>;
+export { getDependencyPathsForDependency, getDependencyNamesAndPathsForDependencies, getDependencyNamesAndPathsForDependency, getExternalAndIgnoredModulesFromSpecialCases };

package/dist/node_dependencies/index.js

@@ -0,0 +1,132 @@
+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 { dirname, basename, normalize } = require('path');
+const findUp = require('find-up');
+const { not: notJunk } = require('junk');
+const precinct = require('precinct');
+const { listImports } = require('../runtimes/node/list_imports');
+const { getPackageJson } = require('./package_json');
+const { resolvePathPreserveSymlinks } = require('./resolve');
+const { getExternalAndIgnoredModulesFromSpecialCases } = require('./special_cases');
+const { getDependencyPathsForDependency, getDependencyNamesAndPathsForDependencies, getDependencyNamesAndPathsForDependency, getNewCache, } = require('./traverse');
+const { getTreeFiles } = require('./tree_files');
+const { shouldTreeShake } = require('./tree_shake');
+const AUTO_PLUGINS_DIR = '.netlify/plugins/';
+const getPluginsModulesPath = (srcDir) => findUp(`${AUTO_PLUGINS_DIR}node_modules`, { cwd: srcDir, type: 'directory' });
+// Retrieve the paths to the Node.js files to zip.
+// We only include the files actually needed by the function because AWS Lambda
+// has a size limit for the zipped file. It also makes cold starts faster.
+const listFilesUsingLegacyBundler = function ({ featureFlags, srcPath, mainFile, name, srcDir, stat, pluginsModulesPath, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [treeFiles, depFiles] = yield Promise.all([
+            getTreeFiles(srcPath, stat),
+            getDependencies({ featureFlags, functionName: name, mainFile, pluginsModulesPath, srcDir }),
+        ]);
+        const files = [...treeFiles, ...depFiles].map(normalize);
+        const uniqueFiles = [...new Set(files)];
+        // We sort so that the archive's checksum is deterministic.
+        // Mutating is fine since `Array.filter()` returns a shallow copy
+        const filteredFiles = uniqueFiles.filter(isNotJunk).sort();
+        return filteredFiles;
+    });
+};
+// Remove temporary files like *~, *.swp, etc.
+const isNotJunk = function (file) {
+    return notJunk(basename(file));
+};
+// Retrieve all the files recursively required by a Node.js file
+const getDependencies = function ({ featureFlags, functionName, mainFile, pluginsModulesPath, srcDir }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageJson = yield getPackageJson(srcDir);
+        const state = getNewCache();
+        try {
+            return yield getFileDependencies({
+                featureFlags,
+                functionName,
+                path: mainFile,
+                packageJson,
+                pluginsModulesPath,
+                state,
+            });
+        }
+        catch (error) {
+            error.message = `In file "${mainFile}"\n${error.message}`;
+            throw error;
+        }
+    });
+};
+const getFileDependencies = function ({ featureFlags, functionName, path, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (state.localFiles.has(path)) {
+            return [];
+        }
+        state.localFiles.add(path);
+        const basedir = dirname(path);
+        const dependencies = featureFlags.parseWithEsbuild
+            ? yield listImports({ functionName, path })
+            : precinct.paperwork(path, { includeCore: false });
+        const depsPaths = yield Promise.all(dependencies.filter(Boolean).map((dependency) => getImportDependencies({
+            dependency,
+            basedir,
+            featureFlags,
+            functionName,
+            packageJson,
+            pluginsModulesPath,
+            state,
+            treeShakeNext,
+        })));
+        // TODO: switch to Array.flat() once we drop support for Node.js < 11.0.0
+        // eslint-disable-next-line unicorn/prefer-spread
+        return [].concat(...depsPaths);
+    });
+};
+const getImportDependencies = function ({ dependency, basedir, featureFlags, functionName, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
+    const shouldTreeShakeNext = treeShakeNext || isNextOnNetlify(dependency);
+    if (shouldTreeShake(dependency, shouldTreeShakeNext)) {
+        return getTreeShakedDependencies({
+            dependency,
+            basedir,
+            featureFlags,
+            functionName,
+            packageJson,
+            pluginsModulesPath,
+            state,
+            treeShakeNext: shouldTreeShakeNext,
+        });
+    }
+    return getDependencyPathsForDependency({ dependency, basedir, state, packageJson, pluginsModulesPath });
+};
+const isNextOnNetlify = function (dependency) {
+    return basename(dependency, '.js') === 'renderNextPage';
+};
+// When a file requires another one, we apply the top-level logic recursively
+const getTreeShakedDependencies = function ({ dependency, basedir, featureFlags, functionName, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = yield resolvePathPreserveSymlinks(dependency, [basedir, pluginsModulesPath].filter(Boolean));
+        const depsPath = yield getFileDependencies({
+            featureFlags,
+            functionName,
+            path,
+            packageJson,
+            pluginsModulesPath,
+            state,
+            treeShakeNext,
+        });
+        return [path, ...depsPath];
+    });
+};
+module.exports = {
+    getDependencyPathsForDependency,
+    getDependencyNamesAndPathsForDependencies,
+    getDependencyNamesAndPathsForDependency,
+    getExternalAndIgnoredModulesFromSpecialCases,
+    getPluginsModulesPath,
+    listFilesUsingLegacyBundler,
+};

package/dist/node_dependencies/module.d.ts

@@ -0,0 +1 @@
+export function getModuleName(dependency: any): any;

package/dist/node_dependencies/module.js

@@ -0,0 +1,10 @@
+const requirePackageName = require('require-package-name');
+// Windows path normalization
+const BACKSLASH_REGEXP = /\\/g;
+// When doing require("moduleName/file/path"), only keep `moduleName`
+const getModuleName = function (dependency) {
+    const dependencyA = dependency.replace(BACKSLASH_REGEXP, '/');
+    const moduleName = requirePackageName(dependencyA);
+    return moduleName;
+};
+module.exports = { getModuleName };

package/dist/node_dependencies/nested.d.ts

@@ -0,0 +1,10 @@
+export function getNestedDependencies({ dependencies, peerDependencies, optionalDependencies }: {
+    dependencies?: {};
+    peerDependencies?: {};
+    optionalDependencies?: {};
+}): string[];
+export function handleModuleNotFound({ error, moduleName, packageJson }: {
+    error: any;
+    moduleName: any;
+    packageJson: any;
+}): any[];

package/{src → dist}/node_dependencies/nested.js

@@ -1,25 +1,21 @@
-const { valid: validVersion, validRange, satisfies, gte: greaterThanEqual, ltr: lessThanRange } = require('semver')
-
+const { valid: validVersion, validRange, satisfies, gte: greaterThanEqual, ltr: lessThanRange } = require('semver');
 // Apply the Node.js module logic recursively on its own dependencies, using
 // the `package.json` `dependencies`, `peerDependencies` and
 // `optionalDependencies` keys
 const getNestedDependencies = function ({ dependencies = {}, peerDependencies = {}, optionalDependencies = {} }) {
-  return [
-    ...Object.keys(dependencies),
-    ...Object.keys(peerDependencies).filter(shouldIncludePeerDependency),
-    ...Object.keys(optionalDependencies),
-  ]
-}
-
+    return [
+        ...Object.keys(dependencies),
+        ...Object.keys(peerDependencies).filter(shouldIncludePeerDependency),
+        ...Object.keys(optionalDependencies),
+    ];
+};
 // Workaround for https://github.com/netlify/zip-it-and-ship-it/issues/73
 // TODO: remove this after adding proper modules exclusion as outlined in
 // https://github.com/netlify/zip-it-and-ship-it/issues/68
 const shouldIncludePeerDependency = function (name) {
-  return !EXCLUDED_PEER_DEPENDENCIES.has(name)
-}
-
-const EXCLUDED_PEER_DEPENDENCIES = new Set(['@prisma/cli', 'prisma2', 'prisma'])
-
+    return !EXCLUDED_PEER_DEPENDENCIES.has(name);
+};
+const EXCLUDED_PEER_DEPENDENCIES = new Set(['@prisma/cli', 'prisma2', 'prisma']);
 // Modules can be required conditionally (inside an `if` or `try`/`catch` block).
 // When a `require()` statement is found but the module is not found, it is
 // possible that that block either always evaluates to:
@@ -43,52 +39,35 @@ const EXCLUDED_PEER_DEPENDENCIES = new Set(['@prisma/cli', 'prisma2', 'prisma'])
 //  - are not reported when missing
 //  - are included in module dependencies
 const handleModuleNotFound = function ({ error, moduleName, packageJson }) {
-  if (
-    error.code === 'MODULE_NOT_FOUND' &&
-    (isOptionalModule(moduleName, packageJson) || isExternalCrittersModule(moduleName, packageJson))
-  ) {
-    return []
-  }
-
-  throw error
-}
-
-const isOptionalModule = function (
-  moduleName,
-  { optionalDependencies = {}, peerDependenciesMeta = {}, peerDependencies = {} },
-) {
-  return (
-    optionalDependencies[moduleName] !== undefined ||
-    (peerDependenciesMeta[moduleName] &&
-      peerDependenciesMeta[moduleName].optional &&
-      peerDependencies[moduleName] !== undefined)
-  )
-}
-
-const MIN_NEXT_VERSION = '10.0.4'
-
-const satisfiesRange = (range) =>
-  validRange(range) && (satisfies(MIN_NEXT_VERSION, range) || lessThanRange(MIN_NEXT_VERSION, range))
-
+    if (error.code === 'MODULE_NOT_FOUND' &&
+        (isOptionalModule(moduleName, packageJson) || isExternalCrittersModule(moduleName, packageJson))) {
+        return [];
+    }
+    throw error;
+};
+const isOptionalModule = function (moduleName, { optionalDependencies = {}, peerDependenciesMeta = {}, peerDependencies = {} }) {
+    return (optionalDependencies[moduleName] !== undefined ||
+        (peerDependenciesMeta[moduleName] &&
+            peerDependenciesMeta[moduleName].optional &&
+            peerDependencies[moduleName] !== undefined));
+};
+const MIN_NEXT_VERSION = '10.0.4';
+const satisfiesRange = (range) => validRange(range) && (satisfies(MIN_NEXT_VERSION, range) || lessThanRange(MIN_NEXT_VERSION, range));
 // 'critters' is used only in Next.js >= 10.0.4 when enabling an experimental option and has to be installed manually
 // we ignore it if it's missing
 const isExternalCrittersModule = function (moduleName, { dependencies = {}, devDependencies = {} }) {
-  if (moduleName !== 'critters') {
-    return false
-  }
-  const nextVersion = dependencies.next || devDependencies.next
-
-  if (nextVersion === 'latest') {
-    return true
-  }
-
-  // can the declared Next.js version resolve to >=10.0.4 ?
-  // test exact versions
-  if (validVersion(nextVersion)) {
-    return greaterThanEqual(nextVersion, MIN_NEXT_VERSION)
-  }
-
-  return satisfiesRange(nextVersion)
-}
-
-module.exports = { getNestedDependencies, handleModuleNotFound }
+    if (moduleName !== 'critters') {
+        return false;
+    }
+    const nextVersion = dependencies.next || devDependencies.next;
+    if (nextVersion === 'latest') {
+        return true;
+    }
+    // can the declared Next.js version resolve to >=10.0.4 ?
+    // test exact versions
+    if (validVersion(nextVersion)) {
+        return greaterThanEqual(nextVersion, MIN_NEXT_VERSION);
+    }
+    return satisfiesRange(nextVersion);
+};
+module.exports = { getNestedDependencies, handleModuleNotFound };

package/dist/node_dependencies/package_json.d.ts

@@ -0,0 +1 @@
+export function getPackageJson(srcDir: any): Promise<any>;

package/dist/node_dependencies/package_json.js

@@ -0,0 +1,29 @@
+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 pkgDir = require('pkg-dir');
+// Retrieve the `package.json` of a specific project or module
+const getPackageJson = function (srcDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageRoot = yield pkgDir(srcDir);
+        if (packageRoot === undefined) {
+            return {};
+        }
+        const packageJsonPath = `${packageRoot}/package.json`;
+        try {
+            // The path depends on the user's build, i.e. must be dynamic
+            // eslint-disable-next-line import/no-dynamic-require, node/global-require
+            return require(packageJsonPath);
+        }
+        catch (error) {
+            throw new Error(`${packageJsonPath} is invalid JSON: ${error.message}`);
+        }
+    });
+};
+module.exports = { getPackageJson };

package/dist/node_dependencies/published.d.ts

@@ -0,0 +1 @@
+export function getPublishedFiles(modulePath: any): Promise<string[]>;