@netlify/build 27.20.3 → 27.20.5

package/lib/plugins_core/functions/index.js

@@ -1,161 +1,114 @@
-import { resolve } from 'path'
-
-import { zipFunctions } from '@netlify/zip-it-and-ship-it'
-import { pathExists } from 'path-exists'
-
-import { log } from '../../log/logger.js'
-import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js'
-
-import { getZipError } from './error.js'
-import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js'
-import { getZisiParameters } from './zisi.js'
-
+import { resolve } from 'path';
+import { zipFunctions } from '@netlify/zip-it-and-ship-it';
+import { pathExists } from 'path-exists';
+import { log } from '../../log/logger.js';
+import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js';
+import { getZipError } from './error.js';
+import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js';
+import { getZisiParameters } from './zisi.js';
 // Returns `true` if at least one of the functions has been configured to use
 // esbuild.
-const isUsingEsbuild = (functionsConfig = {}) =>
-  Object.values(functionsConfig).some((configObject) => configObject.node_bundler === 'esbuild')
-
-const zipFunctionsAndLogResults = async ({
-  buildDir,
-  childEnv,
-  featureFlags,
-  functionsConfig,
-  functionsDist,
-  functionsSrc,
-  internalFunctionsSrc,
-  isRunningLocally,
-  logs,
-  repositoryRoot,
-}) => {
-  const zisiParameters = getZisiParameters({
-    buildDir,
-    childEnv,
-    featureFlags,
-    functionsConfig,
-    functionsDist,
-    internalFunctionsSrc,
-    isRunningLocally,
-    repositoryRoot,
-  })
-  const bundler = isUsingEsbuild(functionsConfig) ? 'esbuild' : 'zisi'
-
-  try {
-    // Printing an empty line before bundling output.
-    log(logs, '')
-
-    const sourceDirectories = [internalFunctionsSrc, functionsSrc].filter(Boolean)
-    const results = await zipItAndShipIt.zipFunctions(sourceDirectories, functionsDist, zisiParameters)
-
-    logBundleResults({ logs, results })
-
-    return { bundler }
-  } catch (error) {
-    throw await getZipError(error, functionsSrc)
-  }
-}
-
+const isUsingEsbuild = (functionsConfig = {}) => Object.values(functionsConfig).some((configObject) => configObject.node_bundler === 'esbuild');
+const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, functionsSrc, internalFunctionsSrc, isRunningLocally, logs, repositoryRoot, }) => {
+    const zisiParameters = getZisiParameters({
+        buildDir,
+        childEnv,
+        featureFlags,
+        functionsConfig,
+        functionsDist,
+        internalFunctionsSrc,
+        isRunningLocally,
+        repositoryRoot,
+    });
+    const bundler = isUsingEsbuild(functionsConfig) ? 'esbuild' : 'zisi';
+    try {
+        // Printing an empty line before bundling output.
+        log(logs, '');
+        const sourceDirectories = [internalFunctionsSrc, functionsSrc].filter(Boolean);
+        const results = await zipItAndShipIt.zipFunctions(sourceDirectories, functionsDist, zisiParameters);
+        logBundleResults({ logs, results });
+        return { bundler };
+    }
+    catch (error) {
+        throw await getZipError(error, functionsSrc);
+    }
+};
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
-
-const coreStep = async function ({
-  childEnv,
-  constants: {
-    INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc,
-    IS_LOCAL: isRunningLocally,
-    FUNCTIONS_SRC: relativeFunctionsSrc,
-    FUNCTIONS_DIST: relativeFunctionsDist,
-  },
-  buildDir,
-  logs,
-  netlifyConfig,
-  featureFlags,
-  repositoryRoot,
-}) {
-  const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc)
-  const functionsDist = resolve(buildDir, relativeFunctionsDist)
-  const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc)
-  const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc)
-  const functionsSrcExists = await validateFunctionsSrc({ functionsSrc, logs, relativeFunctionsSrc })
-  const [userFunctions = [], internalFunctions = []] = await getUserAndInternalFunctions({
-    featureFlags,
-    functionsSrc,
-    functionsSrcExists,
-    internalFunctionsSrc,
-    internalFunctionsSrcExists,
-  })
-
-  if (functionsSrc && !functionsSrcExists) {
-    logFunctionsNonExistingDir(logs, relativeFunctionsSrc)
-
-    if (internalFunctions.length !== 0) {
-      log(logs, '')
+const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, logs, netlifyConfig, featureFlags, repositoryRoot, }) {
+    const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc);
+    const functionsDist = resolve(buildDir, relativeFunctionsDist);
+    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc);
+    const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc);
+    const functionsSrcExists = await validateFunctionsSrc({ functionsSrc, logs, relativeFunctionsSrc });
+    const [userFunctions = [], internalFunctions = []] = await getUserAndInternalFunctions({
+        featureFlags,
+        functionsSrc,
+        functionsSrcExists,
+        internalFunctionsSrc,
+        internalFunctionsSrcExists,
+    });
+    if (functionsSrc && !functionsSrcExists) {
+        logFunctionsNonExistingDir(logs, relativeFunctionsSrc);
+        if (internalFunctions.length !== 0) {
+            log(logs, '');
+        }
     }
