@push.rocks/smartstate 2.0.31 → 2.1.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartstate',
-    version: '2.0.31',
-    description: 'A package for handling and managing state in applications.'
+    version: '2.1.0',
+    description: 'A TypeScript-first reactive state management library with middleware, computed state, batching, persistence, and Web Component Context Protocol support.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLDREQUE0RDtDQUMxRSxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDBKQUEwSjtDQUN4SyxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1,3 +1,5 @@
 export * from './smartstate.classes.smartstate.js';
 export * from './smartstate.classes.statepart.js';
 export * from './smartstate.classes.stateaction.js';
+export * from './smartstate.classes.computed.js';
+export * from './smartstate.contextprovider.js';

package/dist_ts/index.js

@@ -1,4 +1,6 @@
 export * from './smartstate.classes.smartstate.js';
 export * from './smartstate.classes.statepart.js';
 export * from './smartstate.classes.stateaction.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxxQ0FBcUMsQ0FBQyJ9
+export * from './smartstate.classes.computed.js';
+export * from './smartstate.contextprovider.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsaUNBQWlDLENBQUMifQ==

package/dist_ts/smartstate.classes.computed.d.ts

@@ -0,0 +1,7 @@
+import * as plugins from './smartstate.plugins.js';
+import type { StatePart } from './smartstate.classes.statepart.js';
+/**
+ * creates a computed observable derived from multiple state parts.
+ * the observable is lazy — it only subscribes to sources when subscribed to.
+ */
+export declare function computed<TResult>(sources: StatePart<any, any>[], computeFn: (...states: any[]) => TResult): plugins.smartrx.rxjs.Observable<TResult>;

package/dist_ts/smartstate.classes.computed.js

@@ -0,0 +1,10 @@
+import * as plugins from './smartstate.plugins.js';
+import { combineLatest, map } from 'rxjs';
+/**
+ * creates a computed observable derived from multiple state parts.
+ * the observable is lazy — it only subscribes to sources when subscribed to.
+ */
+export function computed(sources, computeFn) {
+    return combineLatest(sources.map((sp) => sp.select())).pipe(map((states) => computeFn(...states)));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdGF0ZS5jbGFzc2VzLmNvbXB1dGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzdGF0ZS5jbGFzc2VzLmNvbXB1dGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFDbkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxHQUFHLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFHMUM7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FDdEIsT0FBOEIsRUFDOUIsU0FBd0M7SUFFeEMsT0FBTyxhQUFhLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQ3pELEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsU0FBUyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FDTSxDQUFDO0FBQ2hELENBQUMifQ==

package/dist_ts/smartstate.classes.smartstate.d.ts

@@ -1,3 +1,4 @@
+import * as plugins from './smartstate.plugins.js';
 import { StatePart } from './smartstate.classes.statepart.js';
 export type TInitMode = 'soft' | 'mandatory' | 'force' | 'persistent';
 /**
@@ -8,23 +9,31 @@ export declare class Smartstate<StatePartNameType extends string> {
         [key in StatePartNameType]?: StatePart<StatePartNameType, any>;
     };
     private pendingStatePartCreation;
+    private batchDepth;
+    private pendingNotifications;
     constructor();
+    /**
+     * whether state changes are currently being batched
+     */
+    get isBatching(): boolean;
+    /**
+     * registers a state part for deferred notification during a batch
+     */
+    registerPendingNotification(statePart: StatePart<any, any>): void;
+    /**
+     * batches multiple state updates so subscribers are only notified once all updates complete
+     */
+    batch(updateFn: () => Promise<void> | void): Promise<void>;
+    /**
+     * creates a computed observable derived from multiple state parts
+     */
+    computed<TResult>(sources: StatePart<StatePartNameType, any>[], computeFn: (...states: any[]) => TResult): plugins.smartrx.rxjs.Observable<TResult>;
     /**
      * Allows getting and initializing a new statepart
-     * initMode === 'soft' (default) - returns existing statepart if exists, creates new if not
-     * initMode === 'mandatory' - requires statepart to not exist, fails if it does
-     * initMode === 'force' - always creates new statepart, overwriting any existing
-     * initMode === 'persistent' - like 'soft' but with webstore persistence
-     * @param statePartNameArg
-     * @param initialArg
-     * @param initMode
      */
     getStatePart<PayloadType>(statePartNameArg: StatePartNameType, initialArg?: PayloadType, initMode?: TInitMode): Promise<StatePart<StatePartNameType, PayloadType>>;
     /**
      * Creates a statepart
-     * @param statePartName
-     * @param initialPayloadArg
-     * @param initMode
      */
     private createStatePart;
 }

