@netlify/config 18.2.4 → 18.2.5

package/lib/options/feature_flags.js

@@ -1,15 +1,12 @@
 // From CLI `--featureFlags=a,b,c` to programmatic `{ a: true, b: true, c: true }`
 export const normalizeCliFeatureFlags = function (cliFeatureFlags) {
-  return Object.assign({}, ...cliFeatureFlags.split(',').filter(isNotEmpty).map(getFeatureFlag))
-}
-
+    return Object.assign({}, ...cliFeatureFlags.split(',').filter(isNotEmpty).map(getFeatureFlag));
+};
 const isNotEmpty = function (name) {
-  return name.trim() !== ''
-}
-
+    return name.trim() !== '';
+};
 const getFeatureFlag = function (name) {
-  return { [name]: true }
-}
-
+    return { [name]: true };
+};
 // Default values for feature flags
-export const DEFAULT_FEATURE_FLAGS = {}
+export const DEFAULT_FEATURE_FLAGS = {};

package/lib/options/main.js

@@ -1,111 +1,91 @@
-import { resolve } from 'path'
-import process from 'process'
-
-import { isDirectory } from 'path-type'
-
-import { throwUserError } from '../error.js'
-import { getBufferLogs } from '../log/logger.js'
-import { logOpts } from '../log/main.js'
-import { removeFalsy } from '../utils/remove_falsy.js'
-
-import { getBaseOverride } from './base.js'
-import { getBranch } from './branch.js'
-import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js'
-import { getRepositoryRoot } from './repository_root.js'
-
+import { resolve } from 'path';
+import process from 'process';
+import { isDirectory } from 'path-type';
+import { throwUserError } from '../error.js';
+import { getBufferLogs } from '../log/logger.js';
+import { logOpts } from '../log/main.js';
+import { removeFalsy } from '../utils/remove_falsy.js';
+import { getBaseOverride } from './base.js';
+import { getBranch } from './branch.js';
+import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js';
+import { getRepositoryRoot } from './repository_root.js';
 // Assign default options
 export const addDefaultOpts = function (opts = {}) {
-  const rawOpts = removeFalsy(opts)
-
-  const defaultOpts = getDefaultOpts(rawOpts)
-  const mergedOpts = {
-    ...defaultOpts,
-    ...rawOpts,
-    featureFlags: { ...defaultOpts.featureFlags, ...rawOpts.featureFlags },
-  }
-  const normalizedOpts = removeFalsy(mergedOpts)
-
-  const logs = getBufferLogs(normalizedOpts)
-  const normalizedOptsA = { ...normalizedOpts, logs }
-
-  logOpts(rawOpts, normalizedOptsA)
-
-  return normalizedOptsA
-}
-
+    const rawOpts = removeFalsy(opts);
+    const defaultOpts = getDefaultOpts(rawOpts);
+    const mergedOpts = {
+        ...defaultOpts,
+        ...rawOpts,
+        featureFlags: { ...defaultOpts.featureFlags, ...rawOpts.featureFlags },
+    };
+    const normalizedOpts = removeFalsy(mergedOpts);
+    const logs = getBufferLogs(normalizedOpts);
+    const normalizedOptsA = { ...normalizedOpts, logs };
+    logOpts(rawOpts, normalizedOptsA);
+    return normalizedOptsA;
+};
 const getDefaultOpts = function ({ env: envOpt = {}, cwd: cwdOpt, defaultConfig = {} }) {
-  const combinedEnv = { ...process.env, ...envOpt }
-  return {
-    defaultConfig,
-    ...getDefaultCwd(cwdOpt),
-    env: envOpt,
-    context: combinedEnv.CONTEXT || 'production',
-    branch: combinedEnv.BRANCH,
-    host: combinedEnv.NETLIFY_API_HOST,
-    token: combinedEnv.NETLIFY_AUTH_TOKEN,
-    siteId: combinedEnv.NETLIFY_SITE_ID,
-    deployId: combinedEnv.DEPLOY_ID || DEFAULT_DEPLOY_ID,
-    buildId: combinedEnv.BUILD_ID || DEFAULT_BUILD_ID,
-    mode: 'require',
-    offline: false,
-    debug: getDefaultDebug(combinedEnv, defaultConfig),
-    buffer: false,
-    featureFlags: DEFAULT_FEATURE_FLAGS,
-    inlineConfig: {},
-    configMutations: [],
-  }
-}
-
+    const combinedEnv = { ...process.env, ...envOpt };
+    return {
+        defaultConfig,
+        ...getDefaultCwd(cwdOpt),
+        env: envOpt,
+        context: combinedEnv.CONTEXT || 'production',
+        branch: combinedEnv.BRANCH,
+        host: combinedEnv.NETLIFY_API_HOST,
+        token: combinedEnv.NETLIFY_AUTH_TOKEN,
+        siteId: combinedEnv.NETLIFY_SITE_ID,
+        deployId: combinedEnv.DEPLOY_ID || DEFAULT_DEPLOY_ID,
+        buildId: combinedEnv.BUILD_ID || DEFAULT_BUILD_ID,
+        mode: 'require',
+        offline: false,
+        debug: getDefaultDebug(combinedEnv, defaultConfig),
+        buffer: false,
+        featureFlags: DEFAULT_FEATURE_FLAGS,
+        inlineConfig: {},
+        configMutations: [],
+    };
+};
 // Local builds do not have any deploys, so some dummy ids are used instead
