configorama 0.6.4 → 0.6.5

package/src/resolvers/valueFromCron.test.js

@@ -0,0 +1,132 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { _parseCronExpression } = require('./valueFromCron')
+
+test('parseCronExpression: basic patterns', () => {
+  assert.equal(_parseCronExpression('every minute'), '* * * * *')
+  assert.equal(_parseCronExpression('every hour'), '0 * * * *')
+  assert.equal(_parseCronExpression('every day'), '0 0 * * *')
+  assert.equal(_parseCronExpression('daily'), '0 0 * * *')
+  assert.equal(_parseCronExpression('hourly'), '0 * * * *')
+  assert.equal(_parseCronExpression('yearly'), '0 0 1 1 *')
+})
+
+test('parseCronExpression: business patterns', () => {
+  assert.equal(_parseCronExpression('weekdays'), '0 0 * * 1-5')
+  assert.equal(_parseCronExpression('weekends'), '0 0 * * 0,6')
+  assert.equal(_parseCronExpression('business hours'), '0 9-17 * * 1-5')
+})
+
+test('parseCronExpression: interval patterns', () => {
+  assert.equal(_parseCronExpression('every 5 minutes'), '*/5 * * * *')
+  assert.equal(_parseCronExpression('every 15 minutes'), '*/15 * * * *')
+  assert.equal(_parseCronExpression('every 2 hours'), '0 */2 * * *')
+  assert.equal(_parseCronExpression('every 3 days'), '0 0 */3 * *')
+  assert.equal(_parseCronExpression('every 2 weeks'), '0 0 * * 0/2')
+  assert.equal(_parseCronExpression('every 6 months'), '0 0 1 */6 *')
+  
+  // Test singular/plural forms
+  assert.equal(_parseCronExpression('every 1 minute'), '*/1 * * * *')
+  assert.equal(_parseCronExpression('every 1 hour'), '0 */1 * * *')
+  assert.equal(_parseCronExpression('every 1 day'), '0 0 */1 * *')
+  assert.equal(_parseCronExpression('every 1 week'), '0 0 * * 0/1')
+  assert.equal(_parseCronExpression('every 1 month'), '0 0 1 */1 *')
+  
+  // Test plural forms
+  assert.equal(_parseCronExpression('every 5 minutes'), '*/5 * * * *')
+  assert.equal(_parseCronExpression('every 2 hours'), '0 */2 * * *')
+  assert.equal(_parseCronExpression('every 3 days'), '0 0 */3 * *')
+  assert.equal(_parseCronExpression('every 2 weeks'), '0 0 * * 0/2')
+  assert.equal(_parseCronExpression('every 6 months'), '0 0 1 */6 *')
+})
+
+test('parseCronExpression: simple interval patterns', () => {
+  // Test singular forms
+  assert.equal(_parseCronExpression('1 minute'), '*/1 * * * *')
+  assert.equal(_parseCronExpression('1 hour'), '0 */1 * * *')
+  assert.equal(_parseCronExpression('1 day'), '0 0 */1 * *')
+  assert.equal(_parseCronExpression('1 week'), '0 0 * * 0/1')
+  assert.equal(_parseCronExpression('1 month'), '0 0 1 */1 *')
+  
+  // Test plural forms
+  assert.equal(_parseCronExpression('5 minutes'), '*/5 * * * *')
+  assert.equal(_parseCronExpression('2 hours'), '0 */2 * * *')
+  assert.equal(_parseCronExpression('3 days'), '0 0 */3 * *')
+  assert.equal(_parseCronExpression('2 weeks'), '0 0 * * 0/2')
+  assert.equal(_parseCronExpression('6 months'), '0 0 1 */6 *')
+})
+
+test('parseCronExpression: specific times', () => {
+  assert.equal(_parseCronExpression('at 9:30'), '30 9 * * *')
+  assert.equal(_parseCronExpression('at 14:15'), '15 14 * * *')
+  assert.equal(_parseCronExpression('at 9:30 am'), '30 9 * * *')
+  assert.equal(_parseCronExpression('at 9:30 pm'), '30 21 * * *')
+  assert.equal(_parseCronExpression('at 12:30 am'), '30 0 * * *')
+  assert.equal(_parseCronExpression('at 12:30 pm'), '30 12 * * *')
+})
+
+test('parseCronExpression: weekday + time patterns', () => {
+  assert.equal(_parseCronExpression('on monday at 9:00'), '0 9 * * 1', 'monday')
+  assert.equal(_parseCronExpression('on friday at 17:30'), '30 17 * * 5', 'friday')
+  assert.equal(_parseCronExpression('on sunday at 12:00'), '0 12 * * 0', 'sunday')
+  assert.equal(_parseCronExpression('on wednesday at 9:30 pm'), '30 21 * * 3', 'wednesday')
+  assert.equal(_parseCronExpression('on saturday,sunday at 12:00'), '0 12 * * 6,0', 'saturday,sunday')
+  const mwf = _parseCronExpression('on monday,wednesday,friday at 9:00')
+  console.log('mwf', mwf)
+  assert.equal(mwf, '0 9 * * 1,3,5', 'monday,wednesday,friday')
+  const tth = _parseCronExpression('on tuesday,thursday at 2:30 pm')
+  assert.equal(tth, '30 14 * * 2,4', 'tuesday,thursday')
+  const sst = _parseCronExpression('on saturday,sunday at 12:00')
+  assert.equal(sst, '0 12 * * 6,0', 'saturday,sunday')
+})
+
+test('parseCronExpression: ordinal dates of month', () => {
+  assert.equal(_parseCronExpression('on 1st of month at 00:00'), '0 0 1 * *')
+  assert.equal(_parseCronExpression('on 15th of month at 9:30 am'), '30 9 15 * *')
+  assert.equal(_parseCronExpression('on 31st of month at 2:00 pm'), '0 14 31 * *')
+  assert.equal(_parseCronExpression('on 2nd of month at 12:00'), '0 12 2 * *')
+  assert.equal(_parseCronExpression('on 3rd of month at 15:30'), '30 15 3 * *')
+  assert.equal(_parseCronExpression('on 4th of month at 12:00 am'), '0 0 4 * *')
+})
+
+test('parseCronExpression: case insensitive', () => {
+  assert.equal(_parseCronExpression('EVERY MINUTE'), '* * * * *')
+  assert.equal(_parseCronExpression('Weekdays'), '0 0 * * 1-5')
+  assert.equal(_parseCronExpression('At 9:30 PM'), '30 21 * * *')
+  assert.equal(_parseCronExpression('ON MONDAY AT 9:00'), '0 9 * * 1')
+})
+
+test('parseCronExpression: existing cron expressions pass through', () => {
+  assert.equal(_parseCronExpression('0 12 * * *'), '0 12 * * *')
+  assert.equal(_parseCronExpression('*/5 * * * *'), '*/5 * * * *')
+  //assert.equal(_parseCronExpression('@reboot'), '@reboot')
+  assert.equal(_parseCronExpression('15 2,14 * * *'), '15 2,14 * * *')
+})
+
+test('parseCronExpression: days of week', () => {
+  assert.equal(_parseCronExpression('monday'), '0 0 * * 1')
+  assert.equal(_parseCronExpression('tuesday'), '0 0 * * 2')
+  assert.equal(_parseCronExpression('wednesday'), '0 0 * * 3')
+  assert.equal(_parseCronExpression('thursday'), '0 0 * * 4')
+  assert.equal(_parseCronExpression('friday'), '0 0 * * 5')
+  assert.equal(_parseCronExpression('saturday'), '0 0 * * 6')
+  assert.equal(_parseCronExpression('sunday'), '0 0 * * 0')
+})
+
+test('parseCronExpression: special patterns', () => {
+  assert.equal(_parseCronExpression('first day of month'), '0 0 1 * *')
+  assert.equal(_parseCronExpression('middle of month'), '0 0 15 * *')
+  assert.equal(_parseCronExpression('never'), '0 0 30 2 *')
+  assert.equal(_parseCronExpression('reboot'), '@reboot')
+  assert.equal(_parseCronExpression('startup'), '@reboot')
+})
+
+test('parseCronExpression: error handling', () => {
+  assert.throws(() => _parseCronExpression(''), /must be a non-empty string/)
+  assert.throws(() => _parseCronExpression(null), /must be a non-empty string/)
+  assert.throws(() => _parseCronExpression(123), /must be a non-empty string/)
+  assert.throws(() => _parseCronExpression('invalid pattern'), /Unrecognized cron pattern/)
+  assert.throws(() => _parseCronExpression('every xyz'), /Unrecognized cron pattern/)
+})
+
+test.run()

