@netlify/config 18.2.4 → 18.2.5

package/lib/merge_normalize.js

@@ -1,31 +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'
-
+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
-}
-
+    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
-}
+    validatePreNormalizeConfig(config);
+    const configA = normalizeConfig(config);
+    validatePostNormalizeConfig(configA);
+    return configA;
+};

package/lib/mutations/apply.js

@@ -1,10 +1,8 @@
-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'
-
+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`
@@ -12,67 +10,57 @@ import { getPropName } from './config_prop_name.js'
 // 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)
-}
-
+    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 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}".`)
-  }
-}
-
+    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 } }
-}
-
+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' },
-}
+    '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

@@ -1,16 +1,14 @@
 // Retrieve normalized property name
 export const getPropName = function (keys) {
-  return keys.reduce(normalizeDynamicProp, '')
-}
-
+    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}`
-}
-
+    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.*'])
+const DYNAMIC_OBJECT_PROPS = new Set(['build.services', 'build.environment', 'functions', 'functions.*']);

package/lib/mutations/update.js

@@ -1,117 +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'
-
+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),
-  ])
-}
-
+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
-}
-
+    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)
-}
-
+    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)
-}
-
+    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`),
-  ])
-}
-
+    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),
-  ])
-}
-
+    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`
-}
-
+    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)
-}
-
+    // 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 {}
-}
-
+    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)
-}
+    if (await pathExists(src)) {
+        await fs.copyFile(src, dest);
+        return;
+    }
+    await deleteNoError(dest);
+};

package/lib/normalize.js

@@ -1,36 +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'
-
+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 }
-}
-
+    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) })
-}
-
+    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: [],
-}
-
+    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 })
-}
+    return removeFalsy({ ...plugin, inputs });
+};

package/lib/options/base.js

@@ -1,66 +1,54 @@
-import { promises as fs } from 'fs'
-import { dirname, relative, sep } from 'path'
-
-import { pathExists } from 'path-exists'
-
+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 }
-}
-
+    // 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
-}
-
+    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']
-
+    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 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
-}
+    if (!(await pathExists(path))) {
+        return;
+    }
+    return path;
+};

package/lib/options/branch.js

@@ -1,5 +1,4 @@
-import { execaCommand } from 'execa'
-
+import { execaCommand } from 'execa';
 // Find out git branch among (in priority order):
 //   - `branch` option
 //   - `BRANCH` environment variable
@@ -7,28 +6,26 @@ import { execaCommand } from 'execa'
 //   - `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
-}
-
+    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 {}
-}
-
-const FALLBACK_BRANCH = 'master'
+    try {
+        const { stdout } = await execaCommand(`git rev-parse --abbrev-ref ${gitRef}`, { cwd: repositoryRoot });
+        return stdout;
+    }
+    catch {
+        // continue regardless error
+    }
+};
+const FALLBACK_BRANCH = 'master';