@netlify/build 25.0.0 → 26.0.0

package/src/plugins/child/utils.js

@@ -1,30 +1,26 @@
-'use strict'
+import { bindOpts as cacheBindOpts } from '@netlify/cache-utils'
+import { add as functionsAdd, list as functionsList, listAll as functionsListAll } from '@netlify/functions-utils'
+import { getGitUtils } from '@netlify/git-utils'
+import { run, runCommand } from '@netlify/run-utils'
 
-const { failBuild, failPlugin, cancelBuild, failPluginWithWarning } = require('../error')
-const { isSoftFailEvent } = require('../events')
+import { failBuild, failPlugin, cancelBuild, failPluginWithWarning } from '../error.js'
+import { isSoftFailEvent } from '../events.js'
 
-const { addLazyProp } = require('./lazy')
-const { show } = require('./status')
-
-const cacheUtilsPromise = import('@netlify/cache-utils')
-const functionsUtilsPromise = import('@netlify/functions-utils')
-const gitUtilsPromise = import('@netlify/git-utils')
-const runUtilsPromise = import('@netlify/run-utils')
+import { addLazyProp } from './lazy.js'
+import { show } from './status.js'
 
 // Retrieve the `utils` argument.
-const getUtils = async function ({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, runState }) {
-  const [cacheUtils, functionsUtils, { getGitUtils }, { run, runCommand }] = await Promise.all([
-    cacheUtilsPromise,
-    functionsUtilsPromise,
-    gitUtilsPromise,
-    runUtilsPromise,
-  ])
+export const getUtils = function ({
+  event,
+  constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR },
+  runState,
+}) {
   // eslint-disable-next-line fp/no-mutation
   run.command = runCommand
 
   const build = getBuildUtils(event)
-  const cache = getCacheUtils(cacheUtils, CACHE_DIR)
-  const functions = getFunctionsUtils(functionsUtils, FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC)
+  const cache = getCacheUtils(CACHE_DIR)
+  const functions = getFunctionsUtils(FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC)
   const status = getStatusUtils(runState)
   const utils = { build, cache, run, functions, status }
   addLazyProp(utils, 'git', () => getGitUtils())
@@ -43,20 +39,18 @@ const getBuildUtils = function (event) {
   return { failBuild, failPlugin, cancelBuild }
 }
 
-const getCacheUtils = function (cacheUtils, CACHE_DIR) {
-  return cacheUtils.bindOpts({ cacheDir: CACHE_DIR })
+const getCacheUtils = function (CACHE_DIR) {
+  return cacheBindOpts({ cacheDir: CACHE_DIR })
 }
 
-const getFunctionsUtils = function (functionsUtils, FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC) {
+const getFunctionsUtils = function (FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC) {
   const functionsDirectories = [INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC].filter(Boolean)
-  const add = (src) => functionsUtils.add(src, INTERNAL_FUNCTIONS_SRC, { fail: failBuild })
-  const list = functionsUtils.list.bind(null, functionsDirectories, { fail: failBuild })
-  const listAll = functionsUtils.listAll.bind(null, functionsDirectories, { fail: failBuild })
+  const add = (src) => functionsAdd(src, INTERNAL_FUNCTIONS_SRC, { fail: failBuild })
+  const list = functionsList.bind(null, functionsDirectories, { fail: failBuild })
+  const listAll = functionsListAll.bind(null, functionsDirectories, { fail: failBuild })
   return { add, list, listAll }
 }
 
 const getStatusUtils = function (runState) {
   return { show: show.bind(undefined, runState) }
 }
-
-module.exports = { getUtils }

package/src/plugins/child/validate.js

@@ -1,11 +1,9 @@
-'use strict'
-
-const { addErrorInfo } = require('../../error/info')
-const { serializeArray } = require('../../log/serialize')
-const { listEvents } = require('../events')
+import { addErrorInfo } from '../../error/info.js'
+import { serializeArray } from '../../log/serialize.js'
+import { EVENTS } from '../events.js'
 
 // Validate the shape of a plugin return value
-const validatePlugin = async function (logic) {
+export const validatePlugin = function (logic) {
   try {
     // This validation must work with the return value of `import()` which has
     // a `Module` prototype, not `Object`
@@ -13,9 +11,8 @@ const validatePlugin = async function (logic) {
       throw new Error('Plugin must be an object or a function')
     }
 
-    const EVENTS = await listEvents()
     Object.entries(logic).forEach(([propName, value]) => {
-      validateEventHandler(value, propName, EVENTS)
+      validateEventHandler(value, propName)
     })
   } catch (error) {
     addErrorInfo(error, { type: 'pluginValidation' })
@@ -24,7 +21,7 @@ const validatePlugin = async function (logic) {
 }
 
 // All other properties are event handlers
-const validateEventHandler = function (value, propName, EVENTS) {
+const validateEventHandler = function (value, propName) {
   if (!EVENTS.includes(propName)) {
     throw new Error(`Invalid event '${propName}'.
 Please use a valid event name. One of:
@@ -35,5 +32,3 @@ ${serializeArray(EVENTS)}`)
     throw new TypeError(`Invalid event handler '${propName}': must be a function`)
   }
 }
-
-module.exports = { validatePlugin }

package/src/plugins/compatibility.js

@@ -1,9 +1,9 @@
-'use strict'
-const pEvery = require('p-every')
-const pLocate = require('p-locate')
-const { satisfies, clean: cleanVersion } = require('semver')
+import pEvery from 'p-every'
+import pLocate from 'p-locate'
+import semver from 'semver'
 
-const { resolvePath } = require('../utils/resolve')
+import { importJsonFile } from '../utils/json.js'
+import { resolvePath } from '../utils/resolve.js'
 
 // Retrieve the `expectedVersion` of a plugin:
 //  - This is the version which should be run
@@ -14,7 +14,7 @@ const { resolvePath } = require('../utils/resolve')
 //  - This is the same logic except it does not use version pinning
 //  - This is only used to print a warning message when the `compatibleVersion`
 //    is older than the currently used version.
-const getExpectedVersion = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
+export const getExpectedVersion = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
   const { version, conditions } = await getCompatibleEntry({
     versions,
     nodeVersion,
@@ -42,7 +42,7 @@ const getExpectedVersion = async function ({ versions, nodeVersion, packageJson,
 //  - Otherwise, use `latestVersion`
 const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
   if (pinnedVersion !== undefined) {
-    return versions.find(({ version }) => satisfies(version, pinnedVersion)) || { version: pinnedVersion }
+    return versions.find(({ version }) => semver.satisfies(version, pinnedVersion)) || { version: pinnedVersion }
   }
 
   const versionsWithConditions = versions.filter(hasConditions)
@@ -76,7 +76,7 @@ const getConditionWarning = function ({ type, condition }) {
 // Plugins can use `compatibility.{version}.nodeVersion: 'allowedNodeVersion'`
 // to deliver different plugin versions based on the Node.js version
 const nodeVersionTest = function (allowedNodeVersion, { nodeVersion }) {
-  return satisfies(nodeVersion, allowedNodeVersion)
+  return semver.satisfies(nodeVersion, allowedNodeVersion)
 }
 
 const nodeVersionWarning = function (allowedNodeVersion) {
@@ -100,16 +100,15 @@ const siteDependencyTest = async function ({ dependencyName, allowedVersion, sit
   }
 
   // if this is a valid version we can apply the rule directly
-  if (cleanVersion(siteDependency) !== null) {
-    return satisfies(siteDependency, allowedVersion)
+  if (semver.clean(siteDependency) !== null) {
+    return semver.satisfies(siteDependency, allowedVersion)
   }
 
   try {
     // if this is a range we need to get the exact version
     const packageJsonPath = await resolvePath(`${dependencyName}/package.json`, buildDir)
-    // eslint-disable-next-line node/global-require, import/no-dynamic-require
-    const { version } = require(packageJsonPath)
-    return satisfies(version, allowedVersion)
+    const { version } = await importJsonFile(packageJsonPath)
+    return semver.satisfies(version, allowedVersion)
   } catch (error) {
     return false
   }
@@ -123,9 +122,7 @@ const siteDependencyWarning = function ([dependencyName, allowedVersion]) {
   return `${dependencyName}@${allowedVersion}`
 }
 
-const CONDITIONS = {
+export const CONDITIONS = {
   nodeVersion: { test: nodeVersionTest, warning: nodeVersionWarning },
   siteDependencies: { test: siteDependenciesTest, warning: siteDependenciesWarning },
 }
-
-module.exports = { getExpectedVersion, CONDITIONS }

package/src/plugins/error.js

@@ -1,29 +1,27 @@
-'use strict'
-
-const { addErrorInfo } = require('../error/info')
-const { logFailPluginWarning } = require('../log/messages/plugins')
+import { addErrorInfo } from '../error/info.js'
+import { logFailPluginWarning } from '../log/messages/plugins.js'
 
 // Stop build.
 // As opposed to throwing an error directly or to uncaught exceptions, this is
 // displayed as a user error, not an implementation error.
-const failBuild = function (message, opts) {
+export const failBuild = function (message, opts) {
   throw normalizeError('failBuild', failBuild, message, opts)
 }
 
 // Stop plugin. Same as `failBuild` but only stops plugin not whole build
-const failPlugin = function (message, opts) {
+export const failPlugin = function (message, opts) {
   throw normalizeError('failPlugin', failPlugin, message, opts)
 }
 
 // Cancel build. Same as `failBuild` except it marks the build as "canceled".
-const cancelBuild = function (message, opts) {
+export const cancelBuild = function (message, opts) {
   throw normalizeError('cancelBuild', cancelBuild, message, opts)
 }
 
 // `onSuccess`, `onEnd` and `onError` cannot cancel the build since they are run
 // or might be run after deployment. When calling `failBuild()` or
 // `cancelBuild()`, `failPlugin()` is run instead and a warning is printed.
-const failPluginWithWarning = function (methodName, event, message, opts) {
+export const failPluginWithWarning = function (methodName, event, message, opts) {
   logFailPluginWarning(methodName, event)
   failPlugin(message, opts)
 }
@@ -47,10 +45,3 @@ const getError = function (error, message, func) {
   Error.captureStackTrace(errorA, func)
   return errorA
 }
-
-module.exports = {
-  failBuild,
-  failPlugin,
-  failPluginWithWarning,
-  cancelBuild,
-}

package/src/plugins/events.js

@@ -1,32 +1,17 @@
-'use strict'
-
-const netlifyConfigPromise = import('@netlify/config')
-
-const listEvents = async function () {
-  const { EVENTS } = await netlifyConfigPromise
-  return EVENTS
-}
+export { EVENTS } from '@netlify/config'
 
 const isAmongEvents = function (events, event) {
   return events.includes(event)
 }
 
 // Check if failure of the event should not make the build fail
-const isSoftFailEvent = isAmongEvents.bind(null, ['onSuccess', 'onError', 'onEnd'])
+export const isSoftFailEvent = isAmongEvents.bind(null, ['onSuccess', 'onError', 'onEnd'])
 
 // Check if the event is triggered even when the build fails
-const runsAlsoOnBuildFailure = isAmongEvents.bind(null, ['onError', 'onEnd'])
+export const runsAlsoOnBuildFailure = isAmongEvents.bind(null, ['onError', 'onEnd'])
 
 // Check if the event is only triggered when the build fails
-const runsOnlyOnBuildFailure = isAmongEvents.bind(null, ['onError'])
+export const runsOnlyOnBuildFailure = isAmongEvents.bind(null, ['onError'])
 
 // Check if the event is happening after deploy
-const runsAfterDeploy = isAmongEvents.bind(null, ['onSuccess', 'onEnd'])
-
-module.exports = {
-  listEvents,
-  isSoftFailEvent,
-  runsAlsoOnBuildFailure,
-  runsOnlyOnBuildFailure,
-  runsAfterDeploy,
-}
+export const runsAfterDeploy = isAmongEvents.bind(null, ['onSuccess', 'onEnd'])

package/src/plugins/expected_version.js

@@ -1,17 +1,16 @@
-'use strict'
+import semver from 'semver'
 
-const { satisfies } = require('semver')
+import { addErrorInfo } from '../error/info.js'
+import { importJsonFile } from '../utils/json.js'
+import { resolvePath } from '../utils/resolve.js'
 
-const { addErrorInfo } = require('../error/info')
-const { resolvePath } = require('../utils/resolve')
-
-const { getExpectedVersion } = require('./compatibility')
-const { getPluginsList } = require('./list')
+import { getExpectedVersion } from './compatibility.js'
+import { getPluginsList } from './list.js'
 
 // When using plugins in our official list, those are installed in .netlify/plugins/
 // We ensure that the last version that's been approved is always the one being used.
 // We also ensure that the plugin is our official list.
-const addExpectedVersions = async function ({
+export const addExpectedVersions = async function ({
   pluginsOptions,
   autoPluginsDir,
   packageJson,
@@ -89,14 +88,13 @@ const isMissingVersion = async function ({ autoPluginsDir, packageName, pluginPa
     // Plugin was not previously installed
     (pluginPath === undefined ||
       // Plugin was previously installed but a different version should be used
-      !satisfies(await getAutoPluginVersion(packageName, autoPluginsDir), expectedVersion))
+      !semver.satisfies(await getAutoPluginVersion(packageName, autoPluginsDir), expectedVersion))
   )
 }
 
 const getAutoPluginVersion = async function (packageName, autoPluginsDir) {
   const packageJsonPath = await resolvePath(`${packageName}/package.json`, autoPluginsDir)
-  // eslint-disable-next-line node/global-require, import/no-dynamic-require
-  const { version } = require(packageJsonPath)
+  const { version } = await importJsonFile(packageJsonPath)
   return version
 }
 
@@ -119,5 +117,3 @@ Please run "npm install -D ${packageName}" or "yarn add -D ${packageName}".`,
   addErrorInfo(error, { type: 'resolveConfig' })
   throw error
 }
-
-module.exports = { addExpectedVersions }

package/src/plugins/ipc.js

@@ -1,24 +1,22 @@
-'use strict'
+import process from 'process'
+import { promisify } from 'util'
 
-const process = require('process')
-const { promisify } = require('util')
+import pEvent from 'p-event'
+import { v4 as uuidv4 } from 'uuid'
 
-const pEvent = require('p-event')
-const { v4: uuidv4 } = require('uuid')
-
-const { jsonToError, errorToJson } = require('../error/build')
-const { addErrorInfo } = require('../error/info')
-const {
+import { jsonToError, errorToJson } from '../error/build.js'
+import { addErrorInfo } from '../error/info.js'
+import {
   logSendingEventToChild,
   logSentEventToChild,
   logReceivedEventFromChild,
   logSendingEventToParent,
-} = require('../log/messages/ipc')
+} from '../log/messages/ipc.js'
 
 // Send event from child to parent process then wait for response
 // We need to fire them in parallel because `process.send()` can be slow
 // to await, i.e. child might send response before parent start listening for it
-const callChild = async function ({ childProcess, eventName, payload, logs, verbose }) {
+export const callChild = async function ({ childProcess, eventName, payload, logs, verbose }) {
   const callId = uuidv4()
   const [response] = await Promise.all([
     getEventFromChild(childProcess, callId),
@@ -36,7 +34,7 @@ const callChild = async function ({ childProcess, eventName, payload, logs, verb
 //  - child process `exit`
 // In the later two cases, we propagate the error.
 // We need to make `p-event` listeners are properly cleaned up too.
-const getEventFromChild = async function (childProcess, callId) {
+export const getEventFromChild = async function (childProcess, callId) {
   if (childProcessHasExited(childProcess)) {
     throw getChildExitError('Could not receive event from child process because it already exited.')
   }
@@ -104,7 +102,7 @@ const sendEventToChild = async function ({ childProcess, callId, eventName, payl
 // This runs forever until `childProcess.kill()` is called.
 // We need to use `new Promise()` and callbacks because this runs forever.
 // eslint-disable-next-line promise/prefer-await-to-callbacks
-const getEventsFromParent = function (callback) {
+export const getEventsFromParent = function (callback) {
   return new Promise((resolve, reject) => {
     process.on('message', async (message) => {
       try {
@@ -120,7 +118,7 @@ const getEventsFromParent = function (callback) {
 }
 
 // Send event from child to parent process
-const sendEventToParent = async function (callId, payload, verbose, error) {
+export const sendEventToParent = async function (callId, payload, verbose, error) {
   logSendingEventToParent(verbose, error)
   await promisify(process.send.bind(process))([callId, payload])
 }
@@ -145,10 +143,3 @@ const parsePayload = function ({ error = {}, error: { name } = {}, ...payload })
   const errorA = jsonToError(error)
   return { ...payload, error: errorA }
 }
-
-module.exports = {
-  callChild,
-  getEventFromChild,
-  getEventsFromParent,
-  sendEventToParent,
-}

package/src/plugins/list.js

@@ -1,15 +1,10 @@
-'use strict'
+import { pluginsUrl, pluginsList as oldPluginsList } from '@netlify/plugins-list'
+import got from 'got'
+import isPlainObj from 'is-plain-obj'
 
-const got = require('got')
-const isPlainObj = require('is-plain-obj')
+import { logPluginsList, logPluginsFetchError } from '../log/messages/plugins.js'
 
-// TODO: use static `import` after migrating this repository to pure ES modules
-const netlifyPluginsList = import('@netlify/plugins-list')
-
-const { logPluginsList } = require('../log/messages/plugins')
-const { logPluginsFetchError } = require('../log/messages/plugins')
-
-const { CONDITIONS } = require('./compatibility')
+import { CONDITIONS } from './compatibility.js'
 
 // Retrieve the list of plugins officially vetted by us and displayed in our
 // plugins directory UI.
@@ -18,14 +13,13 @@ const { CONDITIONS } = require('./compatibility')
 // make this request is somewhat ok (in the 100ms range).
 // We only fetch this plugins list when needed, i.e. we defer it as much as
 // possible.
-const getPluginsList = async function ({ debug, logs, testOpts: { pluginsListUrl } }) {
+export const getPluginsList = async function ({ debug, logs, testOpts: { pluginsListUrl } }) {
   // We try not to mock in integration tests. However, sending a request for
   // each test would be too slow and make tests unreliable.
   if (pluginsListUrl === 'test') {
     return []
   }
 
-  const { pluginsUrl } = await netlifyPluginsList
   const pluginsListUrlA = pluginsListUrl === undefined ? pluginsUrl : pluginsListUrl
   const pluginsList = await fetchPluginsList({ logs, pluginsListUrl: pluginsListUrlA })
   const pluginsListA = normalizePluginsList(pluginsList)
@@ -50,7 +44,6 @@ const fetchPluginsList = async function ({ logs, pluginsListUrl }) {
     //    buildbot release.
   } catch (error) {
     logPluginsFetchError(logs, error.message)
-    const { pluginsList: oldPluginsList } = await netlifyPluginsList
     return oldPluginsList
   }
 }
@@ -91,5 +84,3 @@ const isCondition = function ([type]) {
 const normalizeCondition = function ([type, condition]) {
   return { type, condition }
 }
-
-module.exports = { getPluginsList }

package/src/plugins/load.js

@@ -1,14 +1,20 @@
-'use strict'
+import { addErrorInfo } from '../error/info.js'
+import { addPluginLoadErrorStatus } from '../status/load_error.js'
+import { measureDuration } from '../time/main.js'
 
-const { addErrorInfo } = require('../error/info')
-const { addPluginLoadErrorStatus } = require('../status/load_error')
-const { measureDuration } = require('../time/main')
-
-const { callChild } = require('./ipc')
+import { callChild } from './ipc.js'
 
 // Retrieve all plugins steps
 // Can use either a module name or a file path to the plugin.
-const loadPlugins = async function ({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose }) {
+export const loadPlugins = async function ({
+  pluginsOptions,
+  childProcesses,
+  packageJson,
+  timers,
+  logs,
+  debug,
+  verbose,
+}) {
   return pluginsOptions.length === 0
     ? { pluginsSteps: [], timers }
     : await loadAllPlugins({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose })
@@ -62,5 +68,3 @@ const loadPlugin = async function (
     throw error
   }
 }
-
-module.exports = { loadPlugins }

package/src/plugins/manifest/check.js

@@ -1,12 +1,10 @@
-'use strict'
-
-const { addErrorInfo } = require('../../error/info')
-const { serializeObject } = require('../../log/serialize')
-const { THEME } = require('../../log/theme')
+import { addErrorInfo } from '../../error/info.js'
+import { serializeObject } from '../../log/serialize.js'
+import { THEME } from '../../log/theme.js'
 
 // Check that plugin inputs match the validation specified in "manifest.yml"
 // Also assign default values
-const checkInputs = function ({
+export const checkInputs = function ({
   inputs,
   manifest: { inputs: rules = [] },
   packageName,
@@ -106,5 +104,3 @@ const addInputError = function ({ error, name, packageName, pluginPackageJson, l
     location: { event: 'load', packageName, input: name, loadedFrom, origin },
   })
 }
-
-module.exports = { checkInputs }

package/src/plugins/manifest/load.js

@@ -1,18 +1,16 @@
-'use strict'
+import { readFile } from 'fs'
+import { promisify } from 'util'
 
-const { readFile } = require('fs')
-const { promisify } = require('util')
+import { load as loadYaml, JSON_SCHEMA } from 'js-yaml'
 
-const { load: loadYaml, JSON_SCHEMA } = require('js-yaml')
+import { addErrorInfo } from '../../error/info.js'
 
-const { addErrorInfo } = require('../../error/info')
-
-const { validateManifest } = require('./validate')
+import { validateManifest } from './validate.js'
 
 const pReadFile = promisify(readFile)
 
 // Load "manifest.yml" using its file path
-const loadManifest = async function ({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin }) {
+export const loadManifest = async function ({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin }) {
   try {
     const rawManifest = await loadRawManifest(manifestPath)
     const manifest = await parseManifest(rawManifest)
@@ -44,5 +42,3 @@ const parseManifest = async function (rawManifest) {
     throw new Error(`Could not parse plugin's "manifest.yml"\n${error.message}`)
   }
 }
-
-module.exports = { loadManifest }

package/src/plugins/manifest/main.js

@@ -1,13 +1,11 @@
-'use strict'
+import { addPluginLoadErrorStatus } from '../../status/load_error.js'
 
-const { addPluginLoadErrorStatus } = require('../../status/load_error')
-
-const { checkInputs } = require('./check')
-const { loadManifest } = require('./load')
-const { getManifestPath } = require('./path')
+import { checkInputs } from './check.js'
+import { loadManifest } from './load.js'
+import { getManifestPath } from './path.js'
 
 // Load plugin's `manifest.yml`
-const useManifest = async function (
+export const useManifest = async function (
   { packageName, loadedFrom, origin, inputs },
   { pluginDir, packageDir, pluginPackageJson, pluginPackageJson: { version }, debug },
 ) {
@@ -22,5 +20,3 @@ const useManifest = async function (
     throw error
   }
 }
-
-module.exports = { useManifest }

package/src/plugins/manifest/path.js

@@ -1,11 +1,9 @@
-'use strict'
+import locatePath from 'locate-path'
 
-const locatePath = require('locate-path')
-
-const { addErrorInfo } = require('../../error/info')
+import { addErrorInfo } from '../../error/info.js'
 
 // Retrieve "manifest.yml" path for a specific plugin
-const getManifestPath = async function ({ pluginDir, packageDir, packageName }) {
+export const getManifestPath = async function ({ pluginDir, packageDir, packageName }) {
   const dirs = [pluginDir, packageDir]
     .filter(Boolean)
     .flatMap((dir) => MANIFEST_FILENAMES.map((filename) => `${dir}/${filename}`))
@@ -31,5 +29,3 @@ This might mean:
 }
 
 const MANIFEST_FILENAMES = ['manifest.yml', 'manifest.yaml']
-
-module.exports = { getManifestPath }

package/src/plugins/manifest/validate.js

@@ -1,11 +1,9 @@
-'use strict'
+import isPlainObj from 'is-plain-obj'
 
-const isPlainObj = require('is-plain-obj')
-
-const { THEME } = require('../../log/theme')
+import { THEME } from '../../log/theme.js'
 
 // Validate `manifest.yml` syntax
-const validateManifest = function (manifest, rawManifest) {
+export const validateManifest = function (manifest, rawManifest) {
   try {
     validateBasic(manifest)
     validateUnknownProps(manifest)
@@ -108,5 +106,3 @@ const validateInputRequired = function ({ required }) {
     throw new Error('"required" property must be a boolean')
   }
 }
-
-module.exports = { validateManifest }