assign-gingerly 0.0.71 → 0.0.73

package/DX/emojis.js

@@ -33,7 +33,22 @@ export const akaMethods = {
     '🔍': 'querySelector',
     '🧺': 'querySelectorAll',
     '+': 'add',
+    '-': 'remove',
     '🧬': 'cloneNode',
+    '🔄️': 'reset',
+    '🎯': 'closest',
+    '✅': 'matches',
+    '☑️': 'checkValidity',
+    '📤': 'submit',
+    '🎚️': 'toggle',
+    '📦': 'contains',
+    '🏷️': 'setAttribute',
+    '✂️': 'removeAttribute',
+    '📝': 'log',
+    '⚠️': 'warn',
+    '🚨': 'error',
+    '🤱': 'appendChild'
+    //'🧩': 'includes'
 };
 export const aka = {
     '©️': 'content?.cloneNode?.true',
@@ -46,5 +61,6 @@ export const aka = {
 export const emojis = {
     builtInEmoji,
     akaMethods,
+    aka
 };
 export default emojis;

package/DX/emojis.ts

@@ -35,7 +35,22 @@ export const akaMethods: Record<string, string> = {
     '🔍': 'querySelector',
     '🧺': 'querySelectorAll',
     '+': 'add',
+    '-': 'remove',
     '🧬': 'cloneNode',
+    '🔄️': 'reset',
+    '🎯': 'closest',
+    '✅': 'matches',
+    '☑️': 'checkValidity',
+    '📤': 'submit',
+    '🎚️': 'toggle',
+    '📦': 'contains',
+    '🏷️': 'setAttribute',
+    '✂️': 'removeAttribute',
+    '📝': 'log',
+    '⚠️': 'warn',
+    '🚨': 'error',
+    '🤱': 'appendChild'
+    //'🧩': 'includes'
 };
 
 export const aka: Record<string, string> = {
@@ -51,6 +66,7 @@ export const aka: Record<string, string> = {
 export const emojis = {
     builtInEmoji,
     akaMethods,
+    aka
 }
 
 export default emojis;

package/README.md

@@ -380,6 +380,30 @@ When a path segment matches a name in the `withMethods` array/set:
 - If it's a **middle segment** and the next segment is NOT a method: called with the next segment as a string argument
 - If the property is not a function: silently skipped
 
+**Zero-argument calls (`|` marker):**
+
+Append `|` to a segment to call a listed method with no arguments, without consuming the next segment:
+
+```TypeScript
+assignGingerly(elementRef, {
+  '?.deref|?.classList?.add': 'active'
+}, { withMethods: ['deref', 'add'] });
+
+// Equivalent to: elementRef.deref().classList.add('active')
+```
+
+On the **last segment**, `|` calls the method with no arguments and ignores the RHS value:
+
+```TypeScript
+assignGingerly(form, {
+  '?.reset|': true
+}, { withMethods: ['reset'] });
+
+// Equivalent to: form.reset()
+```
+
+The `|` suffix only applies to names listed in `withMethods` — on any other segment it is treated as part of a literal property name.
+
 **Array arguments:**
 
 Arrays are spread as multiple arguments:
@@ -403,7 +427,7 @@ const elementRef = {
 };
 
 assignGingerly(elementRef, {
-  '?.deref?.classList?.add': 'active'
+  '?.deref|?.classList?.add': 'active'
 }, { withMethods: ['deref', 'add'] });
 
 // Equivalent to: elementRef.deref().classList.add('active')
@@ -564,10 +588,13 @@ div.innerHTML = `
 assignGingerly(div, {
   '?.🔍?.my-element?.🎨?.+': 'highlighted'
 }, {
+  aka: {
+    //not a method!
+    '🎨': 'classList',
+  },
   akaMethods: {
     '🔍': 'querySelector',
-    '🎨': 'classList',
-    '+': 'add'
+    '+': 'add',
   }
 });
 

package/assignFrom.js

@@ -377,7 +377,7 @@ function getEffectiveIds(options) {
 /**
  * Process #[x] normal keys synchronously.
  */
-function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, options) {
+function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, options, permissions) {
     const ids = getEffectiveIds(options);
     if (!ids)
         return;
@@ -392,12 +392,12 @@ function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, option
         const value = expandedPattern[key];
         if (parsed.remainingPath) {
             const resolvedValue = getValues({ __v: value }, from, { withMethods, aka, akaMethods, protocols, root: target });
-            assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
+            assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options, permissions);
         }
         else {
             const resolvedValue = getValues(typeof value === 'object' && value !== null ? value : { __v: value }, from, { withMethods, aka, akaMethods, protocols, root: target });
             if (!('__v' in resolvedValue)) {
-                assignGingerly(el, resolvedValue, options);
+                assignGingerly(el, resolvedValue, options, permissions);
             }
         }
     }
@@ -436,7 +436,7 @@ export function assignFrom(target, pattern, options, permissions) {
             }
         }
         if (Object.keys(ternaryResolved).length > 0) {
-            assignGingerly(target, ternaryResolved, options);
+            assignGingerly(target, ternaryResolved, options, permissions);
         }
     }
     // Process normal keys via getValues (sync) + assignGingerly
@@ -472,11 +472,11 @@ export function assignFrom(target, pattern, options, permissions) {
         }
         const resolved = getValues(normalPattern, options.from, resolveOptions);
         handleSpreads(resolved);
-        assignGingerly(target, resolved, options);
+        assignGingerly(target, resolved, options, permissions);
     }
     // Process #[x] normal keys (sync)
     if (idRefNormalKeys.length > 0) {
-        processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, options);
+        processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, options, permissions);
     }
     // Process handler commands — fire-and-forget (async)
     if (handlerKeys.length > 0) {

package/assignFrom.ts

@@ -13,7 +13,7 @@ import { getValues, getValue } from './getValues.js';
 import assignGingerly from './assignGingerly.js';
 import { resolveIdVariable, parseIdRef } from './resolveIdRef.js';
 import { processInferredAssignments } from './inferredAssignments.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
 import type { AssignFromOptions, AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 
 // Re-export types for consumers
@@ -387,10 +387,11 @@ function getEffectiveIds(options: AssignFromOptions): Record<string, any> | unde
  * Process #[x] normal keys synchronously.
  */
 function processIdRefNormalKeys(
-  idRefNormalKeys: string[],
-  expandedPattern: Record<string, any>,
-  target: any,
-  options: AssignFromOptions
+  idRefNormalKeys: string[],
+  expandedPattern: Record<string, any>,
+  target: any,
+  options: AssignFromOptions,
+  permissions?: AssignPermissions
 ): void {
   const ids = getEffectiveIds(options);
   if (!ids) return;
@@ -409,7 +410,7 @@ function processIdRefNormalKeys(
         { __v: value }, from,
         { withMethods, aka, akaMethods, protocols, root: target }
       );
-      assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
+      assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options, permissions);
     } else {
       const resolvedValue = getValues(
         typeof value === 'object' && value !== null ? value : { __v: value },
@@ -417,7 +418,7 @@ function processIdRefNormalKeys(
         { withMethods, aka, akaMethods, protocols, root: target }
       );
       if (!('__v' in resolvedValue)) {
-        assignGingerly(el, resolvedValue, options);
+        assignGingerly(el, resolvedValue, options, permissions);
       }
     }
   }
@@ -463,7 +464,7 @@ export function assignFrom(
       }
     }
     if (Object.keys(ternaryResolved).length > 0) {
-      assignGingerly(target, ternaryResolved, options);
+      assignGingerly(target, ternaryResolved, options, permissions);
     }
   }
 
@@ -501,12 +502,12 @@ export function assignFrom(
     const resolved = getValues(normalPattern, options.from, resolveOptions);
 
     handleSpreads(resolved);
-    assignGingerly(target, resolved, options);
+    assignGingerly(target, resolved, options, permissions);
   }
 
   // Process #[x] normal keys (sync)
   if (idRefNormalKeys.length > 0) {
-    processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, options);
+    processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, options, permissions);
   }
 
   // Process handler commands — fire-and-forget (async)

package/assignFromAsync.js

@@ -40,7 +40,7 @@ export async function assignFromAsync(target, pattern, options, permissions) {
         });
         // Recursively handle "..." spread keys at all nesting levels
         handleSpreads(resolved);
-        assignGingerly(target, resolved, options);
+        assignGingerly(target, resolved, options, permissions);
     }
     // Process #[x] normal keys — resolve element, then apply remaining path + value
     if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
@@ -59,7 +59,7 @@ export async function assignFromAsync(target, pattern, options, permissions) {
                 // Resolve the RHS value
                 const resolvedValue = await resolveValues({ __v: value }, from, { withMethods, aka, akaMethods, protocols, root: el });
                 // Apply remaining path on the resolved element
-                assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
+                assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options, permissions);
             }
             else {
                 // No remaining path — resolve and assign directly to the element
@@ -68,7 +68,7 @@ export async function assignFromAsync(target, pattern, options, permissions) {
                     // Single value — can't assign to element root without a path
                 }
                 else {
-                    assignGingerly(el, resolvedValue, options);
+                    assignGingerly(el, resolvedValue, options, permissions);
                 }
             }
         }

package/assignFromAsync.ts

@@ -22,7 +22,7 @@
 import { resolveValues } from './resolveValues.js';
 import {IAssignGingerlyOptions} from './types/assign-gingerly/types.js';
 import assignGingerly from './assignGingerly.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
 import type { AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 import {
   expandSubstitutions, categorizeKeys, handleSpreads, isHandlerCommand
@@ -77,7 +77,7 @@ export async function assignFromAsync(
     // Recursively handle "..." spread keys at all nesting levels
     handleSpreads(resolved);
 
-    assignGingerly(target, resolved, options);
+    assignGingerly(target, resolved, options, permissions);
   }
 
   // Process #[x] normal keys — resolve element, then apply remaining path + value
@@ -100,7 +100,7 @@ export async function assignFromAsync(
           { withMethods, aka, akaMethods, protocols, root: el }
         );
         // Apply remaining path on the resolved element
-        assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
+        assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options, permissions);
       } else {
         // No remaining path — resolve and assign directly to the element
         const resolvedValue = await resolveValues(
@@ -111,7 +111,7 @@ export async function assignFromAsync(
         if ('__v' in resolvedValue) {
           // Single value — can't assign to element root without a path
         } else {
-          assignGingerly(el, resolvedValue, options);
+          assignGingerly(el, resolvedValue, options, permissions);
         }
       }
     }