@netlify/build 27.18.4 → 27.18.6-rc

package/src/log/messages/core_steps.js

@@ -1,104 +0,0 @@
-import path from 'path'
-
-import { log, logArray, logErrorSubHeader, logWarningSubHeader } from '../logger.js'
-import { THEME } from '../theme.js'
-
-const logBundleResultFunctions = ({ functions, headerMessage, logs, error }) => {
-  const functionNames = functions.map(({ path: functionPath }) => path.basename(functionPath))
-
-  if (error) {
-    logErrorSubHeader(logs, headerMessage)
-  } else {
-    logWarningSubHeader(logs, headerMessage)
-  }
-
-  logArray(logs, functionNames)
-}
-
-export const logBundleResults = ({ logs, results = [] }) => {
-  const resultsWithErrors = results.filter(({ bundlerErrors }) => bundlerErrors && bundlerErrors.length !== 0)
-  const resultsWithWarnings = results.filter(
-    ({ bundler, bundlerWarnings }) => bundler === 'esbuild' && bundlerWarnings && bundlerWarnings.length !== 0,
-  )
-  const modulesWithDynamicImports = [
-    ...new Set(results.flatMap((result) => result.nodeModulesWithDynamicImports || [])),
-  ]
-
-  if (resultsWithErrors.length !== 0) {
-    logBundleResultFunctions({
-      functions: resultsWithErrors,
-      headerMessage: 'Failed to bundle functions with selected bundler (fallback used):',
-      logs,
-      error: true,
-    })
-  }
-
-  if (resultsWithWarnings.length !== 0) {
-    logBundleResultFunctions({
-      functions: resultsWithWarnings,
-      headerMessage: 'Functions bundled with warnings:',
-      logs,
-      error: false,
-    })
-  }
-
-  if (modulesWithDynamicImports.length !== 0) {
-    logModulesWithDynamicImports({ logs, modulesWithDynamicImports })
-  }
-}
-
-export const logFunctionsNonExistingDir = function (logs, relativeFunctionsSrc) {
-  log(logs, `The Netlify Functions setting targets a non-existing directory: ${relativeFunctionsSrc}`)
-}
-
-// Print the list of Netlify Functions about to be bundled
-export const logFunctionsToBundle = function ({
-  logs,
-  userFunctions,
-  userFunctionsSrc,
-  userFunctionsSrcExists,
-  internalFunctions,
-  internalFunctionsSrc,
-  type = 'Functions',
-}) {
-  if (internalFunctions.length !== 0) {
-    log(logs, `Packaging ${type} from ${THEME.highlightWords(internalFunctionsSrc)} directory:`)
-    logArray(logs, internalFunctions, { indent: false })
-  }
-
-  if (!userFunctionsSrcExists) {
-    return
-  }
-
-  if (userFunctions.length === 0) {
-    log(logs, `No ${type} were found in ${THEME.highlightWords(userFunctionsSrc)} directory`)
-
-    return
-  }
-
-  if (internalFunctions.length !== 0) {
-    log(logs, '')
-  }
-
-  log(logs, `Packaging ${type} from ${THEME.highlightWords(userFunctionsSrc)} directory:`)
-  logArray(logs, userFunctions, { indent: false })
-}
-
-const logModulesWithDynamicImports = ({ logs, modulesWithDynamicImports }) => {
-  const externalNodeModules = modulesWithDynamicImports.map((moduleName) => `"${moduleName}"`).join(', ')
-
-  logWarningSubHeader(logs, `The following Node.js modules use dynamic expressions to include files:`)
-  logArray(logs, modulesWithDynamicImports)
-  log(
-    logs,
-    `\n  Because files included with dynamic expressions aren't bundled with your serverless functions by default,
-  this may result in an error when invoking a function. To resolve this error, you can mark these Node.js
-  modules as external in the [functions] section of your \`netlify.toml\` configuration file:
-
-  [functions]
-    external_node_modules = [${externalNodeModules}]
-
-  Visit https://ntl.fyi/dynamic-imports for more information.
-  `,
-  )
-}

package/src/log/messages/dry.js

