@netlify/build 27.20.4 → 27.20.6

package/lib/core/config.js

@@ -1,16 +1,13 @@
-import { resolveConfig, updateConfig, restoreConfig } from '@netlify/config'
-import mapObj from 'map-obj'
-
-import { getChildEnv } from '../env/main.js'
-import { addApiErrorHandlers } from '../error/api.js'
-import { changeErrorType } from '../error/info.js'
-import { logBuildDir, logConfigPath, logConfig, logContext } from '../log/messages/config.js'
-import { logConfigOnUpload, logHeadersOnUpload, logRedirectsOnUpload } from '../log/messages/mutations.js'
-import { measureDuration } from '../time/main.js'
-import { getPackageJson } from '../utils/package.js'
-
-import { getUserNodeVersion } from './user_node_version.js'
-
+import { resolveConfig, updateConfig, restoreConfig } from '@netlify/config';
+import mapObj from 'map-obj';
+import { getChildEnv } from '../env/main.js';
+import { addApiErrorHandlers } from '../error/api.js';
+import { changeErrorType } from '../error/info.js';
+import { logBuildDir, logConfigPath, logConfig, logContext } from '../log/messages/config.js';
+import { logConfigOnUpload, logHeadersOnUpload, logRedirectsOnUpload } from '../log/messages/mutations.js';
+import { measureDuration } from '../time/main.js';
+import { getPackageJson } from '../utils/package.js';
+import { getUserNodeVersion } from './user_node_version.js';
 // Retrieve immutable options passed to `@netlify/config`.
 // This does not include options which might change during the course of the
 // build:
@@ -18,102 +15,65 @@ import { getUserNodeVersion } from './user_node_version.js'
 //    the build
 //  - If plugins change the configuration, `configMutations` is used instead
 // In both cases, almost all options should remain the same.
