@netlify/config 18.2.5-rc → 18.2.5

package/lib/env/main.js

@@ -0,0 +1,150 @@
+import omit from 'omit.js';
+import { removeFalsy } from '../utils/remove_falsy.js';
+import { getEnvelope } from './envelope.js';
+import { getGitEnv } from './git.js';
+// Retrieve this site's environment variable. Also take into account team-wide
+// environment variables and addons.
+// The buildbot already has the right environment variables. This is mostly
+// meant so that local builds can mimic production builds
+// TODO: add `netlify.toml` `build.environment`, after normalization
+// TODO: add `CONTEXT` and others
+export const getEnv = async function ({ api, mode, config, siteInfo, accounts, addons, buildDir, branch, deployId, buildId, context, }) {
+    if (mode === 'buildbot') {
+        return {};
+    }
+    const generalEnv = await getGeneralEnv({ siteInfo, buildDir, branch, deployId, buildId, context });
+    const [accountEnv, addonsEnv, uiEnv, configFileEnv] = await getUserEnv({ api, config, siteInfo, accounts, addons });
+    // Sources of environment variables, in descending order of precedence.
+    const sources = [
+        { key: 'configFile', values: configFileEnv },
+        { key: 'ui', values: uiEnv },
+        { key: 'addons', values: addonsEnv },
+        { key: 'account', values: accountEnv },
+        { key: 'general', values: generalEnv },
+    ];
+    // A hash mapping names of environment variables to objects containing the following properties:
+    // - sources: List of sources where the environment variable was found. The first element is the source that
+    //   actually provided the variable (i.e. the one with the highest precedence).
+    // - value: The value of the environment variable.
+    const env = new Map();
+    sources.forEach((source) => {
+        Object.keys(source.values).forEach((key) => {
+            if (env.has(key)) {
+                const { sources: envSources, value } = env.get(key);
+                env.set(key, {
+                    sources: [...envSources, source.key],
+                    value: convertToString(value),
+                });
+            }
+            else {
+                env.set(key, {
+                    sources: [source.key],
+                    value: convertToString(source.values[key]),
+                });
+            }
+        });
+    });
+    return Object.fromEntries(env);
+};
+const convertToString = (value) => {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return value.toString();
+};
+// Environment variables not set by users, but meant to mimic the production
+// environment.
+const getGeneralEnv = async function ({ siteInfo, siteInfo: { id, name }, buildDir, branch, deployId, buildId, context, }) {
+    const gitEnv = await getGitEnv(buildDir, branch);
+    const deployUrls = getDeployUrls({ siteInfo, branch, deployId });
+    return removeFalsy({
+        SITE_ID: id,
+        SITE_NAME: name,
+        DEPLOY_ID: deployId,
+        BUILD_ID: buildId,
+        ...deployUrls,
+        CONTEXT: context,
+        NETLIFY_LOCAL: 'true',
+        ...gitEnv,
+        // Localization
+        LANG: 'en_US.UTF-8',
+        LANGUAGE: 'en_US:en',
+        LC_ALL: 'en_US.UTF-8',
+        // Disable telemetry of some tools
+        GATSBY_TELEMETRY_DISABLED: '1',
+        NEXT_TELEMETRY_DISABLED: '1',
+    });
+};
+const getDeployUrls = function ({ siteInfo: { name = DEFAULT_SITE_NAME, ssl_url: sslUrl, build_settings: { repo_url: REPOSITORY_URL } = {} }, branch, deployId, }) {
+    return {
+        URL: sslUrl,
+        REPOSITORY_URL,
+        DEPLOY_PRIME_URL: `https://${branch}--${name}${NETLIFY_DEFAULT_DOMAIN}`,
+        DEPLOY_URL: `https://${deployId}--${name}${NETLIFY_DEFAULT_DOMAIN}`,
+    };
+};
+const NETLIFY_DEFAULT_DOMAIN = '.netlify.app';
+// `site.name` is `undefined` when there is no token or siteId
+const DEFAULT_SITE_NAME = 'site-name';
+// Environment variables specified by the user
+const getUserEnv = async function ({ api, config, siteInfo, accounts, addons }) {
+    const accountEnv = await getAccountEnv({ api, siteInfo, accounts });
+    const addonsEnv = getAddonsEnv(addons);
+    const uiEnv = getUiEnv({ siteInfo });
+    const configFileEnv = getConfigFileEnv({ config });
+    return [accountEnv, addonsEnv, uiEnv, configFileEnv].map(cleanUserEnv);
+};
+// Account-wide environment variables
+const getAccountEnv = async function ({ api, siteInfo, accounts }) {
+    if (siteInfo.use_envelope) {
+        const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug });
+        return envelope;
+    }
+    const { site_env: siteEnv = {} } = accounts.find(({ slug }) => slug === siteInfo.account_slug) || {};
+    return siteEnv;
+};
+// Environment variables from addons
+const getAddonsEnv = function (addons) {
+    return Object.assign({}, ...addons.map(getAddonEnv));
+};
+const getAddonEnv = function ({ env }) {
+    return env;
+};
+// Site-specific environment variables set in the UI
+const getUiEnv = function ({ siteInfo: { build_settings: { env = {} } = {} } }) {
+    return env;
+};
+// Site-specific environment variables set in netlify.toml
+const getConfigFileEnv = function ({ config: { build: { environment = {} }, }, }) {
+    return environment;
+};
+// Some environment variables cannot be overridden by configuration
+const cleanUserEnv = function (userEnv) {
+    return omit.default(userEnv, READONLY_ENV);
+};
+const READONLY_ENV = [
+    // Set in local builds
+    'BRANCH',
+    'CACHED_COMMIT_REF',
+    'COMMIT_REF',
+    'CONTEXT',
+    'HEAD',
+    'REPOSITORY_URL',
+    'URL',
+    // CI builds set NETLIFY=true while CLI and programmatic builds set
+    // NETLIFY_LOCAL=true
+    'NETLIFY',
+    'NETLIFY_LOCAL',
+    // Not set in local builds because there is no CI build/deploy, incoming hooks nor PR
+    'INCOMING_HOOK_BODY',
+    'INCOMING_HOOK_TITLE',
+    'INCOMING_HOOK_URL',
+    'NETLIFY_BUILD_BASE',
+    'NETLIFY_BUILD_LIFECYCLE_TRIAL',
+    'NETLIFY_IMAGES_CDN_DOMAIN',
+    'PULL_REQUEST',
+    'REVIEW_ID',
+];

