@netlify/config 18.2.4 → 18.2.5

package/lib/simplify.js

@@ -1,103 +1,77 @@
-import isPlainObj from 'is-plain-obj'
-import mapObj from 'map-obj'
-
-import { removeFalsy } from './utils/remove_falsy.js'
-
+import isPlainObj from 'is-plain-obj';
+import mapObj from 'map-obj';
+import { removeFalsy } from './utils/remove_falsy.js';
 // Removes default values (empty objects and arrays) from the configuration.
-export const simplifyConfig = function ({
-  build: { environment, processing: { css, html, images, js, ...processing } = {}, services, ...build } = {},
-  functions,
-  plugins,
-  headers,
-  redirects,
-  context = {},
-  ...config
-}) {
-  const buildA = {
-    ...build,
-    ...simplifyEnvironment(environment),
-    ...removeEmptyObject(
-      {
-        ...processing,
-        ...removeEmptyObject(css, 'css'),
-        ...removeEmptyObject(html, 'html'),
-        ...removeEmptyObject(images, 'images'),
-        ...removeEmptyObject(js, 'js'),
-      },
-      'processing',
-    ),
-    ...removeEmptyObject(services, 'services'),
-  }
-  return removeFalsy({
-    ...config,
-    ...removeEmptyObject(simplifyFunctions(functions), 'functions'),
-    ...removeEmptyObject(buildA, 'build'),
-    ...removeEmptyArray(plugins, 'plugins'),
-    ...removeEmptyArray(headers, 'headers'),
-    ...removeEmptyArray(simplifyRedirects(redirects), 'redirects'),
-    ...removeEmptyObject(simplifyContexts(context), 'context'),
-  })
-}
-
+export const simplifyConfig = function ({ build: { environment, processing: { css, html, images, js, ...processing } = {}, services, ...build } = {}, functions, plugins, headers, redirects, context = {}, ...config }) {
+    const buildA = {
+        ...build,
+        ...simplifyEnvironment(environment),
+        ...removeEmptyObject({
+            ...processing,
+            ...removeEmptyObject(css, 'css'),
+            ...removeEmptyObject(html, 'html'),
+            ...removeEmptyObject(images, 'images'),
+            ...removeEmptyObject(js, 'js'),
+        }, 'processing'),
+        ...removeEmptyObject(services, 'services'),
+    };
+    return removeFalsy({
+        ...config,
+        ...removeEmptyObject(simplifyFunctions(functions), 'functions'),
+        ...removeEmptyObject(buildA, 'build'),
+        ...removeEmptyArray(plugins, 'plugins'),
+        ...removeEmptyArray(headers, 'headers'),
+        ...removeEmptyArray(simplifyRedirects(redirects), 'redirects'),
+        ...removeEmptyObject(simplifyContexts(context), 'context'),
+    });
+};
 const simplifyEnvironment = function (environment) {
-  return Array.isArray(environment)
-    ? removeEmptyArray(environment, 'environment')
-    : removeEmptyObject(environment, 'environment')
-}
-
+    return Array.isArray(environment)
+        ? removeEmptyArray(environment, 'environment')
+        : removeEmptyObject(environment, 'environment');
+};
 const simplifyContexts = function (contextProps) {
-  return mapObj(contextProps, simplifyContextProps)
-}
-
+    return mapObj(contextProps, simplifyContextProps);
+};
 const simplifyContextProps = function (context, contextConfig) {
-  return [context, simplifyConfig(contextConfig)]
-}
-
+    return [context, simplifyConfig(contextConfig)];
+};
 const simplifyFunctions = function (functions) {
-  return isPlainObj(functions) ? Object.entries(functions).reduce(simplifyFunction, {}) : functions
-}
-
+    return isPlainObj(functions) ? Object.entries(functions).reduce(simplifyFunction, {}) : functions;
+};
 const simplifyFunction = function (functions, [key, value]) {
-  return { ...functions, ...removeEmptyObject(value, key) }
-}
-
+    return { ...functions, ...removeEmptyObject(value, key) };
+};
 const simplifyRedirects = function (redirects) {
-  return Array.isArray(redirects) ? redirects.map(simplifyRedirect) : redirects
-}
-
+    return Array.isArray(redirects) ? redirects.map(simplifyRedirect) : redirects;
+};
 const simplifyRedirect = function (redirect) {
-  if (!isPlainObj(redirect)) {
-    return redirect
-  }
-
-  const { force, proxy, query, conditions, headers, ...redirectA } = redirect
-  return {
-    ...redirectA,
-    ...removeDefaultValue(force, 'force', false),
-    ...removeDefaultValue(proxy, 'proxy', false),
-    ...removeEmptyObject(query, 'query'),
-    ...removeEmptyObject(conditions, 'conditions'),
-    ...removeEmptyObject(headers, 'headers'),
-  }
-}
-
+    if (!isPlainObj(redirect)) {
+        return redirect;
+    }
+    const { force, proxy, query, conditions, headers, ...redirectA } = redirect;
+    return {
+        ...redirectA,
+        ...removeDefaultValue(force, 'force', false),
+        ...removeDefaultValue(proxy, 'proxy', false),
+        ...removeEmptyObject(query, 'query'),
+        ...removeEmptyObject(conditions, 'conditions'),
+        ...removeEmptyObject(headers, 'headers'),
+    };
+};
 const removeDefaultValue = function (value, propName, defaultValue) {
-  return value === defaultValue ? {} : { [propName]: value }
-}
-
+    return value === defaultValue ? {} : { [propName]: value };
+};
 export const removeEmptyObject = function (object, propName) {
-  if (!isPlainObj(object)) {
-    return {}
-  }
-
-  const objectA = removeFalsy(object)
-  return Object.keys(objectA).length === 0 ? {} : { [propName]: objectA }
-}
-
+    if (!isPlainObj(object)) {
+        return {};
+    }
+    const objectA = removeFalsy(object);
+    return Object.keys(objectA).length === 0 ? {} : { [propName]: objectA };
+};
 export const removeEmptyArray = function (array, propName) {
-  if (!Array.isArray(array)) {
-    return {}
-  }
-
-  return array.length === 0 ? {} : { [propName]: array }
-}
+    if (!Array.isArray(array)) {
+        return {};
+    }
+    return array.length === 0 ? {} : { [propName]: array };
+};

