assign-gingerly 0.0.78 → 0.0.80

package/assignGingerly.js

@@ -420,6 +420,7 @@ export function isAllowedMethod(methodName, withMethods, permissionProcessor) {
 export function evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor) {
     let current = target;
     let i = 0;
+    let lastSegmentConsumed = false;
     // Process all segments except the last one
     while (i < pathParts.length - 1) {
         const part = pathParts[i];
@@ -433,14 +434,18 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods, p
             const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
             const method = current[methodName];
             if (typeof method === 'function') {
+                const appendArgs = permissionProcessor?.getMethodAppendArgs(methodName) ?? [];
                 if (isZeroArgMethod || nextIsMethod) {
                     // Zero-arg call - next part is either a method or explicitly not an argument
-                    current = method.call(current);
+                    current = method.call(current, ...appendArgs);
                 }
                 else {
                     // Only current is method - call with next part as string arg
-                    current = method.call(current, nextPart);
+                    current = method.call(current, nextPart, ...appendArgs);
                     i++; // Skip next part since we consumed it as argument
+                    if (i === pathParts.length - 1) {
+                        lastSegmentConsumed = true;
+                    }
                 }
             }
             else {
@@ -469,7 +474,8 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods, p
         target: current,
         lastKey,
         isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
-        isZeroArg
+        isZeroArg,
+        lastSegmentConsumed
     };
 }
 /**
@@ -541,8 +547,9 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                     const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
                     const method = current[methodName];
                     if (typeof method === 'function') {
+                        const appendArgs = permissionProcessor?.getMethodAppendArgs(methodName) ?? [];
                         if (isZeroArgMethod) {
-                            current = method.call(current);
+                            current = method.call(current, ...appendArgs);
                             continue;
                         }
                         // For methods in the middle, we need to check the next part
@@ -551,15 +558,15 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                         const nextIsMethod = nextPart && (withMethods.has(nextPart)
                             || (nextPart.endsWith('|') && withMethods.has(nextPart.slice(0, -1))));
                         if (nextIsMethod) {
-                            current = method.call(current);
+                            current = method.call(current, ...appendArgs);
                         }
                         else if (nextPart) {
-                            current = method.call(current, nextPart);
+                            current = method.call(current, nextPart, ...appendArgs);
                             // Skip next part
                             pathToForEach.splice(nextIndex, 1);
                         }
                         else {
-                            current = method.call(current);
+                            current = method.call(current, ...appendArgs);
                         }
                     }
                     else {
@@ -582,15 +589,16 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                 // Last segment is a method - call it
                 const method = result.target[result.lastKey];
                 if (typeof method === 'function') {
+                    const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
                     if (result.isZeroArg) {
-                        // Trailing | marker - call with no arguments, ignoring the value
-                        method.call(result.target);
+                        // Trailing | marker - call with appended args only, ignoring the value
+                        method.call(result.target, ...appendArgs);
                     }
                     else if (Array.isArray(value)) {
-                        method.apply(result.target, value);
+                        method.apply(result.target, [...value, ...appendArgs]);
                     }
                     else {
-                        method.call(result.target, value);
+                        method.call(result.target, value, ...appendArgs);
                     }
                 }
             }
@@ -620,6 +628,95 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
         }
     }
 }
+/**
+ * Resolve the RHS of a toggle (=!) command to the value that should be negated.
+ * Supports:
+ * - '?.path' nested path strings resolved against target (returns the resolved value, or true if missing)
+ * - plain key strings looked up on target (returns the value, or true if missing)
+ * - resolved literal values (e.g., booleans from assignFrom) returned as-is
+ */
+function resolveValueToNegate(rhsPath, target) {
+    if (typeof rhsPath === 'string' && isNestedPath(rhsPath)) {
+        const rhsPathParts = parsePath(rhsPath);
+        let current = target;
+        let exists = true;
+        for (const part of rhsPathParts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                exists = false;
+                break;
+            }
+        }
+        return exists ? current : true;
+    }
+    if (typeof rhsPath === 'string') {
+        return (rhsPath in target) ? target[rhsPath] : true;
+    }
+    // Non-string resolved value (e.g., boolean, number, null from assignFrom)
+    return rhsPath;
+}
+/**
+ * Navigate a path that leads to an iterable, returning the iterable value or undefined.
+ * Handles withMethods and the evaluatePathWithMethods semantics.
+ */
+function getIterableAtPath(target, pathParts, value, withMethods, permissionProcessor) {
+    let current = target;
+    if (pathParts.length > 0) {
+        if (withMethods && withMethods.size > 0) {
+            const result = evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor);
+            // evaluatePathWithMethods returns the container object + last key by default.
+            // If the last segment was consumed as a method argument, or the last segment
+            // is a zero-arg method marked with |, result.target is already the value.
+            if (result.lastSegmentConsumed) {
+                current = result.target;
+            }
+            else if (result.isMethod) {
+                const method = result.target[result.lastKey];
+                if (typeof method === 'function') {
+                    const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
+                    current = method.call(result.target, ...appendArgs);
+                }
+                else {
+                    current = method;
+                }
+            }
+            else {
+                current = result.target[result.lastKey];
+            }
+        }
+        else {
+            for (const part of pathParts) {
+                current = current[part];
+            }
+        }
+    }
+    return isIterable(current) ? current : undefined;
+}
+/**
+ * Apply an operator command (+=, =!, -=, Y=) to each item in an iterable.
+ * Detects @each in the path, navigates to the iterable, then builds a synthetic
+ * command key for the remaining path and delegates to assignGingerly per item.
+ * Nested @each is handled recursively through assignGingerly.
+ */
+function applyCommandToEach(target, pathParts, commandSuffix, value, withMethods, aliasMap, options, permissionProcessor) {
+    const forEachIndex = pathParts.findIndex(part => isForEachSymbol(part, aliasMap));
+    if (forEachIndex === -1)
+        return;
+    const pathToForEach = pathParts.slice(0, forEachIndex);
+    const pathAfterForEach = pathParts.slice(forEachIndex + 1);
+    const iterable = getIterableAtPath(target, pathToForEach, value, withMethods, permissionProcessor);
+    if (!iterable)
+        return;
+    const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
+    const syntheticKey = pathAfterForEach.length > 0
+        ? `?.${pathAfterForEach.join('?.')}${commandSuffix}`
+        : commandSuffix;
+    for (const item of items) {
+        assignGingerly(item, { [syntheticKey]: value }, options, permissionProcessor);
+    }
+}
 /**
  * Apply alias substitutions to a key string.
  * Replaces complete tokens between `?.` delimiters with their aliased values.
@@ -724,6 +821,11 @@ export function assignGingerly(target, source, options, permissionProcessor) {
             if (path) {
                 if (isNestedPath(path)) {
                     const pathParts = parsePath(path);
+                    // Check for @each in path
+                    if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                        applyCommandToEach(target, pathParts, ' +=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+                        continue;
+                    }
                     // Check for withMethods path evaluation
                     let lhsValue;
                     let lhsParent;
@@ -792,54 +894,47 @@ export function assignGingerly(target, source, options, permissionProcessor) {
             const lhsPath = parseToggleCommand(key);
             if (lhsPath) {
                 const rhsPath = value;
-                // Resolve LHS
-                let lhsParent;
-                let lhsLastKey;
                 if (isNestedPath(lhsPath)) {
                     const lhsPathParts = parsePath(lhsPath);
-                    lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
-                    lhsParent = ensureNestedPath(target, lhsPathParts);
-                }
-                else {
-                    lhsLastKey = lhsPath;
-                    lhsParent = target;
-                }
-                // Determine what to negate
-                let valueToNegate;
-                if (rhsPath === '.') {
-                    // Self-reference: negate the LHS value itself (if it exists)
-                    if (lhsLastKey in lhsParent) {
-                        valueToNegate = lhsParent[lhsLastKey];
+                    // Check for @each in the LHS path
+                    if (lhsPathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                        // Resolve non-self-referencing RHS paths against the original target
+                        // before iterating, so each item negates the same root value.
+                        const resolvedValue = (rhsPath === '.' || typeof rhsPath !== 'string')
+                            ? rhsPath
+                            : resolveValueToNegate(rhsPath, target);
+                        applyCommandToEach(target, lhsPathParts, ' =!', resolvedValue, withMethodsSet, aliasMap, options, permissionProcessor);
+                        continue;
+                    }
+                    // No @each in path - standard toggle
+                    const lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+                    const lhsParent = ensureNestedPath(target, lhsPathParts);
+                    // Determine what to negate
+                    let valueToNegate;
+                    if (rhsPath === '.') {
+                        valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
                     }
                     else {
-                        valueToNegate = undefined;
+                        valueToNegate = resolveValueToNegate(rhsPath, target);
+                    }
+                    if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+                        lhsParent[lhsLastKey] = !valueToNegate;
                     }
                 }
                 else {
-                    // RHS path: navigate to get the value (don't create paths)
-                    if (isNestedPath(rhsPath)) {
-                        const rhsPathParts = parsePath(rhsPath);
-                        let current = target;
-                        let exists = true;
-                        for (const part of rhsPathParts) {
-                            if (current && typeof current === 'object' && part in current) {
-                                current = current[part];
-                            }
-                            else {
-                                exists = false;
-                                break;
-                            }
-                        }
-                        valueToNegate = exists ? current : true;
+                    // Plain key LHS
+                    const lhsLastKey = lhsPath;
+                    const lhsParent = target;
+                    let valueToNegate;
+                    if (rhsPath === '.') {
+                        valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
                     }
                     else {
-                        // Plain key RHS
-                        valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
+                        valueToNegate = resolveValueToNegate(rhsPath, target);
+                    }
+                    if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+                        lhsParent[lhsLastKey] = !valueToNegate;
                     }
-                }
-                // Apply negation to LHS — check restriction first
-                if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
-                    lhsParent[lhsLastKey] = !valueToNegate;
                 }
             }
             continue;
@@ -853,6 +948,11 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 let canDelete = true;
                 if (isNestedPath(path)) {
                     const pathParts = parsePath(path);
+                    // Check for @each in path
+                    if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                        applyCommandToEach(target, pathParts, ' -=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+                        continue;
+                    }
                     if (pathParts.length === 0) {
                         parent = target;
                     }
@@ -898,6 +998,11 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 if (permissionProcessor?.checkRestrictedProp(lastKey)) {
                     continue;
                 }
+                // Check for @each in path
+                if (isNestedPath(path) && pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+                    applyCommandToEach(target, pathParts, ' Y=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+                    continue;
+                }
                 // Navigate to the target sub-object
                 let mergeTarget;
                 if (isNestedPath(path)) {
@@ -953,22 +1058,9 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 const pathToForEach = pathParts.slice(0, forEachIndex);
                 const pathAfterForEach = pathParts.slice(forEachIndex + 1);
                 // Navigate to the iterable
-                let current = target;
-                if (pathToForEach.length > 0) {
-                    if (withMethodsSet) {
-                        const result = evaluatePathWithMethods(target, pathToForEach, value, withMethodsSet, permissionProcessor);
-                        // The result.target is the current position after evaluating the path
-                        // This is already the iterable we want
-                        current = result.target;
-                    }
-                    else {
-                        for (const part of pathToForEach) {
-                            current = current[part];
-                        }
-                    }
-                }
+                const current = getIterableAtPath(target, pathToForEach, value, withMethodsSet, permissionProcessor);
                 // Apply to each item in the iterable
-                if (isIterable(current)) {
+                if (current) {
                     applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissionProcessor);
                 }
                 // If not iterable, let JavaScript throw error naturally when trying to iterate
@@ -991,12 +1083,13 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                         // Last segment is a method — call it
                         const method = result.target[result.lastKey];
                         if (typeof method === 'function') {
-                            // Trailing | marker - call with no arguments, ignoring the value
+                            const appendArgs = capturedPermissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
+                            // Trailing | marker - call with appended args only, ignoring the value
                             const returnVal = result.isZeroArg
-                                ? method.call(result.target)
+                                ? method.call(result.target, ...appendArgs)
                                 : Array.isArray(capturedValue)
-                                    ? method.apply(result.target, capturedValue)
-                                    : method.call(result.target, capturedValue);
+                                    ? method.apply(result.target, [...capturedValue, ...appendArgs])
+                                    : method.call(result.target, capturedValue, ...appendArgs);
                             // If it's an async method, await it (for side effects)
                             if (result.isAsyncMethod)
                                 await returnVal;
@@ -1035,15 +1128,16 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                     // Last segment is a method - call it
                     const method = result.target[result.lastKey];
                     if (typeof method === 'function') {
+                        const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
                         if (result.isZeroArg) {
-                            // Trailing | marker - call with no arguments, ignoring the value
-                            method.call(result.target);
+                            // Trailing | marker - call with appended args only, ignoring the value
+                            method.call(result.target, ...appendArgs);
                         }
                         else if (Array.isArray(value)) {
-                            method.apply(result.target, value);
+                            method.apply(result.target, [...value, ...appendArgs]);
                         }
                         else {
-                            method.call(result.target, value);
+                            method.call(result.target, value, ...appendArgs);
                         }
                     }
                     // Silently skip if not a function
@@ -1117,15 +1211,16 @@ export function assignGingerly(target, source, options, permissionProcessor) {
                 const methodName = isZeroArgKey ? key.slice(0, -1) : key;
                 const method = target[methodName];
                 if (typeof method === 'function') {
+                    const appendArgs = permissionProcessor?.getMethodAppendArgs(methodName) ?? [];
                     if (isZeroArgKey) {
-                        // Trailing | marker - call with no arguments, ignoring the value
-                        method.call(target);
+                        // Trailing | marker - call with appended args only, ignoring the value
+                        method.call(target, ...appendArgs);
                     }
                     else if (Array.isArray(value)) {
-                        method.apply(target, value);
+                        method.apply(target, [...value, ...appendArgs]);
                     }
                     else {
-                        method.call(target, value);
+                        method.call(target, value, ...appendArgs);
                     }
                 }
                 // Silently skip if not a function