@netlify/config 18.2.5-rc → 18.2.5

package/lib/main.js

@@ -0,0 +1,210 @@
+import { getApiClient } from './api/client.js';
+import { getSiteInfo } from './api/site_info.js';
+import { getInitialBase, getBase, addBase } from './base.js';
+import { getBuildDir } from './build_dir.js';
+import { getCachedConfig } from './cached_config.js';
+import { normalizeContextProps, mergeContext } from './context.js';
+import { parseDefaultConfig } from './default.js';
+import { getEnv } from './env/main.js';
+import { resolveConfigPaths } from './files.js';
+import { getHeadersPath, addHeaders } from './headers.js';
+import { getInlineConfig } from './inline_config.js';
+import { logResult } from './log/main.js';
+import { mergeConfigs } from './merge.js';
+import { normalizeBeforeConfigMerge, normalizeAfterConfigMerge } from './merge_normalize.js';
+import { addDefaultOpts, normalizeOpts } from './options/main.js';
+import { UI_ORIGIN, CONFIG_ORIGIN, INLINE_ORIGIN } from './origin.js';
+import { parseConfig } from './parse.js';
+import { getConfigPath } from './path.js';
+import { getRedirectsPath, addRedirects } from './redirects.js';
+export { DEV_EVENTS, EVENTS } from './events.js';
+export { cleanupConfig } from './log/cleanup.js';
+export { updateConfig, restoreConfig } from './mutations/update.js';
+// Load the configuration file.
+// Takes an optional configuration file path as input and return the resolved
+// `config` together with related properties such as the `configPath`.
+export const resolveConfig = async function (opts) {
+    const { cachedConfig, cachedConfigPath, host, scheme, pathPrefix, testOpts, token, offline, ...optsA } = addDefaultOpts(opts);
+    // `api` is not JSON-serializable, so we cannot cache it inside `cachedConfig`
+    const api = getApiClient({ token, offline, host, scheme, pathPrefix, testOpts });
+    const parsedCachedConfig = await getCachedConfig({ cachedConfig, cachedConfigPath, token, api });
+    if (parsedCachedConfig !== undefined) {
+        return parsedCachedConfig;
+    }
+    const { config: configOpt, defaultConfig, inlineConfig, configMutations, cwd, context, repositoryRoot, base, branch, siteId, deployId, buildId, baseRelDir, mode, debug, logs, featureFlags, } = await normalizeOpts(optsA);
+    const { siteInfo, accounts, addons } = await getSiteInfo({ api, siteId, mode, testOpts });
+    const { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA } = parseDefaultConfig({
+        defaultConfig,
+        base,
+        baseRelDir,
+        siteInfo,
+        logs,
+        debug,
+    });
+    const inlineConfigA = getInlineConfig({ inlineConfig, configMutations, logs, debug });
+    const { configPath, config, buildDir, redirectsPath, headersPath } = await loadConfig({
+        configOpt,
+        cwd,
+        context,
+        repositoryRoot,
+        branch,
+        defaultConfig: defaultConfigA,
+        inlineConfig: inlineConfigA,
+        baseRelDir: baseRelDirA,
+        logs,
+        featureFlags,
+    });
+    const env = await getEnv({
+        api,
+        mode,
+        config,
+        siteInfo,
+        accounts,
+        addons,
+        buildDir,
+        branch,
+        deployId,
+        buildId,
+        context,
+    });
+    // @todo Remove in the next major version.
+    const configA = addLegacyFunctionsDirectory(config);
+    const result = {
+        siteInfo,
+        accounts,
+        addons,
+        env,
+        configPath,
+        redirectsPath,
+        headersPath,
+        buildDir,
+        repositoryRoot,
+        config: configA,
+        context,
+        branch,
+        token,
+        api,
+        logs,
+    };
+    logResult(result, { logs, debug });
+    return result;
+};
+// Adds a `build.functions` property that mirrors `functionsDirectory`, for
+// backward compatibility.
+const addLegacyFunctionsDirectory = (config) => {
+    if (!config.functionsDirectory) {
+        return config;
+    }
+    return {
+        ...config,
+        build: {
+            ...config.build,
+            functions: config.functionsDirectory,
+        },
+    };
+};
+// Try to load the configuration file in two passes.
+// The first pass uses the `defaultConfig`'s `build.base` (if defined).
+// The second pass uses the `build.base` from the first pass (if defined).
+const loadConfig = async function ({ configOpt, cwd, context, repositoryRoot, branch, defaultConfig, inlineConfig, baseRelDir, logs, featureFlags, }) {
+    const initialBase = getInitialBase({ repositoryRoot, defaultConfig, inlineConfig });
+    const { configPath, config, buildDir, base, redirectsPath, headersPath } = await getFullConfig({
+        configOpt,
+        cwd,
+        context,
+        repositoryRoot,
+        branch,
+        defaultConfig,
+        inlineConfig,
+        baseRelDir,
+        configBase: initialBase,
+        logs,
+        featureFlags,
+    });
+    // No second pass needed if:
+    //  - there is no `build.base` (in which case both `base` and `initialBase`
+    //    are `undefined`)
+    //  - `build.base` is the same as the `Base directory` UI setting (already
+    //    used in the first round)
+    //  - `baseRelDir` feature flag is not used. This feature flag was introduced
+    //    to ensure backward compatibility.
+    if (!baseRelDir || base === initialBase) {
+        return { configPath, config, buildDir, redirectsPath, headersPath };
+    }
+    const { configPath: configPathA, config: configA, buildDir: buildDirA, redirectsPath: redirectsPathA, headersPath: headersPathA, } = await getFullConfig({
+        cwd,
+        context,
+        repositoryRoot,
+        branch,
+        defaultConfig,
+        inlineConfig,
+        baseRelDir,
+        configBase: base,
+        base,
+        logs,
+        featureFlags,
+    });
+    return {
+        configPath: configPathA,
+        config: configA,
+        buildDir: buildDirA,
+        redirectsPath: redirectsPathA,
+        headersPath: headersPathA,
+    };
+};
+// Load configuration file and normalize it, merge contexts, etc.
+const getFullConfig = async function ({ configOpt, cwd, context, repositoryRoot, branch, defaultConfig, inlineConfig, baseRelDir, configBase, base, logs, featureFlags, }) {
+    const configPath = await getConfigPath({ configOpt, cwd, repositoryRoot, configBase });
+    try {
+        const config = await parseConfig(configPath);
+        const configA = mergeAndNormalizeConfig({
+            config,
+            defaultConfig,
+            inlineConfig,
+            context,
+            branch,
+            logs,
+        });
+        const { config: configB, buildDir, base: baseA, } = await resolveFiles({ config: configA, repositoryRoot, base, baseRelDir });
+        const headersPath = getHeadersPath(configB);
+        const configC = await addHeaders({ config: configB, headersPath, logs, featureFlags });
+        const redirectsPath = getRedirectsPath(configC);
+        const configD = await addRedirects({ config: configC, redirectsPath, logs, featureFlags });
+        return { configPath, config: configD, buildDir, base: baseA, redirectsPath, headersPath };
+    }
+    catch (error) {
+        const configName = configPath === undefined ? '' : ` file ${configPath}`;
+        error.message = `When resolving config${configName}:\n${error.message}`;
+        throw error;
+    }
+};
+// Merge:
+//  - `--defaultConfig`: UI build settings and UI-installed plugins
+//  - `inlineConfig`: Netlify CLI flags
+// Then merge context-specific configuration.
+// Before and after those steps, also performs validation and normalization.
+// Those need to be done at different stages depending on whether they should
+// happen before/after the merges mentioned above.
+const mergeAndNormalizeConfig = function ({ config, defaultConfig, inlineConfig, context, branch, logs }) {
+    const configA = normalizeConfigAndContext(config, CONFIG_ORIGIN);
+    const defaultConfigA = normalizeConfigAndContext(defaultConfig, UI_ORIGIN);
+    const inlineConfigA = normalizeConfigAndContext(inlineConfig, INLINE_ORIGIN);
+    const configB = mergeConfigs([defaultConfigA, configA]);
+    const configC = mergeContext({ config: configB, context, branch, logs });
+    const configD = mergeConfigs([configC, inlineConfigA]);
+    const configE = normalizeAfterConfigMerge(configD);
+    return configE;
+};
+const normalizeConfigAndContext = function (config, origin) {
+    const configA = normalizeBeforeConfigMerge(config, origin);
+    const configB = normalizeContextProps({ config: configA, origin });
+    return configB;
+};
+// Find base directory, build directory and resolve all paths to absolute paths
+const resolveFiles = async function ({ config, repositoryRoot, base, baseRelDir }) {
+    const baseA = getBase(base, repositoryRoot, config);
+    const buildDir = await getBuildDir(repositoryRoot, baseA);
+    const configA = await resolveConfigPaths({ config, repositoryRoot, buildDir, baseRelDir });
+    const configB = addBase(configA, baseA);
+    return { config: configB, buildDir, base: baseA };
+};