-export const getConfigOpts = function ({
-  config,
-  defaultConfig,
-  cwd,
-  repositoryRoot,
-  apiHost,
-  token,
-  siteId,
-  context,
-  branch,
-  baseRelDir,
-  envOpt,
-  mode,
-  offline,
-  deployId,
-  buildId,
-  testOpts,
-  featureFlags,
-}) {
-  return {
-    config,
-    defaultConfig,
-    cwd,
-    repositoryRoot,
-    context,
-    branch,
-    baseRelDir,
-    host: apiHost,
-    token,
-    siteId,
-    deployId,
-    buildId,
-    mode,
-    offline,
-    env: envOpt,
-    testOpts,
-    featureFlags,
-  }
-}
-
+export const getConfigOpts = function ({ config, defaultConfig, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, envOpt, mode, offline, deployId, buildId, testOpts, featureFlags, }) {
+    return {
+        config,
+        defaultConfig,
+        cwd,
+        repositoryRoot,
+        context,
+        branch,
+        baseRelDir,
+        host: apiHost,
+        token,
+        siteId,
+        deployId,
+        buildId,
+        mode,
+        offline,
+        env: envOpt,
+        testOpts,
+        featureFlags,
+    };
+};
 // Retrieve configuration object
 const tLoadConfig = async function ({ configOpts, cachedConfig, cachedConfigPath, envOpt, debug, logs, nodePath }) {
-  const {
-    configPath,
-    headersPath,
-    redirectsPath,
-    buildDir,
-    repositoryRoot,
-    config: netlifyConfig,
-    context: contextA,
-    branch: branchA,
-    token: tokenA,
-    api,
-    siteInfo,
-    env,
-  } = await resolveInitialConfig(configOpts, cachedConfig, cachedConfigPath)
-  logConfigInfo({ logs, configPath, buildDir, netlifyConfig, context: contextA, debug })
-
-  const apiA = addApiErrorHandlers(api)
-  const envValues = mapObj(env, (key, { value }) => [key, value])
-  const childEnv = getChildEnv({ envOpt, env: envValues })
-  const [{ packageJson }, userNodeVersion] = await Promise.all([getPackageJson(buildDir), getUserNodeVersion(nodePath)])
-  return {
-    netlifyConfig,
-    configPath,
-    headersPath,
-    redirectsPath,
-    buildDir,
-    repositoryRoot,
-    packageJson,
-    userNodeVersion,
-    childEnv,
-    context: contextA,
-    branch: branchA,
-    token: tokenA,
-    api: apiA,
-    siteInfo,
-  }
-}
-
-export const loadConfig = measureDuration(tLoadConfig, 'resolve_config')
-
+    const { configPath, headersPath, redirectsPath, buildDir, repositoryRoot, config: netlifyConfig, context: contextA, branch: branchA, token: tokenA, api, siteInfo, env, } = await resolveInitialConfig(configOpts, cachedConfig, cachedConfigPath);
+    logConfigInfo({ logs, configPath, buildDir, netlifyConfig, context: contextA, debug });
+    const apiA = addApiErrorHandlers(api);
+    const envValues = mapObj(env, (key, { value }) => [key, value]);
+    const childEnv = getChildEnv({ envOpt, env: envValues });
+    const [{ packageJson }, userNodeVersion] = await Promise.all([getPackageJson(buildDir), getUserNodeVersion(nodePath)]);
+    return {
+        netlifyConfig,
+        configPath,
+        headersPath,
+        redirectsPath,
+        buildDir,
+        repositoryRoot,
+        packageJson,
+        userNodeVersion,
+        childEnv,
+        context: contextA,
+        branch: branchA,
+        token: tokenA,
+        api: apiA,
+        siteInfo,
+    };
+};
+export const loadConfig = measureDuration(tLoadConfig, 'resolve_config');
 // Retrieve initial configuration.
 // In the buildbot and CLI, we re-use the already parsed `@netlify/config`
 // return value which is passed as `cachedConfig`/`cachedConfigPath`.
 const resolveInitialConfig = async function (configOpts, cachedConfig, cachedConfigPath) {
-  return await resolveConfig({ ...configOpts, cachedConfig, cachedConfigPath })
-}
-
+    return await resolveConfig({ ...configOpts, cachedConfig, cachedConfigPath });
+};
 const logConfigInfo = function ({ logs, configPath, buildDir, netlifyConfig, context, debug }) {
-  logBuildDir(logs, buildDir)
-  logConfigPath(logs, configPath)
-  logConfig({ logs, netlifyConfig, debug })
-  logContext(logs, context)
-}
-
+    logBuildDir(logs, buildDir);
+    logConfigPath(logs, configPath);
+    logConfig({ logs, netlifyConfig, debug });
+    logContext(logs, context);
+};
 // Retrieve the configuration after it's been changed.
 // This ensures any configuration changes done by plugins is validated and
 // normalized.
