assign-gingerly 0.0.18 → 0.0.19

package/README.md

@@ -292,7 +292,7 @@ This guarantees that applying the reversal object restores the object to its exa
 ## Dependency injection based on a registry object and a Symbolic reference mapping
 
 ```Typescript
-interface IBaseRegistryItem<T = any, TObjToExtend = any> {
+interface IEnhancementRegistryItem<T = any, TObjToExtend = any> {
     spawn: {new(objToExtend: TObjToExtend, ctx: SpawnContext, initVals: Partial<T>): T}
     symlinks?: {[key: symbol]: keyof T}
     // Optional: for element enhancement access
@@ -317,15 +317,15 @@ class YourEnhancement{
     set madAboutFourteen(nv){}
 }
 
-class BaseRegistry{
-    push(IBaseRegistryItem | IBaseRegistryItem[]){
+class EnhancementRegistry{
+    push(IEnhancementRegistryItem | IEnhancementRegistryItem[]){
         ...
     }
 }
 
 //Here's where the dependency injection mapping takes place
-const baseRegistry = new BaseRegistry;
-baseRegistry.push([
+const EnhancementRegistry = new EnhancementRegistry;
+EnhancementRegistry.push([
     {
         symlinks: {
             [isHappy]: 'isHappy'
@@ -347,7 +347,7 @@ const result = assignGingerly({}, {
     '?.style?.height': '40px',
     '?.enh?.mellowYellow?.madAboutFourteen': true
 }, {
-    registry: BaseRegistry
+    registry: EnhancementRegistry
 });
 //result.set[isMellow] = false;
 ```
@@ -401,7 +401,7 @@ const registryItem = {
   enhKey: 'myEnh'
 };
 
-const registry = new BaseRegistry();
+const registry = new EnhancementRegistry();
 registry.push(registryItem);
 
 const element = document.createElement('div');
@@ -438,7 +438,7 @@ const registryItem = {
   }
 };
 
-const registry = new BaseRegistry();
+const registry = new EnhancementRegistry();
 registry.push(registryItem);
 
 const target = {};
@@ -465,7 +465,7 @@ const result = assignGingerly({}, {
     '?.style.height': '40px',
     '?.enh?.mellowYellow?.madAboutFourteen': true
 }, {
-    registry: BaseRegistry
+    registry: EnhancementRegistry
 });
 ```
 </details>
@@ -551,7 +551,7 @@ myElement.assignGingerly({
 <details>
 <summary>Lazy Registry Creation</summary>
 
-Each `CustomElementRegistry` instance gets its own `enhancementRegistry` property via a lazy getter. The `BaseRegistry` instance is created on first access and cached for subsequent uses:
+Each `CustomElementRegistry` instance gets its own `enhancementRegistry` property via a lazy getter. The `EnhancementRegistry` instance is created on first access and cached for subsequent uses:
 
 ```TypeScript
 const element1 = document.createElement('div');
@@ -572,7 +572,7 @@ console.log(registry1 === element1.customElementRegistry.enhancementRegistry); /
 You can still provide an explicit `registry` option to override the automatic behavior:
 
 ```TypeScript
-const customRegistry = new BaseRegistry();
+const customRegistry = new EnhancementRegistry();
 // ... configure customRegistry ...
 
 myElement.assignGingerly({
@@ -593,7 +593,7 @@ The `enh.set` proxy allows you to assign properties to enhancements using a clea
 
 ```TypeScript
 import 'assign-gingerly/object-extension.js';