package/lib/merge.js

@@ -0,0 +1,43 @@
+import deepmerge from 'deepmerge';
+import isPlainObj from 'is-plain-obj';
+import { groupBy } from './utils/group.js';
+import { removeUndefined } from './utils/remove_falsy.js';
+// Merge an array of configuration objects.
+// Last items have higher priority.
+// Configuration objects are deeply merged.
+//   - Arrays are overridden, not concatenated.
+export const mergeConfigs = function (configs) {
+    const cleanedConfigs = configs.map(removeUndefinedProps);
+    return deepmerge.all(cleanedConfigs, { arrayMerge });
+};
+const removeUndefinedProps = function ({ build = {}, ...config }) {
+    return removeUndefined({ ...config, build: removeUndefined(build) });
+};
+// By default `deepmerge` concatenates arrays. We use the `arrayMerge` option
+// to remove this behavior. Also, we merge some array properties differently,
+// such as `plugins`.
+const arrayMerge = function (arrayA, arrayB) {
+    if (isPluginsProperty(arrayA) && isPluginsProperty(arrayB)) {
+        return mergePlugins(arrayA, arrayB);
+    }
+    return arrayB;
+};
+// `deepmerge` does not allow retrieving the name of the array property being
+// merged, so we need to do some heuristics.
+const isPluginsProperty = function (array) {
+    return Array.isArray(array) && array.every(isPluginObject);
+};
+const isPluginObject = function (object) {
+    return isPlainObj(object) && typeof object.package === 'string';
+};
+// Merge two `config.plugins`. Merge plugins with the same `plugin.package`.
+const mergePlugins = function (pluginsA, pluginsB) {
+    const plugins = [...pluginsA, ...pluginsB];
+    return groupBy(plugins, 'package').map(mergePluginConfigs);
+};
+const mergePluginConfigs = function (plugins) {
+    return plugins.reduce(mergePluginsPair, {});
+};
+const mergePluginsPair = function (pluginA, pluginB) {
+    return deepmerge(pluginA, pluginB, { arrayMerge });
+};