@@ -122,65 +82,40 @@ const logConfigInfo = function ({ logs, configPath, buildDir, netlifyConfig, con
 // Errors are propagated and assigned to the specific plugin or core step
 // which changed the configuration.
 export const resolveUpdatedConfig = async function (configOpts, configMutations) {
-  try {
-    return await resolveConfig({ ...configOpts, configMutations, debug: false })
-  } catch (error) {
-    changeErrorType(error, 'resolveConfig', 'pluginValidation')
-    throw error
-  }
-}
-
+    try {
+        return await resolveConfig({ ...configOpts, configMutations, debug: false });
+    }
+    catch (error) {
+        changeErrorType(error, 'resolveConfig', 'pluginValidation');
+        throw error;
+    }
+};
 // If the configuration was changed, persist it to `netlify.toml`.
 // If `netlify.toml` does not exist, create it inside repository root.
 // This is only done when `saveConfig` is `true`. This allows performing this
 // in the buildbot but not in local builds, since only the latter run in a
 // container and we want to avoid saving files on local machines.
-export const saveUpdatedConfig = async function ({
-  configMutations,
-  buildDir,
-  repositoryRoot,
-  configPath = `${repositoryRoot}/netlify.toml`,
-  headersPath,
-  redirectsPath,
-  logs,
-  featureFlags,
-  context,
-  branch,
-  debug,
-  saveConfig,
-}) {
-  if (!saveConfig) {
-    return
-  }
-
-  await updateConfig(configMutations, {
-    buildDir,
-    configPath,
-    headersPath,
-    redirectsPath,
-    context,
-    branch,
-    logs,
-    featureFlags,
-  })
-
-  await logConfigOnUpload({ logs, configPath, debug })
-  await logHeadersOnUpload({ logs, headersPath, debug })
-  await logRedirectsOnUpload({ logs, redirectsPath, debug })
-}
-
-export const restoreUpdatedConfig = async function ({
-  configMutations,
-  buildDir,
-  repositoryRoot,
-  configPath = `${repositoryRoot}/netlify.toml`,
-  headersPath,
-  redirectsPath,
-  saveConfig,
-}) {
-  if (!saveConfig) {
-    return
-  }
-
-  await restoreConfig(configMutations, { buildDir, configPath, headersPath, redirectsPath })
-}
+export const saveUpdatedConfig = async function ({ configMutations, buildDir, repositoryRoot, configPath = `${repositoryRoot}/netlify.toml`, headersPath, redirectsPath, logs, featureFlags, context, branch, debug, saveConfig, }) {
+    if (!saveConfig) {
+        return;
+    }
+    await updateConfig(configMutations, {
+        buildDir,
+        configPath,
+        headersPath,
+        redirectsPath,
+        context,
+        branch,
+        logs,
+        featureFlags,
+    });
+    await logConfigOnUpload({ logs, configPath, debug });
+    await logHeadersOnUpload({ logs, headersPath, debug });
+    await logRedirectsOnUpload({ logs, redirectsPath, debug });
+};
+export const restoreUpdatedConfig = async function ({ configMutations, buildDir, repositoryRoot, configPath = `${repositoryRoot}/netlify.toml`, headersPath, redirectsPath, saveConfig, }) {
+    if (!saveConfig) {
+        return;
+    }
+    await restoreConfig(configMutations, { buildDir, configPath, headersPath, redirectsPath });
+};

package/lib/core/constants.js

@@ -1,156 +1,116 @@
-import { relative, normalize } from 'path'
-
-import { getCacheDir } from '@netlify/cache-utils'
-import mapObj from 'map-obj'
-import { pathExists } from 'path-exists'
-
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-
+import { relative, normalize } from 'path';
+import { getCacheDir } from '@netlify/cache-utils';
+import mapObj from 'map-obj';
+import { pathExists } from 'path-exists';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
 // Retrieve constants passed to plugins
-export const getConstants = async function ({
-  configPath,
-  buildDir,
-  functionsDistDir,
-  edgeFunctionsDistDir,
-  cacheDir,
-  netlifyConfig,
-  siteInfo: { id: siteId },
-  apiHost,
-  token,
-  mode,
-}) {
-  const isLocal = mode !== 'buildbot'
-  const normalizedCacheDir = getCacheDir({ cacheDir, cwd: buildDir })
-
-  const constants = {
-    // Path to the Netlify configuration file
-    CONFIG_PATH: configPath,
-    // The directory where built serverless functions are placed before deployment
-    FUNCTIONS_DIST: functionsDistDir,
-    // The directory where built Edge Functions are placed before deployment
-    EDGE_FUNCTIONS_DIST: edgeFunctionsDistDir,
-    // Path to the Netlify build cache folder
-    CACHE_DIR: normalizedCacheDir,
-    // Boolean indicating whether the build was run locally (Netlify CLI) or in the production CI
-    IS_LOCAL: isLocal,
-    // The version of Netlify Build
-    NETLIFY_BUILD_VERSION: ROOT_PACKAGE_JSON.version,
-    // The Netlify Site ID
-    SITE_ID: siteId,
-    // The Netlify API access token
-    NETLIFY_API_TOKEN: token,
-    // The Netlify API host
-    NETLIFY_API_HOST: apiHost,
-    // The directory where internal functions (i.e. generated programmatically
-    // via plugins or others) live
-    INTERNAL_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_FUNCTIONS_SRC}`,
-    // The directory where internal Edge Functions (i.e. generated programmatically
-    // via plugins or others) live
-    INTERNAL_EDGE_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_EDGE_FUNCTIONS_SRC}`,
-  }
-  const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig })
-  return constantsA
-}
-
-const INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions'
-const INTERNAL_FUNCTIONS_SRC = '.netlify/functions-internal'
-
+export const getConstants = async function ({ configPath, buildDir, functionsDistDir, edgeFunctionsDistDir, cacheDir, netlifyConfig, siteInfo: { id: siteId }, apiHost, token, mode, }) {
+    const isLocal = mode !== 'buildbot';
+    const normalizedCacheDir = getCacheDir({ cacheDir, cwd: buildDir });
+    const constants = {
+        // Path to the Netlify configuration file
+        CONFIG_PATH: configPath,
+        // The directory where built serverless functions are placed before deployment
+        FUNCTIONS_DIST: functionsDistDir,
+        // The directory where built Edge Functions are placed before deployment
+        EDGE_FUNCTIONS_DIST: edgeFunctionsDistDir,
+        // Path to the Netlify build cache folder
+        CACHE_DIR: normalizedCacheDir,
+        // Boolean indicating whether the build was run locally (Netlify CLI) or in the production CI
+        IS_LOCAL: isLocal,
+        // The version of Netlify Build
+        NETLIFY_BUILD_VERSION: ROOT_PACKAGE_JSON.version,
+        // The Netlify Site ID
+        SITE_ID: siteId,
+        // The Netlify API access token
+        NETLIFY_API_TOKEN: token,
+        // The Netlify API host
+        NETLIFY_API_HOST: apiHost,
+        // The directory where internal functions (i.e. generated programmatically
+        // via plugins or others) live
+        INTERNAL_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_FUNCTIONS_SRC}`,
+        // The directory where internal Edge Functions (i.e. generated programmatically
+        // via plugins or others) live
+        INTERNAL_EDGE_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_EDGE_FUNCTIONS_SRC}`,
+    };
+    const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig });
+    return constantsA;
+};
+const INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions';
+const INTERNAL_FUNCTIONS_SRC = '.netlify/functions-internal';
 // Retrieve constants which might change during the build if a plugin modifies
 // `netlifyConfig` or creates some default directories.
 // Unlike readonly constants, this is called again before each build step.