package/src/resolvers/valueFromEval.js

@@ -0,0 +1,37 @@
+// const evalRefSyntax = RegExp(/^eval\((~?[\{\}\:\${}a-zA=>+!-Z0-9._\-\/,'"\*\` ]+?)?\)/g)
+const evalRefSyntax = RegExp(/^eval\((.*)?\)/g)
+
+async function getValueFromEval(variableString) {
+  // console.log('getValueFromEval variableString', variableString)
+  // console.log('getValueFromEval variableString', variableString)
+  // Extract the expression inside eval()
+  const match = variableString.match(/^eval\((.+)\)$/)
+  // console.log('match', match)
+  if (!match) {
+    throw new Error(`Invalid eval syntax: ${variableString}. Expected format: eval(expression)`)
+  }
+  
+  const expression = match[1].trim()
+  // console.log('expression', expression)
+  
+  // Use "justin" variant to support strict comparison (===, !==) and other JS-like operators
+  try {
+    const { default: subscript } = await import('subscript/justin')
+    
+    // Handle string comparisons by ensuring both sides are quoted
+    const processedExpression = expression.replace(/([a-zA-Z0-9_]+)\s*([=!<>]=?)\s*['"]([^'"]+)['"]/g, '"$1"$2"$3"')
+    
+    // console.log('processedExpression', processedExpression)
+    const fn = subscript(processedExpression)
+    const result = fn()
+    return result
+  } catch (error) {
+    throw new Error(`Error evaluating expression "${expression}": ${error.message}`)
+  }
+}
+
+module.exports = {
+  type: 'eval',
+  match: evalRefSyntax,
+  resolver: getValueFromEval
+}