package/lib/merge_normalize.js

@@ -0,0 +1,24 @@
+import { normalizeConfigCase } from './case.js';
+import { normalizeConfig } from './normalize.js';
+import { addOrigins } from './origin.js';
+import { validateIdenticalPlugins } from './validate/identical.js';
+import { validatePreCaseNormalize, validatePreMergeConfig, validatePreNormalizeConfig, validatePostNormalizeConfig, } from './validate/main.js';
+// Perform validation and normalization logic to apply to all of:
+//  - config, defaultConfig, inlineConfig
+//  - context-specific configs
+// Therefore, this is performing before merging those together.
+export const normalizeBeforeConfigMerge = function (config, origin) {
+    validatePreCaseNormalize(config);
+    const configA = normalizeConfigCase(config);
+    validatePreMergeConfig(configA);
+    const configB = addOrigins(configA, origin);
+    validateIdenticalPlugins(configB);
+    return configB;
+};
+// Validation and normalization logic performed after merging
+export const normalizeAfterConfigMerge = function (config) {
+    validatePreNormalizeConfig(config);
+    const configA = normalizeConfig(config);
+    validatePostNormalizeConfig(configA);
+    return configA;
+};

package/lib/mutations/apply.js

@@ -0,0 +1,66 @@
+import { throwUserError } from '../error.js';
+import { EVENTS } from '../events.js';
+import { WILDCARD_ALL, FUNCTION_CONFIG_PROPERTIES } from '../functions_config.js';
+import { setProp } from '../utils/set.js';
+import { getPropName } from './config_prop_name.js';
+// Apply a series of mutations to `inlineConfig`.
+// Meant to be used to apply configuration changes at build time.
+// Those are applied on the `inlineConfig` object after `@netlify/config`
+// normalization. Therefore, this function also denormalizes (reverts that
+// normalization) so that the final `config` object can be serialized back to
+// a `netlify.toml`.
+export const applyMutations = function (inlineConfig, configMutations) {
+    return configMutations.reduce(applyMutation, inlineConfig);
+};
+const applyMutation = function (inlineConfig, { keys, value, event }) {
+    const propName = getPropName(keys);
+    if (!(propName in MUTABLE_PROPS)) {
+        throwUserError(`"netlifyConfig.${propName}" is read-only.`);
+    }
+    const { lastEvent, denormalize } = MUTABLE_PROPS[propName];
+    validateEvent(lastEvent, event, propName);
+    return denormalize === undefined ? setProp(inlineConfig, keys, value) : denormalize(inlineConfig, value, keys);
+};
+const validateEvent = function (lastEvent, event, propName) {
+    if (EVENTS.indexOf(lastEvent) < EVENTS.indexOf(event)) {
+        throwUserError(`"netlifyConfig.${propName}" cannot be modified after "${lastEvent}".`);
+    }
+};
+// `functions['*'].*` has higher priority than `functions.*` so we convert the
+// latter to the former.
+const denormalizeFunctionsTopProps = function ({ functions, functions: { [WILDCARD_ALL]: wildcardProps } = {}, ...inlineConfig }, value, [, key]) {
+    return FUNCTION_CONFIG_PROPERTIES.has(key)
+        ? {
+            ...inlineConfig,
+            functions: { ...functions, [WILDCARD_ALL]: { ...wildcardProps, [key]: value } },
+        }
+        : { ...inlineConfig, functions: { ...functions, [key]: value } };
+};
+// List of properties that are not read-only.
+const MUTABLE_PROPS = {
+    'build.command': { lastEvent: 'onPreBuild' },
+    'build.edge_functions': { lastEvent: 'onPostBuild' },
+    'build.environment': { lastEvent: 'onPostBuild' },
+    'build.environment.*': { lastEvent: 'onPostBuild' },
+    'build.functions': { lastEvent: 'onBuild' },
+    'build.processing': { lastEvent: 'onPostBuild' },
+    'build.processing.css': { lastEvent: 'onPostBuild' },
+    'build.processing.css.bundle': { lastEvent: 'onPostBuild' },
+    'build.processing.css.minify': { lastEvent: 'onPostBuild' },
+    'build.processing.html': { lastEvent: 'onPostBuild' },
+    'build.processing.html.pretty_urls': { lastEvent: 'onPostBuild' },
+    'build.processing.images': { lastEvent: 'onPostBuild' },
+    'build.processing.images.compress': { lastEvent: 'onPostBuild' },
+    'build.processing.js': { lastEvent: 'onPostBuild' },
+    'build.processing.js.bundle': { lastEvent: 'onPostBuild' },
+    'build.processing.js.minify': { lastEvent: 'onPostBuild' },
+    'build.processing.skip_processing': { lastEvent: 'onPostBuild' },
+    'build.publish': { lastEvent: 'onPostBuild' },
+    'build.services': { lastEvent: 'onPostBuild' },
+    'build.services.*': { lastEvent: 'onPostBuild' },
+    edge_functions: { lastEvent: 'onPostBuild' },
+    'functions.*': { lastEvent: 'onBuild', denormalize: denormalizeFunctionsTopProps },
+    'functions.*.*': { lastEvent: 'onBuild' },
+    headers: { lastEvent: 'onPostBuild' },
+    redirects: { lastEvent: 'onPostBuild' },
+};