-const DEFAULT_DEPLOY_ID = '0'
-const DEFAULT_BUILD_ID = '0'
-
+const DEFAULT_DEPLOY_ID = '0';
+const DEFAULT_BUILD_ID = '0';
 // --debug can be set using an environment variable `NETLIFY_BUILD_DEBUG` either
 // locally or in the UI build settings
 const getDefaultDebug = function (combinedEnv, { build: { environment = {} } = {} }) {
-  return Boolean(combinedEnv.NETLIFY_BUILD_DEBUG || environment.NETLIFY_BUILD_DEBUG)
-}
-
+    return Boolean(combinedEnv.NETLIFY_BUILD_DEBUG || environment.NETLIFY_BUILD_DEBUG);
+};
 // `process.cwd()` can throw, so only call it when needed
 const getDefaultCwd = function (cwdOpt) {
-  if (cwdOpt !== undefined) {
-    return {}
-  }
-
-  const cwd = process.cwd()
-  return { cwd }
-}
-
+    if (cwdOpt !== undefined) {
+        return {};
+    }
+    const cwd = process.cwd();
+    return { cwd };
+};
 // Normalize options
 export const normalizeOpts = async function (opts) {
-  const repositoryRoot = await getRepositoryRoot(opts)
-  const optsA = { ...opts, repositoryRoot }
-
-  const branch = await getBranch(optsA)
-  const optsB = { ...optsA, branch }
-
-  const optsC = removeFalsy(optsB)
-  const optsD = await normalizeDirs(optsC)
-
-  const baseOverride = await getBaseOverride(optsD)
-  const optsE = { ...baseOverride, ...optsD }
-  return optsE
-}
-
+    const repositoryRoot = await getRepositoryRoot(opts);
+    const optsA = { ...opts, repositoryRoot };
+    const branch = await getBranch(optsA);
+    const optsB = { ...optsA, branch };
+    const optsC = removeFalsy(optsB);
+    const optsD = await normalizeDirs(optsC);
+    const baseOverride = await getBaseOverride(optsD);
+    const optsE = { ...baseOverride, ...optsD };
+    return optsE;
+};
 // Verify that options point to existing directories.
 // Also resolve them to absolute file paths.
 const normalizeDirs = async function (opts) {
-  const dirOpts = await Promise.all(DIR_OPTIONS.map((optName) => normalizeDir(opts, optName)))
-  return Object.assign({}, opts, ...dirOpts)
-}
-
-const DIR_OPTIONS = ['cwd', 'repositoryRoot']
-
+    const dirOpts = await Promise.all(DIR_OPTIONS.map((optName) => normalizeDir(opts, optName)));
+    return Object.assign({}, opts, ...dirOpts);
+};
+const DIR_OPTIONS = ['cwd', 'repositoryRoot'];
 const normalizeDir = async function (opts, optName) {
-  const path = opts[optName]
-  const resolvedPath = resolve(path)
-  if (!(await isDirectory(path))) {
-    throwUserError(`Option '${optName}' points to a non-existing directory: ${resolvedPath}`)
-  }
-  return { [optName]: resolvedPath }
-}
+    const path = opts[optName];
+    const resolvedPath = resolve(path);
+    if (!(await isDirectory(path))) {
+        throwUserError(`Option '${optName}' points to a non-existing directory: ${resolvedPath}`);
+    }
+    return { [optName]: resolvedPath };
+};

