@netlify/build 25.0.0 → 26.0.0

package/src/plugins/node_version.js

@@ -1,21 +1,17 @@
-'use strict'
+import { version as currentVersion, execPath } from 'process'
 
-const { version: currentVersion, execPath } = require('process')
+import semver from 'semver'
 
-const { satisfies, clean: cleanVersion } = require('semver')
-
-const {
-  engines: { node: nodeVersionSupportedRange },
-} = require('../../package.json')
-const { addErrorInfo } = require('../error/info')
+import { addErrorInfo } from '../error/info.js'
+import { ROOT_PACKAGE_JSON } from '../utils/json.js'
 
 // Local plugins and `package.json`-installed plugins use user's preferred Node.js version if higher than our minimum
 // supported version. Else default to the system Node version.
 // Local and programmatic builds use `@netlify/build` Node.js version, which is
 // usually the system's Node.js version.
 // If the user Node version does not satisfy our supported engine range use our own system Node version
-const addPluginsNodeVersion = function ({ pluginsOptions, nodePath, userNodeVersion }) {
-  const currentNodeVersion = cleanVersion(currentVersion)
+export const addPluginsNodeVersion = function ({ pluginsOptions, nodePath, userNodeVersion }) {
+  const currentNodeVersion = semver.clean(currentVersion)
   return pluginsOptions.map((pluginOptions) =>
     addPluginNodeVersion({ pluginOptions, currentNodeVersion, userNodeVersion, nodePath }),
   )
@@ -29,18 +25,18 @@ const addPluginNodeVersion = function ({
   nodePath,
 }) {
   return (loadedFrom === 'local' || loadedFrom === 'package.json') &&
-    satisfies(userNodeVersion, nodeVersionSupportedRange)
+    semver.satisfies(userNodeVersion, ROOT_PACKAGE_JSON.engines.node)
     ? { ...pluginOptions, nodePath, nodeVersion: userNodeVersion }
     : { ...pluginOptions, nodePath: execPath, nodeVersion: currentNodeVersion }
 }
 
 // Ensure Node.js version is compatible with plugin's `engines.node`
-const checkNodeVersion = function ({
+export const checkNodeVersion = function ({
   nodeVersion,
   packageName,
   pluginPackageJson: { engines: { node: pluginNodeVersionRange } = {} } = {},
 }) {
-  if (pluginNodeVersionRange && !satisfies(nodeVersion, pluginNodeVersionRange)) {
+  if (pluginNodeVersionRange && !semver.satisfies(nodeVersion, pluginNodeVersionRange)) {
     throwUserError(
       `The Node.js version is ${nodeVersion} but the plugin "${packageName}" requires ${pluginNodeVersionRange}`,
     )
@@ -52,5 +48,3 @@ const throwUserError = function (message) {
   addErrorInfo(error, { type: 'resolveConfig' })
   throw error
 }
-
-module.exports = { addPluginsNodeVersion, checkNodeVersion }

package/src/plugins/options.js

@@ -1,15 +1,13 @@
-'use strict'
+import { dirname } from 'path'
 
-const { dirname } = require('path')
+import { installLocalPluginsDependencies } from '../install/local.js'
+import { measureDuration } from '../time/main.js'
+import { ROOT_PACKAGE_JSON } from '../utils/json.js'
+import { getPackageJson } from '../utils/package.js'
 
-const corePackageJson = require('../../package.json')
-const { installLocalPluginsDependencies } = require('../install/local')
-const { measureDuration } = require('../time/main')
-const { getPackageJson } = require('../utils/package')
-
-const { useManifest } = require('./manifest/main')
-const { checkNodeVersion } = require('./node_version')
-const { resolvePluginsPath } = require('./resolve')
+import { useManifest } from './manifest/main.js'
+import { checkNodeVersion } from './node_version.js'
+import { resolvePluginsPath } from './resolve.js'
 
 // Load core plugins and user plugins
 const tGetPluginsOptions = async function ({
@@ -51,7 +49,7 @@ const tGetPluginsOptions = async function ({
   return { pluginsOptions: pluginsOptionsC }
 }
 
-const getPluginsOptions = measureDuration(tGetPluginsOptions, 'get_plugins_options')
+export const getPluginsOptions = measureDuration(tGetPluginsOptions, 'get_plugins_options')
 
 // Retrieve plugin's main file path.
 // Then load plugin's `package.json` and `manifest.yml`.
@@ -82,12 +80,9 @@ const isNotRedundantCorePlugin = function (pluginOptionsA, index, pluginsOptions
 
 // Retrieve information about @netlify/build when an error happens there and not
 // in a plugin
-const getSpawnInfo = function () {
-  const { name } = corePackageJson
+export const getSpawnInfo = function () {
   return {
-    plugin: { packageName: name, pluginPackageJson: corePackageJson },
-    location: { event: 'load', packageName: name, loadedFrom: 'core', origin: 'core' },
+    plugin: { packageName: ROOT_PACKAGE_JSON.name, pluginPackageJson: ROOT_PACKAGE_JSON },
+    location: { event: 'load', packageName: ROOT_PACKAGE_JSON.name, loadedFrom: 'core', origin: 'core' },
   }
 }
-
-module.exports = { getPluginsOptions, getSpawnInfo }

package/src/plugins/pinned_version.js

@@ -1,11 +1,9 @@
-'use strict'
-
-const { handleBuildError } = require('../error/handle')
-const { getMajorVersion } = require('../utils/semver')
+import { handleBuildError } from '../error/handle.js'
+import { getMajorVersion } from '../utils/semver.js'
 
 // Retrieve plugin's pinned major versions by fetching the latest `PluginRun`
 // Only applies to `netlify.toml`-only installed plugins.
-const addPinnedVersions = async function ({ pluginsOptions, api, siteInfo: { id: siteId }, sendStatus }) {
+export const addPinnedVersions = async function ({ pluginsOptions, api, siteInfo: { id: siteId }, sendStatus }) {
   if (!sendStatus || api === undefined || !siteId) {
     return pluginsOptions
   }
@@ -40,7 +38,7 @@ const addPinnedVersion = function (pluginOptions, pluginRuns) {
 
 // Send an API request to pin plugins' major versions.
 // Only applies to UI-installed plugins.
-const pinPlugins = async function ({
+export const pinPlugins = async function ({
   pluginsOptions,
   failedPlugins,
   api,
@@ -131,5 +129,3 @@ const pinPlugin = async function ({
 const shouldIgnoreError = function ({ status }) {
   return status === 404
 }
-
-module.exports = { addPinnedVersions, pinPlugins }

package/src/plugins/resolve.js

@@ -1,19 +1,17 @@
-'use strict'
+import { addErrorInfo } from '../error/info.js'
+import { installMissingPlugins } from '../install/missing.js'
+import { resolvePath, tryResolvePath } from '../utils/resolve.js'
 
-const { addErrorInfo } = require('../error/info')
-const { installMissingPlugins } = require('../install/missing')
-const { resolvePath, tryResolvePath } = require('../utils/resolve')
-
-const { addExpectedVersions } = require('./expected_version')
-const { addPluginsNodeVersion } = require('./node_version')
-const { addPinnedVersions } = require('./pinned_version')
+import { addExpectedVersions } from './expected_version.js'
+import { addPluginsNodeVersion } from './node_version.js'
+import { addPinnedVersions } from './pinned_version.js'
 
 // Try to find plugins in four places, by priority order:
 //  - already loaded (core plugins)
 //  - local plugin
 //  - external plugin already installed in `node_modules`, most likely through `package.json`
 //  - automatically installed by us, to `.netlify/plugins/`
-const resolvePluginsPath = async function ({
+export const resolvePluginsPath = async function ({
   pluginsOptions,
   siteInfo,
   buildDir,
@@ -152,5 +150,3 @@ const resolveMissingPluginPath = async function ({ pluginOptions, pluginOptions:
 const isMissingPlugin = function ({ isMissing }) {
   return isMissing
 }
-
-module.exports = { resolvePluginsPath }

package/src/plugins/spawn.js

@@ -1,15 +1,15 @@
-'use strict'
+import { fileURLToPath } from 'url'
 
-const execa = require('execa')
+import execa from 'execa'
 
-const { addErrorInfo } = require('../error/info')
-const { logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins } = require('../log/messages/compatibility')
-const { measureDuration } = require('../time/main')
+import { addErrorInfo } from '../error/info.js'
+import { logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins } from '../log/messages/compatibility.js'
+import { measureDuration } from '../time/main.js'
 
-const { getEventFromChild } = require('./ipc')
-const { getSpawnInfo } = require('./options')
+import { getEventFromChild } from './ipc.js'
+import { getSpawnInfo } from './options.js'
 
-const CHILD_MAIN_FILE = `${__dirname}/child/main.js`
+const CHILD_MAIN_FILE = fileURLToPath(new URL('child/main.js', import.meta.url))
 
 // Start child processes used by all plugins
 // We fire plugins through child processes so that:
@@ -28,7 +28,7 @@ const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs
   return { childProcesses }
 }
 
-const startPlugins = measureDuration(tStartPlugins, 'start_plugins')
+export const startPlugins = measureDuration(tStartPlugins, 'start_plugins')
 
 const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv }) {
   const childProcess = execa.node(CHILD_MAIN_FILE, {
@@ -53,7 +53,7 @@ const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv })
 }
 
 // Stop all plugins child processes
-const stopPlugins = function (childProcesses) {
+export const stopPlugins = function (childProcesses) {
   childProcesses.forEach(stopPlugin)
 }
 
@@ -64,5 +64,3 @@ const stopPlugin = function ({ childProcess }) {
 
   childProcess.kill()
 }
-
-module.exports = { startPlugins, stopPlugins }

package/src/plugins_core/add.js

@@ -1,10 +1,8 @@
-'use strict'
-
-const { listCorePlugins, isCorePlugin } = require('./list')
+import { listCorePlugins, isCorePlugin } from './list.js'
 
 // Add core plugins and user plugins together.
 // Do not allow user override of core plugins.
-const addCorePlugins = function ({ netlifyConfig: { plugins }, constants }) {
+export const addCorePlugins = function ({ netlifyConfig: { plugins }, constants }) {
   const corePlugins = listCorePlugins(constants)
   const allCorePlugins = corePlugins
     .map((corePlugin) => addCoreProperties(corePlugin, plugins))
@@ -49,5 +47,3 @@ const normalizePluginOptions = function ({
 }) {
   return { packageName, pluginPath, pinnedVersion, loadedFrom, origin, inputs }
 }
-
-module.exports = { addCorePlugins }

package/src/plugins_core/build_command.js

@@ -1,13 +1,11 @@
-'use strict'
+import { platform } from 'process'
 
-const { platform } = require('process')
+import execa from 'execa'
 
-const execa = require('execa')
-
-const { addErrorInfo } = require('../error/info')
-const { getBuildCommandDescription } = require('../log/description')
-const { logBuildCommandStart } = require('../log/messages/steps')
-const { getBuildCommandStdio, handleBuildCommandOutput } = require('../log/stream')
+import { addErrorInfo } from '../error/info.js'
+import { getBuildCommandDescription } from '../log/description.js'
+import { logBuildCommandStart } from '../log/messages/steps.js'
+import { getBuildCommandStdio, handleBuildCommandOutput } from '../log/stream.js'
 
 // Fire `build.command`
 const coreStep = async function ({
@@ -67,7 +65,7 @@ const hasBuildCommand = function ({
   return buildCommand !== undefined && buildCommand !== ''
 }
 
-const buildCommandCore = {
+export const buildCommandCore = {
   event: 'onBuild',
   coreStep,
   coreStepId: 'build_command',
@@ -75,5 +73,3 @@ const buildCommandCore = {
   coreStepDescription,
   condition: hasBuildCommand,
 }
-
-module.exports = { buildCommandCore }

package/src/plugins_core/deploy/buildbot_client.js

@@ -1,16 +1,14 @@
-'use strict'
+import net from 'net'
+import { normalize, resolve, relative } from 'path'
+import { promisify } from 'util'
 
-const net = require('net')
-const { normalize, resolve, relative } = require('path')
-const { promisify } = require('util')
+import pEvent from 'p-event'
 
-const pEvent = require('p-event')
+import { addErrorInfo } from '../../error/info.js'
+import { runsAfterDeploy } from '../../plugins/events.js'
+import { addAsyncErrorMessage } from '../../utils/errors.js'
 
-const { addErrorInfo } = require('../../error/info')
-const { runsAfterDeploy } = require('../../plugins/events')
-const { addAsyncErrorMessage } = require('../../utils/errors')
-
-const createBuildbotClient = function (buildbotServerSocket) {
+export const createBuildbotClient = function (buildbotServerSocket) {
   const connectionOpts = getConnectionOpts(buildbotServerSocket)
   const client = net.createConnection(connectionOpts)
   return client
@@ -30,9 +28,9 @@ const eConnectBuildbotClient = async function (client) {
   await pEvent(client, 'connect')
 }
 
-const connectBuildbotClient = addAsyncErrorMessage(eConnectBuildbotClient, 'Could not connect to buildbot')
+export const connectBuildbotClient = addAsyncErrorMessage(eConnectBuildbotClient, 'Could not connect to buildbot')
 
-const closeBuildbotClient = async function (client) {
+export const closeBuildbotClient = async function (client) {
   if (client.destroyed) {
     return
   }
@@ -56,7 +54,7 @@ const getNextParsedResponsePromise = addAsyncErrorMessage(
   'Invalid response from buildbot',
 )
 
-const deploySiteWithBuildbotClient = async function ({ client, events, buildDir, repositoryRoot, constants }) {
+export const deploySiteWithBuildbotClient = async function ({ client, events, buildDir, repositoryRoot, constants }) {
   const action = shouldWaitForPostProcessing(events) ? 'deploySiteAndAwaitLive' : 'deploySite'
   const deployDir = getDeployDir({ buildDir, repositoryRoot, constants })
   const payload = { action, deployDir }
@@ -102,10 +100,3 @@ const shouldWaitForPostProcessing = function (events) {
 const hasPostDeployLogic = function (event) {
   return runsAfterDeploy(event)
 }
-
-module.exports = {
-  createBuildbotClient,
-  connectBuildbotClient,
-  closeBuildbotClient,
-  deploySiteWithBuildbotClient,
-}

package/src/plugins_core/deploy/index.js

@@ -1,14 +1,12 @@
-'use strict'
+import { saveUpdatedConfig, restoreUpdatedConfig } from '../../core/config.js'
+import { logDeploySuccess } from '../../log/messages/plugins.js'
 
-const { saveUpdatedConfig, restoreUpdatedConfig } = require('../../core/config')
-const { logDeploySuccess } = require('../../log/messages/plugins')
-
-const {
+import {
   createBuildbotClient,
   connectBuildbotClient,
   closeBuildbotClient,
   deploySiteWithBuildbotClient,
-} = require('./buildbot_client')
+} from './buildbot_client.js'
 
 const coreStep = async function ({
   buildDir,
@@ -63,7 +61,7 @@ const shouldDeploy = function ({ buildbotServerSocket }) {
   return buildbotServerSocket !== undefined
 }
 
-const deploySite = {
+export const deploySite = {
   event: 'onPostBuild',
   coreStep,
   coreStepId: 'deploy_site',
@@ -71,5 +69,3 @@ const deploySite = {
   coreStepDescription: () => 'Deploy site',
   condition: shouldDeploy,
 }
-
-module.exports = { deploySite }

package/src/plugins_core/functions/error.js

@@ -1,15 +1,13 @@
-'use strict'
+import readdirp from 'readdirp'
 
-const readdirp = require('readdirp')
-
-const { addErrorInfo } = require('../../error/info')
+import { addErrorInfo } from '../../error/info.js'
 
 const MODULE_NOT_FOUND_CODE = 'MODULE_NOT_FOUND'
 const MODULE_NOT_FOUND_ESBUILD_REGEXP = /^Could not resolve ['"]([^'"]+)/
 const MODULE_NOT_FOUND_REGEXP = /Cannot find module ['"]([^'"]+)/
 
 // Handle errors coming from zip-it-and-ship-it
-const getZipError = async function (error, functionsSrc) {
+export const getZipError = async function (error, functionsSrc) {
   const moduleNotFoundError = await getModuleNotFoundError(error, functionsSrc)
 
   if (moduleNotFoundError) {
@@ -151,7 +149,7 @@ package = "@netlify/plugin-functions-install-core"
 }
 
 // We need to load the site's `package.json` when bundling Functions. This is
-// because `optionalDependencies` can make `require()` fail, but we don't want
+// because `optionalDependencies` can make `import()` fail, but we don't want
 // to error then. However, if the `package.json` is invalid, we fail the build.
 const isPackageJsonError = function (error) {
   return error.message.includes(PACKAGE_JSON_ORIGINAL_MESSAGE)
@@ -163,5 +161,3 @@ const getPackageJsonError = function (error) {
   addErrorInfo(error, { type: 'resolveConfig' })
   return error
 }
-
-module.exports = { getZipError }

package/src/plugins_core/functions/feature_flags.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const getZisiFeatureFlags = (featureFlags) => ({
+export const getZisiFeatureFlags = (featureFlags) => ({
   ...featureFlags,
   buildGoSource: featureFlags.buildbot_build_go_functions,
   defaultEsModulesToEsbuild: featureFlags.buildbot_es_modules_esbuild,
@@ -9,5 +7,3 @@ const getZisiFeatureFlags = (featureFlags) => ({
   parseWithEsbuild: featureFlags.buildbot_zisi_esbuild_parser,
   traceWithNft: featureFlags.buildbot_zisi_trace_nft,
 })
-
-module.exports = { getZisiFeatureFlags }

package/src/plugins_core/functions/index.js

@@ -1,18 +1,15 @@
-'use strict'
+import { join, resolve } from 'path'
 
-const { join, resolve } = require('path')
+import { zipFunctions } from '@netlify/zip-it-and-ship-it'
+import mapObject from 'map-obj'
+import pathExists from 'path-exists'
 
-// We can't use destructuring for zisi as we rely on spies for the `zipFunctions` method within our tests
-const zipItAndShipIt = require('@netlify/zip-it-and-ship-it')
-const mapObject = require('map-obj')
-const pathExists = require('path-exists')
+import { log } from '../../log/logger.js'
+import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js'
 
-const { log } = require('../../log/logger')
-const { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } = require('../../log/messages/core_steps')
-
-const { getZipError } = require('./error')
-const { getZisiFeatureFlags } = require('./feature_flags')
-const { getUserAndInternalFunctions, validateFunctionsSrc } = require('./utils')
+import { getZipError } from './error.js'
+import { getZisiFeatureFlags } from './feature_flags.js'
+import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js'
 
 // Returns `true` if at least one of the functions has been configured to use
 // esbuild.
@@ -182,7 +179,7 @@ const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNA
   return await pathExists(internalFunctionsSrc)
 }
 
-const bundleFunctions = {
+export const bundleFunctions = {
   event: 'onBuild',
   coreStep,
   coreStepId: 'functions_bundling',
@@ -191,4 +188,13 @@ const bundleFunctions = {
   condition: hasFunctionsDirectories,
 }
 
-module.exports = { bundleFunctions }
+// Named imports with ES modules cannot be mocked (unlike CommonJS) because
+// they are bound at load time.
+// However, some of our tests are asserting which arguments are passed to
+// `zip-it-and-ship-it` methods. Therefore, we need to use an intermediary
+// function and export them so tests can use it.
+export const zipItAndShipIt = {
+  async zipFunctions(...args) {
+    return await zipFunctions(...args)
+  },
+}

package/src/plugins_core/functions/utils.js

@@ -1,16 +1,14 @@
-'use strict'
+import { stat } from 'fs'
+import { relative } from 'path'
+import { promisify } from 'util'
 
-const { stat } = require('fs')
-const { relative } = require('path')
-const { promisify } = require('util')
+import { listFunctions } from '@netlify/zip-it-and-ship-it'
 
-const { listFunctions } = require('@netlify/zip-it-and-ship-it')
+import { addErrorInfo } from '../../error/info.js'
 
-const pStat = promisify(stat)
-
-const { addErrorInfo } = require('../../error/info')
+import { getZisiFeatureFlags } from './feature_flags.js'
 
-const { getZisiFeatureFlags } = require('./feature_flags')
+const pStat = promisify(stat)
 
 // Returns the `mainFile` of each function found in `functionsSrc`, relative to
 // `functionsSrc`.
@@ -24,7 +22,7 @@ const getRelativeFunctionMainFiles = async function ({ featureFlags, functionsSr
   return functions.map(({ mainFile }) => relative(functionsSrc, mainFile))
 }
 
-const getUserAndInternalFunctions = ({
+export const getUserAndInternalFunctions = ({
   featureFlags,
   functionsSrc,
   functionsSrcExists,
@@ -42,7 +40,7 @@ const getUserAndInternalFunctions = ({
 // Returns `true` if the functions directory exists and is valid. Returns
 // `false` if it doesn't exist. Throws an error if it's invalid or can't
 // be accessed.
-const validateFunctionsSrc = async function ({ functionsSrc, relativeFunctionsSrc }) {
+export const validateFunctionsSrc = async function ({ functionsSrc, relativeFunctionsSrc }) {
   if (functionsSrc === undefined) {
     return false
   }
@@ -69,5 +67,3 @@ const validateFunctionsSrc = async function ({ functionsSrc, relativeFunctionsSr
     throw error
   }
 }
-
-module.exports = { getUserAndInternalFunctions, validateFunctionsSrc }

package/src/plugins_core/functions_install/index.js

@@ -1,11 +1,9 @@
-'use strict'
+import pathExists from 'path-exists'
 
-const pathExists = require('path-exists')
-
-const { installFunctionDependencies } = require('../../install/functions')
+import { installFunctionDependencies } from '../../install/functions.js'
 
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
-const onPreBuild = async function ({ constants: { FUNCTIONS_SRC, IS_LOCAL } }) {
+export const onPreBuild = async function ({ constants: { FUNCTIONS_SRC, IS_LOCAL } }) {
   if (!(await pathExists(FUNCTIONS_SRC))) {
     return {}
   }
@@ -13,5 +11,3 @@ const onPreBuild = async function ({ constants: { FUNCTIONS_SRC, IS_LOCAL } }) {
   await installFunctionDependencies(FUNCTIONS_SRC, IS_LOCAL)
   return {}
 }
-
-module.exports = { onPreBuild }

package/src/plugins_core/list.js

@@ -1,8 +1,13 @@
-'use strict'
+import { createRequire } from 'module'
+import { fileURLToPath } from 'url'
 
-const { LOCAL_INSTALL_PLUGIN_NAME } = require('../install/local')
+import { LOCAL_INSTALL_PLUGIN_NAME } from '../install/local.js'
 
-const FUNCTIONS_INSTALL_PLUGIN = `${__dirname}/functions_install/index.js`
+// TODO: use `import.resolve()` once it is available without any experimental
+// flags
+const require = createRequire(import.meta.url)
+
+const FUNCTIONS_INSTALL_PLUGIN = fileURLToPath(new URL('functions_install/index.js', import.meta.url))
 
 // List of core plugin names
 const FUNCTIONS_INSTALL_PLUGIN_NAME = '@netlify/plugin-functions-install-core'
@@ -12,7 +17,7 @@ const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGI
 const EDGE_HANDLERS_PLUGIN_PATH = require.resolve(EDGE_HANDLERS_PLUGIN_NAME)
 
 // Plugins that are installed and enabled by default
-const listCorePlugins = function ({ FUNCTIONS_SRC, EDGE_HANDLERS_SRC }) {
+export const listCorePlugins = function ({ FUNCTIONS_SRC, EDGE_HANDLERS_SRC }) {
   const functionsInstallPlugin = getFunctionsInstallPlugin(FUNCTIONS_SRC)
   const edgeHandlersPlugin = getEdgeHandlersPlugin(EDGE_HANDLERS_SRC)
   return [functionsInstallPlugin, edgeHandlersPlugin].filter(Boolean)
@@ -38,8 +43,6 @@ const getEdgeHandlersPlugin = function (EDGE_HANDLERS_SRC) {
   return { package: EDGE_HANDLERS_PLUGIN_NAME, pluginPath: EDGE_HANDLERS_PLUGIN_PATH }
 }
 
-const isCorePlugin = function (packageName) {
+export const isCorePlugin = function (packageName) {
   return CORE_PLUGINS.has(packageName)
 }
-
-module.exports = { listCorePlugins, isCorePlugin }

package/src/status/add.js

@@ -1,7 +1,5 @@
-'use strict'
-
 // Merge plugin status to the list of plugin statuses.
-const addStatus = function ({ newStatus, statuses, event, packageName, pluginPackageJson: { version } = {} }) {
+export const addStatus = function ({ newStatus, statuses, event, packageName, pluginPackageJson: { version } = {} }) {
   // Either:
   //  - `build.command`
   //  - no status was set
@@ -36,5 +34,3 @@ const canOverrideStatus = function (formerStatus, newStatus) {
 
 // Possible status states, ordered by severity.
 const STATES = ['success', 'canceled_plugin', 'failed_plugin', 'failed_build']
-
-module.exports = { addStatus }

package/src/status/colors.js

@@ -1,9 +1,7 @@
-'use strict'
-
-const stripAnsi = require('strip-ansi')
+import stripAnsi from 'strip-ansi'
 
 // Remove colors from statuses
-const removeStatusesColors = function (statuses) {
+export const removeStatusesColors = function (statuses) {
   return statuses.map(removeStatusColors)
 }
 
@@ -23,5 +21,3 @@ const removeAttrColor = function (status, attribute) {
   const valueA = stripAnsi(value)
   return { [attribute]: valueA }
 }
-
-module.exports = { removeStatusesColors }

package/src/status/load_error.js

@@ -1,15 +1,11 @@
-'use strict'
-
-const { addErrorInfo } = require('../error/info')
-const { getFullErrorInfo } = require('../error/parse/parse')
-const { serializeErrorStatus } = require('../error/parse/serialize_status')
+import { addErrorInfo } from '../error/info.js'
+import { getFullErrorInfo } from '../error/parse/parse.js'
+import { serializeErrorStatus } from '../error/parse/serialize_status.js'
 
 // Errors that happen during plugin loads should be reported as error statuses
-const addPluginLoadErrorStatus = function ({ error, packageName, version, debug }) {
+export const addPluginLoadErrorStatus = function ({ error, packageName, version, debug }) {
   const fullErrorInfo = getFullErrorInfo({ error, colors: false, debug })
   const errorStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' })
   const statuses = [{ ...errorStatus, event: 'load', packageName, version }]
   addErrorInfo(error, { statuses })
 }
-
-module.exports = { addPluginLoadErrorStatus }

package/src/status/report.js

@@ -1,12 +1,10 @@
-'use strict'
+import { handleBuildError } from '../error/handle.js'
+import { logStatuses } from '../log/messages/status.js'
 
-const { handleBuildError } = require('../error/handle')
-const { logStatuses } = require('../log/messages/status')
-
-const { removeStatusesColors } = require('./colors')
+import { removeStatusesColors } from './colors.js'
 
 // Report plugin statuses to the console and API
-const reportStatuses = async function ({
+export const reportStatuses = async function ({
   statuses,
   childEnv,
   api,
@@ -128,5 +126,3 @@ const sendApiStatus = async function ({
     await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts })
   }
 }
-
-module.exports = { reportStatuses }