configorama 0.6.18 → 0.7.0

package/src/utils/parsing/preProcess.js

@@ -3,16 +3,27 @@
  * and escape variables inside help() filter arguments
  */
 const { splitByComma } = require('../strings/splitByComma')
+const { extractVariableWrapper } = require('../variables/variableUtils')
 
 /**
  * Preprocess config to fix malformed fallback references
  * @param {Object} configObject - The parsed configuration object
  * @param {RegExp} variableSyntax - The variable syntax regex to use
+ * @param {Array} [variableTypes] - Array of variable type definitions with type/prefix fields
  * @returns {Object} The preprocessed configuration object
  */
-function preProcess(configObject, variableSyntax) {
-  // Known reference prefixes that should be wrapped in ${}
-  const refPrefixes = ['self:', 'opt:', 'env:', 'file:', 'text:', 'deep:']
+function preProcess(configObject, variableSyntax, variableTypes) {
+  // Extract prefix/suffix from variable syntax for reconstructing variables
+  const { prefix: varPrefix, suffix: varSuffix } = variableSyntax
+    ? extractVariableWrapper(variableSyntax.source)
+    : { prefix: '${', suffix: '}' }
+
+  // Extract reference prefixes from variable types, or use defaults
+  const refPrefixes = variableTypes && variableTypes.length > 0
+    ? variableTypes
+        .map(v => (v.prefix || v.type) + ':')
+        .filter(p => p !== 'dot.prop:' && p !== 'string:' && p !== 'number:')
+    : ['self:', 'opt:', 'env:', 'file:', 'text:', 'deep:']
 
   /**
    * Escape variables inside help() filter arguments so main resolver skips them
@@ -52,31 +63,37 @@ function preProcess(configObject, variableSyntax) {
     let changed = true
 
     // Keep iterating until no more changes (to handle nested variables)
+    const prefixLen = varPrefix.length
+    const suffixLen = varSuffix.length
+
     while (changed) {
       changed = false
 
-      // Find innermost ${...} blocks (ones that don't contain other ${)
+      // Find innermost variable blocks (ones that don't contain other variables)
       let i = 0
       while (i < result.length) {
-        if (result[i] === '$' && result[i + 1] === '{') {
+        if (result.substring(i, i + prefixLen) === varPrefix) {
           const start = i
-          let braceCount = 1
-          let j = i + 2
-
-          // Find the matching closing brace by counting { and }
-          while (j < result.length && braceCount > 0) {
-            if (result[j] === '{') {
-              braceCount++
-            } else if (result[j] === '}') {
-              braceCount--
+          let depth = 1
+          let j = i + prefixLen
+
+          // Find the matching suffix by counting full prefix/suffix occurrences
+          while (j < result.length && depth > 0) {
+            if (result.substring(j, j + prefixLen) === varPrefix) {
+              depth++
+              j += prefixLen
+            } else if (result.substring(j, j + suffixLen) === varSuffix) {
+              depth--
+              if (depth > 0) j += suffixLen
+            } else {
+              j++
             }
-            j++
           }
 
-          if (braceCount === 0) {
-            const end = j
+          if (depth === 0) {
+            const end = j + suffixLen
             const match = result.substring(start, end)
-            const content = result.substring(start + 2, end - 1)
+            const content = result.substring(start + prefixLen, end - suffixLen)
 
             // Only process if there's a comma (indicating fallback syntax)
             if (content.includes(',')) {
@@ -84,10 +101,10 @@ function preProcess(configObject, variableSyntax) {
               const parts = splitByComma(content, variableSyntax)
 
               if (parts.length > 1) {
-                // Check if the first part has nested ${} - if so, skip this (process inner ones first)
+                // Check if the first part has nested variables - if so, skip this (process inner ones first)
                 const firstPart = parts[0]
-                if (firstPart.includes('${')) {
-                  i = start + 2 // Move past ${ to find inner variables
+                if (firstPart.includes(varPrefix)) {
+                  i = start + prefixLen // Move past prefix to find inner variables
                   continue
                 }
 
@@ -101,16 +118,16 @@ function preProcess(configObject, variableSyntax) {
 
                   // Check if this looks like a reference but is not wrapped
                   const looksLikeRef = refPrefixes.some(prefix => trimmed.startsWith(prefix))
-                  const alreadyWrapped = trimmed.startsWith('${') && trimmed.endsWith('}')
+                  const alreadyWrapped = trimmed.startsWith(varPrefix) && trimmed.endsWith(varSuffix)
 
                   if (looksLikeRef && !alreadyWrapped) {
-                    return ` \${${trimmed}}`
+                    return ` ${varPrefix}${trimmed}${varSuffix}`
                   }
 
                   return ` ${trimmed}`
                 })
 
-                const replacement = `\${${fixed.join(',')}}`
+                const replacement = `${varPrefix}${fixed.join(',')}${varSuffix}`
                 if (replacement !== match) {
                   result = result.substring(0, start) + replacement + result.substring(end)
                   changed = true
@@ -119,7 +136,7 @@ function preProcess(configObject, variableSyntax) {
               }
             }
 
-            i = start + 2 // Move past ${ to continue searching for nested variables
+            i = start + prefixLen // Move past prefix to continue searching for nested variables
           } else {
             i++
           }

package/src/utils/parsing/preProcess.test.js

@@ -0,0 +1,214 @@
+// Tests for preProcess utility (fixFallbacksInString)
+
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const preProcess = require('./preProcess')
+
+// Default ${} syntax
+const defaultSyntax = /\$\{([ ~:a-zA-Z0-9._\\'",\-\/\(\)]+?)\}/g
+
+// Custom syntaxes
+const doubleBraceSyntax = /\$\{\{([ ~:a-zA-Z0-9._\\'",\-\/\(\)]+?)\}\}/g
+const hashSyntax = /\#\{([ ~:a-zA-Z0-9._\\'",\-\/\(\)]+?)\}/g
+const angleSyntax = /\<([ ~:a-zA-Z0-9._\\'",\-\/\(\)]+?)\>/g
+
+// Tests for fixFallbacksInString with default ${} syntax
+test('fixFallbacksInString - wraps unwrapped self: fallback', () => {
+  const input = { key: '${opt:missing, self:fallback}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, ${self:fallback}}')
+})
+
+test('fixFallbacksInString - wraps unwrapped env: fallback', () => {
+  const input = { key: '${opt:missing, env:FALLBACK}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, ${env:FALLBACK}}')
+})
+
+test('fixFallbacksInString - wraps unwrapped opt: fallback', () => {
+  const input = { key: '${self:missing, opt:fallback}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${self:missing, ${opt:fallback}}')
+})
+
+test('fixFallbacksInString - wraps unwrapped file: fallback', () => {
+  const input = { key: '${opt:missing, file:./config.json}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, ${file:./config.json}}')
+})
+
+test('fixFallbacksInString - leaves already wrapped fallback alone', () => {
+  const input = { key: '${opt:missing, ${self:fallback}}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, ${self:fallback}}')
+})
+
+test('fixFallbacksInString - leaves string fallback alone', () => {
+  const input = { key: '${opt:missing, "default"}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, "default"}')
+})
+
+test('fixFallbacksInString - leaves numeric fallback alone', () => {
+  const input = { key: '${opt:missing, 42}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, 42}')
+})
+
+test('fixFallbacksInString - handles multiple fallbacks', () => {
+  const input = { key: '${opt:missing, self:first, env:second}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${opt:missing, ${self:first}, ${env:second}}')
+})
+
+test('fixFallbacksInString - handles nested variables in primary', () => {
+  const input = { key: '${file(./config.${opt:stage}.json), "default"}' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, '${file(./config.${opt:stage}.json), "default"}')
+})
+
+// Tests for ${{}} syntax
+test('fixFallbacksInString - ${{}} syntax wraps unwrapped fallback', () => {
+  const input = { key: '${{opt:missing, self:fallback}}' }
+  const result = preProcess(input, doubleBraceSyntax)
+  assert.is(result.key, '${{opt:missing, ${{self:fallback}}}}')
+})
+
+test('fixFallbacksInString - ${{}} syntax leaves wrapped fallback alone', () => {
+  const input = { key: '${{opt:missing, ${{self:fallback}}}}' }
+  const result = preProcess(input, doubleBraceSyntax)
+  assert.is(result.key, '${{opt:missing, ${{self:fallback}}}}')
+})
+
+test('fixFallbacksInString - ${{}} syntax leaves string fallback alone', () => {
+  const input = { key: '${{opt:missing, "default"}}' }
+  const result = preProcess(input, doubleBraceSyntax)
+  assert.is(result.key, '${{opt:missing, "default"}}')
+})
+
+// Tests for #{} syntax
+test('fixFallbacksInString - #{} syntax wraps unwrapped fallback', () => {
+  const input = { key: '#{opt:missing, self:fallback}' }
+  const result = preProcess(input, hashSyntax)
+  assert.is(result.key, '#{opt:missing, #{self:fallback}}')
+})
+
+test('fixFallbacksInString - #{} syntax leaves wrapped fallback alone', () => {
+  const input = { key: '#{opt:missing, #{self:fallback}}' }
+  const result = preProcess(input, hashSyntax)
+  assert.is(result.key, '#{opt:missing, #{self:fallback}}')
+})
+
+test('fixFallbacksInString - #{} syntax handles multiple fallbacks', () => {
+  const input = { key: '#{opt:missing, env:FIRST, self:second}' }
+  const result = preProcess(input, hashSyntax)
+  assert.is(result.key, '#{opt:missing, #{env:FIRST}, #{self:second}}')
+})
+
+// Tests for <> syntax
+test('fixFallbacksInString - <> syntax wraps unwrapped fallback', () => {
+  const input = { key: '<opt:missing, self:fallback>' }
+  const result = preProcess(input, angleSyntax)
+  assert.is(result.key, '<opt:missing, <self:fallback>>')
+})
+
+test('fixFallbacksInString - <> syntax leaves wrapped fallback alone', () => {
+  const input = { key: '<opt:missing, <self:fallback>>' }
+  const result = preProcess(input, angleSyntax)
+  assert.is(result.key, '<opt:missing, <self:fallback>>')
+})
+
+test('fixFallbacksInString - <> syntax leaves string fallback alone', () => {
+  const input = { key: '<opt:missing, "default">' }
+  const result = preProcess(input, angleSyntax)
+  assert.is(result.key, '<opt:missing, "default">')
+})
+
+// Edge cases
+test('fixFallbacksInString - handles deeply nested objects', () => {
+  const input = {
+    level1: {
+      level2: {
+        key: '${opt:missing, self:fallback}'
+      }
+    }
+  }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.level1.level2.key, '${opt:missing, ${self:fallback}}')
+})
+
+test('fixFallbacksInString - handles arrays', () => {
+  const input = {
+    items: [
+      '${opt:one, self:fallback1}',
+      '${opt:two, self:fallback2}'
+    ]
+  }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.items[0], '${opt:one, ${self:fallback1}}')
+  assert.is(result.items[1], '${opt:two, ${self:fallback2}}')
+})
+
+test('fixFallbacksInString - handles no variable syntax', () => {
+  const input = { key: 'just a plain string' }
+  const result = preProcess(input, defaultSyntax)
+  assert.is(result.key, 'just a plain string')
+})
+
+test('fixFallbacksInString - handles null variableSyntax', () => {
+  const input = { key: '${opt:missing, self:fallback}' }
+  const result = preProcess(input, null)
+  // Without syntax, should use defaults
+  assert.is(result.key, '${opt:missing, ${self:fallback}}')
+})
+
+// Tests with explicit variableTypes
+const defaultVariableTypes = [
+  { type: 'env' },
+  { type: 'options', prefix: 'opt' },
+  { type: 'self', prefix: 'self' },
+  { type: 'file', prefix: 'file' },
+  { type: 'text', prefix: 'text' },
+  { type: 'deep' },
+]
+
+test('fixFallbacksInString - uses variableTypes to determine prefixes', () => {
+  const input = { key: '${opt:missing, self:fallback}' }
+  const result = preProcess(input, defaultSyntax, defaultVariableTypes)
+  assert.is(result.key, '${opt:missing, ${self:fallback}}')
+})
+
+test('fixFallbacksInString - custom variableTypes with custom prefix', () => {
+  const customTypes = [
+    { type: 'ssm', prefix: 'ssm' },
+    { type: 'secret', prefix: 'secret' },
+  ]
+  const input = { key: '${opt:missing, ssm:/path/to/param}' }
+  const result = preProcess(input, defaultSyntax, customTypes)
+  assert.is(result.key, '${opt:missing, ${ssm:/path/to/param}}')
+})
+
+test('fixFallbacksInString - custom variableTypes wraps secret: fallback', () => {
+  const customTypes = [
+    { type: 'ssm', prefix: 'ssm' },
+    { type: 'secret', prefix: 'secret' },
+    { type: 'self', prefix: 'self' },
+  ]
+  const input = { key: '${self:missing, secret:API_KEY}' }
+  const result = preProcess(input, defaultSyntax, customTypes)
+  assert.is(result.key, '${self:missing, ${secret:API_KEY}}')
+})
+
+test('fixFallbacksInString - ignores dot.prop and string types in prefixes', () => {
+  const typesWithDotProp = [
+    { type: 'env' },
+    { type: 'dot.prop' },
+    { type: 'string' },
+    { type: 'self', prefix: 'self' },
+  ]
+  const input = { key: '${env:MISSING, self:fallback}' }
+  const result = preProcess(input, defaultSyntax, typesWithDotProp)
+  assert.is(result.key, '${env:MISSING, ${self:fallback}}')
+})
+
+test.run()

package/src/utils/paths/getFullFilePath.js

@@ -40,7 +40,7 @@ function getFullPath(fileString, cwd) {
  * @param {string} matchedFileString - The matched file string (e.g., "file(path/to/file.js)")
  * @param {RegExp} syntax - The regex pattern used to match the file string (e.g., fileRefSyntax or textRefSyntax)
  * @param {string} configPath - The base directory path for resolving relative paths
- * @returns {{fullFilePath: string|null, resolvedPath: string}} - Object containing the resolved full file path and the resolved path (after alias resolution)
+ * @returns {{fullFilePath: string, resolvedPath: string, relativePath: string}} - Object containing the resolved full file path, resolved path (after alias resolution), and relative path
  */
 function resolveFilePathFromMatch(matchedFileString, syntax, configPath) {
   const relativePath = trimSurroundingQuotes(

package/src/utils/resolution/preResolveVariable.js

@@ -36,6 +36,7 @@ function hasUnresolvedVars(str, variableSyntax) {
  * @param {object} context.config - Original config object
  * @param {string} context.configDir - Config file directory
  * @param {RegExp} context.variableSyntax - Variable syntax regex
+ * @param {object} [context.options] - CLI options
  * @returns {Promise<*>} Resolved value or undefined if can't pre-resolve
  */
 async function preResolveSingle(varString, context) {

package/src/utils/strings/quoteUtils.js

@@ -43,8 +43,8 @@ function endChar(str, char) {
 /**
  * Ensures a value (string or array of strings) has quotes around it
  * @param {string|string[]} value - The value to quote
- * @param {string} open - Opening quote character (default: '"')
- * @param {string} close - Closing quote character (default: same as open)
+ * @param {string} [open] - Opening quote character (default: '"')
+ * @param {string} [close] - Closing quote character (default: same as open)
  * @returns {string|string[]} The quoted value(s)
  */
 function ensureQuote(value, open = '"', close) {

package/src/utils/strings/splitCsv.js

@@ -5,7 +5,7 @@ const { splitByComma } = require('./splitByComma')
  * NOTE: This is a simpler version that delegates to splitByComma for consistency.
  * For advanced use cases with bracket depth tracking and regex protection, use splitByComma directly.
  * @param {string} str - String to split
- * @param {string} splitter - Optional custom splitter (defaults to ',')
+ * @param {string} [splitter] - Optional custom splitter (defaults to ',')
  * @returns {string[]} Array of split strings
  */
 function splitCsv(str, splitter) {

package/src/utils/ui/logs.js

@@ -2,10 +2,10 @@ const { makeHeader, logHeader : logHeaderBox } = require('@davidwells/box-logger
 
 function logHeader(message) {
   logHeaderBox({
-    content: message, 
-    rightBorder: true, 
-    minWidth: 80, 
-    textStyle: 'bold',
+    content: message,
+    borderRight: true,
+    minWidth: 80,
+    fontStyle: 'bold',
     borderStyle: 'bold',
     borderColor: 'cyanBright',
   })

package/src/utils/validation/warnIfNotFound.js

@@ -14,9 +14,9 @@ function isValidValue(val) {
  * Check if variable resolved to valid value, log warning if not
  * @param {string} variableString - The variable being resolved
  * @param {*} valueToPopulate - The resolved value
- * @param {object} options - Configuration options
- * @param {object} options.patterns - Regex patterns for variable types
- * @param {boolean} options.debug - Whether to log warnings
+ * @param {object} [options] - Configuration options
+ * @param {object} [options.patterns] - Regex patterns for variable types
+ * @param {boolean} [options.debug] - Whether to log warnings
  * @returns {*} The valueToPopulate unchanged
  */
 function warnIfNotFound(variableString, valueToPopulate, options = {}) {

package/src/utils/variables/findNestedVariables.js

@@ -338,10 +338,10 @@ function findNestedVariablesOld(input, regex, variablesKnownTypes, debug = false
 
   // Replace the `__REPLACED_${iteration - 1}__` with the original match
   matches = matches.map((match, index) => {
-    const indexOfReplaced = match.varMatch.match(/__REPLACED_(\d+)__/)
+    const indexOfReplaced = match.fullMatch.match(/__REPLACED_(\d+)__/)
     if (indexOfReplaced) {
       const replacedIndex = parseInt(indexOfReplaced[1])
-      match.varMatch = match.varMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
+      match.fullMatch = match.fullMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
       match.variable = match.variable.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
     }
     return match

package/src/utils/variables/variableUtils.js

@@ -1,3 +1,45 @@
+/**
+ * Extract variable prefix/suffix from regex source
+ * @param {string} syntaxSource - The regex source string (e.g., '\\$\\{(...)\\}')
+ * @returns {{ prefix: string, suffix: string }} The unescaped prefix and suffix
+ */
+function extractVariableWrapper(syntaxSource) {
+  // Find first capturing group ( that's not escaped and not a special group (?:, (?=, etc.)
+  let openParen = -1
+  for (let i = 0; i < syntaxSource.length; i++) {
+    if (syntaxSource[i] === '(' && (i === 0 || syntaxSource[i - 1] !== '\\')) {
+      // Check if it's a special group like (?:, (?=, (?!, (?<
+      if (syntaxSource[i + 1] !== '?') {
+        openParen = i
+        break
+      }
+    }
+  }
+
+  // Find last ) that's not escaped
+  let closeParen = -1
+  for (let i = syntaxSource.length - 1; i >= 0; i--) {
+    if (syntaxSource[i] === ')' && (i === 0 || syntaxSource[i - 1] !== '\\')) {
+      closeParen = i
+      break
+    }
+  }
+
+  let escapedPrefix = openParen > 0 ? syntaxSource.substring(0, openParen) : ''
+  const escapedSuffix = closeParen >= 0 ? syntaxSource.substring(closeParen + 1) : ''
+
+  // Strip any leading non-capturing groups like (?:...) from prefix
+  escapedPrefix = escapedPrefix.replace(/^\(\?:[^)]*\)/g, '')
+
+  // Unescape regex escapes: \$ -> $, \{ -> {, \[ -> [, etc.
+  const unescape = (s) => s.replace(/\\(.)/g, '$1')
+
+  return {
+    prefix: unescape(escapedPrefix) || '${',
+    suffix: unescape(escapedSuffix) || '}'
+  }
+}
+
 /**
  * Get fallback variable string
  * @param {string[]} split - Array from split at comma
@@ -47,6 +89,7 @@ Remove or update the \${${variableString}} to fix
 }
 
 module.exports = {
+  extractVariableWrapper,
   getFallbackString,
   verifyVariable
 } 

package/src/utils/variables/variableUtils.test.js

@@ -1,6 +1,6 @@
 const { test } = require('uvu')
 const assert = require('uvu/assert')
-const { getFallbackString, verifyVariable } = require('./variableUtils')
+const { extractVariableWrapper, getFallbackString, verifyVariable } = require('./variableUtils')
 
 // Tests for getFallbackString
 test('getFallbackString - should reconstruct variable from split array', () => {
@@ -113,5 +113,42 @@ test('verifyVariable - should match with function and config param', () => {
   assert.is(result, true)
 })
 
+// Tests for extractVariableWrapper
+test('extractVariableWrapper - standard ${} syntax', () => {
+  const result = extractVariableWrapper('\\$\\{([^}]+)\\}')
+  assert.equal(result.prefix, '${')
+  assert.equal(result.suffix, '}')
+})
+
+test('extractVariableWrapper - double brace ${{}} syntax', () => {
+  const result = extractVariableWrapper('\\$\\{\\{([^}]+)\\}\\}')
+  assert.equal(result.prefix, '${{')
+  assert.equal(result.suffix, '}}')
+})
+
+test('extractVariableWrapper - hash #{} syntax', () => {
+  const result = extractVariableWrapper('\\#\\{([^}]+)\\}')
+  assert.equal(result.prefix, '#{')
+  assert.equal(result.suffix, '}')
+})
+
+test('extractVariableWrapper - angle bracket <> syntax', () => {
+  const result = extractVariableWrapper('\\<([^>]+)\\>')
+  assert.equal(result.prefix, '<')
+  assert.equal(result.suffix, '>')
+})
+
+test('extractVariableWrapper - double bracket [[]] syntax', () => {
+  const result = extractVariableWrapper('\\[\\[([^\\]]+)\\]\\]')
+  assert.equal(result.prefix, '[[')
+  assert.equal(result.suffix, ']]')
+})
+
+test('extractVariableWrapper - strips non-capturing group prefix', () => {
+  const result = extractVariableWrapper('(?:prefix)\\$\\{([^}]+)\\}')
+  assert.equal(result.prefix, '${')
+  assert.equal(result.suffix, '}')
+})
+
 // Run all tests
 test.run()

package/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.js"],"names":[],"mappings":""}

package/types/src/functions/md5.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(string: string): string;
+export = _exports;
+//# sourceMappingURL=md5.d.ts.map

package/types/src/functions/md5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.d.ts","sourceRoot":"","sources":["../../../src/functions/md5.js"],"names":[],"mappings":"AAOiB,kCAHL,MAAM,GACN,MAAM,CAOjB"}

package/types/src/index.d.ts

@@ -0,0 +1,100 @@
+declare namespace _exports {
+    export { ConfigoramaSettings, ConfigoramaResult };
+}
+declare function _exports<T = any>(configPathOrObject: string | any, settings?: ConfigoramaSettings): Promise<T | ConfigoramaResult<T>>;
+declare namespace _exports {
+    export { Configorama };
+    export function sync<T = any>(configPathOrObject: string | any, settings?: ConfigoramaSettings): T;
+    export function analyze(configPathOrObject: string | object, settings?: object): Promise<any>;
+    export { parsers as format };
+}
+export = _exports;
+type ConfigoramaSettings = {
+    /**
+     * - options to populate for ${opt:xyz}. These could be CLI flags
+     */
+    options?: {
+        [x: string]: any;
+    };
+    /**
+     * - Regex of variable syntax
+     */
+    syntax?: string;
+    /**
+     * - cwd of config. Needed if raw object passed in instead of file path
+     */
+    configDir?: string;
+    /**
+     * - array of custom variable sources
+     */
+    variableSources?: any[];
+    /**
+     * - Object of custom filters
+     */
+    filters?: {
+        [x: string]: Function;
+    };
+    /**
+     * - Object of custom functions
+     */
+    functions?: {
+        [x: string]: Function;
+    };
+    /**
+     * - allow unknown variables to pass through without throwing errors
+     */
+    allowUnknownVars?: boolean;
+    /**
+     * - allow undefined values to pass through without throwing errors
+     */
+    allowUndefinedValues?: boolean;
+    /**
+     * - values passed into .js config files if user using javascript config
+     */
+    dynamicArgs?: any | Function;
+    /**
+     * - return both config and metadata about variables found
+     */
+    returnMetadata?: boolean;
+    /**
+     * - keys to merge in arrays of objects
+     */
+    mergeKeys?: string[];
+    /**
+     * - map of file paths to override
+     */
+    filePathOverrides?: {
+        [x: string]: string;
+    };
+};
+type ConfigoramaResult<T = any> = {
+    /**
+     * - The variable syntax pattern used
+     */
+    variableSyntax: RegExp;
+    /**
+     * - Map of variable types found
+     */
+    variableTypes: {
+        [x: string]: any;
+    };
+    /**
+     * - The resolved configuration object
+     */
+    config: T;
+    /**
+     * - The original unresolved configuration
+     */
+    originalConfig: any;
+    /**
+     * - Metadata about variables found and resolved
+     */
+    metadata: any;
+    /**
+     * - Resolution history per path for debugging
+     */
+    resolutionHistory: any;
+};
+import Configorama = require("./main");
+import parsers = require("./parsers");
+//# sourceMappingURL=index.d.ts.map

package/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAwCiB,0BALH,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,OAAO,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAiD7C;;;IASqB,qBALR,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,CAAC,CAgBb;IAQwB,4CAJb,MAAM,GAAC,MAAM,aACd,MAAM,gBAUhB;;;;;;;;;;;;;;aApHa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;uBAIN,OAAO;;;;2BACP,OAAO;;;;kBACP,cAAe;;;;qBACf,OAAO;;;;gBACP,MAAM,EAAE;;;;;;;;uBAKR,CAAC;;;;oBAED,MAAM;;;;;;;;;;YAEN,CAAC"}