package/lib/mutations/config_prop_name.js

@@ -0,0 +1,14 @@
+// Retrieve normalized property name
+export const getPropName = function (keys) {
+    return keys.reduce(normalizeDynamicProp, '');
+};
+// Some properties are user-defined, i.e. we need to replace them with a "*" token
+// Check if a property name is dynamic, such as `functions.{functionName}`, or
+// is an array index.
+// In those cases, we replace it by "*".
+const normalizeDynamicProp = function (propName, key) {
+    const normalizedKey = Number.isInteger(key) || DYNAMIC_OBJECT_PROPS.has(propName) ? '*' : String(key);
+    return propName === '' ? normalizedKey : `${propName}.${normalizedKey}`;
+};
+// Properties with dynamic children
+const DYNAMIC_OBJECT_PROPS = new Set(['build.services', 'build.environment', 'functions', 'functions.*']);

package/lib/mutations/update.js

@@ -0,0 +1,98 @@
+import { promises as fs } from 'fs';
+import { pathExists } from 'path-exists';
+import { ensureConfigPriority } from '../context.js';
+import { addHeaders } from '../headers.js';
+import { mergeConfigs } from '../merge.js';
+import { parseOptionalConfig } from '../parse.js';
+import { addRedirects } from '../redirects.js';
+import { simplifyConfig } from '../simplify.js';
+import { serializeToml } from '../utils/toml.js';
+import { applyMutations } from './apply.js';
+// Persist configuration changes to `netlify.toml`.
+// If `netlify.toml` does not exist, creates it. Otherwise, merges the changes.
+export const updateConfig = async function (configMutations, { buildDir, configPath, headersPath, redirectsPath, context, branch, logs, featureFlags }) {
+    if (configMutations.length === 0) {
+        return;
+    }
+    const inlineConfig = applyMutations({}, configMutations);
+    const normalizedInlineConfig = ensureConfigPriority(inlineConfig, context, branch);
+    const updatedConfig = await mergeWithConfig(normalizedInlineConfig, configPath);
+    const configWithHeaders = await addHeaders({ config: updatedConfig, headersPath, logs, featureFlags });
+    const finalConfig = await addRedirects({ config: configWithHeaders, redirectsPath, logs, featureFlags });
+    const simplifiedConfig = simplifyConfig(finalConfig);
+    await backupConfig({ buildDir, configPath, headersPath, redirectsPath });
+    await Promise.all([
+        saveConfig(configPath, simplifiedConfig),
+        deleteSideFile(headersPath),
+        deleteSideFile(redirectsPath),
+    ]);
+};
+// If `netlify.toml` exists, deeply merges the configuration changes.
+const mergeWithConfig = async function (normalizedInlineConfig, configPath) {
+    const config = await parseOptionalConfig(configPath);
+    const updatedConfig = mergeConfigs([config, normalizedInlineConfig]);
+    return updatedConfig;
+};
+// Serialize the changes to `netlify.toml`
+const saveConfig = async function (configPath, simplifiedConfig) {
+    const serializedConfig = serializeToml(simplifiedConfig);
+    await fs.writeFile(configPath, serializedConfig);
+};
+// Deletes `_headers/_redirects` since they are merged to `netlify.toml`,
+// to fix any priority problem.
+const deleteSideFile = async function (filePath) {
+    if (filePath === undefined || !(await pathExists(filePath))) {
+        return;
+    }
+    await fs.unlink(filePath);
+};
+// Modifications to `netlify.toml` and `_headers/_redirects` are only meant for
+// the deploy API call. After it's been performed, we restore their former
+// state.
+// We do this by backing them up inside some sibling directory.
+const backupConfig = async function ({ buildDir, configPath, headersPath, redirectsPath }) {
+    const tempDir = getTempDir(buildDir);
+    await fs.mkdir(tempDir, { recursive: true });
+    await Promise.all([
+        backupFile(configPath, `${tempDir}/netlify.toml`),
+        backupFile(headersPath, `${tempDir}/_headers`),
+        backupFile(redirectsPath, `${tempDir}/_redirects`),
+    ]);
+};
+export const restoreConfig = async function (configMutations, { buildDir, configPath, headersPath, redirectsPath }) {
+    if (configMutations.length === 0) {
+        return;
+    }
+    const tempDir = getTempDir(buildDir);
+    await Promise.all([
+        copyOrDelete(`${tempDir}/netlify.toml`, configPath),
+        copyOrDelete(`${tempDir}/_headers`, headersPath),
+        copyOrDelete(`${tempDir}/_redirects`, redirectsPath),
+    ]);
+};
+const getTempDir = function (buildDir) {
+    return `${buildDir}/.netlify/deploy`;
+};
+const backupFile = async function (original, backup) {
+    // this makes sure we don't restore stale files
+    await deleteNoError(backup);
+    if (!(await pathExists(original))) {
+        return;
+    }
+    await fs.copyFile(original, backup);
+};
+const deleteNoError = async (path) => {
+    try {
+        await fs.unlink(path);
+    }
+    catch {
+        // continue regardless error
+    }
+};
+const copyOrDelete = async function (src, dest) {
+    if (await pathExists(src)) {
+        await fs.copyFile(src, dest);
+        return;
+    }
+    await deleteNoError(dest);
+};