-  }
-
-  logFunctionsToBundle({
-    logs,
-    userFunctions,
-    userFunctionsSrc: relativeFunctionsSrc,
-    userFunctionsSrcExists: functionsSrcExists,
-    internalFunctions,
-    internalFunctionsSrc: relativeInternalFunctionsSrc,
-  })
-
-  if (userFunctions.length === 0 && internalFunctions.length === 0) {
-    return {}
-  }
-
-  const { bundler } = await zipFunctionsAndLogResults({
-    buildDir,
-    childEnv,
-    featureFlags,
-    functionsConfig: netlifyConfig.functions,
-    functionsDist,
-    functionsSrc,
-    internalFunctionsSrc,
-    isRunningLocally,
-    logs,
-    repositoryRoot,
-  })
-
-  return {
-    tags: {
-      bundler,
-    },
-  }
-}
-
+    logFunctionsToBundle({
+        logs,
+        userFunctions,
+        userFunctionsSrc: relativeFunctionsSrc,
+        userFunctionsSrcExists: functionsSrcExists,
+        internalFunctions,
+        internalFunctionsSrc: relativeInternalFunctionsSrc,
+    });
+    if (userFunctions.length === 0 && internalFunctions.length === 0) {
+        return {};
+    }
+    const { bundler } = await zipFunctionsAndLogResults({
+        buildDir,
+        childEnv,
+        featureFlags,
+        functionsConfig: netlifyConfig.functions,
+        functionsDist,
+        functionsSrc,
+        internalFunctionsSrc,
+        isRunningLocally,
+        logs,
+        repositoryRoot,
+    });
+    return {
+        tags: {
+            bundler,
+        },
+    };
+};
 // We run this core step if at least one of the functions directories (the
 // one configured by the user or the internal one) exists. We use a dynamic
 // `condition` because the directories might be created by the build command
 // or plugins.
 const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC } }) {
-  const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== ''
-
-  if (hasFunctionsSrc) {
-    return true
-  }
-
-  const internalFunctionsSrc = resolve(buildDir, INTERNAL_FUNCTIONS_SRC)
-
-  return await pathExists(internalFunctionsSrc)
-}
-
+    const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== '';
+    if (hasFunctionsSrc) {
+        return true;
+    }
+    const internalFunctionsSrc = resolve(buildDir, INTERNAL_FUNCTIONS_SRC);
+    return await pathExists(internalFunctionsSrc);
+};
 export const bundleFunctions = {
-  event: 'onBuild',
-  coreStep,
-  coreStepId: 'functions_bundling',
-  coreStepName: 'Functions bundling',
-  coreStepDescription: () => 'Functions bundling',
-  condition: hasFunctionsDirectories,
-}
-
+    event: 'onBuild',
+    coreStep,
+    coreStepId: 'functions_bundling',
+    coreStepName: 'Functions bundling',
+    coreStepDescription: () => 'Functions bundling',
+    condition: hasFunctionsDirectories,
+};
 // 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)
-  },
-}
+    async zipFunctions(...args) {
+        return await zipFunctions(...args);
+    },
+};

package/lib/plugins_core/functions/utils.js