package/lib/options/repository_root.js

@@ -1,21 +1,16 @@
-import { dirname } from 'path'
-
-import { findUp } from 'find-up'
-
+import { dirname } from 'path';
+import { findUp } from 'find-up';
 // Find out repository root among (in priority order):
 //  - `repositoryRoot` option
 //  - find a `.git` directory up from `cwd`
 //  - `cwd` (fallback)
 export const getRepositoryRoot = async function ({ repositoryRoot, cwd }) {
-  if (repositoryRoot !== undefined) {
-    return repositoryRoot
-  }
-
-  const repositoryRootA = await findUp('.git', { cwd, type: 'directory' })
-
-  if (repositoryRootA === undefined) {
-    return cwd
-  }
-
-  return dirname(repositoryRootA)
-}
+    if (repositoryRoot !== undefined) {
+        return repositoryRoot;
+    }
+    const repositoryRootA = await findUp('.git', { cwd, type: 'directory' });
+    if (repositoryRootA === undefined) {
+        return cwd;
+    }
+    return dirname(repositoryRootA);
+};

package/lib/origin.js

@@ -1,38 +1,31 @@
-import { isTruthy } from './utils/remove_falsy.js'
-
+import { isTruthy } from './utils/remove_falsy.js';
 // `build.commandOrigin`, `build.publishOrigin` and `plugins[*].origin` constants
-export const UI_ORIGIN = 'ui'
-export const CONFIG_ORIGIN = 'config'
-export const DEFAULT_ORIGIN = 'default'
-export const INLINE_ORIGIN = 'inline'
-
+export const UI_ORIGIN = 'ui';
+export const CONFIG_ORIGIN = 'config';
+export const DEFAULT_ORIGIN = 'default';
+export const INLINE_ORIGIN = 'inline';
 // Add `build.commandOrigin`, `build.publishOrigin` and `plugins[*].origin`.
 // This shows whether those properties came from the `ui` or from the `config`.
 export const addOrigins = function (config, origin) {
-  const configA = addBuildCommandOrigin({ config, origin })
-  const configB = addBuildPublishOrigin({ config: configA, origin })
-  const configC = addConfigPluginOrigin({ config: configB, origin })
-  const configD = addHeadersOrigin({ config: configC, origin })
-  const configE = addRedirectsOrigin({ config: configD, origin })
-  return configE
-}
-
+    const configA = addBuildCommandOrigin({ config, origin });
+    const configB = addBuildPublishOrigin({ config: configA, origin });
+    const configC = addConfigPluginOrigin({ config: configB, origin });
+    const configD = addHeadersOrigin({ config: configC, origin });
+    const configE = addRedirectsOrigin({ config: configD, origin });
+    return configE;
+};
 const addBuildCommandOrigin = function ({ config, config: { build = {} }, origin }) {
-  return isTruthy(build.command) ? { ...config, build: { ...build, commandOrigin: origin } } : config
-}
-
+    return isTruthy(build.command) ? { ...config, build: { ...build, commandOrigin: origin } } : config;
+};
 const addBuildPublishOrigin = function ({ config, config: { build = {} }, origin }) {
-  return isTruthy(build.publish) ? { ...config, build: { ...build, publishOrigin: origin } } : config
-}
-
+    return isTruthy(build.publish) ? { ...config, build: { ...build, publishOrigin: origin } } : config;
+};
 const addConfigPluginOrigin = function ({ config, config: { plugins }, origin }) {
-  return Array.isArray(plugins) ? { ...config, plugins: plugins.map((plugin) => ({ ...plugin, origin })) } : config
-}
-
+    return Array.isArray(plugins) ? { ...config, plugins: plugins.map((plugin) => ({ ...plugin, origin })) } : config;
+};
 const addHeadersOrigin = function ({ config, config: { headers }, origin }) {
-  return isTruthy(headers) ? { ...config, headersOrigin: origin } : config
-}
-
+    return isTruthy(headers) ? { ...config, headersOrigin: origin } : config;
+};
 const addRedirectsOrigin = function ({ config, config: { redirects }, origin }) {
-  return isTruthy(redirects) ? { ...config, redirectsOrigin: origin } : config
-}
+    return isTruthy(redirects) ? { ...config, redirectsOrigin: origin } : config;
+};