@@ -1,63 +0,0 @@
-import figures from 'figures'
-
-import { logMessage, logSubHeader } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logDryRunStart = function ({ logs, eventWidth, stepsCount }) {
-  const columnWidth = getDryColumnWidth(eventWidth, stepsCount)
-  const line = '─'.repeat(columnWidth)
-  const secondLine = '─'.repeat(columnWidth)
-
-  logSubHeader(logs, 'Netlify Build Commands')
-  logMessage(
-    logs,
-    `For more information on build events see the docs https://github.com/netlify/build
-
-Running \`netlify build\` will execute this build flow
-
-${THEME.header(`┌─${line}─┬─${secondLine}─┐
-│ ${DRY_HEADER_NAMES[0].padEnd(columnWidth)} │ ${DRY_HEADER_NAMES[1].padEnd(columnWidth)} │
-└─${line}─┴─${secondLine}─┘`)}`,
-  )
-}
-
-export const logDryRunStep = function ({
-  logs,
-  step: { event, packageName, coreStepDescription },
-  index,
-  netlifyConfig,
-  eventWidth,
-  stepsCount,
-}) {
-  const columnWidth = getDryColumnWidth(eventWidth, stepsCount)
-  const fullName = getFullName(coreStepDescription, netlifyConfig, packageName)
-  const line = '─'.repeat(columnWidth)
-  const countText = `${index + 1}. `
-  const downArrow = stepsCount === index + 1 ? '  ' : ` ${figures.arrowDown}`
-  const eventWidthA = columnWidth - countText.length - downArrow.length
-
-  logMessage(
-    logs,
-    `${THEME.header(`┌─${line}─┐`)}
-${THEME.header(`│ ${countText}${event.padEnd(eventWidthA)}${downArrow} │`)} ${fullName}
-${THEME.header(`└─${line}─┘ `)}`,
-  )
-}
-
-const getFullName = function (coreStepDescription, netlifyConfig, packageName) {
-  return coreStepDescription === undefined
-    ? `Plugin ${THEME.highlightWords(packageName)}`
-    : coreStepDescription({ netlifyConfig })
-}
-
-const getDryColumnWidth = function (eventWidth, stepsCount) {
-  const symbolsWidth = `${stepsCount}`.length + COLUMN_EXTRA_WIDTH
-  return Math.max(eventWidth + symbolsWidth, DRY_HEADER_NAMES[1].length)
-}
-
-const COLUMN_EXTRA_WIDTH = 4
-const DRY_HEADER_NAMES = ['Event', 'Location']
-
-export const logDryRunEnd = function (logs) {
-  logMessage(logs, `\nIf this looks good to you, run \`netlify build\` to execute the build\n`)
-}

package/src/log/messages/install.js

@@ -1,32 +0,0 @@
-import { isRuntime } from '../../utils/runtime.js'
-import { log, logArray, logSubHeader } from '../logger.js'
-
-export const logInstallMissingPlugins = function (logs, packages) {
-  const runtimes = packages.filter((pkg) => isRuntime(pkg))
-  const plugins = packages.filter((pkg) => !isRuntime(pkg))
-
-  if (plugins.length !== 0) {
-    logSubHeader(logs, 'Installing plugins')
-    logArray(logs, packages)
-  }
-
-  if (runtimes.length !== 0) {
-    const [nextRuntime] = runtimes
-
-    logSubHeader(logs, `Using Next.js Runtime - v${nextRuntime.pluginPackageJson.version}`)
-  }
-}
-
-export const logInstallLocalPluginsDeps = function (logs, localPluginsOptions) {
-  const packages = localPluginsOptions.map(getPackageName)
-  logSubHeader(logs, 'Installing local plugins dependencies')
-  logArray(logs, packages)
-}
-
-export const logInstallFunctionDependencies = function () {
-  log(undefined, 'Installing functions dependencies')
-}
-
-const getPackageName = function ({ packageName }) {
-  return packageName
-}

package/src/log/messages/ipc.js

