@rio-cloud/cdk-v2-constructs 7.14.1 → 8.0.1

package/node_modules/path-expression-matcher/src/index.d.ts

@@ -189,169 +189,81 @@ export interface MatcherSnapshot {
 }
 
 /**
- * ReadOnlyMatcher - A safe, read-only view over a {@link Matcher} instance.
+ * MatcherView - A lightweight read-only view over a {@link Matcher} instance.
  *
- * Returned by {@link Matcher.readOnly}. Exposes all query and inspection
- * methods but **throws a `TypeError`** if any state-mutating method is called
- * (`push`, `pop`, `reset`, `updateCurrent`, `restore`).  Direct property
- * writes are also blocked.
+ * Created once by {@link Matcher} and reused across all callbacks — no allocation
+ * on every invocation. Holds a direct reference to the parent Matcher's internal
+ * state so it always reflects the current parser position with zero copying or
+ * freezing overhead.
  *
- * Pass this to consumers that only need to inspect or match the current path
- * so they cannot accidentally corrupt the parser state.
+ * Mutation methods (`push`, `pop`, `reset`, `updateCurrent`, `restore`) are simply
+ * absent from this class, so misuse is caught at compile time by TypeScript rather
+ * than at runtime.
+ *
+ * Obtain via {@link Matcher#readOnly} — the same instance is returned every time.
  *
  * @example
  * ```typescript
  * const matcher = new Matcher();
+ * const view: MatcherView = matcher.readOnly();
+ *
  * matcher.push("root", {});
  * matcher.push("users", {});
  * matcher.push("user", { id: "123" });
  *
- * const ro: ReadOnlyMatcher = matcher.readOnly();
- *
- * ro.matches(expr);      // ✓ works
- * ro.getCurrentTag();    // ✓ "user"
- * ro.getDepth();         // ✓ 3
- * ro.push("child", {}); // ✗ TypeError: Cannot call 'push' on a read-only Matcher
- * ro.reset();            // ✗ TypeError: Cannot call 'reset' on a read-only Matcher
+ * view.matches(expr);      // ✓ true
+ * view.getCurrentTag();    // ✓ "user"
+ * view.getDepth();         // ✓ 3
+ * // view.push(...)        // ✗ Property 'push' does not exist on type 'MatcherView'
  * ```
  */