package/lib/normalize.js

@@ -0,0 +1,32 @@
+import { normalizeFunctionsProps, WILDCARD_ALL } from './functions_config.js';
+import { mergeConfigs } from './merge.js';
+import { DEFAULT_ORIGIN } from './origin.js';
+import { removeFalsy } from './utils/remove_falsy.js';
+// Normalize configuration object
+export const normalizeConfig = function (config) {
+    const configA = removeEmpty(config);
+    const { build, functions, plugins, ...configB } = mergeConfigs([DEFAULT_CONFIG, configA]);
+    const { build: buildA, functions: functionsA, functionsDirectoryProps } = normalizeFunctionsProps(build, functions);
+    const pluginsA = plugins.map(normalizePlugin);
+    return { ...configB, build: buildA, functions: functionsA, plugins: pluginsA, ...functionsDirectoryProps };
+};
+// Remove empty strings.
+// This notably ensures that empty strings in the build command are removed.
+// Otherwise those would be run during builds, making the build fail.
+const removeEmpty = function ({ build, ...config }) {
+    return removeFalsy({ ...config, build: removeFalsy(build) });
+};
+const DEFAULT_CONFIG = {
+    build: {
+        environment: {},
+        publish: '.',
+        publishOrigin: DEFAULT_ORIGIN,
+        processing: { css: {}, html: {}, images: {}, js: {} },
+        services: {},
+    },
+    functions: { [WILDCARD_ALL]: {} },
+    plugins: [],
+};
+const normalizePlugin = function ({ inputs = {}, ...plugin }) {
+    return removeFalsy({ ...plugin, inputs });
+};