package/lib/error.js

@@ -0,0 +1,28 @@
+// We distinguish between errors thrown intentionally and uncaught exceptions
+// (such as bugs) with a `customErrorInfo.type` property.
+export const throwUserError = function (messageOrError, error) {
+    const errorA = getError(messageOrError, error);
+    errorA[CUSTOM_ERROR_KEY] = { type: USER_ERROR_TYPE };
+    throw errorA;
+};
+// Can pass either `message`, `error` or `message, error`
+const getError = function (messageOrError, error) {
+    if (messageOrError instanceof Error) {
+        return messageOrError;
+    }
+    if (error === undefined) {
+        return new Error(messageOrError);
+    }
+    error.message = `${messageOrError}\n${error.message}`;
+    return error;
+};
+export const isUserError = function (error) {
+    return (canHaveErrorInfo(error) && error[CUSTOM_ERROR_KEY] !== undefined && error[CUSTOM_ERROR_KEY].type === USER_ERROR_TYPE);
+};
+// Exceptions that are not objects (including `Error` instances) cannot have an
+// `CUSTOM_ERROR_KEY` property
+const canHaveErrorInfo = function (error) {
+    return error != null;
+};
+const CUSTOM_ERROR_KEY = 'customErrorInfo';
+const USER_ERROR_TYPE = 'resolveConfig';

package/lib/events.js

@@ -0,0 +1,21 @@
+// List of build plugins events
+export const EVENTS = [
+    // Before build command
+    'onPreBuild',
+    // After build command, before Functions bundling
+    'onBuild',
+    // After Functions bundling
+    'onPostBuild',
+    // After build success
+    'onSuccess',
+    // After build error
+    'onError',
+    // After build error or success
+    'onEnd',
+];
+export const DEV_EVENTS = [
+    // Before dev command
+    'onPreDev',
+    // The dev command
+    'onDev',
+];

package/lib/files.js