package/src/resolvers/valueFromEval.test.js

@@ -0,0 +1,44 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { resolver } = require('./valueFromEval')
+
+test('Basic boolean evaluation - true', async () => {
+  const result = await resolver('eval(200 > 100)')
+  assert.is(result, true)
+})
+
+test('Basic boolean evaluation - false', async () => {
+  const result = await resolver('eval(100 > 200)')
+  assert.is(result, false)
+})
+
+test('Numeric evaluation', async () => {
+  const result = await resolver('eval(10 + 5)')
+  assert.is(result, 15)
+})
+
+test('String comparison', async () => {
+  const result = await resolver('eval("hello" == "hello")')
+  assert.is(result, true)
+})
+
+test('String comparison - strict', async () => {
+  const result = await resolver('eval("hello" === "hello")')
+  assert.is(result, true)
+})
+
+test('Complex boolean expression', async () => {
+  const result = await resolver('eval(100 > 50)')
+  assert.is(result, true)
+})
+
+test('Invalid syntax throws error', async () => {
+  try {
+    await resolver('eval(')
+    assert.unreachable('Should have thrown an error')
+  } catch (error) {
+    assert.ok(error.message.includes('Invalid eval syntax'))
+  }
+})
+
+test.run()

package/src/resolvers/valueFromGit.js

@@ -227,8 +227,9 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
     // console.log('cwd', cwd)
     const output = await _exec(cmd, { cwd })
     const date = new Date(output)