package/lib/options/base.js

@@ -0,0 +1,54 @@
+import { promises as fs } from 'fs';
+import { dirname, relative, sep } from 'path';
+import { pathExists } from 'path-exists';
+// Retrieve `base` override.
+// This uses any directory below `repositoryRoot` and above (or equal to)
+// `cwd` that has a `.netlify` or `netlify.toml`. This allows Netlify CLI users
+// to `cd` into monorepo directories to change their base and build directories.
+// Do all checks in parallel for speed
+export const getBaseOverride = async function ({ repositoryRoot, cwd }) {
+    // Performance optimization
+    if (repositoryRoot === cwd) {
+        return {};
+    }
+    const [repositoryRootA, cwdA] = await Promise.all([fs.realpath(repositoryRoot), fs.realpath(cwd)]);
+    const basePaths = getBasePaths(repositoryRootA, cwdA);
+    const basePath = await locatePath(basePaths);
+    if (basePath === undefined) {
+        return {};
+    }
+    // `base` starting with a `/` are relative to `repositoryRoot`, so we cannot
+    // return an absolute path
+    const base = relative(repositoryRoot, dirname(basePath));
+    // When `base` is explicitely overridden, `baseRelDir: true` makes more sense
+    // since we want `publish`, `functions` and `edge_functions` to be relative to it.
+    return { base, baseRelDir: true };
+};
+// Returns list of files to check for the existence of a `base`
+const getBasePaths = function (repositoryRoot, cwd) {
+    const subdirs = getSubdirs(repositoryRoot, cwd);
+    const basePaths = subdirs.flatMap((subdir) => BASE_FILENAMES.map((filename) => `${subdir}/${filename}`));
+    return basePaths;
+};
+// Retrieves list of directories between `repositoryRoot` and `cwd`, including
+// `cwd` but excluding `repositoryRoot`
+const getSubdirs = function (repositoryRoot, dir, subdirs = []) {
+    if (!dir.startsWith(`${repositoryRoot}${sep}`)) {
+        return subdirs;
+    }
+    return getSubdirs(repositoryRoot, dirname(dir), [...subdirs, dir]);
+};
+const BASE_FILENAMES = ['.netlify', 'netlify.toml', 'package.json'];
+// Returns the first path that exists.
+// Like `locate-path` library but works with mixed files/directories
+const locatePath = async function (paths) {
+    const results = await Promise.all(paths.map(returnIfExists));
+    const path = results.find(Boolean);
+    return path;
+};
+const returnIfExists = async function (path) {
+    if (!(await pathExists(path))) {
+        return;
+    }
+    return path;
+};