-//import { BaseRegistry } from 'assign-gingerly';
+//import { EnhancementRegistry } from 'assign-gingerly';
 
 // Define an enhancement class
 class MyEnhancement {
@@ -662,7 +662,7 @@ Element enhancement classes should follow this constructor signature:
 
 ```TypeScript
 interface SpawnContext<T, TMountContext = any> {
-  config: IBaseRegistryItem<T>;
+  config: IEnhancementRegistryItem<T>;
   mountCtx?: TMountContext;  // Optional custom context passed by caller
 }
 
@@ -716,7 +716,7 @@ This is useful for:
 In addition to spawn and symlinks, registry items support optional properties `enhKey`, `withAttrs`, `canSpawn`, and `lifecycleKeys`:
 
 ```TypeScript
-interface IBaseRegistryItem<T, TObj = Element> {
+interface IEnhancementRegistryItem<T, TObj = Element> {
   spawn: { 
     new (obj?: TObj, ctx?: SpawnContext<T>, initVals?: Partial<T>): T;
     canSpawn?: (obj: TObj, ctx?: SpawnContext<T>) => boolean;  // Optional spawn guard
@@ -813,10 +813,10 @@ console.log(element.enh.plainData); // { prop1: 'value1', prop2: 'value2' }
 <details>
 <summary>Finding Registry Items by enhKey</summary>
 
-The `BaseRegistry` class includes a `findByEnhKey` method:
+The `EnhancementRegistry` class includes a `findByEnhKey` method:
 
 ```TypeScript
-const registry = new BaseRegistry();
+const registry = new EnhancementRegistry();
 registry.push({
   spawn: MyEnhancement,
   enhKey: 'myEnh'
@@ -1228,7 +1228,7 @@ class DivOnlyEnhancement {
   }
 }
 
-const registry = new BaseRegistry();
+const registry = new EnhancementRegistry();
 registry.push({
   spawn: DivOnlyEnhancement,
   enhKey: 'divOnly'
@@ -1262,7 +1262,7 @@ static canSpawn(obj: any, ctx?: SpawnContext<T>): boolean
 ```
 
 - `obj`: The target object being enhanced (element, plain object, etc.)
-- `ctx`: Optional spawn context containing `{ config: IBaseRegistryItem<T> }`
+- `ctx`: Optional spawn context containing `{ config: IEnhancementRegistryItem<T> }`
 - Returns: `true` to allow spawning, `false` to block
 
 ### Use Cases
@@ -1329,7 +1329,7 @@ class ValidatedEnhancement {
 ### Example with Dependency Injection
 
 ```TypeScript
-import assignGingerly, { BaseRegistry } from 'assign-gingerly';
+import assignGingerly, { EnhancementRegistry } from 'assign-gingerly';
 
 class ElementOnlyEnhancement {
   value = null;
@@ -1339,7 +1339,7 @@ class ElementOnlyEnhancement {
   }
 }
 
-const registry = new BaseRegistry();
+const registry = new EnhancementRegistry();
 const enhSymbol = Symbol.for('myEnhancement');
 
 registry.push({

package/assignGingerly.js

@@ -1,3 +1,21 @@
+// Polyfill for Map.prototype.getOrInsert and WeakMap.prototype.getOrInsert
+if (typeof Map.prototype.getOrInsert !== 'function') {
+  Map.prototype.getOrInsert = function(key, insert) {
+    if (this.has(key)) return this.get(key);
+    const value = insert();
+    this.set(key, value);
+    return value;
+  };
+}
+if (typeof WeakMap.prototype.getOrInsert !== 'function') {
+  WeakMap.prototype.getOrInsert = function(key, insert) {
+    if (this.has(key)) return this.get(key);
+    const value = insert();
+    this.set(key, value);
+    return value;
+  };
+}
+
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions
  */
@@ -16,7 +34,7 @@ export function getInstanceMap() {
 /**
  * Base registry class for managing enhancement configurations
  */
-export class BaseRegistry {
+export class EnhancementRegistry {
     items = [];
     push(items) {
         if (Array.isArray(items)) {
@@ -142,7 +160,7 @@ export function assignGingerly(target, source, options) {
     if (!target || typeof target !== 'object') {
         return target;
     }
-    const registry = options?.registry instanceof BaseRegistry
+    const registry = options?.registry instanceof EnhancementRegistry
         ? options.registry
         : options?.registry
             ? new options.registry()
@@ -305,10 +323,7 @@ export function assignGingerly(target, source, options) {
             if (registryItem) {
                 const instanceMap = getInstanceMap();
                 // Get or initialize the instances map for this target
-                if (!instanceMap.has(target)) {
-                    instanceMap.set(target, new Map());
-                }
-                const instances = instanceMap.get(target);
+                const instances = instanceMap.getOrInsert(target, () => new Map());
                 // Check if instance already exists (keyed by registryItem)
                 let instance = instances.get(registryItem);
                 if (!instance) {
@@ -363,10 +378,7 @@ export function assignGingerly(target, source, options) {
                             const registryItem = registry.findBySymbol(prop);
                             if (registryItem) {
                                 const instanceMap = getInstanceMap();
-                                if (!instanceMap.has(target)) {
-                                    instanceMap.set(target, new Map());
-                                }
-                                const instances = instanceMap.get(target);
+                                const instances = instanceMap.getOrInsert(target, () => new Map());
                                 let instance = instances.get(registryItem);
                                 if (!instance) {
                                     const SpawnClass = registryItem.spawn;

package/assignGingerly.ts

@@ -11,7 +11,7 @@ export type IBaseRegistryItem<T = any> = EnhancementConfig<T>;
  * Interface for the options passed to assignGingerly
  */
 export interface IAssignGingerlyOptions {
-  registry?: typeof BaseRegistry | BaseRegistry;
+  registry?: typeof EnhancementRegistry | EnhancementRegistry;
 }
 
 /**
@@ -34,7 +34,7 @@ export function getInstanceMap(): WeakMap<object, Map<EnhancementConfig, any>> {
 /**
  * Base registry class for managing enhancement configurations
  */
-export class BaseRegistry {
+export class EnhancementRegistry {
   private items: EnhancementConfig[] = [];
 
   push(items: EnhancementConfig | EnhancementConfig[]): void {
@@ -179,7 +179,7 @@ export function assignGingerly(
     return target;
   }
 
-  const registry = options?.registry instanceof BaseRegistry
+  const registry = options?.registry instanceof EnhancementRegistry
     ? options.registry
     : options?.registry
     ? new options.registry()
@@ -350,10 +350,7 @@ export function assignGingerly(
       if (registryItem) {
         const instanceMap = getInstanceMap();
         // Get or initialize the instances map for this target
-        if (!instanceMap.has(target)) {
-          instanceMap.set(target, new Map());
-        }
-        const instances = instanceMap.get(target)!;
+        const instances = instanceMap.getOrInsert(target, () => new Map());
 
         // Check if instance already exists (keyed by registryItem)
         let instance = instances.get(registryItem);
@@ -418,10 +415,7 @@ export function assignGingerly(
                 const registryItem = registry.findBySymbol(prop);
                 if (registryItem) {
                   const instanceMap = getInstanceMap();
-                  if (!instanceMap.has(target)) {
-                    instanceMap.set(target, new Map());
-                  }
-                  const instances = instanceMap.get(target)!;
+                  const instances = instanceMap.getOrInsert(target, () => new Map());
                   let instance = instances.get(registryItem);
 
                   if (!instance) {

package/buildCSSQuery.js

@@ -1,44 +1,11 @@
-/**
- * Resolves template variables in a string recursively
- * @param template - Template string with ${var} placeholders
- * @param patterns - The patterns object containing variable values
- * @param resolvedCache - Cache of already resolved values
- * @param visitedKeys - Set of keys being resolved (for cycle detection)
- * @returns Resolved string
- */
-function resolveTemplate(template, patterns, resolvedCache, visitedKeys = new Set()) {
-    return template.replace(/\$\{(\w+)\}/g, (match, varName) => {
-        // Check if already resolved
-        if (resolvedCache.has(varName)) {
-            return resolvedCache.get(varName);
-        }
-        // Check for circular reference
-        if (visitedKeys.has(varName)) {
-            throw new Error(`Circular reference detected in template variable: ${varName}`);
-        }
-        const value = patterns[varName];
-        if (value === undefined) {
-            throw new Error(`Undefined template variable: ${varName}`);
-        }
-        if (typeof value === 'string') {
-            // Recursively resolve
-            visitedKeys.add(varName);
-            const resolved = resolveTemplate(value, patterns, resolvedCache, visitedKeys);
-            visitedKeys.delete(varName);
-            resolvedCache.set(varName, resolved);
-            return resolved;
-        }
-        // Non-string value, return as-is
-        return String(value);
-    });
-}
+import { resolveTemplate } from './resolveTemplate.js';
 /**
  * Extracts attribute names from withAttrs configuration
  * Resolves template variables and excludes underscore-prefixed config keys
  * @param withAttrs - The attribute patterns configuration
  * @returns Array of resolved attribute names
  */
-function extractAttributeNames(withAttrs) {
+export function extractAttributeNames(withAttrs) {
     const names = [];
     const resolvedCache = new Map();
     // Add base if present

package/buildCSSQuery.ts

@@ -1,49 +1,5 @@
 import { EnhancementConfig, AttrPatterns } from './types/assign-gingerly/types';
-
-/**
- * Resolves template variables in a string recursively
- * @param template - Template string with ${var} placeholders
- * @param patterns - The patterns object containing variable values
- * @param resolvedCache - Cache of already resolved values
- * @param visitedKeys - Set of keys being resolved (for cycle detection)
- * @returns Resolved string
- */
-function resolveTemplate(
-    template: string,
-    patterns: Record<string, any>,
-    resolvedCache: Map<string, string>,
-    visitedKeys: Set<string> = new Set()
-): string {
-    return template.replace(/\$\{(\w+)\}/g, (match, varName) => {
-        // Check if already resolved
-        if (resolvedCache.has(varName)) {
-            return resolvedCache.get(varName)!;
-        }
-        
-        // Check for circular reference
-        if (visitedKeys.has(varName)) {
-            throw new Error(`Circular reference detected in template variable: ${varName}`);
-        }
-        
-        const value = patterns[varName];
-        
-        if (value === undefined) {
-            throw new Error(`Undefined template variable: ${varName}`);
-        }
-        
-        if (typeof value === 'string') {
-            // Recursively resolve
-            visitedKeys.add(varName);
-            const resolved = resolveTemplate(value, patterns, resolvedCache, visitedKeys);
-            visitedKeys.delete(varName);
-            resolvedCache.set(varName, resolved);
-            return resolved;
-        }
-        
-        // Non-string value, return as-is
-        return String(value);
-    });
-}
+import { resolveTemplate } from './resolveTemplate.js';
 
 /**
  * Extracts attribute names from withAttrs configuration
@@ -51,7 +7,7 @@ function resolveTemplate(
  * @param withAttrs - The attribute patterns configuration
  * @returns Array of resolved attribute names
  */
-function extractAttributeNames(withAttrs: AttrPatterns<any>): string[] {
+export function extractAttributeNames(withAttrs: AttrPatterns<any>): string[] {
     const names: string[] = [];
     const resolvedCache = new Map<string, string>();
     

package/global.d.ts

@@ -0,0 +1,25 @@
+// Type declarations for Map.prototype.getOrInsert and WeakMap.prototype.getOrInsert
+// Feature is now supported in all modern browsers (Chrome 146+, Firefox 134+, Safari 18.2+)
+// See: https://web-platform-dx.github.io/web-features-explorer/features/getorinsert/
+
+interface Map<K, V> {
+  /**
+   * Returns the value associated with the key if it exists, otherwise inserts
+   * the value returned by the insert callback and returns it.
+   * @param key The key to look up
+   * @param insert A callback that returns the value to insert if the key doesn't exist
+   * @returns The existing or newly inserted value
+   */
+  getOrInsert(key: K, insert: () => V): V;
+}
+
+interface WeakMap<K extends object, V> {
+  /**
+   * Returns the value associated with the key if it exists, otherwise inserts
+   * the value returned by the insert callback and returns it.
+   * @param key The key to look up
+   * @param insert A callback that returns the value to insert if the key doesn't exist
+   * @returns The existing or newly inserted value
+   */
+  getOrInsert(key: K, insert: () => V): V;
+}

package/index.js

@@ -1,8 +1,9 @@
 export { assignGingerly } from './assignGingerly.js';
 export { assignTentatively } from './assignTentatively.js';
-export { BaseRegistry } from './assignGingerly.js';
+export { EnhancementRegistry } from './assignGingerly.js';
 export { waitForEvent } from './waitForEvent.js';
 export { ParserRegistry, globalParserRegistry } from './parserRegistry.js';
 export { parseWithAttrs } from './parseWithAttrs.js';
 export { buildCSSQuery } from './buildCSSQuery.js';
+export { resolveTemplate } from './resolveTemplate.js';
 import './object-extension.js';

package/index.ts

@@ -1,8 +1,9 @@
 export {assignGingerly} from './assignGingerly.js';
 export {assignTentatively} from './assignTentatively.js';
-export {BaseRegistry} from './assignGingerly.js';
+export {EnhancementRegistry} from './assignGingerly.js';
 export {waitForEvent} from './waitForEvent.js';
 export {ParserRegistry, globalParserRegistry} from './parserRegistry.js';
 export {parseWithAttrs} from './parseWithAttrs.js';
 export {buildCSSQuery} from './buildCSSQuery.js';
+export {resolveTemplate} from './resolveTemplate.js';
 import './object-extension.js';

package/object-extension.js

@@ -1,4 +1,22 @@
-import assignGingerly, { BaseRegistry, getInstanceMap } from './assignGingerly.js';
+// Polyfill for Map.prototype.getOrInsert and WeakMap.prototype.getOrInsert
+if (typeof Map.prototype.getOrInsert !== 'function') {
+  Map.prototype.getOrInsert = function(key, insert) {
+    if (this.has(key)) return this.get(key);
+    const value = insert();
+    this.set(key, value);
+    return value;
+  };
+}
+if (typeof WeakMap.prototype.getOrInsert !== 'function') {
+  WeakMap.prototype.getOrInsert = function(key, insert) {
+    if (this.has(key)) return this.get(key);
+    const value = insert();
+    this.set(key, value);
+    return value;
+  };
+}
+
+import assignGingerly, { EnhancementRegistry, getInstanceMap } from './assignGingerly.js';
 import { parseWithAttrs } from './parseWithAttrs.js';
 /**
  * Normalizes lifecycleKeys to always return an object with dispose and resolved keys
@@ -21,7 +39,7 @@ if (typeof CustomElementRegistry !== 'undefined') {
     Object.defineProperty(CustomElementRegistry.prototype, 'enhancementRegistry', {
         get: function () {
             // Create a new BaseRegistry instance on first access and cache it
-            const registry = new BaseRegistry();
+            const registry = new EnhancementRegistry();
             // Replace the getter with the actual value
             Object.defineProperty(this, 'enhancementRegistry', {
                 value: registry,
@@ -66,10 +84,7 @@ class ElementEnhancementContainer {
         }
         // Get or create instance using the global instance map
         const instanceMap = getInstanceMap();
-        if (!instanceMap.has(element)) {
-            instanceMap.set(element, new Map());
-        }
-        const instances = instanceMap.get(element);
+        const instances = instanceMap.getOrInsert(element, () => new Map());
         let instance = instances.get(registryItem);
         if (!instance) {
             // Need to spawn
@@ -201,10 +216,7 @@ class ElementEnhancementContainer {
                             const SpawnClass = registryItem.spawn;
                             // Check the global instance map first
                             const instanceMap = getInstanceMap();
-                            if (!instanceMap.has(element)) {
-                                instanceMap.set(element, new Map());
-                            }
-                            const instances = instanceMap.get(element);
+                            const instances = instanceMap.getOrInsert(element, () => new Map());
                             let instance = instances.get(registryItem);
                             if (!instance) {
                                 // Need to spawn
@@ -259,10 +271,7 @@ if (typeof Element !== 'undefined') {
     const enhContainerWeakMap = new WeakMap();
     Object.defineProperty(Element.prototype, 'enh', {
         get: function () {
-            if (!enhContainerWeakMap.has(this)) {
-                enhContainerWeakMap.set(this, new ElementEnhancementContainer(this));
-            }
-            return enhContainerWeakMap.get(this);
+            return enhContainerWeakMap.getOrInsert(this, () => new ElementEnhancementContainer(this));
         },
         enumerable: true,
         configurable: true,

package/object-extension.ts

@@ -1,4 +1,4 @@
-import assignGingerly, { BaseRegistry, IAssignGingerlyOptions, getInstanceMap, INSTANCE_MAP_GUID } from './assignGingerly.js';
+import assignGingerly, { EnhancementRegistry, IAssignGingerlyOptions, getInstanceMap, INSTANCE_MAP_GUID } from './assignGingerly.js';
 import { parseWithAttrs } from './parseWithAttrs.js';
 
 /**
@@ -21,7 +21,7 @@ function normalizeLifecycleKeys(lifecycleKeys: true | { dispose?: string | symbo
  */
 declare global {
   interface CustomElementRegistry {
-    enhancementRegistry: typeof BaseRegistry | BaseRegistry;
+    enhancementRegistry: typeof EnhancementRegistry | EnhancementRegistry;
   }
   
   interface Element {
@@ -84,7 +84,7 @@ if (typeof CustomElementRegistry !== 'undefined') {
   Object.defineProperty(CustomElementRegistry.prototype, 'enhancementRegistry', {
     get: function () {
       // Create a new BaseRegistry instance on first access and cache it
-      const registry = new BaseRegistry();
+      const registry = new EnhancementRegistry();
       // Replace the getter with the actual value
       Object.defineProperty(this, 'enhancementRegistry', {
         value: registry,
@@ -136,10 +136,7 @@ class ElementEnhancementContainer {
     
     // Get or create instance using the global instance map
     const instanceMap = getInstanceMap();
-    if (!instanceMap.has(element)) {
-      instanceMap.set(element, new Map());
-    }
-    const instances = instanceMap.get(element)!;
+    const instances = instanceMap.getOrInsert(element, () => new Map());
     
     let instance = instances.get(registryItem);
     
@@ -304,10 +301,7 @@ class ElementEnhancementContainer {
               
               // Check the global instance map first
               const instanceMap = getInstanceMap();
-              if (!instanceMap.has(element)) {
-                instanceMap.set(element, new Map());
-              }
-              const instances = instanceMap.get(element)!;
+              const instances = instanceMap.getOrInsert(element, () => new Map());
               
               let instance = instances.get(registryItem);
               
@@ -376,11 +370,7 @@ if (typeof Element !== 'undefined') {
   
   Object.defineProperty(Element.prototype, 'enh', {
     get: function (this: Element) {
-      if (!enhContainerWeakMap.has(this)) {
-        enhContainerWeakMap.set(this, new ElementEnhancementContainer(this));
-      }
-      
-      return enhContainerWeakMap.get(this);
+      return enhContainerWeakMap.getOrInsert(this, () => new ElementEnhancementContainer(this));
     },
     enumerable: true,
     configurable: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -47,6 +47,10 @@
     "./buildCSSQuery.js": {
       "default": "./buildCSSQuery.js",
       "types": "./buildCSSQuery.ts"
+    },
+    "./resolveTemplate.js": {
+      "default": "./resolveTemplate.js",
+      "types": "./resolveTemplate.ts"
     }
   },
   "main": "index.js",

package/parseWithAttrs.js

@@ -1,4 +1,23 @@
+// Polyfill for Map.prototype.getOrInsert and WeakMap.prototype.getOrInsert
+if (typeof Map.prototype.getOrInsert !== 'function') {
+  Map.prototype.getOrInsert = function(key, insert) {
+    if (this.has(key)) return this.get(key);
+    const value = insert();
+    this.set(key, value);
+    return value;
+  };
+}
+if (typeof WeakMap.prototype.getOrInsert !== 'function') {
+  WeakMap.prototype.getOrInsert = function(key, insert) {
+    if (this.has(key)) return this.get(key);
+    const value = insert();
+    this.set(key, value);
+    return value;
+  };
+}
+
 import { globalParserRegistry } from './parserRegistry.js';
+import { resolveTemplate } from './resolveTemplate.js';
 // Module-level cache for parsed attribute values
 // Structure: Map<configKey, Map<attrValue, parsedValue>>
 const parseCache = new Map();
@@ -89,10 +108,7 @@ function parseWithCache(attrValue, config, parser) {
     }
     // Get or create cache for this config
     const cacheKey = getCacheKey(config);
-    if (!parseCache.has(cacheKey)) {
-        parseCache.set(cacheKey, new Map());
-    }
-    const valueCache = parseCache.get(cacheKey);
+    const valueCache = parseCache.getOrInsert(cacheKey, () => new Map());
     // Use special key for null values
     const valueCacheKey = attrValue === null ? '__NULL__' : attrValue;
     // Check if we have a cached value
@@ -160,40 +176,6 @@ function getAttributeValue(element, attrName, allowUnprefixed) {
         return enhValue;
     return element.getAttribute(attrName);
 }
-/**
- * Resolves template variables in a string recursively
- * @param template - Template string with ${var} placeholders
- * @param patterns - The patterns object containing variable values
- * @param resolvedCache - Cache of already resolved values
- * @param visitedKeys - Set of keys being resolved (for cycle detection)
- * @returns Resolved string
- */
-function resolveTemplate(template, patterns, resolvedCache, visitedKeys = new Set()) {
-    return template.replace(/\$\{(\w+)\}/g, (match, varName) => {
-        // Check if already resolved
-        if (resolvedCache.has(varName)) {
-            return resolvedCache.get(varName);
-        }
-        // Check for circular reference
-        if (visitedKeys.has(varName)) {
-            throw new Error(`Circular reference detected in template variable: ${varName}`);
-        }
-        const value = patterns[varName];
-        if (value === undefined) {
-            throw new Error(`Undefined template variable: ${varName}`);
-        }
-        if (typeof value === 'string') {
-            // Recursively resolve
-            visitedKeys.add(varName);
-            const resolved = resolveTemplate(value, patterns, resolvedCache, visitedKeys);
-            visitedKeys.delete(varName);
-            resolvedCache.set(varName, resolved);
-            return resolved;
-        }
-        // Non-string value, return as-is
-        return String(value);
-    });
-}
 /**
  * Gets the default parser for a given instanceOf type
  */

package/parseWithAttrs.ts

@@ -1,5 +1,6 @@
 import { AttrPatterns, AttrConfig } from './types/assign-gingerly/types';
 import { globalParserRegistry } from './parserRegistry.js';
+import { resolveTemplate } from './resolveTemplate.js';
 
 // Module-level cache for parsed attribute values
 // Structure: Map<configKey, Map<attrValue, parsedValue>>
@@ -107,11 +108,7 @@ function parseWithCache(
   
   // Get or create cache for this config
   const cacheKey = getCacheKey(config);
-  if (!parseCache.has(cacheKey)) {
-    parseCache.set(cacheKey, new Map());
-  }
-  
-  const valueCache = parseCache.get(cacheKey)!;
+  const valueCache = parseCache.getOrInsert(cacheKey, () => new Map());
   
   // Use special key for null values
   const valueCacheKey = attrValue === null ? '__NULL__' : attrValue;
@@ -193,51 +190,6 @@ function getAttributeValue(
   return element.getAttribute(attrName);
 }
 
-/**
- * Resolves template variables in a string recursively
- * @param template - Template string with ${var} placeholders
- * @param patterns - The patterns object containing variable values
- * @param resolvedCache - Cache of already resolved values
- * @param visitedKeys - Set of keys being resolved (for cycle detection)
- * @returns Resolved string
- */
-function resolveTemplate(
-    template: string,
-    patterns: Record<string, any>,
-    resolvedCache: Map<string, string>,
-    visitedKeys: Set<string> = new Set()
-): string {
-    return template.replace(/\$\{(\w+)\}/g, (match, varName) => {
-        // Check if already resolved
-        if (resolvedCache.has(varName)) {
-            return resolvedCache.get(varName)!;
-        }
-        
-        // Check for circular reference
-        if (visitedKeys.has(varName)) {
-            throw new Error(`Circular reference detected in template variable: ${varName}`);
-        }
-        
-        const value = patterns[varName];
-        
-        if (value === undefined) {
-            throw new Error(`Undefined template variable: ${varName}`);
-        }
-        
-        if (typeof value === 'string') {
-            // Recursively resolve
-            visitedKeys.add(varName);
-            const resolved = resolveTemplate(value, patterns, resolvedCache, visitedKeys);
-            visitedKeys.delete(varName);
-            resolvedCache.set(varName, resolved);
-            return resolved;
-        }
-        
-        // Non-string value, return as-is
-        return String(value);
-    });
-}
-
 /**
  * Gets the default parser for a given instanceOf type
  */

package/resolveTemplate.js

@@ -0,0 +1,49 @@
+/**
+ * Resolves template variables in a string recursively
+ * Supports ${varName} syntax for variable substitution
+ *
+ * @param template - Template string with ${var} placeholders
+ * @param patterns - The patterns object containing variable values
+ * @param resolvedCache - Cache of already resolved values
+ * @param visitedKeys - Set of keys being resolved (for cycle detection)
+ * @returns Resolved string
+ *
+ * @throws Error if circular reference is detected
+ * @throws Error if template variable is undefined
+ *
+ * @example
+ * const patterns = {
+ *   base: 'my-component',
+ *   theme: '${base}-theme'
+ * };
+ * const cache = new Map();
+ *
+ * resolveTemplate('${theme}', patterns, cache);
+ * // Returns: 'my-component-theme'
+ */
+export function resolveTemplate(template, patterns, resolvedCache, visitedKeys = new Set()) {
+    return template.replace(/\$\{(\w+)\}/g, (_match, varName) => {
+        // Check if already resolved
+        if (resolvedCache.has(varName)) {
+            return resolvedCache.get(varName);
+        }
+        // Check for circular reference
+        if (visitedKeys.has(varName)) {
+            throw new Error(`Circular reference detected in template variable: ${varName}`);
+        }
+        const value = patterns[varName];
+        if (value === undefined) {
+            throw new Error(`Undefined template variable: ${varName}`);
+        }
+        if (typeof value === 'string') {
+            // Recursively resolve
+            visitedKeys.add(varName);
+            const resolved = resolveTemplate(value, patterns, resolvedCache, visitedKeys);
+            visitedKeys.delete(varName);
+            resolvedCache.set(varName, resolved);
+            return resolved;
+        }
+        // Non-string value, return as-is
+        return String(value);
+    });
+}

package/resolveTemplate.ts

@@ -0,0 +1,59 @@
+/**
+ * Resolves template variables in a string recursively
+ * Supports ${varName} syntax for variable substitution
+ * 
+ * @param template - Template string with ${var} placeholders
+ * @param patterns - The patterns object containing variable values
+ * @param resolvedCache - Cache of already resolved values
+ * @param visitedKeys - Set of keys being resolved (for cycle detection)
+ * @returns Resolved string
+ * 
+ * @throws Error if circular reference is detected
+ * @throws Error if template variable is undefined
+ * 
+ * @example
+ * const patterns = {
+ *   base: 'my-component',
+ *   theme: '${base}-theme'
+ * };
+ * const cache = new Map();
+ * 
+ * resolveTemplate('${theme}', patterns, cache);
+ * // Returns: 'my-component-theme'
+ */
+export function resolveTemplate(
+    template: string,
+    patterns: Record<string, any>,
+    resolvedCache: Map<string, string>,
+    visitedKeys: Set<string> = new Set()
+): string {
+    return template.replace(/\$\{(\w+)\}/g, (_match, varName) => {
+        // Check if already resolved
+        if (resolvedCache.has(varName)) {
+            return resolvedCache.get(varName)!;
+        }
+        
+        // Check for circular reference
+        if (visitedKeys.has(varName)) {
+            throw new Error(`Circular reference detected in template variable: ${varName}`);
+        }
+        
+        const value = patterns[varName];
+        
+        if (value === undefined) {
+            throw new Error(`Undefined template variable: ${varName}`);
+        }
+        
+        if (typeof value === 'string') {
+            // Recursively resolve
+            visitedKeys.add(varName);
+            const resolved = resolveTemplate(value, patterns, resolvedCache, visitedKeys);
+            visitedKeys.delete(varName);
+            resolvedCache.set(varName, resolved);
+            return resolved;
+        }
+        
+        // Non-string value, return as-is
+        return String(value);
+    });
+}