package/lib/utils/group.js

@@ -1,10 +1,9 @@
 // Group objects according to a key attribute.
 // The key must exist in each object and be a string.
 export const groupBy = function (objects, keyName) {
-  const keys = [...new Set(objects.map((object) => object[keyName]))]
-  return keys.map((key) => groupObjects(objects, keyName, key))
-}
-
+    const keys = [...new Set(objects.map((object) => object[keyName]))];
+    return keys.map((key) => groupObjects(objects, keyName, key));
+};
 const groupObjects = function (objects, keyName, key) {
-  return objects.filter((object) => object[keyName] === key)
-}
+    return objects.filter((object) => object[keyName] === key);
+};

package/lib/utils/remove_falsy.js

@@ -1,18 +1,14 @@
-import filterObj from 'filter-obj'
-
+import filterObj from 'filter-obj';
 // Remove falsy values from object
 export const removeFalsy = function (obj) {
-  return filterObj(obj, (key, value) => isTruthy(value))
-}
-
+    return filterObj(obj, (key, value) => isTruthy(value));
+};
 export const removeUndefined = function (obj) {
-  return filterObj(obj, (key, value) => isDefined(value))
-}
-
+    return filterObj(obj, (key, value) => isDefined(value));
+};
 export const isTruthy = function (value) {
-  return isDefined(value) && (typeof value !== 'string' || value.trim() !== '')
-}
-
+    return isDefined(value) && (typeof value !== 'string' || value.trim() !== '');
+};
 export const isDefined = function (value) {
-  return value !== undefined && value !== null
-}
+    return value !== undefined && value !== null;
+};

package/lib/utils/set.js