-    cache.set(file, date)
-    return date.toISOString()
+    const dateString = date.toISOString()
+    cache.set(file, dateString)
+    return dateString
   } catch (err) {
     const projectRoot = findProjectRoot(cwd)
     if (!projectRoot) {
@@ -242,8 +243,9 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
       const backupFile = path.join(projectRoot, _file)
       const output = await _exec(`git log -1 --pretty="%ai" ${backupFile}`, { cwd: projectRoot })
       const date = new Date(output)
-      cache.set(file, date)
-      return date.toISOString()
+      const dateString = date.toISOString()
+      cache.set(file, dateString)
+      return dateString
     } catch (err) {
       if (throwOnMissing) {
         throw new Error(`File ${file} does not exist in Git`)

package/src/types.d.ts

@@ -0,0 +1,112 @@
+// Type definitions for configorama variable validation
+// This file provides TypeScript support for validating configuration variables
+
+// Valid variable prefixes supported by configorama
+export type KnownVariablePrefix = 'env:' | 'opt:' | 'self:' | 'file:' | 'git:' | 'cron:'
+
+// Quoted string literal type for fallback values
+type QuotedString = `"${string}"` | `'${string}'`
+
+// Helper to detect unknown variable prefixes (for validation)
+type UnknownVariablePrefix<S extends string> = S extends `\${${string}:${string}}`
+  ? S extends `\${${KnownVariablePrefix}${string}}`
+    ? never
+    : S
+  : never
+
+// Helper to exclude spaces or commas in the key section
+type NoCommaOrSpace<S extends string> = S extends `${string} ${string}`
+  ? never
+  : S extends `${string},${string}`
+  ? never
+  : S
+
+// Main prefix token that must not include spaces or commas
+type PrefixedKey = NoCommaOrSpace<string>
+
+// Helper for recursively building dot-prop paths from an object
+export type ObjectPaths<T> = T extends object
+  ? {
+      [K in keyof T & string]: T[K] extends object ? `${K}` | `${K}.${ObjectPaths<T[K]>}` : `${K}`
+    }[keyof T & string]
+  : never
+
+// Variables with fallback values (fully validated)
+type PrefixedVariableWithFallbackNumber = `\${${KnownVariablePrefix}${PrefixedKey}, ${number}}`
+type PrefixedVariableWithFallbackString = `\${${KnownVariablePrefix}${PrefixedKey}, ${QuotedString}}`
+type PrefixedVariableWithFallbackBoolean = `\${${KnownVariablePrefix}${PrefixedKey}, ${boolean}}`
+
+// Variables without fallback values (prefix-only)
+type PrefixedVariableNoFallback = `\${${KnownVariablePrefix}${PrefixedKey}}`
+
+// Self-reference (dot-prop) variables
+type SelfReferenceVariable<Root> = `\${${ObjectPaths<Root>}}`
+
+// Generic dot-prop variables (non-typed)
+type GenericDotPropVariable = `\${${string}.${string}}`
+
+// Union of all variable styles supported – narrowed by the primitive type T
+export type VariableToken<T, Root> = T extends string
+  ? PrefixedVariableWithFallbackString | PrefixedVariableNoFallback | SelfReferenceVariable<Root> | GenericDotPropVariable
+  : T extends number
+  ? PrefixedVariableWithFallbackNumber | PrefixedVariableNoFallback | SelfReferenceVariable<Root> | GenericDotPropVariable
+  : T extends boolean  
+  ? PrefixedVariableWithFallbackBoolean | PrefixedVariableNoFallback | SelfReferenceVariable<Root> | GenericDotPropVariable
+  : never
+
+// Resolution rule for primitive types
+export type ResolvedPrimitive<T, Root> = T extends string 
+  ? T | VariableToken<T, Root>
+  : T | VariableToken<T, Root>
+
+// Recursively resolve all values in an object tree
+export type DeepResolved<T, Root = T> = T extends object
+  ? { [K in keyof T]: DeepResolved<T[K], Root> }
+  : ResolvedPrimitive<T, Root>
+
+// Generic configuration resolver function type
+export type ConfigResolver<T> = (config: DeepResolved<T>) => DeepResolved<T>
+
+// Example usage with a custom config interface:
+/*
+interface MyConfig {
+  database: {
+    host: string
+    port: number
+    ssl: boolean
+  }
+  api: {
+    baseUrl: string
+    timeout: number
+  }
+}
+
+// This type allows variables in your config while maintaining type safety
+type ResolvedMyConfig = DeepResolved<MyConfig>
+
+// Usage example:
+const config: ResolvedMyConfig = {
+  database: {
+    host: '${env:DB_HOST, "localhost"}',     // ✅ String with quoted fallback
+    port: '${env:DB_PORT, 5432}',            // ✅ Number with unquoted fallback
+    ssl: '${env:SSL_ENABLED, false}'         // ✅ Boolean with unquoted fallback
+  },
+  api: {
+    baseUrl: '${env:API_URL}',               // ✅ Variable without fallback
+    timeout: '${api.defaultTimeout}'         // ✅ Dot-prop reference
+  }
+}
+
+// These would cause TypeScript errors:
+const badConfig: ResolvedMyConfig = {
+  database: {
+    host: '${env:DB_HOST, localhost}',       // ❌ Unquoted string fallback
+    port: '${env:DB_PORT, "5432"}',          // ❌ Quoted number fallback
+    ssl: '${env:SSL_ENABLED, "false"}'       // ❌ Quoted boolean fallback
+  },
+  api: {
+    baseUrl: '${unknownPrefix:API_URL}',     // ❌ Unknown variable prefix
+    timeout: 5000
+  }
+}
+*/

package/src/utils/cleanVariable.js

@@ -1,4 +1,6 @@
 const { findNestedVariables } = require('./find-nested-variables')
+
+const DEBUG = false
 /**
  * Convert variable into string
  * ${opt:foo} => 'opt:foo'
@@ -8,8 +10,20 @@ const { findNestedVariables } = require('./find-nested-variables')
 
 const fileRefSyntax = RegExp(/^file\((~?[a-zA-Z0-9._\-\/,'" ]+?)\)/g)
 const funcRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
-module.exports = function cleanVariable(match, variableSyntax, simple, caller) {
-  //console.log(`Clean input  [${caller}]`, match)
+module.exports = function cleanVariable(
+  match, 
+  variableSyntax, 
+  simple, 
+  caller, 
+  recursive = false,
+) {
+  if (DEBUG) {
+    console.log(`Clean input  [${caller}]`, match)
+  }
+  
+  // const outermostMatch = removeOuterMostBraces(match)
+  // console.log('outermostMatch', outermostMatch)
+  // return outermostMatch
 
   let varToClean = match
 
@@ -38,7 +52,13 @@ module.exports = function cleanVariable(match, variableSyntax, simple, caller) {
   const clean = varToClean.replace(variableSyntax, (context, contents) => {
     return contents.trim()
   })
-  //console.log(`Clean output [${caller}]`, clean)
+
+  // if (recursive && clean.match(variableSyntax)) {
+  //   return cleanVariable(clean, variableSyntax, simple, caller, true)
+  // }
+  if (DEBUG) {
+    console.log(`Clean output [${caller}]`, clean)
+  }
   return clean
 
   // Support for simple variable cleaning with no space tweaks
@@ -62,3 +82,47 @@ module.exports = function cleanVariable(match, variableSyntax, simple, caller) {
   // ^ trim White Space OutSide Quotes https://regex101.com/r/BuBNPN/1
   // Needed for fallback values with spaces. ${empty, 'fallback value with space'}
 }
+
+
+function findOutermostBraces(str) {
+  const matches = []
+  let i = 0
+  
+  while (i < str.length) {
+    if (str.substring(i, i + 2) === '${') {
+      let braceCount = 1
+      let start = i
+      i += 2
+      
+      while (i < str.length && braceCount > 0) {
+        if (str[i] === '{') braceCount++
+        else if (str[i] === '}') braceCount--
+        i++
+      }
+      
+      if (braceCount === 0) {
+        matches.push(str.substring(start, i))
+      }
+    } else {
+      i++
+    }
+  }
+  
+  return matches
+}
+
+/**
+ * Removes the outermost ${} from a string
+ * @param {string} str - The input string containing ${} syntax
+ * @returns {string} The string with outermost ${} removed
+ * @example
+ * removeOuterMostBraces('${eval(${self:three} > ${self:four})}') 
+ * // returns 'eval(${self:three} > ${self:four})'
+ */
+function removeOuterMostBraces(str) {
+  const matches = findOutermostBraces(str)
+  if (matches.length === 0) return str
+  
+  const outermostMatch = matches[0]
+  return outermostMatch.slice(2, -1)
+}

package/src/utils/createEditorLink.js

@@ -0,0 +1,23 @@
+const path = require('path')
+const chalk = require('./chalk')
+
+/**
+ * Creates a hyperlink for the default editor (Cursor/VS Code)
+ * @param {string} filePath - The file path to link to
+ * @param {number} line - Line number (default: 1)
+ * @param {number} column - Column number (default: 1)
+ * @param {string} customDisplay - Custom display text (default: filename:line)
+ * @param {string} color - Chalk color for the link (default: 'cyanBright')
+ * @returns {string} The hyperlink string
+ */
+function createEditorLink(filePath, line = 1, column = 1, customDisplay = null, color = 'cyanBright') {
+  const absolutePath = path.resolve(filePath)
+  const url = `cursor://file${absolutePath}:${line}:${column}`
+  const display = customDisplay ? customDisplay: `${path.basename(filePath)}:${line}`
+  
+  return `\x1b]8;;${url}\x1b\\${chalk[color](display)}\x1b]8;;\x1b\\`
+}
+
+module.exports = {
+  createEditorLink
+}

package/src/utils/find-nested-variables.js

@@ -193,7 +193,16 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
             fallbackData.stringValue = trimQuotes(item)
             fallbackData.isResolvedFallback = true
           }
-          
+
+          if (isVariable) {
+            const varType = item.match(variablesKnownTypes)[1]
+            fallbackData.varType = varType
+            // if (varType === 'self:') {
+            //   fallbackData.fullMatch = item.replace('self:', '')
+            //   fallbackData.variable = item.replace('self:', '')
+            //   fallbackData.varType = 'dot.prop'
+            // }
+          }
           return fallbackData
         })
       }

