configorama 0.7.2 → 0.9.0

package/src/utils/PromiseTracker.js

@@ -8,6 +8,8 @@ class PromiseTracker {
   reset() {
     this.promiseList = []
     this.promiseMap = {}
+    // Track which variables depend on which (for cycle detection)
+    this.dependencyGraph = {}
     this.startTime = Date.now()
     this.cursor = 0
   }
@@ -81,6 +83,58 @@ class PromiseTracker {
     promise.waitList += ` ${specifier}`
     return promise
   }
+  // Add a dependency edge: "from" depends on "to"
+  addDependency(from, to) {
+    if (!this.dependencyGraph[from]) {
+      this.dependencyGraph[from] = new Set()
+    }
+    this.dependencyGraph[from].add(to)
+  }
+  // Check if adding dependency from → to would create a cycle
+  wouldCreateCycle(from, to) {
+    // Check if "to" can reach "from" (meaning from → to would close a cycle)
+    const visited = new Set()
+    const stack = [to]
+    while (stack.length > 0) {
+      const current = stack.pop()
+      if (current === from) {
+        return true
+      }
+      if (visited.has(current)) {
+        continue
+      }
+      visited.add(current)
+      const deps = this.dependencyGraph[current]
+      if (deps) {
+        for (const dep of deps) {
+          stack.push(dep)
+        }
+      }
+    }
+    return false
+  }
+  // Get the cycle path for error reporting
+  getCyclePath(from, to) {
+    const path = [from, to]
+    const visited = new Set([from, to])
+    let current = to
+    while (current !== from) {
+      const deps = this.dependencyGraph[current]
+      if (!deps) break
+      let found = false
+      for (const dep of deps) {
+        if (dep === from || !visited.has(dep)) {
+          path.push(dep)
+          visited.add(dep)
+          current = dep
+          found = true
+          break
+        }
+      }
+      if (!found) break
+    }
+    return path
+  }
   getPending() {
     return this.promiseList.filter(p => (p.state === 'pending'))
   }

package/src/utils/variables/variableUtils.js

@@ -88,8 +88,61 @@ Remove or update the \${${variableString}} to fix
   return isRealVariable
 }
 
+/**
+ * Build default variable syntax regex with dynamic character class
+ * Excludes suffix characters from the allowed set to prevent parsing issues
+ * @param {string} [prefix='${'] - Variable prefix
+ * @param {string} [suffix='}'] - Variable suffix
+ * @param {string[]} [excludePatterns=['AWS', 'stageVariables']] - Patterns to exclude via negative lookahead
+ * @returns {string} Regex source string
+ */
+function buildVariableSyntax(prefix = '${', suffix = '}', excludePatterns = ['AWS', 'stageVariables']) {
+  // All allowed characters, stored as individual escaped entries for regex character class
+  // Each entry is how it appears in a regex character class
+  // NOTE: { and } are intentionally excluded - they break nested variable matching
+  // NOTE: $ is intentionally excluded - it's part of variable prefix and breaks nesting
+  const allChars = [
+    ' ', '~', ':', 'a-z', 'A-Z', '0-9', '=', '+', '!', '@', '#', '%',
+    '\\^', '&', ';', '`', '\\*', '<', '>', '\\?', '\\.', '_', "'", '"', ',',
+    '\\|', '\\-', '\\/', '\\(', '\\)', '\\[', '\\]', '\\\\'
+  ]
+
+  // Map of unescaped char to its escaped form in regex character class
+  const charEscapeMap = {
+    '^': '\\^', '*': '\\*', '?': '\\?', '.': '\\.', '|': '\\|',
+    '-': '\\-', '/': '\\/', '(': '\\(', ')': '\\)', '[': '\\[', ']': '\\]',
+    '\\': '\\\\'
+  }
+
+  // Get unique characters from suffix that need to be excluded
+  const suffixChars = [...new Set(suffix.split(''))]
+
+  // Filter out chars that appear in suffix
+  const allowedChars = allChars.filter(charEntry => {
+    for (const sc of suffixChars) {
+      const escaped = charEscapeMap[sc] || sc
+      if (charEntry === escaped || charEntry === sc) {
+        return false
+      }
+    }
+    return true
+  })
+
+  // Escape prefix and suffix for regex
+  const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const escapedSuffix = suffix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+  // Build negative lookahead for excluded patterns
+  const lookahead = excludePatterns.length > 0
+    ? `(?!${excludePatterns.join('|')})`
+    : ''
+
+  return `${escapedPrefix}(${lookahead}[${allowedChars.join('')}]+?)${escapedSuffix}`
+}
+
 module.exports = {
   extractVariableWrapper,
   getFallbackString,
-  verifyVariable
+  verifyVariable,
+  buildVariableSyntax
 } 

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