package/dist_ts/smartstate.classes.smartstate.js

@@ -1,5 +1,6 @@
 import * as plugins from './smartstate.plugins.js';
 import { StatePart } from './smartstate.classes.statepart.js';
+import { computed } from './smartstate.classes.computed.js';
 /**
  * Smartstate takes care of providing state
  */
@@ -7,16 +8,49 @@ export class Smartstate {
     constructor() {
         this.statePartMap = {};
         this.pendingStatePartCreation = new Map();
+        // Batch support
+        this.batchDepth = 0;
+        this.pendingNotifications = new Set();
+    }
+    /**
+     * whether state changes are currently being batched
+     */
+    get isBatching() {
+        return this.batchDepth > 0;
+    }
+    /**
+     * registers a state part for deferred notification during a batch
+     */
+    registerPendingNotification(statePart) {
+        this.pendingNotifications.add(statePart);
+    }
+    /**
+     * batches multiple state updates so subscribers are only notified once all updates complete
+     */
+    async batch(updateFn) {
+        this.batchDepth++;
+        try {
+            await updateFn();
+        }
+        finally {
+            this.batchDepth--;
+            if (this.batchDepth === 0) {
+                const pending = [...this.pendingNotifications];
+                this.pendingNotifications.clear();
+                for (const sp of pending) {
+                    await sp.notifyChange();
+                }
+            }
+        }
+    }
+    /**
+     * creates a computed observable derived from multiple state parts
+     */
+    computed(sources, computeFn) {
+        return computed(sources, computeFn);
     }
     /**
      * Allows getting and initializing a new statepart
-     * initMode === 'soft' (default) - returns existing statepart if exists, creates new if not
-     * initMode === 'mandatory' - requires statepart to not exist, fails if it does
-     * initMode === 'force' - always creates new statepart, overwriting any existing
-     * initMode === 'persistent' - like 'soft' but with webstore persistence
-     * @param statePartNameArg
-     * @param initialArg
-     * @param initMode
      */
     async getStatePart(statePartNameArg, initialArg, initMode = 'soft') {
         // Return pending creation if one exists to prevent duplicate state parts
@@ -30,17 +64,14 @@ export class Smartstate {
                 case 'mandatory':
                     throw new Error(`State part '${statePartNameArg}' already exists, but initMode is 'mandatory'`);
                 case 'force':
-                    // Force mode: create new state part
-                    break; // Fall through to creation
+                    break;
                 case 'soft':
                 case 'persistent':
                 default:
-                    // Return existing state part
                     return existingStatePart;
             }
         }
         else {
-            // State part doesn't exist
             if (!initialArg) {
                 throw new Error(`State part '${statePartNameArg}' does not exist and no initial state provided`);
             }
@@ -57,9 +88,6 @@ export class Smartstate {
     }
     /**
      * Creates a statepart
-     * @param statePartName
-     * @param initialPayloadArg
-     * @param initMode
      */
     async createStatePart(statePartName, initialPayloadArg, initMode = 'soft') {
         const newState = new StatePart(statePartName, initMode === 'persistent'
@@ -68,21 +96,20 @@ export class Smartstate {
                 storeName: statePartName,
             }
             : null);
+        newState.smartstateRef = this;
         await newState.init();
         const currentState = newState.getState();
         if (initMode === 'persistent' && currentState !== undefined) {
-            // Persisted state exists - merge with defaults, persisted values take precedence
             await newState.setState({
                 ...initialPayloadArg,
                 ...currentState,
             });
         }
         else {
-            // No persisted state or non-persistent mode
             await newState.setState(initialPayloadArg);
         }
         this.statePartMap[statePartName] = newState;
         return newState;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartstate.classes.statepart.d.ts

@@ -1,13 +1,20 @@
 import * as plugins from './smartstate.plugins.js';
 import { StateAction, type IActionDef } from './smartstate.classes.stateaction.js';
+import type { Smartstate } from './smartstate.classes.smartstate.js';
+export type TMiddleware<TPayload> = (newState: TPayload, oldState: TPayload | undefined) => TPayload | Promise<TPayload>;
 export declare class StatePart<TStatePartName, TStatePayload> {
     name: TStatePartName;
     state: plugins.smartrx.rxjs.Subject<TStatePayload>;
     stateStore: TStatePayload | undefined;
+    smartstateRef?: Smartstate<any>;
     private cumulativeDeferred;
     private pendingCumulativeNotification;
+    private pendingBatchNotification;
     private webStoreOptions;
     private webStore;
+    private middlewares;
+    private selectorCache;
+    private defaultSelectObservable;
     constructor(nameArg: TStatePartName, webStoreOptionsArg?: plugins.webstore.IWebStoreOptions);
     /**
      * initializes the webstore
@@ -17,14 +24,18 @@ export declare class StatePart<TStatePartName, TStatePayload> {
      * gets the state from the state store
      */
     getState(): TStatePayload | undefined;
+    /**
+     * adds a middleware that intercepts setState calls.
+     * middleware can transform the state or throw to reject it.
+     * returns a removal function.
+     */
+    addMiddleware(middleware: TMiddleware<TStatePayload>): () => void;
     /**
      * sets the stateStore to the new state
-     * @param newStateArg
      */
     setState(newStateArg: TStatePayload): Promise<TStatePayload>;
     /**
      * Validates state structure - can be overridden for custom validation
-     * @param stateArg
      */
     protected validateState(stateArg: any): stateArg is TStatePayload;
     /**
@@ -33,13 +44,17 @@ export declare class StatePart<TStatePartName, TStatePayload> {
     notifyChange(): Promise<void>;
     private lastStateNotificationPayloadHash;
     /**
-     * creates a cumulative notification by adding a change notification at the end of the call stack;
+     * creates a cumulative notification by adding a change notification at the end of the call stack
      */
     notifyChangeCumulative(): void;
     /**
-     * selects a state or a substate
+     * selects a state or a substate.
+     * supports an optional AbortSignal for automatic unsubscription.
+     * memoizes observables by selector function reference.
      */
-    select<T = TStatePayload>(selectorFn?: (state: TStatePayload) => T): plugins.smartrx.rxjs.Observable<T>;
+    select<T = TStatePayload>(selectorFn?: (state: TStatePayload) => T, options?: {
+        signal?: AbortSignal;
+    }): plugins.smartrx.rxjs.Observable<T>;
     /**
      * creates an action capable of modifying the state
      */
@@ -49,11 +64,13 @@ export declare class StatePart<TStatePartName, TStatePayload> {
      */
     dispatchAction<T>(stateAction: StateAction<TStatePayload, T>, actionPayload: T): Promise<TStatePayload>;
     /**
-     * waits until a certain part of the state becomes available
-     * @param selectorFn
-     * @param timeoutMs - optional timeout in milliseconds to prevent indefinite waiting
+     * waits until a certain part of the state becomes available.
+     * supports optional timeout and AbortSignal.
      */
-    waitUntilPresent<T = TStatePayload>(selectorFn?: (state: TStatePayload) => T, timeoutMs?: number): Promise<T>;
+    waitUntilPresent<T = TStatePayload>(selectorFn?: (state: TStatePayload) => T, optionsOrTimeout?: number | {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     /**
      * is executed
      */

package/dist_ts/smartstate.classes.statepart.js

@@ -1,13 +1,36 @@
 import * as plugins from './smartstate.plugins.js';
+import { Observable, shareReplay, takeUntil } from 'rxjs';
 import { StateAction } from './smartstate.classes.stateaction.js';
+/**
+ * creates an Observable that emits once when the given AbortSignal fires
+ */
+function fromAbortSignal(signal) {
+    return new Observable((subscriber) => {
+        if (signal.aborted) {
+            subscriber.next();
+            subscriber.complete();
+            return;
+        }
+        const handler = () => {
+            subscriber.next();
+            subscriber.complete();
+        };
+        signal.addEventListener('abort', handler);
+        return () => signal.removeEventListener('abort', handler);
+    });
+}
 export class StatePart {
     constructor(nameArg, webStoreOptionsArg) {
         this.state = new plugins.smartrx.rxjs.Subject();
         this.cumulativeDeferred = plugins.smartpromise.cumulativeDefer();
         this.pendingCumulativeNotification = null;
-        this.webStore = null; // Add WebStore instance
+        this.pendingBatchNotification = false;
+        this.webStore = null;
+        this.middlewares = [];
+        // Selector memoization
+        this.selectorCache = new WeakMap();
+        this.defaultSelectObservable = null;
         this.name = nameArg;
-        // Initialize WebStore if webStoreOptions are provided
         if (webStoreOptionsArg) {
             this.webStoreOptions = webStoreOptionsArg;
         }
@@ -32,31 +55,46 @@ export class StatePart {
     getState() {
         return this.stateStore;
     }
+    /**
+     * adds a middleware that intercepts setState calls.
+     * middleware can transform the state or throw to reject it.
+     * returns a removal function.
+     */
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        return () => {
+            const idx = this.middlewares.indexOf(middleware);
+            if (idx !== -1) {
+                this.middlewares.splice(idx, 1);
+            }
+        };
+    }
     /**
      * sets the stateStore to the new state
-     * @param newStateArg
      */
     async setState(newStateArg) {
+        // Run middleware chain
+        let processedState = newStateArg;
+        for (const mw of this.middlewares) {
+            processedState = await mw(processedState, this.stateStore);
+        }
         // Validate state structure
-        if (!this.validateState(newStateArg)) {
+        if (!this.validateState(processedState)) {
             throw new Error(`Invalid state structure for state part '${this.name}'`);
         }
-        // Save to WebStore first to ensure atomicity - if save fails, memory state remains unchanged
+        // Save to WebStore first to ensure atomicity
         if (this.webStore) {
-            await this.webStore.set(String(this.name), newStateArg);
+            await this.webStore.set(String(this.name), processedState);
         }
         // Update in-memory state after successful persistence
-        this.stateStore = newStateArg;
+        this.stateStore = processedState;
         await this.notifyChange();
         return this.stateStore;
     }
     /**
      * Validates state structure - can be overridden for custom validation
-     * @param stateArg
      */
     validateState(stateArg) {
-        // Basic validation - ensure state is not null/undefined
-        // Subclasses can override for more specific validation
         return stateArg !== null && stateArg !== undefined;
     }
     /**
@@ -66,6 +104,12 @@ export class StatePart {
         if (!this.stateStore) {
             return;
         }
+        // If inside a batch, defer the notification
+        if (this.smartstateRef?.isBatching) {
+            this.pendingBatchNotification = true;
+            this.smartstateRef.registerPendingNotification(this);
+            return;
+        }
         const createStateHash = async (stateArg) => {
             return await plugins.smarthashWeb.sha256FromString(plugins.smartjson.stableOneWayStringify(stateArg));
         };
@@ -80,10 +124,9 @@ export class StatePart {
         this.state.next(this.stateStore);
     }
     /**
-     * creates a cumulative notification by adding a change notification at the end of the call stack;
+     * creates a cumulative notification by adding a change notification at the end of the call stack
      */
     notifyChangeCumulative() {
-        // Debounce: clear any pending notification
         if (this.pendingCumulativeNotification) {
             clearTimeout(this.pendingCumulativeNotification);
         }
@@ -95,22 +138,46 @@ export class StatePart {
         }, 0);
     }
     /**
-     * selects a state or a substate
+     * selects a state or a substate.
+     * supports an optional AbortSignal for automatic unsubscription.
+     * memoizes observables by selector function reference.
      */
-    select(selectorFn) {
-        if (!selectorFn) {
-            selectorFn = (state) => state;
+    select(selectorFn, options) {
+        const hasSignal = options?.signal != null;
+        // Check memoization cache (only for non-signal selects)
+        if (!hasSignal) {
+            if (!selectorFn) {
+                if (this.defaultSelectObservable) {
+                    return this.defaultSelectObservable;
+                }
+            }
+            else if (this.selectorCache.has(selectorFn)) {
+                return this.selectorCache.get(selectorFn);
+            }
         }
-        const mapped = this.state.pipe(plugins.smartrx.rxjs.ops.startWith(this.getState()), plugins.smartrx.rxjs.ops.filter((stateArg) => stateArg !== undefined), plugins.smartrx.rxjs.ops.map((stateArg) => {
+        const effectiveSelectorFn = selectorFn || ((state) => state);
+        let mapped = this.state.pipe(plugins.smartrx.rxjs.ops.startWith(this.getState()), plugins.smartrx.rxjs.ops.filter((stateArg) => stateArg !== undefined), plugins.smartrx.rxjs.ops.map((stateArg) => {
             try {
-                return selectorFn(stateArg);
+                return effectiveSelectorFn(stateArg);
             }
             catch (e) {
                 console.error(`Selector error in state part '${this.name}':`, e);
                 return undefined;
             }
         }));
-        return mapped;
+        if (hasSignal) {
+            mapped = mapped.pipe(takeUntil(fromAbortSignal(options.signal)));
+            return mapped;
+        }
+        // Apply shareReplay for caching and store in memo cache
+        const shared = mapped.pipe(shareReplay({ bufferSize: 1, refCount: true }));
+        if (!selectorFn) {
+            this.defaultSelectObservable = shared;
+        }
+        else {
+            this.selectorCache.set(selectorFn, shared);
+        }
+        return shared;
     }
     /**
      * creates an action capable of modifying the state
@@ -128,14 +195,27 @@ export class StatePart {
         return this.getState();
     }
     /**
-     * waits until a certain part of the state becomes available
-     * @param selectorFn
-     * @param timeoutMs - optional timeout in milliseconds to prevent indefinite waiting
+     * waits until a certain part of the state becomes available.
+     * supports optional timeout and AbortSignal.
      */
-    async waitUntilPresent(selectorFn, timeoutMs) {
+    async waitUntilPresent(selectorFn, optionsOrTimeout) {
+        // Parse backward-compatible args
+        let timeoutMs;
+        let signal;
+        if (typeof optionsOrTimeout === 'number') {
+            timeoutMs = optionsOrTimeout;
+        }
+        else if (optionsOrTimeout) {
+            timeoutMs = optionsOrTimeout.timeoutMs;
+            signal = optionsOrTimeout.signal;
+        }
         const done = plugins.smartpromise.defer();
         const selectedObservable = this.select(selectorFn);
         let resolved = false;
+        // Check if already aborted
+        if (signal?.aborted) {
+            throw new Error('Aborted');
+        }
         const subscription = selectedObservable.subscribe((value) => {
             if (value && !resolved) {
                 resolved = true;
@@ -152,6 +232,19 @@ export class StatePart {
                 }
             }, timeoutMs);
         }
+        // Handle abort signal
+        const abortHandler = signal ? () => {
+            if (!resolved) {
+                resolved = true;
+                subscription.unsubscribe();
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                done.reject(new Error('Aborted'));
+            }
+        } : undefined;
+        if (signal && abortHandler) {
+            signal.addEventListener('abort', abortHandler);
+        }
         try {
             const result = await done.promise;
             return result;
@@ -160,6 +253,9 @@ export class StatePart {
             subscription.unsubscribe();
             if (timeoutId)
                 clearTimeout(timeoutId);
+            if (signal && abortHandler) {
+                signal.removeEventListener('abort', abortHandler);
+            }
         }
     }
     /**
@@ -171,4 +267,4 @@ export class StatePart {
         await this.setState(await resultPromise);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartstate.classes.statepart.js","sourceRoot":"","sources":["../ts/smartstate.classes.statepart.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartstate.contextprovider.d.ts

@@ -0,0 +1,16 @@
+import type { StatePart } from './smartstate.classes.statepart.js';
+export interface IContextProviderOptions<TPayload> {
+    /** the context key (compared by strict equality) */
+    context: unknown;
+    /** the state part to provide */
+    statePart: StatePart<any, TPayload>;
+    /** optional selector to provide a derived value instead of the full state */
+    selectorFn?: (state: TPayload) => any;
+}
+/**
+ * attaches a Context Protocol provider to an HTML element.
+ * listens for `context-request` events and responds with the state part's value.
+ * if subscribe=true, retains the callback and invokes it on every state change.
+ * returns a cleanup function that removes the listener and unsubscribes.
+ */
+export declare function attachContextProvider<TPayload>(element: HTMLElement, options: IContextProviderOptions<TPayload>): () => void;

package/dist_ts/smartstate.contextprovider.js

@@ -0,0 +1,44 @@
+/**
+ * attaches a Context Protocol provider to an HTML element.
+ * listens for `context-request` events and responds with the state part's value.
+ * if subscribe=true, retains the callback and invokes it on every state change.
+ * returns a cleanup function that removes the listener and unsubscribes.
+ */
+export function attachContextProvider(element, options) {
+    const { context, statePart, selectorFn } = options;
+    const subscribers = new Set();
+    const subscription = statePart.select(selectorFn).subscribe((value) => {
+        for (const cb of subscribers) {
+            cb(value);
+        }
+    });
+    const getValue = () => {
+        const state = statePart.getState();
+        if (state === undefined)
+            return undefined;
+        return selectorFn ? selectorFn(state) : state;
+    };
+    const handler = (event) => {
+        const e = event;
+        const detail = e.detail;
+        if (!detail || detail.context !== context)
+            return;
+        e.stopPropagation();
+        if (detail.subscribe) {
+            const cb = detail.callback;
+            subscribers.add(cb);
+            const unsubscribe = () => subscribers.delete(cb);
+            cb(getValue(), unsubscribe);
+        }
+        else {
+            detail.callback(getValue());
+        }
+    };
+    element.addEventListener('context-request', handler);
+    return () => {
+        element.removeEventListener('context-request', handler);
+        subscription.unsubscribe();
+        subscribers.clear();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdGF0ZS5jb250ZXh0cHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHN0YXRlLmNvbnRleHRwcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxxQkFBcUIsQ0FDbkMsT0FBb0IsRUFDcEIsT0FBMEM7SUFFMUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLEdBQUcsT0FBTyxDQUFDO0lBQ25ELE1BQU0sV0FBVyxHQUFHLElBQUksR0FBRyxFQUFrRCxDQUFDO0lBRTlFLE1BQU0sWUFBWSxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUU7UUFDcEUsS0FBSyxNQUFNLEVBQUUsSUFBSSxXQUFXLEVBQUUsQ0FBQztZQUM3QixFQUFFLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDWixDQUFDO0lBQ0gsQ0FBQyxDQUFDLENBQUM7SUFFSCxNQUFNLFFBQVEsR0FBRyxHQUFRLEVBQUU7UUFDekIsTUFBTSxLQUFLLEdBQUcsU0FBUyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ25DLElBQUksS0FBSyxLQUFLLFNBQVM7WUFBRSxPQUFPLFNBQVMsQ0FBQztRQUMxQyxPQUFPLFVBQVUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUM7SUFDaEQsQ0FBQyxDQUFDO0lBRUYsTUFBTSxPQUFPLEdBQUcsQ0FBQyxLQUFZLEVBQUUsRUFBRTtRQUMvQixNQUFNLENBQUMsR0FBRyxLQUFvQixDQUFDO1FBQy9CLE1BQU0sTUFBTSxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUM7UUFDeEIsSUFBSSxDQUFDLE1BQU0sSUFBSSxNQUFNLENBQUMsT0FBTyxLQUFLLE9BQU87WUFBRSxPQUFPO1FBRWxELENBQUMsQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUVwQixJQUFJLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUNyQixNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsUUFBUSxDQUFDO1lBQzNCLFdBQVcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDcEIsTUFBTSxXQUFXLEdBQUcsR0FBRyxFQUFFLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUNqRCxFQUFFLENBQUMsUUFBUSxFQUFFLEVBQUUsV0FBVyxDQUFDLENBQUM7UUFDOUIsQ0FBQzthQUFNLENBQUM7WUFDTixNQUFNLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDOUIsQ0FBQztJQUNILENBQUMsQ0FBQztJQUVGLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxpQkFBaUIsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUVyRCxPQUFPLEdBQUcsRUFBRTtRQUNWLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxpQkFBaUIsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUN4RCxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDM0IsV0FBVyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3RCLENBQUMsQ0FBQztBQUNKLENBQUMifQ==