package/lib/options/branch.js

@@ -0,0 +1,31 @@
+import { execaCommand } from 'execa';
+// Find out git branch among (in priority order):
+//   - `branch` option
+//   - `BRANCH` environment variable
+//   - `HEAD` branch (using `git`)
+//   - `main` (using `git`)
+//   - 'master' (fallback)
+export const getBranch = async function ({ branch, repositoryRoot }) {
+    if (branch) {
+        return branch;
+    }
+    const headBranch = await getGitBranch(repositoryRoot, 'HEAD');
+    if (headBranch !== undefined) {
+        return headBranch;
+    }
+    const mainBranch = await getGitBranch(repositoryRoot, 'main');
+    if (mainBranch !== undefined) {
+        return mainBranch;
+    }
+    return FALLBACK_BRANCH;
+};
+const getGitBranch = async function (repositoryRoot, gitRef) {
+    try {
+        const { stdout } = await execaCommand(`git rev-parse --abbrev-ref ${gitRef}`, { cwd: repositoryRoot });
+        return stdout;
+    }
+    catch {
+        // continue regardless error
+    }
+};
+const FALLBACK_BRANCH = 'master';

package/lib/options/feature_flags.js

@@ -0,0 +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));
+};
+const isNotEmpty = function (name) {
+    return name.trim() !== '';
+};
+const getFeatureFlag = function (name) {
+    return { [name]: true };
+};
+// Default values for feature flags
+export const DEFAULT_FEATURE_FLAGS = {};