assign-gingerly 0.0.65 → 0.0.67

package/types/assign-gingerly/types.d.ts

@@ -745,11 +745,11 @@ export interface LazyLoadResolvedParams {
      *  Used for SSR placeholder content (e.g., "Loading..." text) that disappears once real content loads. */
     placeholder?: string;
     /** Assignment config applied to cloned content before insertion.
-     *  Same shape as manageTemplateList's fromEachItem: { assignToFragment, withOptions } or { configs: [...] } */
+     *  Same shape as manageTemplateList's fromEachItem: { toClone, withOptions } or { configs: [...] } */
     assign?: {
-        assignToFragment?: Record<string, any>;
+        toClone?: Record<string, any>;
         withOptions?: Record<string, any>;
-        configs?: Array<{ assignToFragment?: Record<string, any>; withOptions?: Record<string, any> }>;
+        configs?: Array<{ toClone?: Record<string, any>; withOptions?: Record<string, any> }>;
     };
 }
 
@@ -795,7 +795,7 @@ export interface LazyLoadSwitchResolvedParams extends Omit<LazyLoadResolvedParam
 }
 
 export interface FromEachItemConfig {
-    assignToFragment?: Record<string, any>;
+    toClone?: Record<string, any>;
     withOptions?: AssignFromOptions;
     resolve?: {
       key?: string;
@@ -854,28 +854,44 @@ export declare class LazyLoadHandler implements AssignFromHandler {
 
 //#region Event Handler
 
-export interface AssignVector {
-    assignToTarget?: Record<string, any>,
-    assignToSource?: Record<string, any>,
-    assignToLHS?: Record<string, any>,
+export interface AssignDispatchVector {
+    toTarget?: Record<string, any>,
+    toHost?: Record<string, any>,
+    toLHS?: Record<string, any>,
     withOptions?: AssignFromOptions,
-    withAssignToTargetOptions?: AssignFromOptions,
-    withAssignToSourceOptions?: AssignFromOptions,
-    withAssignToLHSOptions?: AssignFromOptions,
-}
-
-
-export interface AddEventListenerConfig extends AssignVector  {
-   get?: {
-     abortController?: string | AbortController,
-     on?: string,
-     nudge?: boolean,
-     options?: AddEventListenerOptions,
+    toTargetOptions?: AssignFromOptions,
+    toHostOptions?: AssignFromOptions,
+    toLHSOptions?: AssignFromOptions,
+    dispatch?: DispatchEventConfig
+}
+
+export interface DispatchEventConfig{
+    type?: string,
+    eventCtr?: string | typeof Event | typeof CustomEvent,
+    detail?: any,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    composed?: boolean
+}
+
+
+export interface AddEventListenerConfig extends AssignDispatchVector  {
+  on: string, 
+  get?: {
+      abortController?: string | AbortController,
+      
+      nudge?: boolean,
+      options?: AddEventListenerOptions,
+      //make this part of dispatch?
+      stopPropagation?: boolean,
+      preventDefault?: boolean
+      dispatch?: DispatchEventConfig
    },
    
-   fromLHS?: AssignVector,
-   fromSource?: AssignVector,
-   fromEvent?: AssignVector,
+   fromLHS?: AssignDispatchVector,
+   fromHost?: AssignDispatchVector,
+   fromEvent?: AssignDispatchVector,
+   fromTarget?: AssignDispatchVector,
    
    
 }

package/builtInEmoji.js

@@ -1,26 +0,0 @@
-/**
- * builtInEmoji.js — Predefined emoji aliases for built-in handlers.
- * 
- * Import and spread into the `handlers` option for concise handler configs:
- * 
- * @example
- * import { builtInEmoji } from 'assign-gingerly/builtInEmoji.js';
- * 
- * assignFrom(target, {
- *     '?.el =>': { do: '🔗', get: { value: ['?.first', ' ', '?.last'] } }
- * }, { from: vm, handlers: builtInEmoji });
- */
-
-/**
- * Emoji → built-in handler name mapping.
- */
-export const builtInEmoji = {
-    '📦': 'builtIns.lazyLoad',
-    '🎚️': 'builtIns.lazyLoadSwitch',
-    '🔗': 'builtIns.join',
-    '🏷️': 'builtIns.microDataJoin',
-    '📋': 'builtIns.manageTemplateList',
-    '📊': 'builtIns.rangeSelector',
-};
-
-export default builtInEmoji;

package/paths.js

@@ -1,231 +0,0 @@
-/**
- * paths.js — Typed path proxy and template tags for assignFrom authoring.
- *
- * Provides compile-time autocomplete and type safety for `?.`-prefixed path strings.
- * Supports method call syntax, alias reversal, and batch proxy extraction.
- */
-
-/**
- * Symbol used internally to detect path proxy objects.
- */
-const PATH_SYMBOL = Symbol('assign-gingerly-path');
-
-/**
- * Create a proxy for id-ref paths (#[varName]).
- */
-function createIdRefProxy(idRef, options) {
-    function handler() {}
-    return new Proxy(handler, {
-        get(_, prop) {
-            if (prop === 'path' || prop === PATH_SYMBOL) {
-                return idRef;
-            }
-            if (typeof prop === 'symbol') return undefined;
-            const chained = `${idRef}?.${String(prop)}`;
-            return createIdRefProxy(chained, options);
-        },
-        apply(_, __, args) {
-            if (args.length > 0) {
-                const arg = args[0];
-                let argStr;
-                if (arg === true) argStr = 'true';
-                else if (arg === false) argStr = 'false';
-                else if (arg && typeof arg === 'object' && PATH_SYMBOL in arg) {
-                    const fullPath = arg[PATH_SYMBOL];
-                    argStr = fullPath.startsWith('?.') ? fullPath.substring(2) : fullPath;
-                }
-                else argStr = String(arg);
-                const chained = `${idRef}?.${argStr}`;
-                return createIdRefProxy(chained, options);
-            }
-            return createIdRefProxy(idRef, options);
-        }
-    });
-}
-
-/**
- * Create a recursive proxy that records property access paths.
- */
-function createPathProxy(prefix, options) {
-    const aliasMap = options?.aka;
-
-    function handler() {}
-
-    return new Proxy(handler, {
-        get(_, prop) {
-            if (prop === 'path' || prop === PATH_SYMBOL) {
-                return prefix.length > 0 ? `?.${prefix}` : '?.';
-            }
-            if (typeof prop === 'symbol') return undefined;
-
-            let segment = String(prop);
-
-            // #-prefix: $['#firstName'] → '#[firstName]' (cached element ref)
-            if (segment.startsWith('#')) {
-                const varName = segment.substring(1);
-                const idRef = `#[${varName}]`;
-                return createIdRefProxy(idRef, options);
-            }
-
-            if (aliasMap) {
-                for (const [alias, target] of Object.entries(aliasMap)) {
-                    if (target === segment) { segment = alias; break; }
-                }
-            }
-
-            const newPath = prefix ? `${prefix}?.${segment}` : segment;
-            return createPathProxy(newPath, options);
-        },
-        apply(_, __, args) {
-            if (args.length > 0) {
-                const arg = args[0];
-                let argStr;
-                if (arg === true) argStr = 'true';
-                else if (arg === false) argStr = 'false';
-                else if (arg && typeof arg === 'object' && PATH_SYMBOL in arg) {
-                    const fullPath = arg[PATH_SYMBOL];
-                    argStr = fullPath.startsWith('?.') ? fullPath.substring(2) : fullPath;
-                }
-                else argStr = String(arg);
-
-                const newPath = prefix ? `${prefix}?.${argStr}` : argStr;
-                return createPathProxy(newPath, options);
-            }
-            return createPathProxy(prefix, options);
-        }
-    });
-}
-
-/**
- * Create a typed path proxy.
- */
-export function paths(options) {
-    return createPathProxy('', options);
-}
-
-/**
- * Create an assignment pair: { [lhs.path]: rhs.path }.
- */
-export function set(lhs) {
-    const lhsStr = lhs && typeof lhs === 'object' && PATH_SYMBOL in lhs
-        ? lhs[PATH_SYMBOL]
-        : String(lhs);
-    return {
-        to(rhs) {
-            const rhsStr = rhs && typeof rhs === 'object' && PATH_SYMBOL in rhs
-                ? rhs[PATH_SYMBOL]
-                : rhs;
-            return { [lhsStr]: rhsStr };
-        }
-    };
-}
-
-/**
- * Recursively walk a value and convert any path proxy objects to path strings.
- */
-export function smoothOver(value) {
-    if (value && typeof value === 'object' && PATH_SYMBOL in value) {
-        return value[PATH_SYMBOL];
-    }
-    if (Array.isArray(value)) {
-        return value.map(smoothOver);
-    }
-    if (value && typeof value === 'object') {
-        const proto = Object.getPrototypeOf(value);
-        if (proto === Object.prototype || proto === null) {
-            const result = {};
-            for (const [k, v] of Object.entries(value)) {
-                result[k] = smoothOver(v);
-            }
-            return result;
-        }
-    }
-    return value;
-}
-
-/**
- * Merge multiple set(...).to(...) pairs into an { assign: {...} } object.
- * Spread the result into a merge config.
- */
-export function doAssign(...pairs) {
-    return { assign: Object.assign({}, ...pairs) };
-}
-
-/**
- * Compile-time loop expansion: generates one entry per key from a factory function.
- */
-export function forEachKeyIn(keys, factory, options) {
-    const $ = paths(options);
-    return keys.map(key => factory(key, $));
-}
-
-/**
- * Tagged template literal that splits a template into an array of parts.
- * Path proxy objects are auto-detected and converted to path strings.
- */
-export function sp(strings, ...values) {
-    const result = [];
-    for (let i = 0; i < strings.length; i++) {
-        if (strings[i]) result.push(strings[i]);
-        if (i < values.length) {
-            const v = values[i];
-            if (v && typeof v === 'object' && PATH_SYMBOL in v) {
-                result.push(v[PATH_SYMBOL]);
-            }
-            else if (Array.isArray(v)) {
-                result.push(v.map(el =>
-                    el && typeof el === 'object' && PATH_SYMBOL in el ? el[PATH_SYMBOL] : el
-                ));
-            }
-            else {
-                result.push(v);
-            }
-        }
-    }
-    return result;
-}
-
-/**
- * Extract the last segment from a `?.`-prefixed path string.
- */
-function extractPropName(pathStr) {
-    const parts = pathStr.split('?.');
-    return parts[parts.length - 1];
-}
-
-/**
- * Tagged template literal that produces {prop, val} objects for microDataJoin.
- */
-export function md(strings, ...values) {
-    const result = [];
-    for (let i = 0; i < strings.length; i++) {
-        if (strings[i]) result.push(strings[i]);
-        if (i < values.length) {
-            const v = values[i];
-            if (v && typeof v === 'object' && PATH_SYMBOL in v) {
-                const pathStr = v[PATH_SYMBOL];
-                result.push({ prop: extractPropName(pathStr), val: pathStr });
-            }
-            else if (Array.isArray(v)) {
-                result.push(v.map(el => {
-                    if (el && typeof el === 'object' && PATH_SYMBOL in el) {
-                        const pathStr = el[PATH_SYMBOL];
-                        return { prop: extractPropName(pathStr), val: pathStr };
-                    }
-                    return el;
-                }));
-            }
-            else if (v && typeof v === 'object' && 'prop' in v) {
-                const processed = { ...v };
-                if (processed.val && typeof processed.val === 'object' && PATH_SYMBOL in processed.val) {
-                    processed.val = processed.val[PATH_SYMBOL];
-                }
-                result.push(processed);
-            }
-            else {
-                result.push(v);
-            }
-        }
-    }
-    return result;
-}