configorama 0.9.11 → 0.9.13

package/README.md

@@ -283,6 +283,7 @@ Supported file types (extensions are case-insensitive):
 | TOML | `.toml`, `.tml` |
 | INI | `.ini` |
 | JSON | `.json`, `.json5`, `.jsonc` |
+| Markdown | `.md`, `.mdx`, `.markdown`, `.mdown`, `.mkdn`, `.mkd` |
 
 ### Sync/Async file references
 

package/cli.js

@@ -7,14 +7,16 @@ const deepLog = require('./src/utils/ui/deep-log')
 const { logHeader } = require('./src/utils/ui/logs')
 const configorama = require('./src')
 const { makeBox } = require('@davidwells/box-logger')
+const getValueAtPath = require('./src/utils/parsing/getValueAtPath')
 
 // Parse command line arguments
 const argv = minimist(process.argv.slice(2), {
   string: ['output', 'o', 'format', 'f', 'param'],
-  boolean: ['help', 'h', 'version', 'v', 'debug', 'allow-unknown', 'allow-undefined', 'list', 'info', 'verify'],
+  boolean: ['help', 'h', 'version', 'v', 'V', 'debug', 'allow-unknown', 'allow-undefined', 'list', 'info', 'verify'],
   alias: {
     h: 'help',
-    v: 'verify',
+    v: 'version',
+    V: 'verify',
     o: 'output',
     f: 'format',
     l: 'list',
@@ -31,7 +33,7 @@ if (argv.help) {
 Configorama - Variable resolution for configuration files
 
 Usage:
-  configorama [options] <file>
+  configorama [options] <file> [path]
 
 Options:
   -h, --help                Show this help message
@@ -40,13 +42,27 @@ Options:
   -f, --format <format>     Output format: json, yaml, or js (default: json)
   -d, --debug               Enable debug mode
   -i, --info                Show info about the config
-  -v, --verify              Verify the config
+  -V, --verify              Verify the config
   --param <key=value>       Pass parameter values (can be used multiple times)
   --allow-unknown           Allow unknown variables to pass through
   --allow-undefined         Allow undefined values in the final output
 
+Path Extraction:
+  Use jq-style paths to extract specific values from the resolved config.
+  Paths can appear before or after options.
+
+  Supported syntax:
+    .foo              Object key access
+    .foo.bar          Nested key access
+    .[0]              Array index (0-based)
+    .[-1]             Negative index (from end)
+    .foo[0].bar       Mixed access
+    .["key-name"]     Bracket notation for special keys
+
 Examples:
   configorama config.yml
+  configorama config.yml .database.host
+  configorama '.servers[0].port' config.yml
   configorama --info config.yml
   configorama --format yaml config.json
   configorama --output resolved.json config.yml
@@ -63,8 +79,22 @@ if (argv.version) {
   process.exit(0)
 }
 
-// Check for input file
-const inputFile = argv._[0]
+// Parse positional args: find file path and jq-style extraction path
+// File is first arg that exists as a file, jq path starts with '.' or '['
+let inputFile = null
+let extractPath = null
+
+for (const arg of argv._) {
+  if (arg === 'setup') continue
+
+  // jq-style paths start with '.' or '['
+  if (arg.startsWith('.') || arg.startsWith('[')) {
+    extractPath = arg
+  } else if (!inputFile) {
+    inputFile = arg
+  }
+}
+
 if (!inputFile) {
   console.error('Error: No input file specified')
   console.error('Run with --help for usage information')
@@ -135,6 +165,15 @@ options.options = rest
 // Process the configuration
 configorama(inputFile, options)
   .then((config) => {
+    // Apply path extraction if specified
+    if (extractPath) {
+      config = getValueAtPath(config, extractPath)
+      if (config === undefined) {
+        console.error(`Error: Path not found: ${extractPath}`)
+        process.exit(1)
+      }
+    }
+
     let output
 
     // Format the output
@@ -186,10 +225,9 @@ configorama(inputFile, options)
       content: error.message,
       type: 'error',
     })
-    console.log('error', error)
     console.log(errorMsg)
     if (argv.debug) {
-      console.error(error.stack)
+      console.error('error', error)
     }
     process.exit(1)
   })

package/index.d.ts

@@ -1,10 +1,7 @@
 // Type definitions for configorama
 // Project: https://github.com/DavidWells/configorama
 
-// Re-export variable validation types
-export * from './src/types'
-
-export interface ConfigoramaSettings {
+interface ConfigoramaSettings {
   /** Options to populate for ${opt:xyz}. These could be CLI flags */
   options?: Record<string, any>
   /** Regex of variable syntax */
@@ -64,7 +61,7 @@ export interface ConfigoramaSettings {
   filePathOverrides?: Record<string, string>
 }
 
-export interface ConfigoramaResult<T = any> {
+interface ConfigoramaResult<T = any> {
   /** The variable syntax pattern used */
   variableSyntax: RegExp
   /** Map of variable types found */
@@ -83,7 +80,7 @@ export interface ConfigoramaResult<T = any> {
  * Context passed to JS/TS/ESM config file functions
  * Used when config files export a function: `export default function(ctx) { ... }`
  */
-export interface ConfigContext<T = any> {
+interface ConfigContext<T = any> {
   /** The original unresolved configuration object */
   originalConfig: T
   /** The current (partially resolved) configuration object */
@@ -104,28 +101,40 @@ declare function configorama<T = any>(
   settings: ConfigoramaSettings & { returnMetadata: true }
 ): Promise<ConfigoramaResult<T>>
 
-export default configorama
-
-/** Configorama sync API */
-export function sync<T = any>(
-  configPathOrObject: string | object,
-  settings?: ConfigoramaSettings
-): T
-
-/** Analyze config variables without resolving them */
-export function analyze(
-  configPathOrObject: string | object,
-  settings?: ConfigoramaSettings
-): Promise<any>
-
-/** Format utilities for parsing various config formats */
-export const format: {
-  yaml: any
-  json: any
-  toml: any
-  ini: any
-  hcl: any
+declare namespace configorama {
+  // Re-export types for consumers
+  export { ConfigoramaSettings, ConfigoramaResult, ConfigContext }
+
+  /** Configorama sync API */
+  export function sync<T = any>(
+    configPathOrObject: string | object,
+    settings?: ConfigoramaSettings
+  ): T
+
+  /** Analyze config variables without resolving them */
+  export function analyze(
+    configPathOrObject: string | object,
+    settings?: ConfigoramaSettings
+  ): Promise<any>
+
+  /** Format utilities for parsing various config formats */
+  export const format: {
+    yaml: any
+    json: any
+    toml: any
+    ini: any
+    hcl: any
+  }
+
+  /** The Configorama class for advanced usage */
+  export const Configorama: any
+
+  /** Build variable syntax regex */
+  export function buildVariableSyntax(
+    prefix?: string,
+    suffix?: string,
+    excludePatterns?: string[]
+  ): string
 }
 
-/** The Configorama class for advanced usage */
-export const Configorama: any
+export = configorama

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.9.11",
+  "version": "0.9.13",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",
@@ -59,26 +59,10 @@
     "jiti": "^2.4.2",
     "js-yaml": "^3.14.1",
     "json5": "^2.2.3",
-    "lodash.assign": "^4.2.0",
     "lodash.camelcase": "^4.3.0",
-    "lodash.capitalize": "^4.2.1",
     "lodash.clonedeep": "^4.5.0",
-    "lodash.flatten": "^4.4.0",
-    "lodash.includes": "^4.3.0",
-    "lodash.isarray": "^4.0.0",
-    "lodash.isdate": "^4.0.1",
-    "lodash.isempty": "^4.4.0",
-    "lodash.isfunction": "^3.0.9",
-    "lodash.isnumber": "^3.0.3",
-    "lodash.isobject": "^3.0.2",
-    "lodash.isregexp": "^4.0.1",
-    "lodash.isstring": "^4.0.1",
     "lodash.kebabcase": "^4.1.1",
-    "lodash.map": "^4.6.0",
-    "lodash.mapvalues": "^4.6.0",
-    "lodash.split": "^4.4.2",
     "minimist": "^1.2.8",
-    "promise.prototype.finally": "^3.1.8",
     "safe-chalk": "^1.0.4",
     "subscript": "^9.1.0",
     "sync-rpc": "^1.3.6",

package/src/main.js

@@ -7,7 +7,6 @@ console.log = () => {}
 // process.exit(1)
 /** */
 /* External dependencies */
-const promiseFinallyShim = require('promise.prototype.finally').shim()
 const findUp = require('find-up')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
@@ -34,7 +33,7 @@ const { arrayToJsonPath } = require('./utils/parsing/arrayToJsonPath')
 const { normalizePath, extractFilePath, resolveInnerVariables } = require('./utils/paths/filePathUtils')
 const { findLineForKey } = require('./utils/paths/findLineForKey')
 /* Utils - regex */
-const { combineRegexes, funcRegex } = require('./utils/regex')
+const { combineRegexes, funcRegex, fileRefSyntax, textRefSyntax } = require('./utils/regex')
 /* Utils - strings */
 const formatFunctionArgs = require('./utils/strings/formatFunctionArgs')
 const { splitByComma } = require('./utils/strings/splitByComma')
@@ -92,8 +91,6 @@ const deepRefSyntax = RegExp(/(\${)?deep:\d+(\.[^}]+)*()}?/)
 const deepIndexReplacePattern = new RegExp(/^deep:|(\.[^}]+)*$/g)
 const deepIndexPattern = /deep\:(\d*)/
 const deepPrefixReplacePattern = /(?:^deep:)\d+\.?/g
-const fileRefSyntax = RegExp(/^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g)
-const textRefSyntax = RegExp(/^text\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g)
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
 const selfRefSyntax = RegExp(/^self:/g)
@@ -684,6 +681,17 @@ class Configorama {
       /** */
       //process.exit(1)
 
+      // Strip body content before variable resolution, re-attach after
+      if (configObject && configObject._body !== undefined) {
+        this._markdownContent = configObject._body
+        this._markdownContentKey = '_body'
+        delete configObject._body
+      } else if (configObject && configObject._content !== undefined) {
+        this._markdownContent = configObject._content
+        this._markdownContentKey = '_content'
+        delete configObject._content
+      }
+
       this.config = configObject
       this.originalConfig = cloneDeep(configObject)
     }
@@ -715,12 +723,8 @@ class Configorama {
       )
 
       if (showFoundVariables) {
-        //*
         deepLog('metadata', metadata)
-        fs.writeFileSync(`metadata-${path.basename(this.configFilePath)}.json`, JSON.stringify(metadata, null, 2))
         deepLog('enrich', enrich)
-        // process.exit(1)
-        /** */
       }
 
       const variableData = metadata.variables
@@ -1240,6 +1244,9 @@ class Configorama {
 
     /* If no variables found just return early */
     if (this.originalString && !this.originalString.match(this.variableSyntax)) {
+      if (this._markdownContent !== undefined) {
+        this.originalConfig[this._markdownContentKey] = this._markdownContent
+      }
       return Promise.resolve(this.originalConfig)
     }
 
@@ -1399,6 +1406,10 @@ class Configorama {
             deepLog(this.config)
             console.log()
           }
+          // Re-attach markdown body content after variable resolution
+          if (this._markdownContent !== undefined) {
+            this.config[this._markdownContentKey] = this._markdownContent
+          }
           return this.config
         })
     })
@@ -2693,7 +2704,10 @@ Missing Value ${missingValue} - ${matchedString}
         && !prop.match(getValueFromEval.match)
         && !prop.match(getValueFromIf.match)
         // AND is not multiline value
-        && (func && prop.split('\n').length < 3)) {
+        && (func && prop.split('\n').length < 3)
+        // Only tag as function if the function name is actually registered
+        // Prevents resolved values like git messages "fix(scope)" from being treated as functions
+        && (func[1] && (this.functions[func[1]] || this.functions[func[1].toLowerCase()]))) {
         // console.log('IS FUNCTION')
         /* if matches function signature like ${merge('foo', 'bar')}
           rewrite the variable to run the function after inputs resolved

package/src/parsers/index.js

@@ -9,6 +9,7 @@ const toml = require('./toml')
 const yaml = require('./yaml')
 const ini = require('./ini')
 const hcl = require('./hcl')
+const markdown = require('./markdown')
 
 /**
  * Collection of format parsers for different config file types
@@ -19,5 +20,6 @@ module.exports = {
   toml: toml,
   yaml: yaml,
   ini: ini,
-  hcl: hcl
+  hcl: hcl,
+  markdown: markdown
 }

package/src/parsers/markdown.js

@@ -0,0 +1,69 @@
+// Extracts and detects frontmatter format from markdown/MDX files
+
+/**
+ * Detect frontmatter syntax format from raw content
+ * @param {string} rawFrontmatter - Raw frontmatter string (without delimiters)
+ * @returns {'yaml'|'toml'|'json'} Detected format
+ */
+function detectSyntax(rawFrontmatter) {
+  const trimmed = rawFrontmatter.trim()
+  if (trimmed.startsWith('{')) {
+    return 'json'
+  }
+  if (/^\[[\w.-]+\]/m.test(trimmed)) {
+    return 'toml'
+  }
+  return 'yaml'
+}
+
+/**
+ * Extract frontmatter and body content from a markdown file
+ * @param {string} fileContents - Full file contents
+ * @returns {{ frontmatterContent: string|null, content: string, format: 'yaml'|'toml'|'json'|null }}
+ */
+function extractFrontmatter(fileContents) {
+  const noMatch = { frontmatterContent: null, content: fileContents, format: null }
+
+  if (!fileContents) {
+    return noMatch
+  }
+
+  // Normalize CRLF to LF for consistent delimiter matching
+  fileContents = fileContents.replace(/\r\n/g, '\n')
+
+  // +++ delimiters → TOML
+  if (fileContents.startsWith('+++\n')) {
+    const endIdx = fileContents.indexOf('\n+++', 4)
+    if (endIdx === -1) return noMatch
+    const frontmatterContent = fileContents.slice(4, endIdx)
+    const content = fileContents.slice(endIdx + 4)
+    return { frontmatterContent, content, format: 'toml' }
+  }
+
+  // --- delimiters → detect format from content
+  if (fileContents.startsWith('---\n')) {
+    const endIdx = fileContents.indexOf('\n---', 4)
+    if (endIdx === -1) return noMatch
+    const frontmatterContent = fileContents.slice(4, endIdx)
+    const content = fileContents.slice(endIdx + 4)
+    const format = detectSyntax(frontmatterContent)
+    return { frontmatterContent, content, format }
+  }
+
+  // <!-- --> comment frontmatter (strict: position 0)
+  if (fileContents.startsWith('<!--\n')) {
+    const endIdx = fileContents.indexOf('\n-->', 5)
+    if (endIdx === -1) return noMatch
+    const frontmatterContent = fileContents.slice(5, endIdx)
+    const content = fileContents.slice(endIdx + 4)
+    const format = detectSyntax(frontmatterContent)
+    return { frontmatterContent, content, format }
+  }
+
+  return noMatch
+}
+
+module.exports = {
+  extractFrontmatter,
+  detectSyntax
+}

package/src/parsers/markdown.test.js

@@ -0,0 +1,132 @@
+/* eslint-disable no-template-curly-in-string */
+// Unit tests for markdown frontmatter extraction and format detection
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { extractFrontmatter, detectSyntax } = require('./markdown')
+
+// --- detectSyntax tests ---
+
+test('detectSyntax: JSON detected by leading {', () => {
+  assert.is(detectSyntax('{ "title": "hello" }'), 'json')
+})
+
+test('detectSyntax: TOML detected by [section] header', () => {
+  assert.is(detectSyntax('title = "hello"\n[section]\nkey = "val"'), 'toml')
+})
+
+test('detectSyntax: TOML detected by [dotted.section] header', () => {
+  assert.is(detectSyntax('[my.config]\nkey = "val"'), 'toml')
+})
+
+test('detectSyntax: defaults to yaml', () => {
+  assert.is(detectSyntax('title: hello\ndescription: world'), 'yaml')
+})
+
+test('detectSyntax: yaml even with empty content', () => {
+  assert.is(detectSyntax(''), 'yaml')
+})
+
+// --- extractFrontmatter: YAML with --- delimiters ---
+
+test('extract YAML frontmatter with --- delimiters', () => {
+  const input = '---\ntitle: hello\nstage: ${opt:stage}\n---\n\n# My Doc\n\nBody content here.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'yaml')
+  assert.is(result.frontmatterContent, 'title: hello\nstage: ${opt:stage}')
+  assert.is(result.content, '\n\n# My Doc\n\nBody content here.')
+})
+
+// --- extractFrontmatter: TOML with +++ delimiters ---
+
+test('extract TOML frontmatter with +++ delimiters', () => {
+  const input = '+++\ntitle = "hello"\nstage = "${opt:stage}"\n+++\n\n# My Doc\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'toml')
+  assert.is(result.frontmatterContent, 'title = "hello"\nstage = "${opt:stage}"')
+  assert.is(result.content, '\n\n# My Doc\n\nBody.')
+})
+
+// --- extractFrontmatter: TOML detected inside --- delimiters ---
+
+test('extract TOML detected inside --- delimiters via [section]', () => {
+  const input = '---\n[metadata]\ntitle = "hello"\n---\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'toml')
+  assert.is(result.frontmatterContent, '[metadata]\ntitle = "hello"')
+  assert.is(result.content, '\n\nBody.')
+})
+
+// --- extractFrontmatter: JSON detected inside --- delimiters ---
+
+test('extract JSON detected inside --- delimiters via leading {', () => {
+  const input = '---\n{\n  "title": "hello"\n}\n---\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'json')
+  assert.is(result.frontmatterContent, '{\n  "title": "hello"\n}')
+  assert.is(result.content, '\n\nBody.')
+})
+
+// --- extractFrontmatter: HTML comment frontmatter ---
+
+test('extract hidden comment frontmatter <!-- -->', () => {
+  const input = '<!--\ntitle: hello\nstage: dev\n-->\n\n# Doc\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'yaml')
+  assert.is(result.frontmatterContent, 'title: hello\nstage: dev')
+  assert.is(result.content, '\n\n# Doc\n\nBody.')
+})
+
+test('comment frontmatter not detected when not at position 0', () => {
+  const input = '\n<!--\ntitle: hello\n-->\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '\n<!--\ntitle: hello\n-->\n\nBody.')
+})
+
+// --- extractFrontmatter: no frontmatter ---
+
+test('no frontmatter returns null + full content', () => {
+  const input = '# Just a markdown file\n\nNo frontmatter here.'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '# Just a markdown file\n\nNo frontmatter here.')
+})
+
+// --- Multiple --- in body don't confuse extraction ---
+
+test('thematic breaks in body do not confuse extraction', () => {
+  const input = '---\ntitle: hello\n---\n\nSome text\n\n---\n\nMore text after thematic break.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'yaml')
+  assert.is(result.frontmatterContent, 'title: hello')
+  assert.is(result.content, '\n\nSome text\n\n---\n\nMore text after thematic break.')
+})
+
+// --- Edge cases ---
+
+test('empty file returns no frontmatter', () => {
+  const result = extractFrontmatter('')
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '')
+})
+
+test('--- only at start with no closing returns no frontmatter', () => {
+  const input = '---\ntitle: hello\nno closing delimiter'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '---\ntitle: hello\nno closing delimiter')
+})
+
+test('+++ only at start with no closing returns no frontmatter', () => {
+  const input = '+++\ntitle = "hello"\nno closing delimiter'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '+++\ntitle = "hello"\nno closing delimiter')
+})
+
+test.run()

package/src/resolvers/valueFromGit.js

@@ -27,6 +27,24 @@ async function _exec(cmd, options = { timeout: 1000 }) {
   })
 }
 