package/lib/parse.js

@@ -1,69 +1,56 @@
-import { promises as fs } from 'fs'
-
-import { pathExists } from 'path-exists'
-
-import { throwUserError } from './error.js'
-import { throwOnInvalidTomlSequence } from './log/messages.js'
-import { parseToml } from './utils/toml.js'
-
+import { promises as fs } from 'fs';
+import { pathExists } from 'path-exists';
+import { throwUserError } from './error.js';
+import { throwOnInvalidTomlSequence } from './log/messages.js';
+import { parseToml } from './utils/toml.js';
 // Load the configuration file and parse it (TOML)
 export const parseConfig = async function (configPath) {
-  if (configPath === undefined) {
-    return {}
-  }
-
-  if (!(await pathExists(configPath))) {
-    throwUserError('Configuration file does not exist')
-  }
-
-  return await readConfigPath(configPath)
-}
-
+    if (configPath === undefined) {
+        return {};
+    }
+    if (!(await pathExists(configPath))) {
+        throwUserError('Configuration file does not exist');
+    }
+    return await readConfigPath(configPath);
+};
 // Same but `configPath` is required and `configPath` might point to a
 // non-existing file.
 export const parseOptionalConfig = async function (configPath) {
-  if (!(await pathExists(configPath))) {
-    return {}
-  }
-
-  return await readConfigPath(configPath)
-}
-
+    if (!(await pathExists(configPath))) {
+        return {};
+    }
+    return await readConfigPath(configPath);
+};
 const readConfigPath = async function (configPath) {
-  const configString = await readConfig(configPath)
-
-  validateTomlBlackslashes(configString)
-
-  try {
-    return parseToml(configString)
-  } catch (error) {
-    throwUserError('Could not parse configuration file', error)
-  }
-}
-
+    const configString = await readConfig(configPath);
+    validateTomlBlackslashes(configString);
+    try {
+        return parseToml(configString);
+    }
+    catch (error) {
+        throwUserError('Could not parse configuration file', error);
+    }
+};
 // Reach the configuration file's raw content
 const readConfig = async function (configPath) {
-  try {
-    return await fs.readFile(configPath, 'utf8')
-  } catch (error) {
-    throwUserError('Could not read configuration file', error)
-  }
-}
-
+    try {
+        return await fs.readFile(configPath, 'utf8');
+    }
+    catch (error) {
+        throwUserError('Could not read configuration file', error);
+    }
+};
 const validateTomlBlackslashes = function (configString) {
-  const result = INVALID_TOML_BLACKSLASH.exec(configString)
-  if (result === null) {
-    return
-  }
-
-  const [, invalidTripleSequence, invalidSequence = invalidTripleSequence] = result
-  throwOnInvalidTomlSequence(invalidSequence)
-}
-
+    const result = INVALID_TOML_BLACKSLASH.exec(configString);
+    if (result === null) {
+        return;
+    }
+    const [, invalidTripleSequence, invalidSequence = invalidTripleSequence] = result;
+    throwOnInvalidTomlSequence(invalidSequence);
+};
 // The TOML specification forbids unrecognized backslash sequences. However,
 // `toml-node` does not respect the specification and do not fail on those.
 // Therefore, we print a warning message.
 // This only applies to " and """ strings, not ' nor '''
 // Also, """ strings can use trailing backslashes.