@@ -0,0 +1,83 @@
+import { resolve, relative, parse } from 'path';
+import { getProperty, setProperty, deleteProperty } from 'dot-prop';
+import { pathExists } from 'path-exists';
+import { throwUserError } from './error.js';
+import { mergeConfigs } from './merge.js';
+import { isTruthy } from './utils/remove_falsy.js';
+// Make configuration paths relative to `buildDir` and converts them to
+// absolute paths
+export const resolveConfigPaths = async function ({ config, repositoryRoot, buildDir, baseRelDir }) {
+    const baseRel = baseRelDir ? buildDir : repositoryRoot;
+    const configA = resolvePaths(config, FILE_PATH_CONFIG_PROPS, baseRel, repositoryRoot);
+    const configB = await addDefaultPaths(configA, repositoryRoot, baseRel);
+    return configB;
+};
+// All file paths in the configuration file are are relative to `buildDir`
+// (if `baseRelDir` is `true`).
+const FILE_PATH_CONFIG_PROPS = ['functionsDirectory', 'build.publish', 'build.edge_functions'];
+const resolvePaths = function (config, propNames, baseRel, repositoryRoot) {
+    return propNames.reduce((configA, propName) => resolvePathProp(configA, propName, baseRel, repositoryRoot), config);
+};
+const resolvePathProp = function (config, propName, baseRel, repositoryRoot) {
+    const path = getProperty(config, propName);
+    if (!isTruthy(path)) {
+        deleteProperty(config, propName);
+        return config;
+    }
+    return setProperty(config, propName, resolvePath(repositoryRoot, baseRel, path, propName));
+};
+export const resolvePath = function (repositoryRoot, baseRel, originalPath, propName) {
+    if (!isTruthy(originalPath)) {
+        return;
+    }
+    const path = originalPath.replace(LEADING_SLASH_REGEXP, '');
+    const pathA = resolve(baseRel, path);
+    validateInsideRoot(originalPath, pathA, repositoryRoot, propName);
+    return pathA;
+};
+// We allow paths in configuration file to start with /
+// In that case, those are actually relative paths not absolute.
+const LEADING_SLASH_REGEXP = /^\/+/;
+// We ensure all file paths are within the repository root directory.
+// However we allow file paths to be outside of the build directory, since this
+// can be convenient in monorepo setups.
+const validateInsideRoot = function (originalPath, path, repositoryRoot, propName) {
+    if (relative(repositoryRoot, path).startsWith('..') || getWindowsDrive(repositoryRoot) !== getWindowsDrive(path)) {
+        throwUserError(`Configuration property "${propName}" "${originalPath}" must be inside the repository root directory.`);
+    }
+};
+const getWindowsDrive = function (path) {
+    return parse(path).root;
+};
+// Some configuration properties have default values that are only set if a
+// specific directory/file exists in the build directory
+const addDefaultPaths = async function (config, repositoryRoot, baseRel) {
+    const defaultPathsConfigs = await Promise.all(DEFAULT_PATHS.map(({ defaultPath, getConfig, propName }) => addDefaultPath({ repositoryRoot, baseRel, defaultPath, getConfig, propName })));
+    const defaultPathsConfigsA = defaultPathsConfigs.filter(Boolean);
+    return mergeConfigs([...defaultPathsConfigsA, config]);
+};
+const DEFAULT_PATHS = [
+    // @todo Remove once we drop support for the legacy default functions directory.
+    {
+        getConfig: (directory) => ({ functionsDirectory: directory, functionsDirectoryOrigin: 'default-v1' }),
+        defaultPath: 'netlify-automatic-functions',
+        propName: 'functions.directory',
+    },
+    {
+        getConfig: (directory) => ({ functionsDirectory: directory, functionsDirectoryOrigin: 'default' }),
+        defaultPath: 'netlify/functions',
+        propName: 'functions.directory',
+    },
+    {
+        getConfig: (directory) => ({ build: { edge_functions: directory } }),
+        defaultPath: 'netlify/edge-functions',
+        propName: 'build.edge_functions',
+    },
+];
+const addDefaultPath = async function ({ repositoryRoot, baseRel, defaultPath, getConfig, propName }) {
+    const absolutePath = resolvePath(repositoryRoot, baseRel, defaultPath, propName);
+    if (!(await pathExists(absolutePath))) {
+        return;
+    }
+    return getConfig(absolutePath);
+};

package/lib/functions_config.js