+/**
+ * Execute a command with arguments array (safe from shell injection)
+ * @param {string} command - Command to execute
+ * @param {string[]} args - Arguments array
+ * @param {import('child_process').ExecFileOptions} [options] - ExecFile options
+ * @returns {Promise<string>}
+ */
+async function _execFile(command, args, options = { timeout: 1000 }) {
+  return new Promise((resolve, reject) => {
+    childProcess.execFile(command, args, options, (err, stdout) => {
+      if (err) {
+        return reject(err)
+      }
+      return resolve(String(stdout).trim())
+    })
+  })
+}
+
 // TODO denote computed fields in metadata
 /*
 {
@@ -230,28 +248,16 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
     throw new Error('File path must be a string')
   }
 
-  // Check for suspicious characters and patterns that could be used for command injection or path traversal
-  const dangerousPatterns = [
-    /[;&|`$]/,  // Command injection chars
-    // /\.\.\//,   // Directory traversal
-    // /\.\./,     // Directory traversal
-    // /^[\/\\]/,  // Absolute paths
-    /[\x00-\x1f\x7f-\x9f]/  // Control characters
-  ]
-
-  if (dangerousPatterns.some(pattern => pattern.test(_file))) {
-    throw new Error('Invalid characters or pattern in file path')
-  }
+  // Strip surrounding quotes and leading slash
+  const file = _file
+    .replace(/^['"]|['"]$/g, '')
+    .replace(/^\//, '')
 
-  // Only allow alphanumeric chars, dashes, underscores, forward slashes, and dots
-  if (!/^[a-zA-Z0-9-_./\\'"]+$/.test(_file)) {
+  // Reject control characters
+  if (/[\x00-\x1f\x7f-\x9f]/.test(file)) {
     throw new Error('File path contains invalid characters')
   }
 
-  // Normalize path and remove leading slash
-  const file = _file
-    .replace(/^\//, '')
-
   const cachedTimestamp = cache.get(file)
   if (cachedTimestamp) return cachedTimestamp
 
@@ -263,10 +269,7 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
   }
 
   try {
-    const cmd = `git log -1 --pretty="%ai" ${file}`
-    // console.log('cmd', cmd)
-    // console.log('cwd', cwd)
-    const output = await _exec(cmd, { cwd })
+    const output = await _execFile('git', ['log', '-1', '--pretty=%ai', '--', file], { cwd })
     const date = new Date(output)
     const dateString = date.toISOString()
     cache.set(file, dateString)
@@ -281,8 +284,8 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
     }
 
     try {
-      const backupFile = path.join(projectRoot, _file)
-      const output = await _exec(`git log -1 --pretty="%ai" ${backupFile}`, { cwd: projectRoot })
+      const backupFile = path.join(projectRoot, file)
+      const output = await _execFile('git', ['log', '-1', '--pretty=%ai', '--', backupFile], { cwd: projectRoot })
       const date = new Date(output)
       const dateString = date.toISOString()
       cache.set(file, dateString)

package/src/resolvers/valueFromNumber.js

@@ -1,5 +1,10 @@
-const isNumber = require('lodash.isnumber')
+// Resolves numeric literal variables to their Number values
+const { isNumber } = require('../utils/lodash')
 
+/**
+ * @param {string} variableString
+ * @returns {boolean}
+ */
 function isNumberVariable(variableString) {
   if (!variableString || variableString.trim().length === 0) {
     return false
@@ -8,6 +13,10 @@ function isNumberVariable(variableString) {
   return !isNaN(num) && isNumber(num)
 }
 
+/**
+ * @param {string} variableString
+ * @returns {Promise<number>}
+ */
 function getValueFromNumber(variableString) {
   return Promise.resolve(Number(variableString))
 }

package/src/types.d.ts

@@ -2,7 +2,7 @@
 // This file provides TypeScript support for validating configuration variables
 
 // Valid variable prefixes supported by configorama
-export type KnownVariablePrefix = 'env:' | 'opt:' | 'self:' | 'file:' | 'git:' | 'cron:'
+export type KnownVariablePrefix = 'env:' | 'opt:' | 'self:' | 'file:' | 'git:' | 'cron:' | 'param:'
 
 // Quoted string literal type for fallback values
 type QuotedString = `"${string}"` | `'${string}'`