mount-observer 0.1.34 → 0.1.36

package/Synthesizer.js

@@ -215,16 +215,25 @@ export class Synthesizer extends HTMLElement {
             // Check if export property exists
             let exportValue = scriptElement.export;
             if (!exportValue) {
-                // Wait for resolved event with timeout
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for resolved event')), 5000));
-                const eventPromise = waitForEvent(scriptElement, 'resolved');
+                // Determine which event to wait for based on script type
+                const scriptType = scriptElement.getAttribute('type');
+                const eventName = scriptType === 'emc-parser' ? 'parser-registered' : 'resolved';
+                // Wait for appropriate event with timeout
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout waiting for ${eventName} event`)), 5000));
+                const eventPromise = waitForEvent(scriptElement, eventName);
                 const event = await Promise.race([eventPromise, timeoutPromise]);
-                exportValue = event.export;
+                // For parser scripts, we don't need an export value
+                // For other scripts, get the export from the event
+                if (scriptType !== 'emc-parser') {
+                    exportValue = event.export;
+                }
             }
             // Clone the script element
             const clonedScript = scriptElement.cloneNode(true);
-            // Copy the export property
-            clonedScript.export = exportValue;
+            // Copy the export property if it exists
+            if (exportValue !== undefined) {
+                clonedScript.export = exportValue;
+            }
             // Append to this element's children
             this.appendChild(clonedScript);
         }

package/Synthesizer.ts

@@ -243,22 +243,33 @@ export abstract class Synthesizer extends HTMLElement {
             let exportValue = (scriptElement as any).export;
             
             if (!exportValue) {
-                // Wait for resolved event with timeout
+                // Determine which event to wait for based on script type
+                const scriptType = scriptElement.getAttribute('type');
+                const eventName = scriptType === 'emc-parser' ? 'parser-registered' : 'resolved';
+                
+                // Wait for appropriate event with timeout
                 const timeoutPromise = new Promise((_, reject) => 
-                    setTimeout(() => reject(new Error('Timeout waiting for resolved event')), 5000)
+                    setTimeout(() => reject(new Error(`Timeout waiting for ${eventName} event`)), 5000)
                 );
                 
-                const eventPromise = waitForEvent(scriptElement, 'resolved');
+                const eventPromise = waitForEvent(scriptElement, eventName);
                 
                 const event = await Promise.race([eventPromise, timeoutPromise]);
-                exportValue = (event as any).export;
+                
+                // For parser scripts, we don't need an export value
+                // For other scripts, get the export from the event
+                if (scriptType !== 'emc-parser') {
+                    exportValue = (event as any).export;
+                }
             }
             
             // Clone the script element
             const clonedScript = scriptElement.cloneNode(true) as HTMLScriptElement;
             
-            // Copy the export property
-            (clonedScript as any).export = exportValue;
+            // Copy the export property if it exists
+            if (exportValue !== undefined) {
+                (clonedScript as any).export = exportValue;
+            }
             
             // Append to this element's children
             this.appendChild(clonedScript);

package/handlers/EMCScript.js

@@ -152,8 +152,8 @@ export class EMCScriptHandler extends EvtRt {
         if (!enh) {
             throw new Error('Element does not have enh property. Make sure ElementMountExtension is loaded.');
         }
-        // Pass synthesizerElement through SpawnContext if available
-        const spawnContext = synthesizerElement ? { synthesizerElement } : undefined;
+        // Pass synthesizerElement and full EMC config through SpawnContext
+        const spawnContext = { synthesizerElement, emc: emcConfig };
         await enh.get(enhancementConfig, spawnContext);
     }
     /**

package/handlers/EMCScript.ts

@@ -180,8 +180,8 @@ export class EMCScriptHandler extends EvtRt {
             throw new Error('Element does not have enh property. Make sure ElementMountExtension is loaded.');
         }
         
-        // Pass synthesizerElement through SpawnContext if available
-        const spawnContext = synthesizerElement ? { synthesizerElement } : undefined;
+        // Pass synthesizerElement and full EMC config through SpawnContext
+        const spawnContext = { synthesizerElement, emc: emcConfig };
         await enh.get(enhancementConfig, spawnContext);
     }
     

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mount-observer",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Observe and act on css matches.",
   "main": "MountObserver.js",
   "module": "MountObserver.js",
   "dependencies": {
-    "assign-gingerly": "0.0.30",
+    "assign-gingerly": "0.0.38",
     "id-generation": "0.0.4"
   },
   "devDependencies": {

package/types/agrace/types.d.ts

@@ -0,0 +1,11 @@
+import {RAConfig} from '../roundabout/types';
+import {AttrPatterns} from '../assign-gingerly/types';
+
+/**
+ * Assign Gingerly Roundabout Config
+ */
+export interface AgraceConfig<TProps = unknown, TActions = TProps, ETProps = TProps, TCustomData = unknown> {
+    raConfig: RAConfig<TProps, TActions, ETProps, TCustomData>,
+    withAttrs?: AttrPatterns<TProps>,
+    template?: string | HTMLTemplateElement,
+}

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

@@ -212,6 +212,13 @@ export interface SpawnContext<T = any, TMountContext = any> {
    * Used for scoped parser registry access during attribute parsing.
    */
   synthesizerElement?: Element;
+  /**
+   * The full EMC configuration object that triggered this spawn.
+   * Passed through so enhancement classes can access their full configuration
+   * (including customData) without needing to separately import the JSON file.
+   * This avoids duplicate JSON imports when using emoji shorthand aliases.
+   */
+  emc?: any;
 }
 
 /**
@@ -226,6 +233,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 +257,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;
@@ -303,10 +317,7 @@ export declare class ElementEnhancementGateway{
 }
 
 export interface ElementEnhancement{
-  dispose(regItem: EnhancementConfig): void;
-}
-
-export interface ElementInfer{
-  value: any;
-  eventType: string
+  get(registryItem: EnhancementConfig | string | symbol, mountCtx?: any): any;
+  dispose(registryItem: EnhancementConfig | string | symbol): void;
+  whenResolved(registryItem: EnhancementConfig | string | symbol, mountCtx?: any): Promise<any>;
 }

package/types/be-bound/types.d.ts

@@ -19,7 +19,8 @@ export interface BindingRule {
     
     localProp?: string,
     localEvent?: string,
-    remoteSpecifierString?: string,
+    remoteId?: string,
+    remoteProp?: string,
     remoteSpecifier?: Specifier,
 
 

package/types/do-invoke/types.d.ts

@@ -1,4 +1,4 @@
-import { ElementEnhancementGateway } from "../assign-gingerly/types";
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
 import { StatementsResult } from "../nested-regex-groups/types";
 
 export interface Specifier {
@@ -23,7 +23,7 @@ export type ProPAP  = Promise<PAP>
 
 export interface Actions{
     hydrate(self: AP): ProPAP;
-    init(self: AP, enhancedElement: Element, initVals: PAP): Promise<void>
+    init(self: AP, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>
 }
 
 

package/types/do-toggle/types.d.ts

@@ -1,4 +1,4 @@
-import { ElementEnhancementGateway, ElementInfer } from "../assign-gingerly/types";
+import { ElementEnhancementGateway } from "../assign-gingerly/types";
 import { StatementsResult } from "../nested-regex-groups/types";
 
 export interface EndUserProps{}

package/types/inferencer/types.d.ts

@@ -0,0 +1,46 @@
+import type { EnhancementConfig } from "../assign-gingerly/types";
+
+/**
+ * Symbol for smart value assignment
+ */
+export declare const value: symbol;
+
+/**
+ * Symbol for smart display assignment
+ */
+export declare const display: symbol;
+
+/**
+ * Enhancement class that provides smart value and display property inference
+ */
+export declare class Infer<TValue = any, TDisplay = any> {
+    get enhancedElement(): Element;
+    constructor(enhancedElement?: Element);
+    get value(): TValue | undefined;
+    set value(nv: TValue);
+    get display(): TDisplay | undefined;
+    set display(nv: TDisplay);
+    get eventType(): string;
+}
+
+/**
+ * Registry item for the Infer enhancement
+ */
+export declare const registryItem: EnhancementConfig;
+
+/**
+ * Infer the most appropriate value property for an element
+ */
+export declare function inferValueProperty(element: Element): string;
+
+/**
+ * Infer the most appropriate display property for an element
+ */
+export declare function inferDisplayProperty(element: Element): string;
+
+/**
+ * Infer the most appropriate event type for an element
+ */
+export declare function inferEventType(element: Element): string;
+
+export default registryItem;

package/types/mount-observer/types.d.ts

@@ -1,6 +1,6 @@
 // Core types for MountObserver v2 - Polyfill Supported Scenario I
 
-import {Spawner, EnhancementConfigBase, EnhKey, AttrPatterns} from '../assign-gingerly/types';
+import {EnhancementConfigBase, EnhKey, AttrPatterns} from '../assign-gingerly/types';
 
 export type Constructor = new (...args: any[]) => any;
 

package/types/roundabout/types.d.ts

@@ -24,11 +24,17 @@ export interface LogicOp<Props = any, TActions = Props>{
 
     delay?: number,
 
+}
+
+/**
+ * Extends LogicOp with a `do` property for specifying which function to call.
+ * Used by positractions where the function is generic and view-model-neutral.
+ */
+export interface LogicOpWithDo<Props = any, TActions = Props> extends LogicOp<Props, TActions>{
     do?:
         | Function
         | (keyof TActions & string)
         | PropsToProps<Props>
-
 }
 
 export type Actions<TProps = any, TActions = TProps> = 
@@ -46,6 +52,8 @@ export type Compacts<TProps = any, TActions = TProps> =
     | Partial<{[key in `when_${keyof TProps & string}_changes_toggle_${keyof TProps & string}`]: number}>
     | Partial<{[key in `when_${keyof TProps & string}_changes_inc_${keyof TProps & string}_by`]: number}>
     | Partial<{[key in `when_${keyof TProps & string}_changes_dispatch`]: string}> //TODO
+    | Partial<{[key in `on_${string}_of_${keyof TProps & string}_inc_${keyof TProps & string}_by`]: number}>
+    | Partial<{[key in `on_${string}_of_${keyof TProps & string}_set_${keyof TProps & string}_to`]: any}>
 ;
 
 export type Hitches<TProps = any, TActions = TProps> = 
@@ -58,7 +66,7 @@ export type Handlers<ETProps = any, TActions = ETProps> =
     export type Positractions<TProps = any, TActions = TProps> = 
     | Array<Positraction<TProps, TActions>>;
 
-export interface Positraction<TProps = any, TActions = TProps> extends LogicOp<TProps, TActions> {
+export interface Positraction<TProps = any, TActions = TProps> extends LogicOpWithDo<TProps, TActions> {
     do: 
         | Function 
         | (keyof TActions & string)
@@ -71,13 +79,30 @@ export interface Positraction<TProps = any, TActions = TProps> extends LogicOp<T
     assignTo?: Array<null | (keyof TProps & string)>
 }
 
+/**
+ * A merge is a fully JSON-serializable reactive rule.
+ * When its conditions are met, it calls assignFrom(vm, assignFrom, { from: vm })
+ * to resolve RHS path strings against the vm and assign the results into the vm.
+ * No method or code is required.
+ */
+export interface Merge<TProps = any> extends LogicOp<TProps> {
+    /**
+     * Pattern object whose keys are LHS assignGingerly paths and whose
+     * values are RHS `?.`-prefixed path strings resolved against the vm.
+     */
+    assign: Record<string, any>;
+}
+
+export type Merges<TProps = any> = Array<Merge<TProps>>;
+
 export interface RAConfig<TProps = unknown, TActions = TProps, ETProps = TProps, TCustomData = unknown> {
     actions?: Actions<TProps,TActions>,
     compacts?: Compacts<TProps, TActions>,
     //onsets?: Onsets<TProps, TActions>,
     handlers?: Handlers<ETProps, TActions>,
-    hitch?: Hitches<TProps, TActions>,
+    hitches?: Hitches<TProps, TActions>,
     positractions?: Positractions<TProps>,
+    merges?: Merges<TProps>,
     /**
      * Configure automatic WeakRef wrapping for properties
      * 
@@ -128,6 +153,12 @@ export interface RoundaboutOptions<TProps = unknown, TActions = TProps, ETProps
      * - Diamond dependencies (A→B, A→C, B→D, C→D)
      */
     internalRouting?: boolean,
+
+    /**
+     * Options passed to every internal assignGingerly call.
+     * See IAssignGingerlyOptions in assign-gingerly for details.
+     */
+    assignGingerlyOptions?: import('../assign-gingerly/types.js').IAssignGingerlyOptions,
     
 
 }