@@ -0,0 +1,67 @@
+import isPlainObj from 'is-plain-obj';
+import { isDefined } from './utils/remove_falsy.js';
+export const bundlers = ['esbuild', 'nft', 'zisi'];
+export const WILDCARD_ALL = '*';
+// Removing the legacy `functions` from the `build` block.
+// Looking for a default directory in the `functions` block, separating it
+// from the rest of the configuration if it exists.
+export const normalizeFunctionsProps = function ({ functions: v1FunctionsDirectory, ...build }, { [WILDCARD_ALL]: wildcardProps, ...functions }) {
+    const functionsA = Object.entries(functions).reduce(normalizeFunctionsProp, { [WILDCARD_ALL]: wildcardProps });
+    const { directory: functionsDirectory, functions: functionsB } = extractFunctionsDirectory(functionsA);
+    const functionsDirectoryProps = getFunctionsDirectoryProps({ functionsDirectory, v1FunctionsDirectory });
+    return { build, functions: functionsB, functionsDirectoryProps };
+};
+// Normalizes a functions configuration object, so that the first level of keys
+// represents function expressions mapped to a configuration object.
+//
+// Example input:
+// {
+//   "external_node_modules": ["one"],
+//   "my-function": { "external_node_modules": ["two"] }
+// }
+//
+// Example output:
+// {
+//   "*": { "external_node_modules": ["one"] },
+//   "my-function": { "external_node_modules": ["two"] }
+// }
+// If `prop` is one of `configProperties``, we might be dealing with a
+// top-level property (i.e. one that targets all functions). We consider
+// that to be the case if the value is an object where all keys are also
+// config properties. If not, it's simply a function with the same name
+// as one of the config properties.
+const normalizeFunctionsProp = (functions, [propName, propValue]) => isConfigProperty(propName) && !isConfigLeaf(propValue)
+    ? { ...functions, [WILDCARD_ALL]: { [propName]: propValue, ...functions[WILDCARD_ALL] } }
+    : { ...functions, [propName]: propValue };
+const isConfigLeaf = (functionConfig) => isPlainObj(functionConfig) && Object.keys(functionConfig).every(isConfigProperty);
+const isConfigProperty = (propName) => FUNCTION_CONFIG_PROPERTIES.has(propName);
+export const FUNCTION_CONFIG_PROPERTIES = new Set([
+    'directory',
+    'external_node_modules',
+    'ignored_node_modules',
+    'included_files',
+    'node_bundler',
+    'schedule',
+]);
+// Takes a functions configuration object and looks for the functions directory
+// definition, returning it under the `directory` key. The rest of the config
+// object is returned under the `functions` key.
+const extractFunctionsDirectory = ({ [WILDCARD_ALL]: { directory, ...wildcardFunctionsConfig }, ...functions }) => ({
+    directory,
+    functions: { ...functions, [WILDCARD_ALL]: wildcardFunctionsConfig },
+});
+const getFunctionsDirectoryProps = ({ functionsDirectory, v1FunctionsDirectory }) => {
+    if (isDefined(functionsDirectory)) {
+        return {
+            functionsDirectory,
+            functionsDirectoryOrigin: 'config',
+        };
+    }
+    if (isDefined(v1FunctionsDirectory)) {
+        return {
+            functionsDirectory: v1FunctionsDirectory,
+            functionsDirectoryOrigin: 'config-v1',
+        };
+    }
+    return {};
+};

package/lib/headers.js

@@ -0,0 +1,20 @@
+import { resolve } from 'path';
+import { parseAllHeaders } from 'netlify-headers-parser';
+import { warnHeadersParsing, warnHeadersCaseSensitivity } from './log/messages.js';
+// Retrieve path to `_headers` file (even if it does not exist yet)
+export const getHeadersPath = function ({ build: { publish } }) {
+    return resolve(publish, HEADERS_FILENAME);
+};
+const HEADERS_FILENAME = '_headers';
+// Add `config.headers`
+export const addHeaders = async function ({ config: { headers: configHeaders, ...config }, headersPath, logs, featureFlags, }) {
+    const { headers, errors } = await parseAllHeaders({
+        headersFiles: [headersPath],
+        configHeaders,
+        minimal: true,
+        featureFlags,
+    });
+    warnHeadersParsing(logs, errors);
+    warnHeadersCaseSensitivity(logs, headers);
+    return { ...config, headers };
+};

package/lib/inline_config.js