-export interface ReadOnlyMatcher {
+export class MatcherView {
   /**
-   * Default path separator (read-only)
+   * Default path separator (read-only, delegates to parent Matcher)
    */
   readonly separator: string;
 
-  /**
-   * Current path stack (each node is a frozen copy)
-   */
-  readonly path: ReadonlyArray<Readonly<PathNode>>;
-
-  // ── Query methods ───────────────────────────────────────────────────────────
-
-  /**
-   * Get current tag name
-   * @returns Current tag name or undefined if path is empty
-   */
   getCurrentTag(): string | undefined;
-
-  /**
-   * Get current namespace
-   * @returns Current namespace or undefined if not present or path is empty
-   */
   getCurrentNamespace(): string | undefined;
-
-  /**
-   * Get current node's attribute value
-   * @param attrName - Attribute name
-   * @returns Attribute value or undefined
-   */
   getAttrValue(attrName: string): any;
-
-  /**
-   * Check if current node has an attribute
-   * @param attrName - Attribute name
-   */
   hasAttr(attrName: string): boolean;
-
-  /**
-   * Get current node's sibling position (child index in parent)
-   * @returns Position index or -1 if path is empty
-   */
   getPosition(): number;
-
-  /**
-   * Get current node's repeat counter (occurrence count of this tag name)
-   * @returns Counter value or -1 if path is empty
-   */
   getCounter(): number;
-
-  /**
-   * Get current node's sibling index (alias for getPosition for backward compatibility)
-   * @returns Index or -1 if path is empty
-   * @deprecated Use getPosition() or getCounter() instead
-   */
+  /** @deprecated Use getPosition() or getCounter() instead */
   getIndex(): number;
-
-  /**
-   * Get current path depth
-   * @returns Number of nodes in the path
-   */
   getDepth(): number;
-
-  /**
-   * Get path as string
-   * @param separator - Optional separator (uses default if not provided)
-   * @param includeNamespace - Whether to include namespace in output
-   * @returns Path string (e.g., "root.users.user" or "ns:root.ns:users.user")
-   */
   toString(separator?: string, includeNamespace?: boolean): string;
-
-  /**
-   * Get path as array of tag names
-   * @returns Array of tag names
-   */
   toArray(): string[];
-
-  /**
-   * Match current path against an Expression
-   * @param expression - The expression to match against
-   * @returns True if current path matches the expression
-   */
   matches(expression: Expression): boolean;
-
-  /**
-   * Create a snapshot of current state
-   * @returns State snapshot that can be restored later
-   */
-  snapshot(): MatcherSnapshot;
-
-  // ── Blocked mutating methods ────────────────────────────────────────────────
-  // These are present in the type so callers get a compile-time error with a
-  // helpful message instead of a silent "property does not exist" error.
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  pop(): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  updateCurrent(attrValues: Record<string, any>): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  reset(): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  restore(snapshot: MatcherSnapshot): never;
+  matchesAny(exprSet: ExpressionSet): boolean;
 }
 
 /**
- * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
- * 
+ * @deprecated Use {@link MatcherView} instead.
+ * Alias kept for backward compatibility with code that references `ReadOnlyMatcher`.
+ */
+export type ReadOnlyMatcher = MatcherView;
+
+/**
+ * Matcher - Tracks current path in XML/JSON tree and matches against Expressions.
+ *
  * The matcher maintains a stack of nodes representing the current path from root to
  * current tag. It only stores attribute values for the current (top) node to minimize
  * memory usage.
- * 
+ *
+ * Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to
+ * user callbacks — the same instance is reused on every call with no allocation overhead.
+ *
  * @example
  * ```typescript
  * const matcher = new Matcher();
  * matcher.push("root", {});
  * matcher.push("users", {});
  * matcher.push("user", { id: "123", type: "admin" });
- * 
+ *
  * const expr = new Expression("root.users.user");
  * matcher.matches(expr); // true
- * 
+ *
  * matcher.pop();
  * matcher.matches(expr); // false
  * ```
@@ -362,11 +274,6 @@ export class Matcher {
    */
   readonly separator: string;
 
-  /**
-   * Current path stack
-   */
-  readonly path: PathNode[];
-
   /**
    * Create a new Matcher
    * @param options - Configuration options
@@ -374,11 +281,11 @@ export class Matcher {
   constructor(options?: MatcherOptions);
 
   /**
-   * Push a new tag onto the path
+   * Push a new tag onto the path.
    * @param tagName - Name of the tag
    * @param attrValues - Attribute key-value pairs for current node (optional)
    * @param namespace - Namespace for the tag (optional)
-   * 
+   *
    * @example
    * ```typescript
    * matcher.push("user", { id: "123", type: "admin" });
@@ -389,130 +296,228 @@ export class Matcher {
   push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): void;
 
   /**
-   * Pop the last tag from the path
+   * Pop the last tag from the path.
    * @returns The popped node or undefined if path is empty
    */
   pop(): PathNode | undefined;
 
   /**
-   * Update current node's attribute values
-   * Useful when attributes are parsed after push
+   * Update current node's attribute values.
+   * Useful when attributes are parsed after push.
    * @param attrValues - Attribute values
    */
   updateCurrent(attrValues: Record<string, any>): void;
 
   /**
-   * Get current tag name
-   * @returns Current tag name or undefined if path is empty
+   * Reset the path to empty.
    */
-  getCurrentTag(): string | undefined;
+  reset(): void;
 
   /**
-   * Get current namespace
-   * @returns Current namespace or undefined if not present or path is empty
+   * Create a snapshot of current state.
+   * @returns State snapshot that can be restored later
    */
-  getCurrentNamespace(): string | undefined;
+  snapshot(): MatcherSnapshot;
 
   /**
-   * Get current node's attribute value
-   * @param attrName - Attribute name
-   * @returns Attribute value or undefined
+   * Restore state from snapshot.
+   * @param snapshot - State snapshot from previous snapshot() call
    */
-  getAttrValue(attrName: string): any;
+  restore(snapshot: MatcherSnapshot): void;
 
-  /**
-   * Check if current node has an attribute
-   * @param attrName - Attribute name
-   */
+  getCurrentTag(): string | undefined;
+  getCurrentNamespace(): string | undefined;
+  getAttrValue(attrName: string): any;
   hasAttr(attrName: string): boolean;
+  getPosition(): number;
+  getCounter(): number;
+  /** @deprecated Use getPosition() or getCounter() instead */
+  getIndex(): number;
+  getDepth(): number;
+  toString(separator?: string, includeNamespace?: boolean): string;
+  toArray(): string[];
+  matches(expression: Expression): boolean;
+  matchesAny(exprSet: ExpressionSet): boolean;
 
   /**
-   * Get current node's sibling position (child index in parent)
-   * @returns Position index or -1 if path is empty
+   * Return the read-only {@link MatcherView} for this matcher.
+   *
+   * The same instance is returned on every call — no allocation occurs.
+   * Pass this to user callbacks; it always reflects current parser state.
+   *
+   * @example
+   * ```typescript
+   * const view = matcher.readOnly();
+   * // same reference every time — safe to cache
+   * view === matcher.readOnly(); // true
+   * ```
    */
-  getPosition(): number;
+  readOnly(): MatcherView;
+}
 