@@ -1,33 +1,27 @@
-import isPlainObj from 'is-plain-obj'
-
+import isPlainObj from 'is-plain-obj';
 // Set a property deeply using an array of `keys` which can be either strings
 // (object properties) or integers (array indices).
 // Adds default values when intermediary properties are undefined or have the
 // wrong type. Also extends arrays when they are too small for a given index.
 // Does not mutate.
 export const setProp = function (parent, keys, value) {
-  if (keys.length === 0) {
-    return value
-  }
-
-  if (Number.isInteger(keys[0])) {
-    return setArrayProp(parent, keys, value)
-  }
-
-  return setObjectProp(parent, keys, value)
-}
-
+    if (keys.length === 0) {
+        return value;
+    }
+    if (Number.isInteger(keys[0])) {
+        return setArrayProp(parent, keys, value);
+    }
+    return setObjectProp(parent, keys, value);
+};
 const setArrayProp = function (parent, [index, ...keys], value) {
-  const arrayParent = Array.isArray(parent) ? parent : []
-  const missingItems = index - arrayParent.length + 1
-  // eslint-disable-next-line unicorn/no-new-array
-  const normalizedParent = missingItems > 0 ? [...arrayParent, ...new Array(missingItems)] : arrayParent
-  const newValue = setProp(normalizedParent[index], keys, value)
-  return [...normalizedParent.slice(0, index), newValue, ...normalizedParent.slice(index + 1)]
-}
-
+    const arrayParent = Array.isArray(parent) ? parent : [];
+    const missingItems = index - arrayParent.length + 1;
+    const normalizedParent = missingItems > 0 ? [...arrayParent, ...new Array(missingItems)] : arrayParent;
+    const newValue = setProp(normalizedParent[index], keys, value);
+    return [...normalizedParent.slice(0, index), newValue, ...normalizedParent.slice(index + 1)];
+};
 const setObjectProp = function (parent, [key, ...keys], value) {
-  const objectParent = isPlainObj(parent) ? parent : {}
-  const newValue = setProp(objectParent[key], keys, value)
-  return { ...objectParent, [key]: newValue }
-}
+    const objectParent = isPlainObj(parent) ? parent : {};
+    const newValue = setProp(objectParent[key], keys, value);
+    return { ...objectParent, [key]: newValue };
+};

package/lib/utils/toml.js

@@ -1,23 +1,20 @@
-import { parse as loadToml } from 'toml'
-import tomlify from 'tomlify-j0.4'
-
+import { parse as loadToml } from 'toml';
+import tomlify from 'tomlify-j0.4';
 // Parse from TOML to JavaScript
 export const parseToml = function (configString) {
-  const config = loadToml(configString)
-  // `toml.parse()` returns a object with `null` prototype deeply, which can
-  // sometimes create problems with some utilities. We convert it.
-  // TOML can return Date instances, but JSON will stringify those, and we
-  // don't use Date in netlify.toml, so this should be ok.
-  return JSON.parse(JSON.stringify(config))
-}
-
+    const config = loadToml(configString);
+    // `toml.parse()` returns a object with `null` prototype deeply, which can
+    // sometimes create problems with some utilities. We convert it.
+    // TOML can return Date instances, but JSON will stringify those, and we
+    // don't use Date in netlify.toml, so this should be ok.
+    return JSON.parse(JSON.stringify(config));
+};
 // Serialize JavaScript object to TOML
 export const serializeToml = function (object) {
-  return tomlify.toToml(object, { space: 2, replace: replaceTomlValue })
-}
-
+    return tomlify.toToml(object, { space: 2, replace: replaceTomlValue });
+};
 // `tomlify-j0.4` serializes integers as floats, e.g. `200.0`.
 // This is a problem with `redirects[*].status`.
 const replaceTomlValue = function (key, value) {
-  return Number.isInteger(value) ? String(value) : false
-}
+    return Number.isInteger(value) ? String(value) : false;
+};

package/lib/validate/context.js

@@ -1,6 +1,5 @@
-import { warnContextPluginConfig, throwContextPluginsConfig } from '../log/messages.js'
-import { UI_ORIGIN } from '../origin.js'
-
+import { warnContextPluginConfig, throwContextPluginsConfig } from '../log/messages.js';
+import { UI_ORIGIN } from '../origin.js';
 // The only reason to specify both `[[plugins]]` and
 // `[[contexts.{context}.plugins]]` is to configure context-specific plugin
 // inputs.