@@ -1,66 +1,45 @@
-import { promises as fs } from 'fs'
-import { relative } from 'path'
-
-import { listFunctions } from '@netlify/zip-it-and-ship-it'
-
-import { addErrorInfo } from '../../error/info.js'
-
-import { getZisiFeatureFlags } from './feature_flags.js'
-
+import { promises as fs } from 'fs';
+import { relative } from 'path';
+import { listFunctions } from '@netlify/zip-it-and-ship-it';
+import { addErrorInfo } from '../../error/info.js';
+import { getZisiFeatureFlags } from './feature_flags.js';
 // Returns the `mainFile` of each function found in `functionsSrc`, relative to
 // `functionsSrc`.
 const getRelativeFunctionMainFiles = async function ({ featureFlags, functionsSrc }) {
-  if (functionsSrc === undefined) {
-    return []
-  }
-
-  const zisiFeatureFlags = getZisiFeatureFlags(featureFlags)
-  const functions = await listFunctions(functionsSrc, { featureFlags: zisiFeatureFlags })
-  return functions.map(({ mainFile }) => relative(functionsSrc, mainFile))
-}
-
-export const getUserAndInternalFunctions = ({
-  featureFlags,
-  functionsSrc,
-  functionsSrcExists,
-  internalFunctionsSrc,
-  internalFunctionsSrcExists,
-}) => {
-  const paths = [
-    functionsSrcExists ? functionsSrc : undefined,
-    internalFunctionsSrcExists ? internalFunctionsSrc : undefined,
-  ]
-
-  return Promise.all(paths.map((path) => path && getRelativeFunctionMainFiles({ featureFlags, functionsSrc: path })))
-}
-
+    if (functionsSrc === undefined) {
+        return [];
+    }
+    const zisiFeatureFlags = getZisiFeatureFlags(featureFlags);
+    const functions = await listFunctions(functionsSrc, { featureFlags: zisiFeatureFlags });
+    return functions.map(({ mainFile }) => relative(functionsSrc, mainFile));
+};
+export const getUserAndInternalFunctions = ({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, }) => {
+    const paths = [
+        functionsSrcExists ? functionsSrc : undefined,
+        internalFunctionsSrcExists ? internalFunctionsSrc : undefined,
+    ];
+    return Promise.all(paths.map((path) => path && getRelativeFunctionMainFiles({ featureFlags, functionsSrc: path })));
+};
 // 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.
 export const validateFunctionsSrc = async function ({ functionsSrc, relativeFunctionsSrc }) {
-  if (functionsSrc === undefined) {
-    return false
-  }
-
-  try {
-    const stats = await fs.stat(functionsSrc)
-
-    if (stats.isDirectory()) {
-      return true
+    if (functionsSrc === undefined) {
+        return false;
+    }
+    try {
+        const stats = await fs.stat(functionsSrc);
+        if (stats.isDirectory()) {
+            return true;
+        }
+        const error = new Error(`The Netlify Functions setting should target a directory, not a regular file: ${relativeFunctionsSrc}`);
+        addErrorInfo(error, { type: 'resolveConfig' });
+        throw error;
     }
-
-    const error = new Error(
-      `The Netlify Functions setting should target a directory, not a regular file: ${relativeFunctionsSrc}`,
-    )
-
-    addErrorInfo(error, { type: 'resolveConfig' })
-
-    throw error
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return false
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
     }
-
-    throw error
-  }
-}
+};

package/lib/plugins_core/functions/zisi.js

