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

package/dist/zip_node.js

@@ -0,0 +1,143 @@
+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 { Buffer } = require('buffer');
+const fs = require('fs');
+const os = require('os');
+const { basename, extname, join, normalize, resolve, sep } = require('path');
+const { promisify } = require('util');
+const copyFile = require('cp-file');
+const deleteFiles = require('del');
+const makeDir = require('make-dir');
+const pMap = require('p-map');
+const unixify = require('unixify');
+const { startZip, addZipFile, addZipContent, endZip } = require('./archive');
+const { ARCHIVE_FORMAT_ZIP } = require('./utils/consts');
+const pStat = promisify(fs.stat);
+const pWriteFile = promisify(fs.writeFile);
+// Taken from https://www.npmjs.com/package/cpy.
+const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
+// Sub-directory to place all user-defined files  (i.e. everything other than
+// the entry file generated by zip-it-and-ship-it).
+const DEFAULT_USER_SUBDIRECTORY = 'src';
+const createDirectory = function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, srcFiles, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { contents: entryContents, filename: entryFilename } = getEntryFile({
+            commonPrefix: basePath,
+            filename,
+            mainFile,
+            userNamespace: DEFAULT_USER_SUBDIRECTORY,
+        });
+        const functionFolder = join(destFolder, basename(filename, extension));
+        // Deleting the functions directory in case it exists before creating it.
+        yield deleteFiles(functionFolder, { force: true });
+        yield makeDir(functionFolder);
+        // Writing entry file.
+        yield pWriteFile(join(functionFolder, entryFilename), entryContents);
+        // Copying source files.
+        yield pMap(srcFiles, (srcFile) => {
+            const srcPath = aliases.get(srcFile) || srcFile;
+            const normalizedSrcPath = normalizeFilePath({
+                commonPrefix: basePath,
+                path: srcPath,
+                pluginsModulesPath,
+                userNamespace: DEFAULT_USER_SUBDIRECTORY,
+            });
+            const destPath = join(functionFolder, normalizedSrcPath);
+            return copyFile(srcFile, destPath);
+        }, { concurrency: COPY_FILE_CONCURRENCY });
+        return functionFolder;
+    });
+};
+const createZipArchive = function ({ aliases, basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, srcFiles, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const destPath = join(destFolder, `${basename(filename, extension)}.zip`);
+        const { archive, output } = startZip(destPath);
+        const entryFilename = `${basename(filename, extension)}.js`;
+        const entryFilePath = resolve(basePath, entryFilename);
+        // We don't need an entry file if it would end up with the same path as the
+        // function's main file.
+        const needsEntryFile = entryFilePath !== mainFile;
+        // There is a naming conflict with the entry file if one of the supporting
+        // files (i.e. not the main file) has the path that the entry file needs to
+        // take.
+        const hasEntryFileConflict = srcFiles.some((srcFile) => srcFile === entryFilePath && srcFile !== mainFile);
+        // If there is a naming conflict, we move all user files (everything other
+        // than the entry file) to its own sub-directory.
+        const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : '';
+        if (needsEntryFile) {
+            const entryFile = getEntryFile({ commonPrefix: basePath, filename, mainFile, userNamespace });
+            addEntryFileToZip(archive, entryFile);
+        }
+        const srcFilesInfos = yield Promise.all(srcFiles.map(addStat));
+        // We ensure this is not async, so that the archive's checksum is
+        // deterministic. Otherwise it depends on the order the files were added.
+        srcFilesInfos.forEach(({ srcFile, stat }) => {
+            zipJsFile({ srcFile, commonPrefix: basePath, pluginsModulesPath, archive, stat, aliases, userNamespace });
+        });
+        yield endZip(archive, output);
+        return destPath;
+    });
+};
+const zipNodeJs = function (_a) {
+    var { archiveFormat } = _a, options = __rest(_a, ["archiveFormat"]);
+    if (archiveFormat === ARCHIVE_FORMAT_ZIP) {
+        return createZipArchive(options);
+    }
+    return createDirectory(options);
+};
+const addEntryFileToZip = function (archive, { contents, filename }) {
+    const contentBuffer = Buffer.from(contents);
+    addZipContent(archive, contentBuffer, filename);
+};
+const addStat = function (srcFile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stat = yield pStat(srcFile);
+        return { srcFile, stat };
+    });
+};
+const getEntryFile = ({ commonPrefix, filename, mainFile, userNamespace }) => {
+    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
+    const extension = extname(filename);
+    const entryFilename = `${basename(filename, extension)}.js`;
+    return {
+        contents: `module.exports = require('.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}')`,
+        filename: entryFilename,
+    };
+};
+const zipJsFile = function ({ srcFile, commonPrefix, pluginsModulesPath, archive, stat, aliases = new Map(), userNamespace, }) {
+    const filename = aliases.get(srcFile) || srcFile;
+    const normalizedFilename = normalizeFilePath({ commonPrefix, path: filename, pluginsModulesPath, userNamespace });
+    addZipFile(archive, srcFile, normalizedFilename, stat);
+};
+// `adm-zip` and `require()` expect Unix paths.
+// We remove the common path prefix.
+// With files on different Windows drives, we remove the drive letter.
+const normalizeFilePath = function ({ commonPrefix, path, pluginsModulesPath, userNamespace }) {
+    const userNamespacePathSegment = userNamespace ? `${userNamespace}${sep}` : '';
+    const pathA = normalize(path);
+    const pathB = pluginsModulesPath === undefined
+        ? pathA
+        : pathA.replace(pluginsModulesPath, `${userNamespacePathSegment}node_modules`);
+    const pathC = pathB.replace(commonPrefix, userNamespacePathSegment);
+    const pathD = unixify(pathC);
+    return pathD;
+};
+module.exports = { zipNodeJs };