@@ -13,45 +12,27 @@ import { UI_ORIGIN } from '../origin.js'
 //    there are no context-specific `inputs`
 //  - The current build is not in `context`
 export const validateContextsPluginsConfig = function ({ contextProps, plugins, contexts, logs }) {
-  Object.entries(contextProps).forEach(([givenContext, givenContextProps]) => {
-    validateContextPluginsConfig({ givenContextProps, plugins, givenContext, contexts, logs })
-  })
-}
-
-const validateContextPluginsConfig = function ({
-  givenContextProps: { plugins: contextPlugins = [] },
-  plugins,
-  givenContext,
-  contexts,
-  logs,
-}) {
-  contextPlugins.forEach((pluginConfig) => {
-    validateContextPluginConfig({ pluginConfig, plugins, givenContext, contexts, logs })
-  })
-}
-
-const validateContextPluginConfig = function ({
-  pluginConfig: { package: packageName, inputs = {} },
-  plugins = [],
-  givenContext,
-  contexts,
-  logs,
-}) {
-  if (!isContextFreePlugin(plugins, packageName)) {
-    return
-  }
-
-  if (isPluginConfigError(contexts, givenContext, inputs)) {
-    throwContextPluginsConfig(packageName, givenContext)
-  }
-
-  warnContextPluginConfig(logs, packageName, givenContext)
-}
-
+    Object.entries(contextProps).forEach(([givenContext, givenContextProps]) => {
+        validateContextPluginsConfig({ givenContextProps, plugins, givenContext, contexts, logs });
+    });
+};
+const validateContextPluginsConfig = function ({ givenContextProps: { plugins: contextPlugins = [] }, plugins, givenContext, contexts, logs, }) {
+    contextPlugins.forEach((pluginConfig) => {
+        validateContextPluginConfig({ pluginConfig, plugins, givenContext, contexts, logs });
+    });
+};
+const validateContextPluginConfig = function ({ pluginConfig: { package: packageName, inputs = {} }, plugins = [], givenContext, contexts, logs, }) {
+    if (!isContextFreePlugin(plugins, packageName)) {
+        return;
+    }
+    if (isPluginConfigError(contexts, givenContext, inputs)) {
+        throwContextPluginsConfig(packageName, givenContext);
+    }
+    warnContextPluginConfig(logs, packageName, givenContext);
+};
 const isContextFreePlugin = function (plugins, packageName) {
-  return plugins.some((plugin) => plugin.package === packageName && plugin.origin === UI_ORIGIN)
-}
-
+    return plugins.some((plugin) => plugin.package === packageName && plugin.origin === UI_ORIGIN);
+};
 const isPluginConfigError = function (contexts, givenContext, inputs) {
-  return contexts.every((context) => context !== givenContext) && Object.keys(inputs).length === 0
-}
+    return contexts.every((context) => context !== givenContext) && Object.keys(inputs).length === 0;
+};

package/lib/validate/example.js

@@ -1,37 +1,30 @@
-import indentString from 'indent-string'
-
-import { THEME } from '../log/theme.js'
-import { serializeToml } from '../utils/toml.js'
-
+import indentString from 'indent-string';
+import { THEME } from '../log/theme.js';
+import { serializeToml } from '../utils/toml.js';
 // Print invalid value and example netlify.toml
 export const getExample = function ({ value, key, prevPath, example, formatInvalid }) {
-  const exampleA = typeof example === 'function' ? example(value, key, prevPath) : example
-  return `
+    const exampleA = typeof example === 'function' ? example(value, key, prevPath) : example;
+    return `
 ${THEME.errorSubHeader('Invalid syntax')}
 
 ${indentString(getInvalidValue(value, prevPath, formatInvalid), 2)}
 
 ${THEME.subHeader('Valid syntax')}
 
-${indentString(serializeToml(exampleA), 2)}`
-}
-
+${indentString(serializeToml(exampleA), 2)}`;
+};
 const getInvalidValue = function (value, prevPath, formatInvalid) {
-  // slice() is temporary, so it does not mutate
-  // eslint-disable-next-line fp/no-mutating-methods
-  const invalidValue = [...prevPath].reverse().reduce(setInvalidValuePart, value)
-
-  // If `formatInvalid` is supplied, we use it to format the invalid value
-  // before serializing it to TOML and printing it.
-  const formattedInvalidValue = typeof formatInvalid === 'function' ? formatInvalid(invalidValue) : invalidValue
-  const invalidValueA = serializeToml(formattedInvalidValue)
-  return invalidValueA
-}
-
+    // slice() is temporary, so it does not mutate
+    const invalidValue = [...prevPath].reverse().reduce(setInvalidValuePart, value);
+    // If `formatInvalid` is supplied, we use it to format the invalid value
+    // before serializing it to TOML and printing it.
+    const formattedInvalidValue = typeof formatInvalid === 'function' ? formatInvalid(invalidValue) : invalidValue;
+    const invalidValueA = serializeToml(formattedInvalidValue);
+    return invalidValueA;
+};
 const setInvalidValuePart = function (value, part) {
-  if (Number.isInteger(part)) {
-    return [value]
-  }
-
-  return value === undefined ? {} : { [part]: value }
-}
+    if (Number.isInteger(part)) {
+        return [value];
+    }
+    return value === undefined ? {} : { [part]: value };
+};