package/src/utils/logs.js

@@ -5,7 +5,8 @@ function logHeader(message) {
     text: message, 
     rightBorder: true, 
     minWidth: 80, 
-    textStyle: 'normal',
+    textStyle: 'bold',
+    borderStyle: 'bold',
     borderColor: 'cyanBright',
   }))
 }

package/src/utils/parse.js

@@ -1,5 +1,8 @@
 const YAML = require('../parsers/yaml')
 const TOML = require('../parsers/toml')
+const INI = require('../parsers/ini')
+const { executeTypeScriptFileSync } = require('../parsers/typescript')
+const { executeESMFileSync } = require('../parsers/esm')
 const cloudFormationSchema = require('./cloudformationSchema')
 
 /**
@@ -34,6 +37,8 @@ function parseFileContents(fileContents, fileType, filePath, varRegex, opts = {}
     }
   } else if (fileType.match(/\.(toml)/)) {
     configObject = TOML.parse(fileContents)
+  } else if (fileType.match(/\.(ini)/)) {
+    configObject = INI.parse(fileContents)
   } else if (fileType.match(/\.(json)/)) {
     configObject = JSON.parse(fileContents)
   } else if (fileType.match(/\.(js)/)) {
@@ -47,11 +52,46 @@ function parseFileContents(fileContents, fileType, filePath, varRegex, opts = {}
         if (jsArgs && typeof jsArgs === 'function') {
           jsArgs = jsArgs()
         }
+        // console.log('jsArgs', jsArgs)
         configObject = jsFile(jsArgs)
       }
     } catch (err) {
       throw new Error(err)
     }
+  } else if (fileType.match(/\.(ts|tsx)/)) {
+    try {
+      let jsArgs = opts.dynamicArgs || {}
+      if (jsArgs && typeof jsArgs === 'function') {
+        jsArgs = jsArgs()
+      }
+      configObject = executeTypeScriptFileSync(filePath, opts)
+      if (configObject.config) {
+        configObject = (typeof configObject.config === 'function') ? configObject.config(jsArgs) : configObject.config
+      } else if (configObject.default) {
+        configObject = (typeof configObject.default === 'function') ? configObject.default(jsArgs) : configObject.default
+      }
+      // console.log('parseFileContents configObject', configObject, opts)
+    } catch (err) {
+      throw new Error(`Failed to execute TypeScript file ${filePath}: ${err.message}`)
+    }
+  } else if (fileType.match(/\.(mjs|esm)/)) {
+    try {
+      let jsArgs = opts.dynamicArgs || {}
+      if (jsArgs && typeof jsArgs === 'function') {
+        jsArgs = jsArgs()
+      }
+      configObject = executeESMFileSync(filePath, opts)
+      if (configObject.config) {
+        configObject = (typeof configObject.config === 'function') ? configObject.config(jsArgs) : configObject.config
+      } else if (configObject.default) {
+        configObject = (typeof configObject.default === 'function') ? configObject.default(jsArgs) : configObject.default
+      } else if (typeof configObject === 'function') {
+        configObject = configObject(jsArgs)
+      }
+      // console.log('parseFileContents ESM configObject', configObject, opts)
+    } catch (err) {
+      throw new Error(`Failed to execute ESM file ${filePath}: ${err.message}`)
+    }
   }
 
   return configObject