@@ -0,0 +1,8 @@
+import { logInlineConfig } from './log/main.js';
+import { applyMutations } from './mutations/apply.js';
+// Retrieve the `--inlineConfig` CLI flag
+export const getInlineConfig = function ({ inlineConfig, configMutations, logs, debug }) {
+    const mutatedInlineConfig = applyMutations(inlineConfig, configMutations);
+    logInlineConfig(mutatedInlineConfig, { logs, debug });
+    return mutatedInlineConfig;
+};

package/lib/log/cleanup.js

@@ -0,0 +1,64 @@
+import filterObj from 'filter-obj';
+import { simplifyConfig } from '../simplify.js';
+// Make sure we are not printing secret values. Use an allow list.
+export const cleanupConfig = function ({ build: { base, command, commandOrigin, environment = {}, edge_functions: edgeFunctions, ignore, processing, publish, publishOrigin, } = {}, headers, headersOrigin, plugins = [], redirects, redirectsOrigin, baseRelDir, functions, functionsDirectory, }) {
+    const environmentA = cleanupEnvironment(environment);
+    const build = {
+        base,
+        command,
+        commandOrigin,
+        environment: environmentA,
+        edge_functions: edgeFunctions,
+        ignore,
+        processing,
+        publish,
+        publishOrigin,
+    };
+    const pluginsA = plugins.map(cleanupPlugin);
+    const netlifyConfig = simplifyConfig({
+        build,
+        plugins: pluginsA,
+        headers,
+        headersOrigin,
+        redirects,
+        redirectsOrigin,
+        baseRelDir,
+        functions,
+        functionsDirectory,
+    });
+    const netlifyConfigA = truncateArray(netlifyConfig, 'headers');
+    const netlifyConfigB = truncateArray(netlifyConfigA, 'redirects');
+    return netlifyConfigB;
+};
+export const cleanupEnvironment = function (environment) {
+    return Object.keys(environment).filter((key) => !BUILDBOT_ENVIRONMENT.has(key));
+};
+// Added by the buildbot. We only want to print environment variables specified
+// by the user.
+const BUILDBOT_ENVIRONMENT = new Set([
+    'BRANCH',
+    'CONTEXT',
+    'DEPLOY_PRIME_URL',
+    'DEPLOY_URL',
+    'GO_VERSION',
+    'NETLIFY_IMAGES_CDN_DOMAIN',
+    'SITE_ID',
+    'SITE_NAME',
+    'URL',
+]);
+const cleanupPlugin = function ({ package: packageName, origin, inputs = {} }) {
+    const inputsA = filterObj(inputs, isPublicInput);
+    return { package: packageName, origin, inputs: inputsA };
+};
+const isPublicInput = function (key, input) {
+    return typeof input === 'boolean';
+};
+// `headers` and `redirects` can be very long, which can take several minutes
+// to print in the build logs. We truncate them before logging.
+const truncateArray = function (netlifyConfig, propName) {
+    const array = netlifyConfig[propName];
+    return Array.isArray(array) && array.length > MAX_ARRAY_LENGTH
+        ? { ...netlifyConfig, [propName]: array.slice(0, MAX_ARRAY_LENGTH) }
+        : netlifyConfig;
+};
+const MAX_ARRAY_LENGTH = 100;

package/lib/log/logger.js

@@ -0,0 +1,36 @@
+import figures from 'figures';
+import { serializeObject } from './serialize.js';
+import { THEME } from './theme.js';
+// When the `buffer` option is true, we return logs instead of printing them
+// on the console. The logs are accumulated in a `logs` array variable.
+export const getBufferLogs = function ({ buffer }) {
+    if (!buffer) {
+        return;
+    }
+    return { stdout: [], stderr: [] };
+};
+// This should be used instead of `console.log()`
+// Printed on stderr because stdout is reserved for the JSON output
+export const log = function (logs, string, { color } = {}) {
+    const stringA = String(string).replace(EMPTY_LINES_REGEXP, EMPTY_LINE);
+    const stringB = color === undefined ? stringA : color(stringA);
+    if (logs !== undefined) {
+        // `logs` is a stateful variable
+        logs.stderr.push(stringB);
+        return;
+    }
+    console.warn(stringB);
+};
+// We need to add a zero width space character in empty lines. Otherwise the
+// buildbot removes those due to a bug: https://github.com/netlify/buildbot/issues/595
+const EMPTY_LINES_REGEXP = /^\s*$/gm;
+const EMPTY_LINE = '\u{200B}';
+export const logWarning = function (logs, string, opts) {
+    log(logs, string, { color: THEME.warningLine, ...opts });
+};
+export const logObject = function (logs, object, opts) {
+    log(logs, serializeObject(object), opts);
+};
+export const logSubHeader = function (logs, string, opts) {
+    log(logs, `\n${figures.pointer} ${string}`, { color: THEME.subHeader, ...opts });
+};