+/**
+ * ExpressionSet - An indexed collection of Expressions for efficient bulk matching
+ *
+ * Pre-indexes expressions at insertion time by depth and terminal tag name so
+ * that `matchesAny()` performs an O(1) bucket lookup rather than a full O(E)
+ * linear scan on every tag.
+ *
+ * Three internal buckets are maintained automatically:
+ *  - **exact** — expressions with a fixed depth and a concrete terminal tag
+ *  - **depth-wildcard** — fixed depth but terminal tag is `*`
+ *  - **deep-wildcard** — expressions containing `..` (cannot be depth-indexed)
+ *
+ * @example
+ * ```typescript
+ * import { Expression, ExpressionSet, Matcher } from 'fast-xml-tagger';
+ *
+ * // Build once at config time
+ * const stopNodes = new ExpressionSet();
+ * stopNodes
+ *   .add(new Expression('root.users.user'))
+ *   .add(new Expression('root.config.*'))
+ *   .add(new Expression('..script'))
+ *   .seal(); // prevent accidental mutation during parsing
+ *
+ * // Query on every tag — hot path
+ * if (stopNodes.matchesAny(matcher)) {
+ *   // handle stop node
+ * }
+ * ```
+ */
+export class ExpressionSet {
   /**
-   * Get current node's repeat counter (occurrence count of this tag name)
-   * @returns Counter value or -1 if path is empty
+   * Create an empty ExpressionSet.
    */
-  getCounter(): number;
+  constructor();
 
   /**
-   * Get current node's sibling index (alias for getPosition for backward compatibility)
-   * @returns Index or -1 if path is empty
-   * @deprecated Use getPosition() or getCounter() instead
+   * Number of expressions currently in the set.
    */
-  getIndex(): number;
+  readonly size: number;
 
   /**
-   * Get current path depth
-   * @returns Number of nodes in the path
+   * Whether the set has been sealed against further modifications.
    */
-  getDepth(): number;
+  readonly isSealed: boolean;
 
   /**
-   * Get path as string
-   * @param separator - Optional separator (uses default if not provided)
-   * @param includeNamespace - Whether to include namespace in output
-   * @returns Path string (e.g., "root.users.user" or "ns:root.ns:users.user")
+   * Add a single Expression to the set.
+   *
+   * Duplicate patterns (same `expression.pattern` string) are silently ignored.
+   *
+   * @param expression - A pre-constructed Expression instance
+   * @returns `this` — for chaining
+   * @throws {TypeError} if the set has been sealed
+   *
+   * @example
+   * ```typescript
+   * set.add(new Expression('root.users.user'));
+   * set.add(new Expression('..script'));
+   * ```
    */
-  toString(separator?: string, includeNamespace?: boolean): string;
+  add(expression: Expression): this;
 
   /**
-   * Get path as array of tag names
-   * @returns Array of tag names
+   * Add multiple expressions at once.
+   *
+   * @param expressions - Array of Expression instances
+   * @returns `this` — for chaining
+   * @throws {TypeError} if the set has been sealed
+   *
+   * @example
+   * ```typescript
+   * set.addAll([
+   *   new Expression('root.users.user'),
+   *   new Expression('root.config.setting'),
+   * ]);
+   * ```
    */
-  toArray(): string[];
+  addAll(expressions: Expression[]): this;
 
   /**
-   * Reset the path to empty
+   * Check whether an Expression with the same pattern is already present.
+   *
+   * @param expression - Expression to look up
+   * @returns `true` if the pattern was already added
    */
-  reset(): void;
+  has(expression: Expression): boolean;
 
   /**
-   * Match current path against an Expression
-   * @param expression - The expression to match against
-   * @returns True if current path matches the expression
-   * 
+   * Seal the set against further modifications.
+   *
+   * After calling `seal()`, any call to `add()` or `addAll()` will throw a
+   * `TypeError`. This is useful to prevent accidental mutation once the config
+   * has been fully built and parsing has started.
+   *
+   * @returns `this` — for chaining
+   *
    * @example
    * ```typescript
-   * const expr = new Expression("root.users.user[id]");
-   * const matcher = new Matcher();
-   * 
-   * matcher.push("root");
-   * matcher.push("users");
-   * matcher.push("user", { id: "123" });
-   * 
-   * matcher.matches(expr); // true
+   * const stopNodes = new ExpressionSet();
+   * stopNodes.addAll(patterns.map(p => new Expression(p))).seal();
+   *
+   * // Later — safe: reads are still allowed
+   * stopNodes.matchesAny(matcher);
+   *
+   * // Later — throws TypeError: ExpressionSet is sealed
+   * stopNodes.add(new Expression('root.extra'));
    * ```
    */
-  matches(expression: Expression): boolean;
-
-  /**
-   * Create a snapshot of current state
-   * @returns State snapshot that can be restored later
-   */
-  snapshot(): MatcherSnapshot;
+  seal(): this;
 
   /**
-   * Restore state from snapshot
-   * @param snapshot - State snapshot from previous snapshot() call
+   * Test whether the matcher's current path matches **any** expression in the set.
+   *
+   * Uses the pre-built index to evaluate only the relevant bucket(s):
+   *  1. Exact depth + tag — O(1) lookup
+   *  2. Depth-matched wildcard tag — O(1) lookup
+   *  3. Deep-wildcard expressions — always scanned (typically a small list)
+   *
+   * @param matcher - A `Matcher` instance or a `ReadOnlyMatcher` view
+   * @returns `true` if at least one expression matches the current path
+   *
+   * @example
+   * ```typescript
+   * // Replaces:
+   * // for (const expr of stopNodeExpressions) {
+   * //   if (matcher.matches(expr)) return true;
+   * // }
+   *
+   * if (stopNodes.matchesAny(matcher)) {
+   *   // current tag is a stop node
+   * }
+   * ```
    */
-  restore(snapshot: MatcherSnapshot): void;
+  matchesAny(matcher: Matcher | MatcherView): boolean;
 
   /**
-   * Return a read-only view of this matcher.
+   * Find the first expression in the set that matches the matcher's current path.
+   *
+   * Uses the pre-built index to evaluate only the relevant bucket(s):
+   *  1. Exact depth + tag — O(1) lookup
+   *  2. Depth-matched wildcard tag — O(1) lookup
+   *  3. Deep-wildcard expressions — always scanned (typically a small list)
+   *
+   * @param matcher - A `Matcher` instance or a `ReadOnlyMatcher` view
+   * @returns Expression if at least one expression matches the current path
+   *
+   * @example
+   * ```typescript
+   * const node = stopNodes.findMatch(matcher);
+   * ```
    */
-  readOnly(): ReadOnlyMatcher;
+  findMatch(matcher: Matcher | MatcherView): Expression;
 }
 
 /**
- * Default export containing both Expression and Matcher
+ * Default export containing Expression, Matcher, and ExpressionSet
  */
 declare const _default: {
   Expression: typeof Expression;
   Matcher: typeof Matcher;
+  MatcherView: typeof MatcherView;
+  ExpressionSet: typeof ExpressionSet;
 };
 
 export default _default;