@@ -1,38 +0,0 @@
-import { log } from '../logger.js'
-
-const logVerbose = function (logs, verbose, message) {
-  if (!verbose) {
-    return
-  }
-
-  log(logs, message)
-}
-
-export const logSendingEventToChild = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step starting.')
-}
-
-export const logSentEventToChild = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step started.')
-}
-
-export const logPluginMethodStart = function (verbose) {
-  logVerbose(undefined, verbose, 'Plugin logic started.')
-}
-
-export const logPluginMethodEnd = function (verbose) {
-  logVerbose(undefined, verbose, 'Plugin logic ended.')
-}
-
-export const logSendingEventToParent = function (verbose, error) {
-  const message = error instanceof Error ? `Step erroring.\n${error.stack}` : 'Stop closing.'
-  logVerbose(undefined, verbose, message)
-}
-
-export const logReceivedEventFromChild = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step ended.')
-}
-
-export const logStepCompleted = function (logs, verbose) {
-  logVerbose(logs, verbose, 'Step completed.')
-}

package/src/log/messages/mutations.js

@@ -1,82 +0,0 @@
-import { promises as fs } from 'fs'
-import { inspect } from 'util'
-
-import { pathExists } from 'path-exists'
-
-import { log, logMessage, logSubHeader } from '../logger.js'
-
-export const logConfigMutations = function (logs, newConfigMutations, debug) {
-  const configMutationsToLog = debug ? newConfigMutations : newConfigMutations.filter(shouldLogConfigMutation)
-  configMutationsToLog.forEach(({ keysString, value }) => {
-    logConfigMutation(logs, keysString, value)
-  })
-}
-
-// Some configuration mutations are only logged in debug mode
-const shouldLogConfigMutation = function ({ keysString }) {
-  return !HIDDEN_PROPS.some((hiddenProp) => keysString.startsWith(hiddenProp))
-}
-
-// `functions` is an object which can have thousands of properties, one per
-// function file. This can be very verbose, especially for plugins which create
-// many function files like Essential Next.js
-const HIDDEN_PROPS = ['functions']
-
-const logConfigMutation = function (logs, keysString, value) {
-  const newValue = shouldHideConfigValue(keysString) ? '' : ` to ${inspect(value, { colors: false })}`
-  log(logs, `Netlify configuration property "${keysString}" value changed${newValue}.`)
-}
-
-const shouldHideConfigValue = function (keysString) {
-  return SECRET_PROPS.some((secretProp) => keysString.startsWith(secretProp))
-}
-
-const SECRET_PROPS = ['build.environment']
-
-export const logConfigOnUpload = async function ({ logs, configPath, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Uploaded config')
-
-  if (!(await pathExists(configPath))) {
-    logMessage(logs, 'No netlify.toml')
-    return
-  }
-
-  const configContents = await fs.readFile(configPath, 'utf8')
-  logMessage(logs, configContents.trim())
-}
-
-export const logHeadersOnUpload = async function ({ logs, headersPath, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Uploaded headers')
-
-  if (!(await pathExists(headersPath))) {
-    logMessage(logs, 'No headers')
-    return
-  }
-
-  const headersContents = await fs.readFile(headersPath, 'utf8')
-  logMessage(logs, headersContents.trim())
-}
-
-export const logRedirectsOnUpload = async function ({ logs, redirectsPath, debug }) {
-  if (!debug) {
-    return
-  }
-
-  logSubHeader(logs, 'Uploaded redirects')
-
-  if (!(await pathExists(redirectsPath))) {
-    logMessage(logs, 'No redirects\n')
-    return
-  }
-
-  const redirectsContents = await fs.readFile(redirectsPath, 'utf8')
-  logMessage(logs, `${redirectsContents.trim()}\n`)
-}

package/src/log/messages/plugins.js

@@ -1,39 +0,0 @@
-import { log, logArray, logWarning, logSubHeader } from '../logger.js'
-
-export const logPluginsFetchError = function (logs, message) {
-  logWarning(
-    logs,
-    `
-Warning: could not fetch latest plugins list. Plugins versions might not be the latest.
-${message}`,
-  )
-}
-
-export const logPluginsList = function ({ pluginsList, debug, logs }) {
-  if (!debug) {
-    return
-  }
-
-  // eslint-disable-next-line fp/no-mutating-methods
-  const pluginsListArray = Object.entries(pluginsList).map(getPluginsListItem).sort()
-
-  logSubHeader(logs, 'Available plugins')
-  logArray(logs, pluginsListArray)
-}
-
-const getPluginsListItem = function ([packageName, versions]) {
-  return `${packageName}@${versions[0].version}`
-}
-
-export const logFailPluginWarning = function (methodName, event) {
-  logWarning(
-    undefined,
-    `Plugin error: since "${event}" happens after deploy, the build has already succeeded and cannot fail anymore. This plugin should either:
-- use utils.build.failPlugin() instead of utils.build.${methodName}() to clarify that the plugin failed, but not the build.
-- use "onPostBuild" instead of "${event}" if the plugin failure should make the build fail too. Please note that "onPostBuild" (unlike "${event}") happens before deploy.`,
-  )
-}
-
-export const logDeploySuccess = function (logs) {
-  log(logs, 'Site deploy was successfully initiated')
-}

package/src/log/messages/status.js

@@ -1,16 +0,0 @@
-import { logMessage, logHeader, logSubHeader } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logStatuses = function (logs, statuses) {
-  logHeader(logs, 'Summary')
-  statuses.forEach((status) => {
-    logStatus(logs, status)
-  })
-}
-
-const logStatus = function (logs, { packageName, title = `Plugin ${packageName} ran successfully`, summary, text }) {
-  const titleA = title.includes(packageName) ? title : `${packageName}: ${title}`
-  const body = text === undefined ? summary : `${summary}\n${THEME.dimWords(text)}`
-  logSubHeader(logs, titleA)
-  logMessage(logs, body)
-}

package/src/log/messages/steps.js

@@ -1,22 +0,0 @@
-import { getLogHeaderFunc } from '../header_func.js'
-import { log, logMessage } from '../logger.js'
-import { THEME } from '../theme.js'
-
-export const logStepStart = function ({ logs, event, packageName, coreStepDescription, index, error, netlifyConfig }) {
-  const description = getDescription({ coreStepDescription, netlifyConfig, packageName, event })
-  const logHeaderFunc = getLogHeaderFunc(error)
-  logHeaderFunc(logs, `${index + 1}. ${description}`)
-  logMessage(logs, '')
-}
-
-const getDescription = function ({ coreStepDescription, netlifyConfig, packageName, event }) {
-  return coreStepDescription === undefined ? `${packageName} (${event} event)` : coreStepDescription({ netlifyConfig })
-}
-
-export const logBuildCommandStart = function (logs, buildCommand) {
-  log(logs, THEME.highlightWords(`$ ${buildCommand}`))
-}
-
-export const logStepSuccess = function (logs) {
-  logMessage(logs, '')
-}

package/src/log/old_version.js

@@ -1,41 +0,0 @@
-import { stdout } from 'process'
-
-import UpdateNotifier from 'update-notifier'
-
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-
-// Many build errors happen in local builds that do not use the latest version
-// of `@netlify/build`. We print a warning message on those.
-// We only print this when Netlify CLI has been used. Programmatic usage might
-// come from a deep dependency calling `@netlify/build` and user might not be
-// able to take any upgrade action, making the message noisy.
-export const logOldCliVersionError = function ({ mode, testOpts }) {
-  if (mode !== 'cli') {
-    return
-  }
-
-  const corePackageJson = getCorePackageJson(testOpts)
-  UpdateNotifier({ pkg: corePackageJson, updateCheckInterval: 1 }).notify({
-    message: OLD_VERSION_MESSAGE,
-    shouldNotifyInNpmScript: true,
-  })
-}
-
-const getCorePackageJson = function (testOpts) {
-  // TODO: Find a way to test this without injecting code in the `src/`
-  if (testOpts.oldCliLogs) {
-    // `update-notifier` does not do anything if not in a TTY.
-    // In tests, we need to monkey patch this
-    // Mutation is required due to how `stdout.isTTY` works
-    // eslint-disable-next-line fp/no-mutation
-    stdout.isTTY = true
-
-    return { ...ROOT_PACKAGE_JSON, version: '0.0.1' }
-  }
-
-  return ROOT_PACKAGE_JSON
-}
-
-const OLD_VERSION_MESSAGE = `Please update netlify-cli to its latest version.
-If netlify-cli is already the latest version,
-please update your dependencies lock file instead.`

package/src/log/serialize.js

@@ -1,13 +0,0 @@
-import { dump } from 'js-yaml'
-
-export const serializeObject = function (object) {
-  return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd()
-}
-
-export const serializeArray = function (array) {
-  return array.map(addDash).join('\n')
-}
-
-const addDash = function (string) {
-  return ` - ${string}`
-}

package/src/log/stream.js

@@ -1,85 +0,0 @@
-import { stdout, stderr } from 'process'
-import { promisify } from 'util'
-
-// TODO: replace with `timers/promises` after dropping Node < 15.0.0
-const pSetTimeout = promisify(setTimeout)
-
-// We try to use `stdio: inherit` because it keeps `stdout/stderr` as `TTY`,
-// which solves many problems. However we can only do it in build.command.
-// Plugins have several events, so need to be switch on and off instead.
-// In buffer mode (`logs` not `undefined`), `pipe` is necessary.
-export const getBuildCommandStdio = function (logs) {
-  if (logs !== undefined) {
-    return 'pipe'
-  }
-
-  return 'inherit'
-}
-
-// Add build command output
-export const handleBuildCommandOutput = function ({ stdout: commandStdout, stderr: commandStderr }, logs) {
-  if (logs === undefined) {
-    return
-  }
-
-  pushBuildCommandOutput(commandStdout, logs.stdout)
-  pushBuildCommandOutput(commandStderr, logs.stderr)
-}
-
-const pushBuildCommandOutput = function (output, logsArray) {
-  if (output === '') {
-    return
-  }
-
-  logsArray.push(output)
-}
-
-// Start plugin step output
-export const pipePluginOutput = function (childProcess, logs) {
-  if (logs === undefined) {
-    return streamOutput(childProcess)
-  }
-
-  return pushOutputToLogs(childProcess, logs)
-}
-
-// Stop streaming/buffering plugin step output
-export const unpipePluginOutput = async function (childProcess, logs, listeners) {
-  // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
-  await pSetTimeout(0)
-
-  if (logs === undefined) {
-    return unstreamOutput(childProcess)
-  }
-
-  unpushOutputToLogs(childProcess, logs, listeners)
-}
-
-// Usually, we stream stdout/stderr because it is more efficient
-const streamOutput = function (childProcess) {
-  childProcess.stdout.pipe(stdout)
-  childProcess.stderr.pipe(stderr)
-}
-
-const unstreamOutput = function (childProcess) {
-  childProcess.stdout.unpipe(stdout)
-  childProcess.stderr.unpipe(stderr)
-}
-
-// In tests, we push to the `logs` array instead
-const pushOutputToLogs = function (childProcess, logs) {
-  const stdoutListener = logsListener.bind(null, logs.stdout)
-  const stderrListener = logsListener.bind(null, logs.stderr)
-  childProcess.stdout.on('data', stdoutListener)
-  childProcess.stderr.on('data', stderrListener)
-  return { stdoutListener, stderrListener }
-}
-
-const logsListener = function (logs, chunk) {
-  logs.push(chunk.toString().trimEnd())
-}
-
-const unpushOutputToLogs = function (childProcess, logs, { stdoutListener, stderrListener }) {
-  childProcess.stdout.removeListener('data', stdoutListener)
-  childProcess.stderr.removeListener('data', stderrListener)
-}

package/src/log/theme.js

@@ -1,26 +0,0 @@
-import chalk from 'chalk'
-
-// Color theme. Please use this instead of requiring chalk directly, to ensure
-// consistent colors.
-export const THEME = {
-  // Main headers
-  header: chalk.cyanBright.bold,
-  // Single lines used as subheaders
-  subHeader: chalk.cyan.bold,
-  // One of several words that should be highlighted inside a line
-  highlightWords: chalk.cyan,
-  // Same for errors
-  errorHeader: chalk.redBright.bold,
-  errorSubHeader: chalk.red.bold,
-  errorLine: chalk.redBright,
-  errorHighlightWords: chalk.redBright.bold,
-  // Same for warnings
-  warningHeader: chalk.yellowBright.bold,
-  warningSubHeader: chalk.yellow.bold,
-  warningLine: chalk.yellowBright,
-  warningHighlightWords: chalk.yellowBright.bold,
-  // One of several words that should be dimmed inside a line
-  dimWords: chalk.gray,
-  // No colors
-  none: (string) => string,
-}

package/src/plugins/child/diff.js

@@ -1,55 +0,0 @@
-import { isDeepStrictEqual } from 'util'
-
-import isPlainObj from 'is-plain-obj'
-import rfdc from 'rfdc'
-
-const clone = rfdc()
-
-// Copy `netlifyConfig` so we can compare before/after mutating it
-export const cloneNetlifyConfig = function (netlifyConfig) {
-  return clone(netlifyConfig)
-}
-
-// Diff `netlifyConfig` before and after mutating it to retrieve an array of
-// `configMutations` objects.
-// We need to keep track of the changes on `netlifyConfig` so they can be
-// processed later to:
-//  - Warn plugin authors when mutating read-only properties
-//  - Apply the change to `netlifyConfig` in the parent process so it can
-//    run `@netlify/config` to normalize and validate the new values
-// `configMutations` is passed to parent process as JSON
-export const getConfigMutations = function (netlifyConfig, netlifyConfigCopy, event) {
-  const configMutations = diffObjects(netlifyConfig, netlifyConfigCopy, [])
-  return configMutations.map((configMutation) => getConfigMutation(configMutation, event))
-}
-
-// We only recurse over plain objects, not arrays. Which means array properties
-// can only be modified all at once.
-const diffObjects = function (objA, objB, parentKeys) {
-  const allKeys = [...new Set([...Object.keys(objA), ...Object.keys(objB)])]
-  return allKeys.flatMap((key) => {
-    const valueA = objA[key]
-    const valueB = objB[key]
-    const keys = [...parentKeys, key]
-
-    if (isPlainObj(valueA) && isPlainObj(valueB)) {
-      return diffObjects(valueA, valueB, keys)
-    }
-
-    if (isDeepStrictEqual(valueA, valueB)) {
-      return []
-    }
-
-    return [{ keys, value: valueB }]
-  })
-}
-
-const getConfigMutation = function ({ keys, value }, event) {
-  const serializedKeys = keys.map(String)
-  return {
-    keys: serializedKeys,
-    keysString: serializedKeys.join('.'),
-    value,
-    event,
-  }
-}

package/src/plugins/child/error.js

@@ -1,32 +0,0 @@
-import logProcessErrors from 'log-process-errors'
-
-import { errorToJson } from '../../error/build.js'
-import { addDefaultErrorInfo, isBuildError } from '../../error/info.js'
-import { normalizeError } from '../../error/parse/normalize.js'
-import { sendEventToParent } from '../ipc.js'
-
-// Handle any top-level error and communicate it back to parent
-export const handleError = async function (error, verbose) {
-  const errorA = normalizeError(error)
-  addDefaultErrorInfo(errorA, { type: 'pluginInternal' })
-  const errorPayload = errorToJson(errorA)
-  await sendEventToParent('error', errorPayload, verbose, errorA)
-}
-
-// On uncaught exceptions and unhandled rejections, print the stack trace.
-// Also, prevent child processes from crashing on uncaught exceptions.
-export const handleProcessErrors = function () {
-  logProcessErrors({ log: handleProcessError, exitOn: [] })
-}
-
-const handleProcessError = async function (error, level, originalError) {
-  if (level !== 'error') {
-    console[level](error)
-    return
-  }
-
-  // Do not use log-process-errors prettification with errors thrown by `utils.build.*`
-  const errorA = isBuildError(originalError) ? originalError : error
-
-  await handleError(errorA)
-}

package/src/plugins/child/lazy.js

@@ -1,18 +0,0 @@
-import memoizeOne from 'memoize-one'
-
-// Add a `object[propName]` whose value is the return value of `getFunc()`, but
-// is only retrieved when accessed.
-export const addLazyProp = function (object, propName, getFunc) {
-  const mGetFunc = memoizeOne(getFunc, returnTrue)
-  // Mutation is required due to the usage of `Object.defineProperty()`
-  // eslint-disable-next-line fp/no-mutating-methods
-  Object.defineProperty(object, propName, {
-    get: mGetFunc,
-    enumerable: true,
-    configurable: true,
-  })
-}
-
-const returnTrue = function () {
-  return true
-}