package/lib/log/main.js

@@ -0,0 +1,39 @@
+import { cleanupConfig, cleanupEnvironment } from './cleanup.js';
+import { logObject, logSubHeader } from './logger.js';
+import { cleanupConfigOpts } from './options.js';
+// Log options in debug mode.
+export const logOpts = function (opts, { logs, debug, cachedConfig, cachedConfigPath }) {
+    // In production, print those in the first call to `@netlify/config`, not the
+    // second one done inside `@netlify/build`
+    if (!debug || cachedConfig !== undefined || cachedConfigPath !== undefined) {
+        return;
+    }
+    logSubHeader(logs, 'Initial build environment');
+    logObject(logs, cleanupConfigOpts(opts));
+};
+// Log `defaultConfig` option in debug mode
+export const logDefaultConfig = function (defaultConfig, { logs, debug, baseRelDir }) {
+    if (!debug || defaultConfig === undefined) {
+        return;
+    }
+    logSubHeader(logs, 'UI build settings');
+    logObject(logs, cleanupConfig({ ...defaultConfig, baseRelDir }));
+};
+// Log `inlineConfig` option in debug mode
+export const logInlineConfig = function (initialConfig, { logs, debug }) {
+    if (!debug || Object.keys(initialConfig).length === 0) {
+        return;
+    }
+    logSubHeader(logs, 'Configuration override');
+    logObject(logs, cleanupConfig(initialConfig));
+};
+// Log return value of `@netlify/config` in debug mode
+export const logResult = function ({ configPath, buildDir, config, context, branch, env }, { logs, debug }) {
+    if (!debug) {
+        return;
+    }
+    logSubHeader(logs, 'Resolved build environment');
+    logObject(logs, { configPath, buildDir, context, branch, env: cleanupEnvironment(env) });
+    logSubHeader(logs, 'Resolved config');
+    logObject(logs, cleanupConfig(config));
+};

package/lib/log/messages.js

