assign-gingerly 0.0.71 → 0.0.73

package/assignGingerly.js

@@ -1,3 +1,4 @@
+import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 import { normalizeAliasOptions } from './getValues.js';
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions
@@ -197,6 +198,23 @@ function parseIncCommand(key) {
     }
     return key.substring(0, key.length - 3); // Remove ' +=' suffix
 }
+/**
+ * Apply the scalar and array semantics of the += command.
+ */
+function addValue(lhs, rhs) {
+    if (Array.isArray(lhs)) {
+        return Array.isArray(rhs) ? [...lhs, ...rhs] : [...lhs, rhs];
+    }
+    if (typeof lhs === 'number' && typeof rhs === 'string') {
+        const parsed = Number(rhs);
+        return Number.isNaN(parsed) ? lhs + rhs : lhs + parsed;
+    }
+    if (typeof lhs === 'string' && typeof rhs === 'number') {
+        const parsed = Number(lhs);
+        return Number.isNaN(parsed) ? lhs + rhs : (parsed + rhs).toString();
+    }
+    return lhs + rhs;
+}
 /**
  * Helper function to check if a key represents a =! command
  */
@@ -364,12 +382,17 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods) {
     while (i < pathParts.length - 1) {
         const part = pathParts[i];
         const nextPart = pathParts[i + 1];
-        if (withMethods.has(part)) {
-            const method = current[part];
+        // A trailing | marks a zero-argument method call: 'deref|' calls deref()
+        // without consuming the next segment. Only applies to names in withMethods.
+        const isZeroArgMethod = part.endsWith('|') && withMethods.has(part.slice(0, -1));
+        const nextIsMethod = withMethods.has(nextPart)
+            || (nextPart.endsWith('|') && withMethods.has(nextPart.slice(0, -1)));
+        if (withMethods.has(part) || isZeroArgMethod) {
+            const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
+            const method = current[methodName];
             if (typeof method === 'function') {
-                // Check if next part is also a method
-                if (withMethods.has(nextPart)) {
-                    // Both are methods - call first with no args
+                if (isZeroArgMethod || nextIsMethod) {
+                    // Zero-arg call - next part is either a method or explicitly not an argument
                     current = method.call(current);
                 }
                 else {
@@ -380,10 +403,10 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods) {
             }
             else {
                 // Not a function - just access property (create if needed)
-                if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
-                    current[part] = {};
+                if (!(methodName in current) || typeof current[methodName] !== 'object' || current[methodName] === null) {
+                    current[methodName] = {};
                 }
-                current = current[part];
+                current = current[methodName];
             }
         }
         else {
@@ -395,11 +418,16 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods) {
         }
         i++;
     }
-    const lastKey = pathParts[pathParts.length - 1];
+    // Strip a trailing | from the last segment only when it names a listed method;
+    // otherwise it is a literal property name (e.g. an exotic key ending in |).
+    const rawLastKey = pathParts[pathParts.length - 1];
+    const isZeroArg = rawLastKey.endsWith('|') && withMethods.has(rawLastKey.slice(0, -1));
+    const lastKey = isZeroArg ? rawLastKey.slice(0, -1) : rawLastKey;
     return {
         target: current,
         lastKey,
-        isMethod: withMethods.has(lastKey)
+        isMethod: withMethods.has(lastKey),
+        isZeroArg
     };
 }
 /**
@@ -446,7 +474,7 @@ function isReactiveForEachSymbol(segment, aliasMap) {
 /**
  * Apply a path to each item in an iterable
  */
-function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, options) {
+function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, options, permissions, restrictedPropSet) {
     // Convert to array for iteration
     const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
     // Apply the remaining path to each item
@@ -465,13 +493,22 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
             // Navigate to the nested iterable
             let current = item;
             for (const part of pathToForEach) {
-                if (withMethods.has(part)) {
-                    const method = current[part];
+                // A trailing | marks a zero-argument method call (only for names in withMethods)
+                const isZeroArgMethod = part.endsWith('|') && withMethods.has(part.slice(0, -1));
+                if (withMethods.has(part) || isZeroArgMethod) {
+                    const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
+                    const method = current[methodName];
                     if (typeof method === 'function') {
+                        if (isZeroArgMethod) {
+                            current = method.call(current);
+                            continue;
+                        }
                         // For methods in the middle, we need to check the next part
                         const nextIndex = pathToForEach.indexOf(part) + 1;
                         const nextPart = pathToForEach[nextIndex];
-                        if (nextPart && withMethods.has(nextPart)) {
+                        const nextIsMethod = nextPart && (withMethods.has(nextPart)
+                            || (nextPart.endsWith('|') && withMethods.has(nextPart.slice(0, -1))));
+                        if (nextIsMethod) {
                             current = method.call(current);
                         }
                         else if (nextPart) {
@@ -484,7 +521,7 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                         }
                     }
                     else {
-                        current = current[part];
+                        current = current[methodName];
                     }
                 }
                 else {
@@ -493,7 +530,7 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
             }
             // Recursively apply to the nested iterable
             if (isIterable(current)) {
-                applyToEach(current, pathAfterForEach, value, withMethods, aliasMap, options);
+                applyToEach(current, pathAfterForEach, value, withMethods, aliasMap, options, permissions, restrictedPropSet);
             }
         }
         else {
@@ -503,7 +540,11 @@ 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') {
-                    if (Array.isArray(value)) {
+                    if (result.isZeroArg) {
+                        // Trailing | marker - call with no arguments, ignoring the value
+                        method.call(result.target);
+                    }
+                    else if (Array.isArray(value)) {
                         method.apply(result.target, value);
                     }
                     else {
@@ -515,13 +556,16 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                 // Normal assignment
                 const lastKey = result.lastKey;
                 const parent = result.target;
-                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
+                    // skip
+                }
+                else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                     if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
                         const currentValue = parent[lastKey];
                         if (typeof currentValue !== 'object' || currentValue === null) {
                             throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
                         }
-                        assignGingerly(currentValue, value, options);
+                        assignGingerly(currentValue, value, options, permissions);
                     }
                     else {
                         parent[lastKey] = value;
@@ -563,6 +607,8 @@ export function assignGingerly(target, source, options, permissions) {
         return target;
     }
     const { aliasMap, withMethods: withMethodsSet } = normalizeAliasOptions(options);
+    // Normalize restrictedPropSettings once per top-level call
+    const restrictedPropSet = buildRestrictedPropSet(permissions);
     // Convert withAsyncMethods array to Set for O(1) lookup
     const withAsyncMethodsSet = options?.withAsyncMethods
         ? options.withAsyncMethods instanceof Set
@@ -654,6 +700,9 @@ export function assignGingerly(target, source, options, permissions) {
                         lhsValue = lhsParent[lhsKey];
                     }
                     //TODO:  this logic seems to occur twice at least.  Maybe make it a method?
+                    if (checkRestrictedProp(restrictedPropSet, lhsKey)) {
+                        continue;
+                    }
                     // Event handler: Element LHS + object RHS with 'on' property
                     if (lhsValue instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
                         const capturedLhs = lhsValue;
@@ -661,28 +710,22 @@ export function assignGingerly(target, source, options, permissions) {
                         const capturedTarget = target;
                         const capturedOptions = options;
                         import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
-                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
+                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissions);
                         });
                         continue;
                     }
                     if (!(lhsKey in lhsParent)) {
                         lhsParent[lhsKey] = value;
                     }
-                    else if (Array.isArray(lhsValue)) {
-                        lhsParent[lhsKey] = Array.isArray(value)
-                            ? [...lhsValue, ...value]
-                            : [...lhsValue, value];
-                    }
-                    else if (typeof lhsValue === 'number' && typeof value === 'string') {
-                        const parsed = Number(value);
-                        lhsParent[lhsKey] = isNaN(parsed) ? lhsValue + value : lhsValue + parsed;
-                    }
                     else {
-                        lhsParent[lhsKey] += value;
+                        lhsParent[lhsKey] = addValue(lhsValue, value);
                     }
                 }
                 else {
                     // Plain key - direct operation on target
+                    if (checkRestrictedProp(restrictedPropSet, path)) {
+                        continue;
+                    }
                     // Event handler: Element LHS + object RHS with 'on' property
                     if (target[path] instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
                         const capturedLhs = target[path];
@@ -690,24 +733,15 @@ export function assignGingerly(target, source, options, permissions) {
                         const capturedTarget = target;
                         const capturedOptions = options;
                         import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
-                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
+                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissions);
                         });
                         continue;
                     }
                     if (!(path in target)) {
                         target[path] = value;
                     }
-                    else if (Array.isArray(target[path])) {
-                        target[path] = Array.isArray(value)
-                            ? [...target[path], ...value]
-                            : [...target[path], value];
-                    }
-                    else if (typeof target[path] === 'number' && typeof value === 'string') {
-                        const parsed = Number(value);
-                        target[path] = isNaN(parsed) ? target[path] + value : target[path] + parsed;
-                    }
                     else {
-                        target[path] += value;
+                        target[path] = addValue(target[path], value);
                     }
                 }
             }
@@ -763,8 +797,10 @@ export function assignGingerly(target, source, options, permissions) {
                         valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
                     }
                 }