-export const addMutableConstants = async function ({
-  constants,
-  buildDir,
-  netlifyConfig: {
-    build: { publish, edge_functions: edgeFunctions },
-    functionsDirectory,
-  },
-}) {
-  const constantsA = {
-    ...constants,
-    // Directory that contains the deploy-ready HTML files and assets generated by the build
-    PUBLISH_DIR: publish,
-    // The directory where function source code lives
-    FUNCTIONS_SRC: functionsDirectory,
-    // The directory where Edge Functions source code lives
-    EDGE_FUNCTIONS_SRC: edgeFunctions,
-  }
-  const constantsB = await addDefaultConstants(constantsA, buildDir)
-  const constantsC = normalizeConstantsPaths(constantsB, buildDir)
-  return constantsC
-}
-
+export const addMutableConstants = async function ({ constants, buildDir, netlifyConfig: { build: { publish, edge_functions: edgeFunctions }, functionsDirectory, }, }) {
+    const constantsA = {
+        ...constants,
+        // Directory that contains the deploy-ready HTML files and assets generated by the build
+        PUBLISH_DIR: publish,
+        // The directory where function source code lives
+        FUNCTIONS_SRC: functionsDirectory,
+        // The directory where Edge Functions source code lives
+        EDGE_FUNCTIONS_SRC: edgeFunctions,
+    };
+    const constantsB = await addDefaultConstants(constantsA, buildDir);
+    const constantsC = normalizeConstantsPaths(constantsB, buildDir);
+    return constantsC;
+};
 // Some `constants` have a default value when a specific file exists.
 // Those default values are assigned by `@netlify/config`. However, the build
 // command or plugins might create those specific files, in which case, the
 // related `constant` should be updated, unless the user has explicitly
 // configured it.
 const addDefaultConstants = async function (constants, buildDir) {
-  const newConstants = await Promise.all(
-    DEFAULT_PATHS.map(({ constantName, defaultPath }) =>
-      addDefaultConstant({ constants, constantName, defaultPath, buildDir }),
-    ),
-  )
-  return Object.assign({}, constants, ...newConstants)
-}
-
+    const newConstants = await Promise.all(DEFAULT_PATHS.map(({ constantName, defaultPath }) => addDefaultConstant({ constants, constantName, defaultPath, buildDir })));
+    return Object.assign({}, constants, ...newConstants);
+};
 // The current directory is the build directory, which is correct, so we don't
 // need to resolve paths
 const DEFAULT_PATHS = [
-  // @todo Remove once we drop support for the legacy default functions directory.
-  { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify-automatic-functions' },
-  { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify/functions' },
-  { constantName: 'EDGE_FUNCTIONS_SRC', defaultPath: 'netlify/edge-functions' },
-]
-
+    // @todo Remove once we drop support for the legacy default functions directory.
+    { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify-automatic-functions' },
+    { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify/functions' },
+    { constantName: 'EDGE_FUNCTIONS_SRC', defaultPath: 'netlify/edge-functions' },
+];
 const addDefaultConstant = async function ({ constants, constantName, defaultPath, buildDir }) {
-  // Configuration paths are relative to the build directory.
-  if (!isEmptyValue(constants[constantName]) || !(await pathExists(`${buildDir}/${defaultPath}`))) {
-    return {}
-  }
-
-  // However, the plugin child process' current directory is the build directory,
-  // so we can pass the relative path instead of the resolved absolute path.
-  return { [constantName]: defaultPath }
-}
-
+    // Configuration paths are relative to the build directory.
+    if (!isEmptyValue(constants[constantName]) || !(await pathExists(`${buildDir}/${defaultPath}`))) {
+        return {};
+    }
+    // However, the plugin child process' current directory is the build directory,
+    // so we can pass the relative path instead of the resolved absolute path.
+    return { [constantName]: defaultPath };
+};
 const normalizeConstantsPaths = function (constants, buildDir) {
-  return mapObj(constants, (key, path) => [key, normalizePath(path, buildDir, key)])
-}
-
+    return mapObj(constants, (key, path) => [key, normalizePath(path, buildDir, key)]);
+};
 // The current directory is `buildDir`. Most constants are inside this `buildDir`.
 // Instead of passing absolute paths, we pass paths relative to `buildDir`, so
 // that logs are less verbose.
 const normalizePath = function (path, buildDir, key) {
-  if (isEmptyValue(path) || !CONSTANT_PATHS.has(key)) {
-    return path
-  }
-
-  const pathA = normalize(path)
-
-  if (pathA === buildDir) {
-    return '.'
-  }
-
-  if (pathA.startsWith(buildDir)) {
-    return relative(buildDir, pathA)
-  }
-
-  return pathA
-}
-
+    if (isEmptyValue(path) || !CONSTANT_PATHS.has(key)) {
+        return path;
+    }
+    const pathA = normalize(path);
+    if (pathA === buildDir) {
+        return '.';
+    }
+    if (pathA.startsWith(buildDir)) {
+        return relative(buildDir, pathA);
+    }
+    return pathA;
+};
 const isEmptyValue = function (path) {
-  return path === undefined || path === ''
-}
-
+    return path === undefined || path === '';
+};
 const CONSTANT_PATHS = new Set([
-  'CONFIG_PATH',
-  'PUBLISH_DIR',
-  'FUNCTIONS_SRC',
-  'FUNCTIONS_DIST',
-  'INTERNAL_EDGE_FUNCTIONS_SRC',
-  'INTERNAL_FUNCTIONS_SRC',
-  'EDGE_FUNCTIONS_DIST',
-  'EDGE_FUNCTIONS_SRC',
-  'CACHE_DIR',
-])
+    'CONFIG_PATH',
+    'PUBLISH_DIR',
+    'FUNCTIONS_SRC',
+    'FUNCTIONS_DIST',
+    'INTERNAL_EDGE_FUNCTIONS_SRC',
+    'INTERNAL_FUNCTIONS_SRC',
+    'EDGE_FUNCTIONS_DIST',
+    'EDGE_FUNCTIONS_SRC',
+    'CACHE_DIR',
+]);