package/node_modules/path-expression-matcher/src/index.js

@@ -23,6 +23,7 @@
 
 import Expression from './Expression.js';
 import Matcher from './Matcher.js';
+import ExpressionSet from './ExpressionSet.js';
 
-export { Expression, Matcher };
-export default { Expression, Matcher };
+export { Expression, Matcher, ExpressionSet };
+export default { Expression, Matcher, ExpressionSet };

package/node_modules/strnum/CHANGELOG.md

@@ -1,6 +1,13 @@
 
-**2.1.1 / 2025-05-15**
-- remove unnecessary check to remove lint error
+**2.2.2 / 2026-03-23**
+- fix for space string
+
+
+**2.2.1 / 2026-03-19**
+- fix false positive for eNotation when no leading zeros
+
+**2.2.0 / 2026-02-28**
+- support infinity
 
 **2.1.0 / 2025-05-01**
 - fix e-notation 

package/node_modules/strnum/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strnum",
-  "version": "2.2.0",
+  "version": "2.2.3",
   "description": "Parse String to Number based on configuration",
   "type": "module",
   "main": "strnum.js",

package/node_modules/strnum/strnum.js

@@ -20,8 +20,9 @@ export default function toNumber(str, options = {}) {
 
     let trimmedStr = str.trim();
 
-    if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
-    else if (str === "0") return 0;
+    if (trimmedStr.length === 0) return str;
+    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
+    else if (trimmedStr === "0") return 0;
     else if (options.hex && hexRegex.test(trimmedStr)) {
         return parse_int(trimmedStr, 16);
         // }else if (options.oct && octRegex.test(str)) {
@@ -97,11 +98,16 @@ function resolveEnotation(str, trimmedStr, options) {
         else if (leadingZeros.length === 1
             && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
             return Number(trimmedStr);
-        } else if (options.leadingZeros && !eAdjacentToLeadingZeros) { //accept with leading zeros
-            //remove leading 0s
-            trimmedStr = (notation[1] || "") + notation[3];
+        } else if (leadingZeros.length > 0) {
+            // Has leading zeros — only accept if leadingZeros option allows it
+            if (options.leadingZeros && !eAdjacentToLeadingZeros) {
+                trimmedStr = (notation[1] || "") + notation[3];
+                return Number(trimmedStr);
+            } else return str;
+        } else {
+            // No leading zeros — always valid e-notation, parse it
             return Number(trimmedStr);
-        } else return str;
+        }
     } else {
         return str;
     }

package/package.json

@@ -15,7 +15,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "7.14.1",
+  "version": "8.0.1",
   "types": "lib/index.d.ts",
   "stability": "stable",
   "exports": {
@@ -51,6 +51,10 @@
       "postbump": "git add docs/API.md"
     }
   },