@@ -1,56 +1,39 @@
-import { join, resolve } from 'path'
-
-import mapObject from 'map-obj'
-
-import { getZisiFeatureFlags } from './feature_flags.js'
-
-export const getZisiParameters = ({
-  buildDir,
-  childEnv,
-  featureFlags,
-  functionsConfig,
-  functionsDist,
-  internalFunctionsSrc,
-  isRunningLocally,
-  repositoryRoot,
-}) => {
-  const nodeVersion = childEnv.AWS_LAMBDA_JS_RUNTIME
-  const manifest = join(functionsDist, 'manifest.json')
-  const config = mapObject(functionsConfig, (expression, object) => [
-    expression,
-    normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally, nodeVersion }),
-  ])
-  const zisiFeatureFlags = getZisiFeatureFlags(featureFlags)
-  // Only internal functions are allowed to have a json config file
-  const configFileDirectories = [resolve(internalFunctionsSrc)]
-
-  return { basePath: buildDir, config, manifest, featureFlags: zisiFeatureFlags, repositoryRoot, configFileDirectories }
-}
-
+import { join, resolve } from 'path';
+import mapObject from 'map-obj';
+import { getZisiFeatureFlags } from './feature_flags.js';
+export const getZisiParameters = ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, repositoryRoot, }) => {
+    const nodeVersion = childEnv.AWS_LAMBDA_JS_RUNTIME;
+    const manifest = join(functionsDist, 'manifest.json');
+    const config = mapObject(functionsConfig, (expression, object) => [
+        expression,
+        normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally, nodeVersion }),
+    ]);
+    const zisiFeatureFlags = getZisiFeatureFlags(featureFlags);
+    // Only internal functions are allowed to have a json config file
+    const configFileDirectories = [resolve(internalFunctionsSrc)];
+    return { basePath: buildDir, config, manifest, featureFlags: zisiFeatureFlags, repositoryRoot, configFileDirectories };
+};
 // The function configuration keys returned by @netlify/config are not an exact
 // match to the properties that @netlify/zip-it-and-ship-it expects. We do that
 // translation here.
 export const normalizeFunctionConfig = ({ buildDir, functionConfig = {}, isRunningLocally, nodeVersion }) => ({
-  externalNodeModules: functionConfig.external_node_modules,
-  includedFiles: functionConfig.included_files,
-  includedFilesBasePath: buildDir,
-  ignoredNodeModules: functionConfig.ignored_node_modules,
-  nodeVersion,
-  schedule: functionConfig.schedule,
-
-  // When the user selects esbuild as the Node bundler, we still want to use
-  // the legacy ZISI bundler as a fallback. Rather than asking the user to
-  // make this decision, we abstract that complexity away by injecting the
-  // fallback behavior ourselves. We do this by transforming the value
-  // `esbuild` into `esbuild_zisi`, which zip-it-and-ship-it understands.
-  nodeBundler: functionConfig.node_bundler === 'esbuild' ? 'esbuild_zisi' : functionConfig.node_bundler,
-
-  // If the build is running in buildbot, we set the Rust target directory to a
-  // path that will get cached in between builds, allowing us to speed up the
-  // build process.
-  rustTargetDirectory: isRunningLocally ? undefined : resolve(buildDir, '.netlify', 'rust-functions-cache', '[name]'),
-
-  // Go functions should be zipped only when building locally. When running in
-  // buildbot, the Go API client will handle the zipping.
-  zipGo: isRunningLocally ? true : undefined,
-})
+    externalNodeModules: functionConfig.external_node_modules,
+    includedFiles: functionConfig.included_files,
+    includedFilesBasePath: buildDir,
+    ignoredNodeModules: functionConfig.ignored_node_modules,
+    nodeVersion,
+    schedule: functionConfig.schedule,
+    // When the user selects esbuild as the Node bundler, we still want to use
+    // the legacy ZISI bundler as a fallback. Rather than asking the user to
+    // make this decision, we abstract that complexity away by injecting the
+    // fallback behavior ourselves. We do this by transforming the value
+    // `esbuild` into `esbuild_zisi`, which zip-it-and-ship-it understands.
+    nodeBundler: functionConfig.node_bundler === 'esbuild' ? 'esbuild_zisi' : functionConfig.node_bundler,
+    // If the build is running in buildbot, we set the Rust target directory to a
+    // path that will get cached in between builds, allowing us to speed up the
+    // build process.
+    rustTargetDirectory: isRunningLocally ? undefined : resolve(buildDir, '.netlify', 'rust-functions-cache', '[name]'),
+    // Go functions should be zipped only when building locally. When running in
+    // buildbot, the Go API client will handle the zipping.
+    zipGo: isRunningLocally ? true : undefined,
+});

package/lib/plugins_core/functions_install/index.js

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

package/lib/plugins_core/list.js

@@ -1,27 +1,20 @@
-import { fileURLToPath } from 'url'
-
-import { LOCAL_INSTALL_PLUGIN_NAME } from '../install/local.js'
-
-const FUNCTIONS_INSTALL_PLUGIN = fileURLToPath(new URL('functions_install/index.js', import.meta.url))
-
+import { fileURLToPath } from 'url';
+import { LOCAL_INSTALL_PLUGIN_NAME } from '../install/local.js';
+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'
-const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGIN_NAME])
-
+const FUNCTIONS_INSTALL_PLUGIN_NAME = '@netlify/plugin-functions-install-core';
+const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGIN_NAME]);
 // Plugins that are installed and enabled by default
 export const listCorePlugins = function ({ FUNCTIONS_SRC }) {
-  const functionsInstallPlugin = getFunctionsInstallPlugin(FUNCTIONS_SRC)
-  return [functionsInstallPlugin].filter(Boolean)
-}
-
+    const functionsInstallPlugin = getFunctionsInstallPlugin(FUNCTIONS_SRC);
+    return [functionsInstallPlugin].filter(Boolean);
+};
 const getFunctionsInstallPlugin = function (FUNCTIONS_SRC) {
-  if (FUNCTIONS_SRC === undefined) {
-    return
-  }
-
-  return { package: FUNCTIONS_INSTALL_PLUGIN_NAME, pluginPath: FUNCTIONS_INSTALL_PLUGIN, optional: true }
-}
-
+    if (FUNCTIONS_SRC === undefined) {
+        return;
+    }
+    return { package: FUNCTIONS_INSTALL_PLUGIN_NAME, pluginPath: FUNCTIONS_INSTALL_PLUGIN, optional: true };
+};
 export const isCorePlugin = function (packageName) {
-  return CORE_PLUGINS.has(packageName)
-}
+    return CORE_PLUGINS.has(packageName);
+};