package/lib/core/dev.js

@@ -1,31 +1,27 @@
-import { handleBuildError } from '../error/handle.js'
-
-import { execBuild, startBuild } from './build.js'
-import { getSeverity } from './severity.js'
-
+import { handleBuildError } from '../error/handle.js';
+import { execBuild, startBuild } from './build.js';
+import { getSeverity } from './severity.js';
 export const startDev = async (devCommand, flags = {}) => {
-  const { errorMonitor, mode, logs, debug, testOpts, ...normalizedFlags } = startBuild(flags)
-  const errorParams = { errorMonitor, mode, logs, debug, testOpts }
-
-  try {
-    const { netlifyConfig: netlifyConfigA, configMutations } = await execBuild({
-      ...normalizedFlags,
-      errorMonitor,
-      errorParams,
-      mode,
-      logs,
-      debug,
-      testOpts,
-      timeline: 'dev',
-      devCommand,
-    })
-    const { success, severityCode } = getSeverity('success')
-
-    return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations }
-  } catch (error) {
-    const { severity, message, stack } = await handleBuildError(error, errorParams)
-    const { success, severityCode } = getSeverity(severity)
-
-    return { success, severityCode, logs, error: { message, stack } }
-  }
-}
+    const { errorMonitor, mode, logs, debug, testOpts, ...normalizedFlags } = startBuild(flags);
+    const errorParams = { errorMonitor, mode, logs, debug, testOpts };
+    try {
+        const { netlifyConfig: netlifyConfigA, configMutations } = await execBuild({
+            ...normalizedFlags,
+            errorMonitor,
+            errorParams,
+            mode,
+            logs,
+            debug,
+            testOpts,
+            timeline: 'dev',
+            devCommand,
+        });
+        const { success, severityCode } = getSeverity('success');
+        return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+    }
+    catch (error) {
+        const { severity, message, stack } = await handleBuildError(error, errorParams);
+        const { success, severityCode } = getSeverity(severity);
+        return { success, severityCode, logs, error: { message, stack } };
+    }
+};

