assign-gingerly 0.0.85 → 0.0.87

package/utils/resolveLhsPath.ts

@@ -0,0 +1,81 @@
+/**
+ * resolveLhsPath.ts — Shared LHS path resolution for operator commands.
+ *
+ * Resolves the `?.`-prefixed path in front of an operator suffix (` =>`, ` =&`, ...)
+ * against a target, preserving the parent object and final key so the caller can
+ * assign a computed/returned value back to that path.
+ *
+ * Shared by processHandlerCommands.ts (` =>`) and the sync-op dispatcher in
+ * assignFrom.ts (` =&`) — the two operators that hand a value back to the LHS
+ * rather than assigning it directly.
+ */
+
+import { evaluatePathWithMethods } from '../assignGingerly.js';
+
+export interface ResolvedLhsPath {
+    lhsTarget: any;
+    lhsParent: any;
+    lhsKey: string | undefined;
+}
+
+export interface ResolveLhsPathOptions {
+    withMethods?: Set<string> | string[];
+}
+
+export function resolveLhsPath(
+    target: any,
+    lhsPath: string,
+    options: ResolveLhsPathOptions
+): ResolvedLhsPath {
+    let lhsTarget: any;
+    let lhsParent: any = undefined;
+    let lhsKey: string | undefined = undefined;
+
+    if (lhsPath.startsWith('?.')) {
+        const pathParts = lhsPath.split('?.').filter(p => p.length > 0);
+        const withMethodsSet = options.withMethods
+            ? options.withMethods instanceof Set
+                ? options.withMethods
+                : new Set(options.withMethods)
+            : undefined;
+
+        if (withMethodsSet && pathParts.length > 0) {
+            const result = evaluatePathWithMethods(target, pathParts, undefined, withMethodsSet);
+            lhsParent = result.target;
+            lhsKey = result.lastKey;
+            lhsTarget = result.target[result.lastKey];
+            // If last key is a method, call it to get the target
+            if (result.isMethod && typeof result.target[result.lastKey] === 'function') {
+                lhsTarget = result.target[result.lastKey].call(result.target);
+                lhsParent = undefined; // Can't assign back to a method call result
+                lhsKey = undefined;
+            }
+        } else {
+            // Simple path navigation — walk to parent, keep last key
+            if (pathParts.length === 0) {
+                lhsTarget = target;
+            } else if (pathParts.length === 1) {
+                lhsParent = target;
+                lhsKey = pathParts[0];
+                lhsTarget = target[pathParts[0]];
+            } else {
+                let current = target;
+                for (let i = 0; i < pathParts.length - 1; i++) {
+                    if (current == null) break;
+                    current = current[pathParts[i]];
+                }
+                lhsParent = current;
+                lhsKey = pathParts[pathParts.length - 1];
+                lhsTarget = current != null ? current[lhsKey] : undefined;
+            }
+        }
+    } else if (lhsPath) {
+        lhsParent = target;
+        lhsKey = lhsPath;
+        lhsTarget = target[lhsPath];
+    } else {
+        lhsTarget = target;
+    }
+
+    return { lhsTarget, lhsParent, lhsKey };
+}

package/handlers/join.ts

@@ -1,79 +0,0 @@
-/**
- * builtIns.join handler for assignFrom.
- * 
- * Joins a resolved array into a single string. Supports nested sub-arrays
- * with "all-or-nothing" semantics: if any element in a nested sub-array
- * resolves to null/undefined, the entire sub-array is dropped.
- * 
- * This handler is auto-loaded by processHandlerCommands when `do: 'builtIns.join'`
- * is encountered — no explicit import is needed.
- * 
- * @example
- * assignFrom(oElement, {
- *     '?.textContent =>': {
- *         do: 'builtIns.join',
- *         resolve: {
- *             value: ['?.lastName', ', ', '?.firstName']
- *         }
- *     }
- * }, { from: vm });
- * 
- * @example
- * // With optional segment (all-or-nothing):
- * assignFrom(oElement, {
- *     '?.textContent =>': {
- *         do: 'builtIns.join',
- *         resolve: {
- *             value: ['?.lastName', [', ', '?.middleName'], ', ', '?.firstName']
- *         }
- *     }
- * }, { from: vm });
- * // If middleName is undefined, the sub-array [', ', undefined] is dropped entirely.
- */
-
-import type { AssignFromHandler } from '../assignFromAsync.js';
-
-/**
- * Process nested arrays with all-or-nothing null semantics.
- * - Top-level null/undefined values are filtered out.
- * - If a nested sub-array contains any null/undefined element, the entire sub-array is dropped.
- * - Nested sub-arrays that pass are flattened into the result.
- */
-function processValue(value: any[]): any[] {
-    const result: any[] = [];
-    for (const item of value) {
-        if (Array.isArray(item)) {
-            // All-or-nothing: if any element is null/undefined, drop the entire sub-array
-            if (item.some(el => el == null)) {
-                continue;
-            }
-            // Sub-array passes — flatten its elements (recursively process nested arrays)
-            result.push(...processValue(item));
-        } else if (item != null) {
-            result.push(item);
-        }
-        // Top-level null/undefined are silently filtered out
-    }
-    return result;
-}
-
-/**
- * JoinHandler — built-in handler for composing strings from resolved arrays.
- * 
- * Returns the joined string via the return-value protocol, which causes
- * processHandlerCommands to assign it back to the LHS path.
- */
-export class JoinHandler implements AssignFromHandler {
-    config: any;
-
-    constructor(config: any) {
-        this.config = config;
-    }
-
-    async assign(lhsTarget: any, resolvedParams: Record<string, any>): Promise<string> {
-        const { value, separator = '' } = resolvedParams;
-
-        const items = Array.isArray(value) ? processValue(value) : [value];
-        return items.join(separator);
-    }
-}