@@ -150,5 +150,49 @@ test('extractVariableWrapper - strips non-capturing group prefix', () => {
   assert.equal(result.suffix, '}')
 })
 
+// Tests for buildVariableSyntax
+const { buildVariableSyntax } = require('./variableUtils')
+
+test('buildVariableSyntax - default ${} syntax excludes $ {', () => {
+  const syntax = buildVariableSyntax('${', '}')
+  const regex = new RegExp(syntax, 'g')
+  // $ and { in value cause no match (they're not in character class)
+  assert.not.ok("${env:FOO, 'test$value'}".match(regex))
+  assert.not.ok("${env:FOO, 'test{value'}".match(regex))
+  // } causes partial match (ends early at the } in value)
+  const partialMatch = "${env:FOO, 'test}value'}".match(regex)
+  assert.ok(partialMatch)
+  assert.is(partialMatch[0], "${env:FOO, 'test}")
+})
+
+test('buildVariableSyntax - supports backslash in values', () => {
+  const syntax = buildVariableSyntax('${', '}')
+  const regex = new RegExp(syntax, 'g')
+  const match = "${env:FOO, 'path\\to\\file'}".match(regex)
+  assert.is(match[0], "${env:FOO, 'path\\to\\file'}")
+})
+
+test('buildVariableSyntax - double brace ${{}} syntax excludes }', () => {
+  const syntax = buildVariableSyntax('${{', '}}')
+  const regex = new RegExp(syntax, 'g')
+  const match = "${{env:FOO, 'value'}}".match(regex)
+  assert.is(match[0], "${{env:FOO, 'value'}}")
+})
+
+test('buildVariableSyntax - angle bracket <> syntax excludes >', () => {
+  const syntax = buildVariableSyntax('<', '>')
+  const regex = new RegExp(syntax, 'g')
+  // > in value causes partial match
+  const match = "<env:FOO, 'a>b'>".match(regex)
+  assert.is(match[0], "<env:FOO, 'a>")
+})
+
+test('buildVariableSyntax - bracket [[]] syntax excludes ]', () => {
+  const syntax = buildVariableSyntax('[[', ']]')
+  const regex = new RegExp(syntax, 'g')
+  const match = "[[env:FOO, 'value']]".match(regex)
+  assert.is(match[0], "[[env:FOO, 'value']]")
+})
+
 // Run all tests
 test.run()

package/types/src/index.d.ts

@@ -3,10 +3,11 @@ declare namespace _exports {
 }
 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 { Configorama };