-const INVALID_TOML_BLACKSLASH =
-  /\n[a-zA-Z]+ *= *(?:(?:""".*(?<!\\)(\\[^"\\btnfruU\n]).*""")|(?:"(?!")[^\n]*(?<!\\)(\\[^"\\btnfruU])[^\n]*"))/su
+const INVALID_TOML_BLACKSLASH = /\n[a-zA-Z]+ *= *(?:(?:""".*(?<!\\)(\\[^"\\btnfruU\n]).*""")|(?:"(?!")[^\n]*(?<!\\)(\\[^"\\btnfruU])[^\n]*"))/su;

package/lib/path.js

@@ -1,52 +1,41 @@
-import { resolve } from 'path'
-
-import { findUp } from 'find-up'
-import pLocate from 'p-locate'
-import { pathExists } from 'path-exists'
-
+import { resolve } from 'path';
+import { findUp } from 'find-up';
+import pLocate from 'p-locate';
+import { pathExists } from 'path-exists';
 // Configuration location can be:
 //  - a local path with the --config CLI flag
 //  - a `netlify.*` file in the `repositoryRoot/{base}`
 //  - a `netlify.*` file in the `repositoryRoot`
 //  - a `netlify.*` file in the current directory or any parent
 export const getConfigPath = async function ({ configOpt, cwd, repositoryRoot, configBase }) {
-  const configPath = await pLocate(
-    [
-      searchConfigOpt(cwd, configOpt),
-      searchBaseConfigFile(repositoryRoot, configBase),
-      searchConfigFile(repositoryRoot),
-      findUp(FILENAME, { cwd }),
-    ],
-    Boolean,
-  )
-  return configPath
-}
-
+    const configPath = await pLocate([
+        searchConfigOpt(cwd, configOpt),
+        searchBaseConfigFile(repositoryRoot, configBase),
+        searchConfigFile(repositoryRoot),
+        findUp(FILENAME, { cwd }),
+    ], Boolean);
+    return configPath;
+};
 // --config CLI flag
 const searchConfigOpt = function (cwd, configOpt) {
-  if (configOpt === undefined) {
-    return
-  }
-
-  return resolve(cwd, configOpt)
-}
-
+    if (configOpt === undefined) {
+        return;
+    }
+    return resolve(cwd, configOpt);
+};
 // Look for `repositoryRoot/{base}/netlify.*`
 const searchBaseConfigFile = function (repositoryRoot, configBase) {
-  if (configBase === undefined) {
-    return
-  }
-
-  return searchConfigFile(configBase)
-}
-
+    if (configBase === undefined) {
+        return;
+    }
+    return searchConfigFile(configBase);
+};
 // Look for several file extensions for `netlify.*`
 const searchConfigFile = async function (cwd) {
-  const path = resolve(cwd, FILENAME)
-  if (!(await pathExists(path))) {
-    return
-  }
-  return path
-}
-
-const FILENAME = 'netlify.toml'
+    const path = resolve(cwd, FILENAME);
+    if (!(await pathExists(path))) {
+        return;
+    }
+    return path;
+};
+const FILENAME = 'netlify.toml';

package/lib/redirects.js

@@ -1,29 +1,19 @@
-import { resolve } from 'path'
-
-import { parseAllRedirects } from 'netlify-redirect-parser'
-
-import { warnRedirectsParsing } from './log/messages.js'
-
+import { resolve } from 'path';
+import { parseAllRedirects } from 'netlify-redirect-parser';
+import { warnRedirectsParsing } from './log/messages.js';
 // Retrieve path to `_redirects` file (even if it does not exist yet)
 export const getRedirectsPath = function ({ build: { publish } }) {
-  return resolve(publish, REDIRECTS_FILENAME)
-}
-
-const REDIRECTS_FILENAME = '_redirects'
-
+    return resolve(publish, REDIRECTS_FILENAME);
+};
+const REDIRECTS_FILENAME = '_redirects';
 // Add `config.redirects`
-export const addRedirects = async function ({
-  config: { redirects: configRedirects, ...config },
-  redirectsPath,
-  logs,
-  featureFlags,
-}) {
-  const { redirects, errors } = await parseAllRedirects({
-    redirectsFiles: [redirectsPath],
-    configRedirects,
-    minimal: true,
-    featureFlags,
-  })
-  warnRedirectsParsing(logs, errors)
-  return { ...config, redirects }
-}
+export const addRedirects = async function ({ config: { redirects: configRedirects, ...config }, redirectsPath, logs, featureFlags, }) {
+    const { redirects, errors } = await parseAllRedirects({
+        redirectsFiles: [redirectsPath],
+        configRedirects,
+        minimal: true,
+        featureFlags,
+    });
+    warnRedirectsParsing(logs, errors);
+    return { ...config, redirects };
+};