package/package.json

@@ -1,20 +1,23 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "4.23.3",
+  "version": "4.23.5-setup-typescript-4",
   "description": "Zip it and ship it",
-  "main": "./src/main.js",
+  "main": "./dist/main.js",
   "bin": {
-    "zip-it-and-ship-it": "src/bin.js"
+    "zip-it-and-ship-it": "dist/bin.js"
   },
   "files": [
-    "src/**/*.js"
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
   ],
   "scripts": {
     "prepublishOnly": "npm ci && npm test",
+    "prepack": "npm run build",
+    "build": "tsc",
     "benchmark": "./benchmarks/run.sh",
-    "test": "run-s format test:dev",
-    "format": "run-s format:check-fix:*",
-    "format:ci": "run-s format:check:*",
+    "test": "run-s build format test:dev",
+    "format": "run-s build format:check-fix:*",
+    "format:ci": "run-s build format:check:*",
     "format:check-fix:lint": "run-e format:check:lint format:fix:lint",
     "format:check:lint": "cross-env-shell eslint $npm_package_config_eslint",
     "format:fix:lint": "cross-env-shell eslint --fix $npm_package_config_eslint",
@@ -22,11 +25,11 @@
     "format:check:prettier": "cross-env-shell prettier --check $npm_package_config_prettier",
     "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
     "test:dev": "ava",
-    "test:ci": "nyc -r lcovonly -r text -r json ava"
+    "test:ci": "npm run build && nyc -r lcovonly -r text -r json ava"
   },
   "config": {
-    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,tests,.github}/**/*.{js,md,html}\" \"*.{js,md,html}\" \".*.{js,md,html}\"",
-    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tests,.github}/**/*.{js,md,yml,json,html}\" \"*.{js,yml,json,html}\" \".*.{js,yml,json,html}\" \"!package-lock.json\""
+    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,tests,.github}/**/*.{js,ts,md,html}\" \"*.{js,ts,md,html}\" \".*.{js,ts,md,html}\"",
+    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tests,.github}/**/*.{js,ts,md,yml,json,html}\" \"*.{js,ts,yml,json,html}\" \".*.{js,ts,yml,json,html}\" \"!package-lock.json\""
   },
   "eslintIgnore": [
     "benchmarks/fixtures/**"
@@ -84,26 +87,29 @@
     "semver": "^7.0.0",
     "tmp-promise": "^3.0.2",
     "toml": "^3.0.0",
+    "typescript": "^4.4.3",
     "unixify": "^1.0.0",
     "yargs": "^16.0.0"
   },
   "devDependencies": {
-    "@netlify/eslint-config-node": "^3.2.8",
+    "@netlify/eslint-config-node": "^3.3.0",
     "adm-zip": "0.5.5",
     "ava": "^3.0.0",
     "cpy": "^8.0.0",
+    "deepmerge": "^4.2.2",
     "get-stream": "^6.0.0",
     "husky": "^4.3.8",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.0.0",
-    "sinon": "^11.1.1"
+    "sinon": "^11.1.1",
+    "typescript": "^4.4.3"
   },
   "engines": {
     "node": ">=10.18.0"
   },
   "ava": {
     "files": [
-      "tests/*.js"
+      "tests/*"
     ],
     "verbose": true,
     "timeout": "2m"

package/src/archive.js

@@ -1,36 +0,0 @@
-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 = async function (archive, output) {
-  archive.finalize()
-  await pEndOfStream(output)
-}
-
-module.exports = { startZip, addZipFile, addZipContent, endZip }

package/src/bin.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-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 = async function () {
-  const { destFolder, srcFolder, ...options } = parseArgs()
-
-  try {
-    const zipped = await 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/src/config.js

@@ -1,32 +0,0 @@
-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/src/feature_flags.js

@@ -1,20 +0,0 @@
-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]) => ({
-      ...result,
-      [key]: input[key] === undefined ? defaultValue : input[key],
-    }),
-    {},
-  )
-
-module.exports = { FLAGS, getFlags }

package/src/main.js