+    export { buildVariableSyntax };
 }
 export = _exports;
 type ConfigoramaSettings = {
@@ -95,6 +96,7 @@ type ConfigoramaResult<T = any> = {
      */
     resolutionHistory: any;
 };
-import Configorama = require("./main");
 import parsers = require("./parsers");
+import Configorama = require("./main");
+import { buildVariableSyntax } from "./utils/variables/variableUtils";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAuCiB,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"}

package/types/src/main.d.ts

@@ -27,6 +27,24 @@ declare class Configorama {
     deep: any[];
     leaves: any[];
     callCount: number;
+    /**
+     * Check if unresolved variables of a given type should pass through
+     * @param {string} type - The resolver type (e.g., 'param', 'file', 'env')
+     * @returns {boolean}
+     */
+    isUnresolvedAllowed(type: string): boolean;
+    /**
+     * Extract type prefix from a variable string
+     * @param {string} varString - Variable string like 'ssm:path/to/thing' or 'custom:value'
+     * @returns {string|null} The type prefix or null if not found
+     */
+    extractTypePrefix(varString: string): string | null;
+    /**
+     * Check if unknown variable types should pass through
+     * @param {string} varString - Variable string like 'ssm:path' or full '${ssm:path}'
+     * @returns {boolean}
+     */
+    isUnknownTypeAllowed(varString: string): boolean;
     /**
      * Populate all variables in the service, conveniently remove and restore the service attributes
      * that confuse the population methods.

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA6HA;IACE,0CAgaC;IAxZC,cAaW;IAOX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAc5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBAsGC;IAoED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAMpB;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CA+Kb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CAofxB;IACD,+EA8BC;IACD,yDAeC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAoDC;CACF"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CAybC;IAjbC,cAcW;IAuBX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAc5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBA8GC;IAoED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAGpB;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,OAAO,CAoBnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CA+Kb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CA6gBxB;IACD,+EA+BC;IACD,yDAeC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAoDC;CACF"}

package/types/src/resolvers/valueFromFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAfG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CA8SxB;AAxVD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAkUD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}
+{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAfG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAoTxB;AA9VD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAwUD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}

package/types/src/resolvers/valueFromParam.d.ts

@@ -0,0 +1,19 @@
+declare const paramRefSyntax: RegExp;
+/**
+ * Resolves parameter values following the Serverless Framework parameter resolution hierarchy:
+ * 1. CLI params (--param="key=value")
+ * 2. Stage-specific params (stages.<stage>.params)
+ * 3. Default params (stages.default.params)
+ *
+ * @param {string} variableString - The variable string (e.g., "param:domain")
+ * @param {Object} options - CLI options that may contain params
+ * @param {Object} config - The full config object for stage-specific params
+ * @returns {Promise<any>} The resolved parameter value
+ */
+declare function getValueFromParam(variableString: string, options?: any, config?: any): Promise<any>;
+export declare let type: string;
+export declare let source: string;
+export declare let syntax: string;
+export declare let description: string;
+export { paramRefSyntax as match, getValueFromParam as resolver };
+//# sourceMappingURL=valueFromParam.d.ts.map

package/types/src/resolvers/valueFromParam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromParam.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromParam.js"],"names":[],"mappings":"AACA,qCAAyC;AAEzC;;;;;;;;;;GAUG;AACH,mDALW,MAAM,gCAGJ,OAAO,CAAC,GAAG,CAAC,CAqExB"}

package/types/src/utils/PromiseTracker.d.ts

@@ -3,6 +3,7 @@ declare class PromiseTracker {
     reset(): void;
     promiseList: any[];
     promiseMap: {};
+    dependencyGraph: {};
     startTime: number;
     cursor: number;
     start(): void;
@@ -12,6 +13,9 @@ declare class PromiseTracker {
     add(variable: any, promise: any, specifier: any, hasFilter: any, promiseKey: any): any;
     contains(variable: any): boolean;
     get(variable: any, specifier: any): any;
+    addDependency(from: any, to: any): void;
+    wouldCreateCycle(from: any, to: any): boolean;
+    getCyclePath(from: any, to: any): any[];
     getPending(): any[];
     getSettled(): any[];
     getAll(): any[];

package/types/src/utils/PromiseTracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PromiseTracker.d.ts","sourceRoot":"","sources":["../../../src/utils/PromiseTracker.js"],"names":[],"mappings":";AAGA;IAIE,cAKC;IAJC,mBAAqB;IACrB,eAAoB;IACpB,kBAA2B;IAC3B,eAAe;IAEjB,cAGC;IADC,yBAAyD;IAE3D,eAqBC;IACD,aAGC;IACD,uFA+BC;IACD,iCAEC;IACD,wCAIC;IACD,oBAEC;IACD,oBAEC;IACD,gBAEC;CACF"}
+{"version":3,"file":"PromiseTracker.d.ts","sourceRoot":"","sources":["../../../src/utils/PromiseTracker.js"],"names":[],"mappings":";AAGA;IAIE,cAOC;IANC,mBAAqB;IACrB,eAAoB;IAEpB,oBAAyB;IACzB,kBAA2B;IAC3B,eAAe;IAEjB,cAGC;IADC,yBAAyD;IAE3D,eAqBC;IACD,aAGC;IACD,uFA+BC;IACD,iCAEC;IACD,wCAIC;IAED,wCAKC;IAED,8CAqBC;IAED,wCAoBC;IACD,oBAEC;IACD,oBAEC;IACD,gBAEC;CACF"}

package/types/src/utils/variables/variableUtils.d.ts

@@ -18,4 +18,13 @@ export function getFallbackString(split: string[], nestedVar: string): string;
  * Verify if variable string is valid
  */
 export function verifyVariable(variableString: any, valueObject: any, variableTypes: any, config: any): any;
+/**
+ * Build default variable syntax regex with dynamic character class
+ * Excludes suffix characters from the allowed set to prevent parsing issues
+ * @param {string} [prefix='${'] - Variable prefix
+ * @param {string} [suffix='}'] - Variable suffix
+ * @param {string[]} [excludePatterns=['AWS', 'stageVariables']] - Patterns to exclude via negative lookahead
+ * @returns {string} Regex source string
+ */
+export function buildVariableSyntax(prefix?: string, suffix?: string, excludePatterns?: string[]): string;
 //# sourceMappingURL=variableUtils.d.ts.map

package/types/src/utils/variables/variableUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variableUtils.d.ts","sourceRoot":"","sources":["../../../../src/utils/variables/variableUtils.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qDAHW,MAAM,GACJ;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAqC9C;AAED;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,aACR,MAAM,GACJ,MAAM,CAelB;AAED;;GAEG;AACH,4GAsBC"}
+{"version":3,"file":"variableUtils.d.ts","sourceRoot":"","sources":["../../../../src/utils/variables/variableUtils.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qDAHW,MAAM,GACJ;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAqC9C;AAED;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,aACR,MAAM,GACJ,MAAM,CAelB;AAED;;GAEG;AACH,4GAsBC;AAED;;;;;;;GAOG;AACH,6CALW,MAAM,WACN,MAAM,oBACN,MAAM,EAAE,GACN,MAAM,CA4ClB"}