assign-gingerly 0.0.1 → 0.0.2

package/README.md

@@ -84,14 +84,14 @@ class YourEnhancement extends ElementEnhancement(EventTarget){
 }
 
 class BaseRegistry{
-    define(IBaseRegistryItem | IBaseRegistryItem[]){
+    push(IBaseRegistryItem | IBaseRegistryItem[]){
         ...
     }
 }
 
 //Here's where the dependency injection mapping takes place
 const baseRegistry = new BaseRegistry;
-baseRegistry.define([
+baseRegistry.push([
     {
         map: {
             [isHappy]: 'isHappy'
@@ -120,12 +120,25 @@ const asyncResult = await assignGingerly({}, {
 asyncResult.set[isMellow] = false;
 ```
 
-The assignGingerly searches the registry for any items that has a mapping with a matching symbol of isHappy and isMellow, and if found, sees it already has an instance of the spawn class associated with the first passed in parameter.  If no such instance is found, it instantiates one, associates the instance with the first parameter, then sets the property value.
+The assignGingerly searches the registry for any items that has a mapping with a matching symbol of isHappy and isMellow, and if found, sees if it already has an instance of the spawn class associated with the first passed in parameter.  If no such instance is found, it instantiates one, associates the instance with the first parameter, then sets the property value.
 
 It also adds a lazy property to the first passed in parameter, "set", which returns a proxy, and that proxy watches for symbol references passed in a value, and sets the value from that spawned instance.  Again, if the spawned instance is not found, it respawns it.
 
 The suggestion to use Symbol.for with a guid, as opposed to just Symbol(), is based on some negative experiences I've had with multiple versions of the same library being referenced, but is not required. Regular symbols could also be used when that risk can be avoided.
 
-Note the first time we mention async.  This is only necessary if you wish to work directly with the merged object.  This allows for lazy loading of the spawning class, which can be useful for large applications that don't need to download all the classes at once.  If you are just "depositing" values into the object, no need to await for anything.  Also, the assignGingerly should first do all the class instantiations that are already loaded (where the class constructor is specified in spawn), and then does all the lazy loaded ones.
+Note that the example above is the first time we mention async.  This is only necessary if you wish to work directly with the merged object.  This allows for lazy loading of the spawning class, which can be useful for large applications that don't need to download all the classes at once.  If you are just "depositing" values into the object, no need to await for anything.  Also, the assignGingerly should first do all the class instantiations that are already loaded (where the class constructor is specified in spawn), and then does all the lazy loaded ones.
+
+## Support for JSON assignment with Symbol.for symbols
+
+```JavaScript
+const asyncResult = await assignGingerly({}, {
+    "[Symbol.for('TFWsx0YH5E6eSfhE7zfLxA')]": true,
+    "[Symbol.for('BqnnTPWRHkWdVGWcGQoAiw')]": true,
+    '?.style.height': '40px',
+    '?.enhancements?.mellowYellow?.madAboutFourteen': true
+}, {
+    registry: BaseRegistry
+});
+```
 
 

package/index.d.ts

@@ -18,7 +18,7 @@ export interface IAssignGingerlyOptions {
  */
 export declare class BaseRegistry {
   private items;
-  define(items: IBaseRegistryItem | IBaseRegistryItem[]): void;
+  push(items: IBaseRegistryItem | IBaseRegistryItem[]): void;
   getItems(): IBaseRegistryItem[];
   findBySymbol(symbol: symbol | string): IBaseRegistryItem | undefined;
 }

package/index.js

@@ -7,7 +7,7 @@ const instanceMap = new WeakMap();
  */
 export class BaseRegistry {
     items = [];
-    define(items) {
+    push(items) {
         if (Array.isArray(items)) {
             this.items.push(...items);
         }
@@ -30,6 +30,22 @@ export class BaseRegistry {
         });
     }
 }
+/**
+ * Helper function to check if a string key represents a Symbol.for expression
+ */
+function isSymbolForKey(key) {
+    return key.startsWith('[Symbol.for(') && key.endsWith(')]');
+}
+/**
+ * Helper function to extract the symbol key from a Symbol.for string
+ */
+function parseSymbolForKey(key) {
+    const match = key.match(/^\[Symbol\.for\(['"](.+)['"]\)\]$/);
+    if (match && match[1]) {
+        return Symbol.for(match[1]);
+    }
+    return null;
+}
 /**
  * Helper function to parse a path string with ?. notation
  */
@@ -72,9 +88,30 @@ export async function assignGingerly(target, source, options) {
             : undefined;
     // Track promises for async spawning
     const asyncSpawns = [];
-    // First pass: handle all non-symbol keys and sync operations
+    // Convert Symbol.for string keys to actual symbols
+    const processedSource = {};
     for (const key of Object.keys(source)) {
-        const value = source[key];
+        if (isSymbolForKey(key)) {
+            const symbol = parseSymbolForKey(key);
+            if (symbol) {
+                processedSource[symbol] = source[key];
+            }
+            else {
+                // Invalid Symbol.for format - treat as regular string key
+                processedSource[key] = source[key];
+            }
+        }
+        else {
+            processedSource[key] = source[key];
+        }
+    }
+    // Copy over actual symbol keys
+    for (const sym of Object.getOwnPropertySymbols(source)) {
+        processedSource[sym] = source[sym];
+    }
+    // First pass: handle all non-symbol keys and sync operations
+    for (const key of Object.keys(processedSource)) {
+        const value = processedSource[key];
         if (isNestedPath(key)) {
             const pathParts = parsePath(key);
             const lastKey = pathParts[pathParts.length - 1];
@@ -104,9 +141,9 @@ export async function assignGingerly(target, source, options) {
         }
     }
     // Second pass: handle symbol keys for dependency injection
-    const symbols = Object.getOwnPropertySymbols(source);
+    const symbols = Object.getOwnPropertySymbols(processedSource);
     for (const sym of symbols) {
-        const value = source[sym];
+        const value = processedSource[sym];
         if (registry) {
             const registryItem = registry.findBySymbol(sym);
             if (registryItem) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -33,9 +33,9 @@
     "update": "ncu -u && npm install"
   },
   "devDependencies": {
-    "@playwright/test": "^1.57.0",
-    "spa-ssi": "0.0.25",
-    "@types/node": "^24.10.2",
+    "@playwright/test": "^1.58.0",
+    "spa-ssi": "0.0.26",
+    "@types/node": "^25.0.10",
     "typescript": "^5.9.3"
   }
 }