@@ -0,0 +1,87 @@
+import { throwUserError } from '../error.js';
+import { logWarning } from './logger.js';
+export const ERROR_CALL_TO_ACTION = `Double-check your login status with 'netlify status' or contact support with details of your error.`;
+export const throwOnInvalidTomlSequence = function (invalidSequence) {
+    throwUserError(`In netlify.toml, the following backslash should be escaped: ${invalidSequence}
+The following should be used instead: \\${invalidSequence}`);
+};
+export const warnLegacyFunctionsDirectory = ({ config = {}, logs }) => {
+    const { functionsDirectory, functionsDirectoryOrigin } = config;
+    if (functionsDirectoryOrigin !== 'config-v1') {
+        return;
+    }
+    logWarning(logs, `
+Detected functions directory configuration in netlify.toml under [build] settings.
+We recommend updating netlify.toml to set the functions directory under [functions] settings using the directory property. For example,
+
+[functions]
+  directory = "${functionsDirectory}"`);
+};
+export const warnContextPluginConfig = function (logs, packageName, context) {
+    logWarning(logs, `
+"${packageName}" is installed in the UI, which means that it runs in all deploy contexts, regardless of file-based configuration.
+To run "${packageName}" in the ${context} context only, uninstall the plugin from the site plugins list.`);
+};
+export const throwContextPluginsConfig = function (packageName, context) {
+    throwUserError(`
+"${packageName}" is installed in the UI, which means that it runs in all deploy contexts, regardless of file-based configuration.
+To run "${packageName}" in the ${context} context only, uninstall the plugin from the site plugins list.
+To run "${packageName}" in all contexts, please remove the following section from "netlify.toml".
+
+  [[context.${context}.plugins]]
+  package = "${packageName}"
+`);
+};
+export const warnHeadersParsing = function (logs, errors) {
+    if (errors.length === 0) {
+        return;
+    }
+    const errorMessage = errors.map(getErrorMessage).join('\n\n');
+    logWarning(logs, `
+Warning: some headers have syntax errors:
+
+${errorMessage}`);
+};
+// Headers with different cases are not currently the way users probably
+// intend them to be, so we print a warning message.
+// See issue at https://github.com/netlify/build/issues/2290
+export const warnHeadersCaseSensitivity = function (logs, headers) {
+    const headersA = headers.flatMap(getHeaderNames).filter(isNotDuplicateHeaderName).map(addHeaderLowerCase);
+    const differentCaseHeader = headersA.find(hasHeaderCaseDuplicate);
+    if (differentCaseHeader === undefined) {
+        return;
+    }
+    const { forPath, headerName } = headersA.find((header) => isHeaderCaseDuplicate(header, differentCaseHeader));
+    const sameForPath = forPath === differentCaseHeader.forPath ? ` for "${forPath}"` : '';
+    logWarning(logs, `
+Warning: the same header is set twice with different cases${sameForPath}: "${headerName}" and "${differentCaseHeader.headerName}"`);
+};
+const getHeaderNames = function ({ for: forPath, values = {} }) {
+    return Object.keys(values).map((headerName) => ({ forPath, headerName }));
+};
+const isNotDuplicateHeaderName = function ({ headerName }, index, headers) {
+    return headers.slice(index + 1).every((header) => header.headerName !== headerName);
+};
+const addHeaderLowerCase = function ({ forPath, headerName }) {
+    const lowerHeaderName = headerName.toLowerCase();
+    return { forPath, headerName, lowerHeaderName };
+};
+const hasHeaderCaseDuplicate = function ({ lowerHeaderName }, index, headers) {
+    return headers.slice(index + 1).some((header) => header.lowerHeaderName === lowerHeaderName);
+};
+const isHeaderCaseDuplicate = function ({ headerName, lowerHeaderName }, differentCaseHeader) {
+    return differentCaseHeader.headerName !== headerName && differentCaseHeader.lowerHeaderName === lowerHeaderName;
+};
+export const warnRedirectsParsing = function (logs, errors) {
+    if (errors.length === 0) {
+        return;
+    }
+    const errorMessage = errors.map(getErrorMessage).join('\n\n');
+    logWarning(logs, `
+Warning: some redirects have syntax errors:
+
+${errorMessage}`);
+};
+const getErrorMessage = function ({ message }) {
+    return message;
+};

package/lib/log/options.js

@@ -0,0 +1,29 @@
+import { DEFAULT_FEATURE_FLAGS } from '../options/feature_flags.js';
+import { removeEmptyArray } from '../simplify.js';
+import { removeFalsy } from '../utils/remove_falsy.js';
+// Use an allowlist to prevent printing confidential values.
+export const cleanupConfigOpts = function ({ config, cwd, context, branch, mode, repositoryRoot, siteId, baseRelDir, env = {}, featureFlags = {}, }) {
+    const envA = Object.keys(env);
+    return removeFalsy({
+        config,
+        cwd,
+        context,
+        branch,
+        mode,
+        repositoryRoot,
+        siteId,
+        baseRelDir,
+        ...removeEmptyArray(envA, 'env'),
+        featureFlags: cleanFeatureFlags(featureFlags),
+    });
+};
+// We only show feature flags related to `@netlify/config`.
+// Also, we only print enabled feature flags.
+const cleanFeatureFlags = function (featureFlags) {
+    return Object.entries(featureFlags)
+        .filter(shouldPrintFeatureFlag)
+        .map(([featureFlagName]) => featureFlagName);
+};
+const shouldPrintFeatureFlag = function ([featureFlagName, enabled]) {
+    return enabled && featureFlagName in DEFAULT_FEATURE_FLAGS;
+};

package/lib/log/serialize.js

@@ -0,0 +1,4 @@
+import { dump } from 'js-yaml';
+export const serializeObject = function (object) {
+    return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd();
+};

package/lib/log/theme.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+// Color theme. Please use this instead of requiring chalk directly, to ensure
+// consistent colors.
+export const THEME = {
+    // Single lines used as subheaders
+    subHeader: chalk.cyan.bold,
+    // Single lines used as subheaders indicating an error
+    errorSubHeader: chalk.red.bold,
+    // Same for warnings
+    warningLine: chalk.yellowBright,
+    // One of several words that should be highlighted inside a line
+    highlightWords: chalk.cyan,
+};