package/lib/status/add.js

@@ -1,36 +1,30 @@
 // Merge plugin status to the list of plugin statuses.
 export const addStatus = function ({ newStatus, statuses, event, packageName, pluginPackageJson: { version } = {} }) {
-  // Either:
-  //  - `build.command`
-  //  - no status was set
-  if (newStatus === undefined) {
-    return statuses
-  }
-
-  const formerStatus = statuses.find((status) => status.packageName === packageName)
-  if (!canOverrideStatus(formerStatus, newStatus)) {
-    return statuses
-  }
-
-  // Overrides plugin's previous status and add more information
-  const newStatuses = statuses.filter((status) => status !== formerStatus)
-  return [...newStatuses, { ...newStatus, event, packageName, version }]
-}
-
+    // Either:
+    //  - `build.command`
+    //  - no status was set
+    if (newStatus === undefined) {
+        return statuses;
+    }
+    const formerStatus = statuses.find((status) => status.packageName === packageName);
+    if (!canOverrideStatus(formerStatus, newStatus)) {
+        return statuses;
+    }
+    // Overrides plugin's previous status and add more information
+    const newStatuses = statuses.filter((status) => status !== formerStatus);
+    return [...newStatuses, { ...newStatus, event, packageName, version }];
+};
 const canOverrideStatus = function (formerStatus, newStatus) {
-  // No previous status
-  if (formerStatus === undefined) {
-    return true
-  }
-
-  // Implicit statuses can never override
-  if (newStatus.implicit) {
-    return false
-  }
-
-  // Error statuses can only be overwritten by more severe error statuses
-  return STATES.indexOf(formerStatus.state) <= STATES.indexOf(newStatus.state)
-}
-
+    // No previous status
+    if (formerStatus === undefined) {
+        return true;
+    }
+    // Implicit statuses can never override
+    if (newStatus.implicit) {
+        return false;
+    }
+    // Error statuses can only be overwritten by more severe error statuses
+    return STATES.indexOf(formerStatus.state) <= STATES.indexOf(newStatus.state);
+};
 // Possible status states, ordered by severity.
-const STATES = ['success', 'canceled_plugin', 'failed_plugin', 'failed_build']
+const STATES = ['success', 'canceled_plugin', 'failed_plugin', 'failed_build'];

package/lib/status/colors.js

@@ -1,23 +1,18 @@
-import stripAnsi from 'strip-ansi'
-
+import stripAnsi from 'strip-ansi';
 // Remove colors from statuses
 export const removeStatusesColors = function (statuses) {
-  return statuses.map(removeStatusColors)
-}
-
+    return statuses.map(removeStatusColors);
+};
 const removeStatusColors = function (status) {
-  const attributes = COLOR_ATTRIBUTES.map((attribute) => removeAttrColor(status, attribute))
-  return Object.assign({}, status, ...attributes)
-}
-
-const COLOR_ATTRIBUTES = ['title', 'summary', 'text']
-
+    const attributes = COLOR_ATTRIBUTES.map((attribute) => removeAttrColor(status, attribute));
+    return Object.assign({}, status, ...attributes);
+};
+const COLOR_ATTRIBUTES = ['title', 'summary', 'text'];
 const removeAttrColor = function (status, attribute) {
-  const value = status[attribute]
-  if (value === undefined) {
-    return {}
-  }
-
-  const valueA = stripAnsi(value)
-  return { [attribute]: valueA }
-}
+    const value = status[attribute];
+    if (value === undefined) {
+        return {};
+    }
+    const valueA = stripAnsi(value);
+    return { [attribute]: valueA };
+};

package/lib/status/load_error.js

@@ -1,11 +1,10 @@
-import { addErrorInfo } from '../error/info.js'
-import { getFullErrorInfo } from '../error/parse/parse.js'
-import { serializeErrorStatus } from '../error/parse/serialize_status.js'
-
+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
 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 })
-}
+    const fullErrorInfo = getFullErrorInfo({ error, colors: false, debug });
+    const errorStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' });
+    const statuses = [{ ...errorStatus, event: 'load', packageName, version }];
+    addErrorInfo(error, { statuses });
+};