package/lib/core/dry.js

@@ -1,39 +1,21 @@
-import pFilter from 'p-filter'
-
-import { logDryRunStart, logDryRunStep, logDryRunEnd } from '../log/messages/dry.js'
-import { runsOnlyOnBuildFailure } from '../plugins/events.js'
-
+import pFilter from 'p-filter';
+import { logDryRunStart, logDryRunStep, logDryRunEnd } from '../log/messages/dry.js';
+import { runsOnlyOnBuildFailure } from '../plugins/events.js';
 // If the `dry` flag is specified, do a dry run
 export const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }) {
-  const successSteps = await pFilter(steps, ({ event, condition }) =>
-    shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }),
-  )
-  const eventWidth = Math.max(...successSteps.map(getEventLength))
-  const stepsCount = successSteps.length
-
-  logDryRunStart({ logs, eventWidth, stepsCount })
-
-  successSteps.forEach((step, index) => {
-    logDryRunStep({ logs, step, index, netlifyConfig, eventWidth, stepsCount })
-  })
-
-  logDryRunEnd(logs)
-}
-
-const shouldIncludeStep = async function ({
-  buildDir,
-  event,
-  condition,
-  netlifyConfig,
-  constants,
-  buildbotServerSocket,
-}) {
-  return (
-    !runsOnlyOnBuildFailure(event) &&
-    (condition === undefined || (await condition({ buildDir, constants, netlifyConfig, buildbotServerSocket })))
-  )
-}
-
+    const successSteps = await pFilter(steps, ({ event, condition }) => shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }));
+    const eventWidth = Math.max(...successSteps.map(getEventLength));
+    const stepsCount = successSteps.length;
+    logDryRunStart({ logs, eventWidth, stepsCount });
+    successSteps.forEach((step, index) => {
+        logDryRunStep({ logs, step, index, netlifyConfig, eventWidth, stepsCount });
+    });
+    logDryRunEnd(logs);
+};
+const shouldIncludeStep = async function ({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket, }) {
+    return (!runsOnlyOnBuildFailure(event) &&
+        (condition === undefined || (await condition({ buildDir, constants, netlifyConfig, buildbotServerSocket }))));
+};
 const getEventLength = function ({ event }) {
-  return event.length
-}
+    return event.length;
+};