assign-gingerly 0.0.30 → 0.0.32

package/resolveValues.ts

@@ -0,0 +1,45 @@
+/**
+ * Resolve RHS path strings in a pattern object against a source object.
+ * 
+ * Any value that is a string starting with `?.` is treated as a path
+ * and resolved against the source object using optional chaining semantics.
+ * Non-string values and strings not starting with `?.` pass through unchanged.
+ * 
+ * @param pattern - Object whose RHS values may contain `?.` path strings
+ * @param source - Object to resolve paths against
+ * @returns New object with path strings replaced by resolved values
+ * 
+ * @example
+ * const pattern = {
+ *   hello: '?.myPropContainer?.stringProp',
+ *   foo: '?.myFooString',
+ *   literal: 42
+ * };
+ * const source = {
+ *   myPropContainer: { stringProp: 'Venus' },
+ *   myFooString: 'bar'
+ * };
+ * const result = resolveValues(pattern, source);
+ * // { hello: 'Venus', foo: 'bar', literal: 42 }
+ */
+export function resolveValues(
+  pattern: Record<string, any>,
+  source: any
+): Record<string, any> {
+  const result: Record<string, any> = {};
+  for (const [key, value] of Object.entries(pattern)) {
+    if (typeof value === 'string' && value.startsWith('?.')) {
+      // Parse path: split by '.', strip '?', filter empties
+      const parts = value.split('.').map(p => p.replace(/\?/g, '')).filter(p => p.length > 0);
+      let current = source;
+      for (const part of parts) {
+        if (current == null) break;
+        current = current[part];
+      }
+      result[key] = current;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}

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

@@ -226,6 +226,14 @@ export interface IAssignGingerlyOptions {
   registry?: typeof EnhancementRegistry | EnhancementRegistry;
   bypassChecks?: boolean;
   withMethods?: string[] | Set<string>;
+  aka?: Record<string, string>;
+  
+  /**
+   * AbortSignal for cleaning up reactive subscriptions (@eachTime)
+   * Required when using @eachTime symbol for reactive iteration
+   * When the signal is aborted, all event listeners are automatically removed
+   */
+  signal?: AbortSignal;
 }
 
 /**
@@ -242,7 +250,6 @@ export declare class EnhancementRegisteredEvent extends Event {
  * Extends EventTarget to dispatch events when configs are registered
  */
 export declare class EnhancementRegistry extends EventTarget {
-  private items;
   push(items: EnhancementConfig | EnhancementConfig[]): void;
   getItems(): EnhancementConfig[];
   findBySymbol(symbol: symbol | string): EnhancementConfig | undefined;
@@ -298,9 +305,12 @@ export declare function assignGingerly(
 export default assignGingerly;
 
 export declare class ElementEnhancementGateway{
+  //TODO:  this isn't right
   enh: ElementEnhancement;
 }
 
 export interface ElementEnhancement{
-  dispose(regItem: EnhancementConfig): void;
+  get(registryItem: EnhancementConfig | string | symbol, mountCtx?: any): any;
+  dispose(registryItem: EnhancementConfig | string | symbol): void;
+  whenResolved(registryItem: EnhancementConfig | string | symbol, mountCtx?: any): Promise<any>;
 }

package/Infer.js

@@ -1,154 +0,0 @@
-/**
- * Symbol for smart value assignment
- * When used with element.set[value], it infers and sets the appropriate value property
- */
-export const value = Symbol.for('assign-gingerly:value');
-/**
- * Symbol for smart display assignment
- * When used with element.set[display], it infers and sets the appropriate display property
- */
-export const display = Symbol.for('assign-gingerly:display');
-/**
- * Enhancement class that provides smart value and display property inference
- * Automatically determines the correct property to set based on element type
- */
-export class Infer {
-    #weakRef;
-    get enhancedElement() {
-        return this.#weakRef.deref();
-    }
-    constructor(enhancedElement) {
-        this.#weakRef = new WeakRef(enhancedElement);
-    }
-    #value;
-    get value() {
-        return this.#value;
-    }
-    set value(nv) {
-        this.#value = nv;
-        const { enhancedElement } = this;
-        enhancedElement[inferValueProperty(enhancedElement)] = nv;
-    }
-    #display;
-    get display() {
-        return this.#display;
-    }
-    set display(nv) {
-        this.#display = nv;
-        const { enhancedElement } = this;
-        enhancedElement[inferDisplayProperty(enhancedElement)] = nv;
-    }
-    /**
-     * Get the inferred event type for the element
-     * @returns The most appropriate event type for this element
-     */
-    get eventType() {
-        return inferEventType(this.enhancedElement);
-    }
-}
-/**
- * Registry item for the Infer enhancement
- * Register this with customElements.enhancementRegistry to enable smart value/display assignment
- */
-export const registryItem = {
-    spawn: Infer,
-    enhKey: 'infer',
-    symlinks: {
-        [value]: 'value',
-        [display]: 'display'
-    }
-};
-/**
- * Infer the most appropriate value property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for value assignment
- */
-export function inferValueProperty(element) {
-    const tagName = element.localName;
-    // Input elements - check type attribute
-    if (tagName === 'input') {
-        const type = element.getAttribute('type')?.toLowerCase();
-        if (type === 'checkbox' || type === 'radio') {
-            return 'checked';
-        }
-        return 'value';
-    }
-    // Form controls with value property
-    if (tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    // Semantic HTML elements with specific properties
-    if (tagName === 'time') {
-        return 'dateTime';
-    }
-    if (tagName === 'data') {
-        return 'value';
-    }
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'value';
-    }
-    if (tagName === 'output') {
-        return 'value';
-    }
-    // Check for itemprop attribute as a hint
-    const itemprop = element.getAttribute('itemprop');
-    if (itemprop) {
-        return itemprop;
-    }
-    // Default fallback
-    return 'textContent';
-}
-/**
- * Infer the most appropriate display property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for display assignment
- */
-export function inferDisplayProperty(element) {
-    const tagName = element.localName;
-    // Form controls display their value
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    // Time elements display formatted time
-    if (tagName === 'time') {
-        return 'textContent';
-    }
-    // Data elements display human-readable content
-    if (tagName === 'data') {
-        return 'textContent';
-    }
-    // Progress/meter elements use ARIA for display
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'ariaValueText';
-    }
-    // Default fallback
-    return 'textContent';
-}
-/**
- * Infer the most appropriate event type for an element
- * Used when no explicit event type is provided
- * @param element - The element to infer the event type for
- * @returns The event type name like 'input', 'change', 'click', 'submit'
- */
-export function inferEventType(element) {
-    const tagName = element.localName;
-    // Form controls that support input event
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'input';
-    }
-    // Form submission
-    if (tagName === 'form') {
-        return 'submit';
-    }
-    // Details element
-    if (tagName === 'details') {
-        return 'toggle';
-    }
-    // Dialog element
-    if (tagName === 'dialog') {
-        return 'close';
-    }
-    // Default fallback for interactive elements
-    return 'click';
-}
-export default registryItem;

package/Infer.ts

@@ -1,190 +0,0 @@
-import type { EnhancementConfig } from "./types/assign-gingerly/types";
-
-/**
- * Symbol for smart value assignment
- * When used with element.set[value], it infers and sets the appropriate value property
- */
-export const value = Symbol.for('assign-gingerly:value');
-
-/**
- * Symbol for smart display assignment
- * When used with element.set[display], it infers and sets the appropriate display property
- */
-export const display = Symbol.for('assign-gingerly:display');
-
-/**
- * Enhancement class that provides smart value and display property inference
- * Automatically determines the correct property to set based on element type
- */
-export class Infer<TValue = any, TDisplay = any> {
-    #weakRef: WeakRef<Element>;
-
-    get enhancedElement(){
-        return this.#weakRef.deref()!;
-    }
-    
-    constructor(enhancedElement?: Element){
-        this.#weakRef = new WeakRef(enhancedElement!);
-    }
-
-    #value: TValue | undefined;
-    
-    get value(): TValue | undefined {
-        return this.#value;
-    }
-    
-    set value(nv: TValue){
-        this.#value = nv;
-        const {enhancedElement} = this;
-        (enhancedElement as any)[inferValueProperty(enhancedElement)] = nv;
-    }
-
-    #display: TDisplay | undefined;
-    
-    get display(): TDisplay | undefined {
-        return this.#display;
-    }
-    
-    set display(nv: TDisplay){
-        this.#display = nv;
-        const {enhancedElement} = this;
-        (enhancedElement as any)[inferDisplayProperty(enhancedElement)] = nv;
-    }
-
-    /**
-     * Get the inferred event type for the element
-     * @returns The most appropriate event type for this element
-     */
-    get eventType(): string {
-        return inferEventType(this.enhancedElement);
-    }
-}
-
-/**
- * Registry item for the Infer enhancement
- * Register this with customElements.enhancementRegistry to enable smart value/display assignment
- */
-export const registryItem: EnhancementConfig = {
-    spawn: Infer,
-    enhKey: 'infer',
-    symlinks: {
-        [value]: 'value',
-        [display]: 'display'
-    }
-}
-
-/**
- * Infer the most appropriate value property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for value assignment
- */
-export function inferValueProperty(element: Element): string {
-    const tagName = element.localName;
-    
-    // Input elements - check type attribute
-    if (tagName === 'input') {
-        const type = element.getAttribute('type')?.toLowerCase();
-        if (type === 'checkbox' || type === 'radio') {
-            return 'checked';
-        }
-        return 'value';
-    }
-    
-    // Form controls with value property
-    if (tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    
-    // Semantic HTML elements with specific properties
-    if (tagName === 'time') {
-        return 'dateTime';
-    }
-    
-    if (tagName === 'data') {
-        return 'value';
-    }
-    
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'value';
-    }
-    
-    if (tagName === 'output') {
-        return 'value';
-    }
-    
-    // Check for itemprop attribute as a hint
-    const itemprop = element.getAttribute('itemprop');
-    if (itemprop) {
-        return itemprop;
-    }
-    
-    // Default fallback
-    return 'textContent';
-}
-
-/**
- * Infer the most appropriate display property for an element
- * @param element - The element to infer the property for
- * @returns The property name to use for display assignment
- */
-export function inferDisplayProperty(element: Element): string {
-    const tagName = element.localName;
-    
-    // Form controls display their value
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'value';
-    }
-    
-    // Time elements display formatted time
-    if (tagName === 'time') {
-        return 'textContent';
-    }
-    
-    // Data elements display human-readable content
-    if (tagName === 'data') {
-        return 'textContent';
-    }
-    
-    // Progress/meter elements use ARIA for display
-    if (tagName === 'meter' || tagName === 'progress') {
-        return 'ariaValueText';
-    }
-    
-    // Default fallback
-    return 'textContent';
-}
-
-/**
- * Infer the most appropriate event type for an element
- * Used when no explicit event type is provided
- * @param element - The element to infer the event type for
- * @returns The event type name like 'input', 'change', 'click', 'submit'
- */
-export function inferEventType(element: Element): string {
-    const tagName = element.localName;
-    
-    // Form controls that support input event
-    if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
-        return 'input';
-    }
-    
-    // Form submission
-    if (tagName === 'form') {
-        return 'submit';
-    }
-    
-    // Details element
-    if (tagName === 'details') {
-        return 'toggle';
-    }
-    
-    // Dialog element
-    if (tagName === 'dialog') {
-        return 'close';
-    }
-    
-    // Default fallback for interactive elements
-    return 'click';
-}
-
-export default registryItem;