+  "engines": {
+    "npm": ">=11",
+    "node": ">=24"
+  },
   "scripts": {
     "compile": "jsii",
     "build": "npm run compile && node esbuild.mjs && npm run eslint && npm test",
@@ -82,7 +86,7 @@
     "@typescript-eslint/eslint-plugin": "6.12.0",
     "@typescript-eslint/parser": "6.12.0",
     "aws-cdk": "^2.177.0",
-    "aws-cdk-lib": "2.241.0",
+    "aws-cdk-lib": "2.248.0",
     "aws-sdk-client-mock": "^4.1.0",
     "commit-and-tag-version": "^12.5.0",
     "constructs": "10.5.1",
@@ -104,17 +108,17 @@
     "typescript": "~5.6.3"
   },
   "peerDependencies": {
-    "aws-cdk-lib": "^2.241.0",
+    "aws-cdk-lib": "^2.248.0",
     "constructs": "^10.5.1"
   },
   "dependencies": {
     "@aws-lambda-powertools/parameters": "^2.10.0",
-    "@aws-sdk/client-cloudformation": "^3.1015.0",
-    "@aws-sdk/client-codedeploy": "^3.1015.0",
-    "@aws-sdk/client-ecs": "3.1015.0",
-    "@aws-sdk/client-organizations": "^3.1015.0",
-    "@aws-sdk/client-secrets-manager": "^3.1015.0",
-    "@aws-sdk/client-ssm": "^3.1015.0",
+    "@aws-sdk/client-cloudformation": "^3.1036.0",
+    "@aws-sdk/client-codedeploy": "^3.1036.0",
+    "@aws-sdk/client-ecs": "3.1036.0",
+    "@aws-sdk/client-organizations": "^3.1036.0",
+    "@aws-sdk/client-secrets-manager": "^3.1036.0",
+    "@aws-sdk/client-ssm": "^3.1036.0",
     "@datadog/datadog-api-client": "^1.29.0",
     "@pepperize/cdk-autoscaling-gitlab-runner": "^0.2.624",
     "@smithy/util-retry": "^3.0.8",
@@ -137,9 +141,6 @@
     "@types/aws-lambda",
     "js-yaml"
   ],
-  "overrides": {
-    "form-data": ">=4.0.4"
-  },
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "7.14.1"
+  "version": "8.0.1"
 }