package/lib/validate/helpers.js

@@ -1,31 +1,25 @@
-import isPlainObj from 'is-plain-obj'
-
+import isPlainObj from 'is-plain-obj';
 export const isArrayOfObjects = function (value) {
-  return Array.isArray(value) && value.every(isPlainObj)
-}
-
+    return Array.isArray(value) && value.every(isPlainObj);
+};
 export const isArrayOfStrings = function (value) {
-  return Array.isArray(value) && value.every(isString)
-}
-
+    return Array.isArray(value) && value.every(isString);
+};
 export const isString = function (value) {
-  return typeof value === 'string'
-}
-
+    return typeof value === 'string';
+};
 // Check an object valid properties, including legacy ones
 export const validProperties = function (propNames, legacyPropNames) {
-  return {
-    check: (value) => checkValidProperty(value, [...propNames, ...legacyPropNames]),
-    message: `has unknown properties. Valid properties are:
+    return {
+        check: (value) => checkValidProperty(value, [...propNames, ...legacyPropNames]),
+        message: `has unknown properties. Valid properties are:
 ${propNames.map((propName) => `  - ${propName}`).join('\n')}`,
-  }
-}
-
+    };
+};
 const checkValidProperty = function (value, propNames) {
-  return Object.keys(value).every((propName) => propNames.includes(propName))
-}
-
+    return Object.keys(value).every((propName) => propNames.includes(propName));
+};
 export const functionsDirectoryCheck = {
-  formatInvalid: ({ functionsDirectory } = {}) => ({ functions: { directory: functionsDirectory } }),
-  propertyName: 'functions.directory',
-}
+    formatInvalid: ({ functionsDirectory } = {}) => ({ functions: { directory: functionsDirectory } }),
+    propertyName: 'functions.directory',
+};

package/lib/validate/identical.js

@@ -1,20 +1,16 @@
-import { throwUserError } from '../error.js'
-
+import { throwUserError } from '../error.js';
 // Validate that plugin are configured only once per origin
 // (`netlify.toml` or UI).
 // Exception: context-specific configuration since we allow context-specific
 // overrides. This does not validate them since contexts have not been merged
 // yet.
 export const validateIdenticalPlugins = function ({ plugins = [] }) {
-  plugins.filter(hasIdenticalPlugin).forEach(throwIndenticalPlugin)
-}
-
+    plugins.filter(hasIdenticalPlugin).forEach(throwIndenticalPlugin);
+};
 const hasIdenticalPlugin = function ({ package: packageName, origin }, index, plugins) {
-  return plugins.slice(index + 1).some((pluginA) => packageName === pluginA.package && origin === pluginA.origin)
-}
-
+    return plugins.slice(index + 1).some((pluginA) => packageName === pluginA.package && origin === pluginA.origin);
+};
 const throwIndenticalPlugin = function ({ package: packageName, origin }) {
-  throwUserError(`Plugin "${packageName}" must not be specified twice in ${ORIGINS[origin]}`)
-}
-
-const ORIGINS = { config: 'netlify.toml', ui: 'the app' }
+    throwUserError(`Plugin "${packageName}" must not be specified twice in ${ORIGINS[origin]}`);
+};
+const ORIGINS = { config: 'netlify.toml', ui: 'the app' };