@@ -1,91 +0,0 @@
-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 = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags } = {}) {
-  const featureFlags = getFlags(inputFeatureFlags)
-  const srcFolders = resolveFunctionsDirectories(relativeSrcFolders)
-  const paths = await listFunctionsDirectories(srcFolders)
-  const functions = await getFunctionsFromPaths(paths, { featureFlags })
-  const listedFunctions = [...functions.values()].map(getListedFunction)
-  return listedFunctions
-}
-
-// List all Netlify Functions files for a specific directory
-const listFunctionsFiles = async function (relativeSrcFolders, { config, featureFlags: inputFeatureFlags } = {}) {
-  const featureFlags = getFlags(inputFeatureFlags)
-  const srcFolders = resolveFunctionsDirectories(relativeSrcFolders)
-  const paths = await listFunctionsDirectories(srcFolders)
-  const [functions, pluginsModulesPath] = await Promise.all([
-    getFunctionsFromPaths(paths, { config, featureFlags }),
-    getPluginsModulesPath(srcFolders[0]),
-  ])
-  const listedFunctionsFiles = await 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 = async function (
-  { config, runtime, name, stat, mainFile, extension, srcPath, srcDir },
-  { featureFlags, pluginsModulesPath },
-) {
-  const srcFiles = await 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/src/manifest.js

@@ -1,22 +0,0 @@
-const { resolve } = require('path')
-const { arch, platform } = require('process')
-
-const { writeFile } = require('./utils/fs')
-
-const MANIFEST_VERSION = 1
-
-const createManifest = async ({ functions, path }) => {
-  const formattedFunctions = functions.map(formatFunction)
-  const payload = {
-    functions: formattedFunctions,
-    system: { arch, platform },
-    timestamp: Date.now(),
-    version: MANIFEST_VERSION,
-  }
-
-  await writeFile(path, JSON.stringify(payload))
-}
-
-const formatFunction = ({ mainFile, name, path, runtime }) => ({ mainFile, name, path: resolve(path), runtime })
-
-module.exports = { createManifest }

package/src/node_dependencies/index.js

@@ -1,161 +0,0 @@
-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 = async function ({
-  featureFlags,
-  srcPath,
-  mainFile,
-  srcDir,
-  stat,
-  pluginsModulesPath,
-}) {
-  const [treeFiles, depFiles] = await Promise.all([
-    getTreeFiles(srcPath, stat),
-    getDependencies(mainFile, srcDir, pluginsModulesPath, featureFlags),
-  ])
-  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 = async function (mainFile, srcDir, pluginsModulesPath, featureFlags) {
-  const packageJson = await getPackageJson(srcDir)
-  const state = getNewCache()
-
-  try {
-    return await getFileDependencies({ featureFlags, path: mainFile, packageJson, pluginsModulesPath, state })
-  } catch (error) {
-    error.message = `In file "${mainFile}"\n${error.message}`
-    throw error
-  }
-}
-
-const getFileDependencies = async function ({
-  featureFlags,
-  path,
-  packageJson,
-  pluginsModulesPath,
-  state,
-  treeShakeNext,
-}) {
-  if (state.localFiles.has(path)) {
-    return []
-  }
-
-  state.localFiles.add(path)
-
-  const basedir = dirname(path)
-  const dependencies = featureFlags.parseWithEsbuild
-    ? await listImports({ path })
-    : precinct.paperwork(path, { includeCore: false })
-  const depsPaths = await Promise.all(
-    dependencies.filter(Boolean).map((dependency) =>
-      getImportDependencies({
-        dependency,
-        basedir,
-        featureFlags,
-        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,
-  packageJson,
-  pluginsModulesPath,
-  state,
-  treeShakeNext,
-}) {
-  const shouldTreeShakeNext = treeShakeNext || isNextOnNetlify(dependency)
-  if (shouldTreeShake(dependency, shouldTreeShakeNext)) {
-    return getTreeShakedDependencies({
-      dependency,
-      basedir,
-      featureFlags,
-      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 = async function ({
-  dependency,
-  basedir,
-  featureFlags,
-  packageJson,
-  pluginsModulesPath,
-  state,
-  treeShakeNext,
-}) {
-  const path = await resolvePathPreserveSymlinks(dependency, [basedir, pluginsModulesPath].filter(Boolean))
-  const depsPath = await getFileDependencies({
-    featureFlags,
-    path,
-    packageJson,
-    pluginsModulesPath,
-    state,
-    treeShakeNext,
-  })
-  return [path, ...depsPath]
-}
-
-module.exports = {
-  getDependencyPathsForDependency,
-  getDependencyNamesAndPathsForDependencies,
-  getDependencyNamesAndPathsForDependency,
-  getExternalAndIgnoredModulesFromSpecialCases,
-  getPluginsModulesPath,
-  listFilesUsingLegacyBundler,
-}

package/src/node_dependencies/module.js

@@ -1,13 +0,0 @@
-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/src/node_dependencies/package_json.js

@@ -1,21 +0,0 @@
-const pkgDir = require('pkg-dir')
-
-// Retrieve the `package.json` of a specific project or module
-const getPackageJson = async function (srcDir) {
-  const packageRoot = await 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 }