-                // Apply negation to LHS
-                lhsParent[lhsLastKey] = !valueToNegate;
+                // Apply negation to LHS — check restriction first
+                if (!checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+                    lhsParent[lhsLastKey] = !valueToNegate;
+                }
             }
             continue;
         }
@@ -817,6 +853,11 @@ export function assignGingerly(target, source, options, permissions) {
         if (isMergeCommand(key)) {
             const path = parseMergeCommand(key);
             if (path) {
+                const pathParts = isNestedPath(path) ? parsePath(path) : [path];
+                const lastKey = pathParts[pathParts.length - 1];
+                if (checkRestrictedProp(restrictedPropSet, lastKey)) {
+                    continue;
+                }
                 // Navigate to the target sub-object
                 let mergeTarget;
                 if (isNestedPath(path)) {
@@ -860,7 +901,7 @@ export function assignGingerly(target, source, options, permissions) {
                     (async () => {
                         try {
                             const { handleEachTime } = await import('./eachTime.js');
-                            await handleEachTime(target, pathParts, forEachIndex, value, withMethodsSet, aliasMap, options);
+                            await handleEachTime(target, pathParts, forEachIndex, value, withMethodsSet, aliasMap, options, permissions, restrictedPropSet);
                         }
                         catch (error) {
                             console.error('Error in @eachTime:', error);
@@ -888,20 +929,22 @@ export function assignGingerly(target, source, options, permissions) {
                 }
                 // Apply to each item in the iterable
                 if (isIterable(current)) {
-                    applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options);
+                    applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissions, restrictedPropSet);
                 }
                 // If not iterable, let JavaScript throw error naturally when trying to iterate
                 continue;
             }
             // No @each in path - handle normally
             // Check if we need to handle async methods (fire-and-forget)
-            if (withAsyncMethodsSet && pathParts.some(p => withAsyncMethodsSet.has(p))) {
+            if (withAsyncMethodsSet && pathParts.some(p => withAsyncMethodsSet.has(p) || (p.endsWith('|') && withAsyncMethodsSet.has(p.slice(0, -1))))) {
                 // Fire-and-forget: dynamically import the async evaluator and run the chain
                 const capturedTarget = target;
                 const capturedPathParts = pathParts;
                 const capturedValue = value;
                 const capturedWithMethodsSet = withMethodsSet || new Set();
                 const capturedOptions = options;
+                const capturedPermissions = permissions;
+                const capturedRestrictedPropSet = restrictedPropSet;
                 (async () => {
                     const { evaluatePathWithAsyncMethods } = await import('./evaluatePathWithAsyncMethods.js');
                     const result = await evaluatePathWithAsyncMethods(capturedTarget, capturedPathParts, capturedValue, capturedWithMethodsSet, withAsyncMethodsSet);
@@ -909,9 +952,12 @@ export function assignGingerly(target, source, options, permissions) {
                         // Last segment is a method — call it
                         const method = result.target[result.lastKey];
                         if (typeof method === 'function') {
-                            const returnVal = Array.isArray(capturedValue)
-                                ? method.apply(result.target, capturedValue)
-                                : method.call(result.target, capturedValue);
+                            // Trailing | marker - call with no arguments, ignoring the value
+                            const returnVal = result.isZeroArg
+                                ? method.call(result.target)
+                                : Array.isArray(capturedValue)
+                                    ? method.apply(result.target, capturedValue)
+                                    : method.call(result.target, capturedValue);
                             // If it's an async method, await it (for side effects)
                             if (result.isAsyncMethod)
                                 await returnVal;
@@ -921,13 +967,16 @@ export function assignGingerly(target, source, options, permissions) {
                         // Not a method — assign the value
                         const lastKey = result.lastKey;
                         const parent = result.target;
-                        if (typeof capturedValue === 'object' && capturedValue !== null && !Array.isArray(capturedValue)) {
+                        if (redirectRestrictedProp(capturedRestrictedPropSet, parent, lastKey, capturedValue)) {
+                            // skip
+                        }
+                        else if (typeof capturedValue === 'object' && capturedValue !== null && !Array.isArray(capturedValue)) {
                             if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
                                 const currentValue = parent[lastKey];
                                 if (typeof currentValue !== 'object' || currentValue === null) {
                                     throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
                                 }
-                                assignGingerly(currentValue, capturedValue, capturedOptions);
+                                assignGingerly(currentValue, capturedValue, capturedOptions, capturedPermissions);
                             }
                             else {
                                 parent[lastKey] = capturedValue;
@@ -947,7 +996,11 @@ export function assignGingerly(target, source, options, permissions) {
                     // Last segment is a method - call it
                     const method = result.target[result.lastKey];
                     if (typeof method === 'function') {
-                        if (Array.isArray(value)) {
+                        if (result.isZeroArg) {
+                            // Trailing | marker - call with no arguments, ignoring the value
+                            method.call(result.target);
+                        }
+                        else if (Array.isArray(value)) {
                             method.apply(result.target, value);
                         }
                         else {
@@ -960,18 +1013,21 @@ export function assignGingerly(target, source, options, permissions) {
                 // Not a method - proceed with normal assignment using evaluated target
                 const lastKey = result.lastKey;
                 const parent = result.target;
-                // Check for static assignTo protocol
-                if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
+                if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
+                    // skip
+                    // Check for static assignTo protocol
+                }
+                else if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
                     continue;
                 }
-                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                     // Check if property exists and is readonly
                     if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
                         const currentValue = parent[lastKey];
                         if (typeof currentValue !== 'object' || currentValue === null) {
                             throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
                         }
-                        assignGingerly(currentValue, value, options);
+                        assignGingerly(currentValue, value, options, permissions);
                     }
                     else {
                         // Property is writable - replace it
@@ -986,11 +1042,14 @@ export function assignGingerly(target, source, options, permissions) {
                 // No withMethods - use original logic
                 const lastKey = pathParts[pathParts.length - 1];
                 const parent = ensureNestedPath(target, pathParts);
-                // Check for static assignTo protocol
-                if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
+                if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
+                    // skip
+                    // Check for static assignTo protocol
+                }
+                else if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
                     continue;
                 }
-                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                     // Check if property exists and is readonly
                     if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
                         // Property is readonly - check if current value is an object
@@ -999,7 +1058,7 @@ export function assignGingerly(target, source, options, permissions) {
                             throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
                         }
                         // Recursively apply assignGingerly to the readonly object
-                        assignGingerly(currentValue, value, options);
+                        assignGingerly(currentValue, value, options, permissions);
                     }
                     else {
                         // Property is writable - replace it
@@ -1013,11 +1072,17 @@ export function assignGingerly(target, source, options, permissions) {
         }
         else {
             // Non-nested path
-            // Check if this is a method call
-            if (withMethodsSet && withMethodsSet.has(key)) {
-                const method = target[key];
+            // Check if this is a method call (a trailing | marks a zero-argument call)
+            const isZeroArgKey = key.endsWith('|') && withMethodsSet !== undefined && withMethodsSet.has(key.slice(0, -1));
+            if (withMethodsSet && (withMethodsSet.has(key) || isZeroArgKey)) {
+                const methodName = isZeroArgKey ? key.slice(0, -1) : key;
+                const method = target[methodName];
                 if (typeof method === 'function') {
-                    if (Array.isArray(value)) {
+                    if (isZeroArgKey) {
+                        // Trailing | marker - call with no arguments, ignoring the value
+                        method.call(target);
+                    }
+                    else if (Array.isArray(value)) {
                         method.apply(target, value);
                     }
                     else {
@@ -1027,12 +1092,14 @@ export function assignGingerly(target, source, options, permissions) {
                 // Silently skip if not a function
                 continue;
             }
-            // Normal assignment
-            // Check for static assignTo protocol
-            if (key in target && tryAssignTo(target[key], value, target, key)) {
+            if (redirectRestrictedProp(restrictedPropSet, target, key, value)) {
+                // skip
+                // Check for static assignTo protocol
+            }
+            else if (key in target && tryAssignTo(target[key], value, target, key)) {
                 continue;
             }
-            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                 // Check if property exists and is readonly
                 if (key in target && isReadonlyProperty(target, key)) {
                     // Property is readonly - check if current value is an object
@@ -1041,7 +1108,7 @@ export function assignGingerly(target, source, options, permissions) {
                         throw new Error(`Cannot merge object into readonly primitive property '${String(key)}'`);
                     }
                     // Recursively apply assignGingerly to the readonly object
-                    assignGingerly(currentValue, value, options);
+                    assignGingerly(currentValue, value, options, permissions);
                 }
                 else {
                     // Property is writable - replace it