@push.rocks/smartstate 2.0.31 → 2.1.1

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.mutationQueue = Promise.resolve();
         this.pendingCumulativeNotification = null;
-        this.webStore = null; // Add WebStore instance
+        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;
         }
@@ -33,84 +56,139 @@ export class StatePart {
         return this.stateStore;
     }
     /**
-     * sets the stateStore to the new state
-     * @param newStateArg
+     * 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 (serialized via mutation queue)
      */
     async setState(newStateArg) {
+        return this.mutationQueue = this.mutationQueue.then(() => this.applyState(newStateArg), () => this.applyState(newStateArg));
+    }
+    /**
+     * applies the state change (middleware → validate → persist → notify)
+     */
+    async applyState(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;
     }
     /**
      * notifies of a change on the state
      */
     async notifyChange() {
-        if (!this.stateStore) {
+        const snapshot = this.stateStore;
+        if (snapshot === undefined) {
+            return;
+        }
+        // If inside a batch, defer the notification
+        if (this.smartstateRef?.isBatching) {
+            this.smartstateRef.registerPendingNotification(this);
             return;
         }
         const createStateHash = async (stateArg) => {
             return await plugins.smarthashWeb.sha256FromString(plugins.smartjson.stableOneWayStringify(stateArg));
         };
-        const currentHash = await createStateHash(this.stateStore);
-        if (this.lastStateNotificationPayloadHash &&
-            currentHash === this.lastStateNotificationPayloadHash) {
-            return;
-        }
-        else {
+        try {
+            const currentHash = await createStateHash(snapshot);
+            if (this.lastStateNotificationPayloadHash &&
+                currentHash === this.lastStateNotificationPayloadHash) {
+                return;
+            }
             this.lastStateNotificationPayloadHash = currentHash;
         }
-        this.state.next(this.stateStore);
+        catch (err) {
+            console.error(`State hash computation failed for '${this.name}':`, err);
+        }
+        this.state.next(snapshot);
     }
     /**
-     * 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);
         }
-        this.pendingCumulativeNotification = setTimeout(async () => {
+        this.pendingCumulativeNotification = setTimeout(() => {
             this.pendingCumulativeNotification = null;
-            if (this.stateStore) {
-                await this.notifyChange();
+            if (this.stateStore !== undefined) {
+                this.notifyChange().catch((err) => {
+                    console.error(`notifyChangeCumulative failed for '${this.name}':`, err);
+                });
             }
         }, 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
@@ -123,21 +201,38 @@ export class StatePart {
      */
     async dispatchAction(stateAction, actionPayload) {
         await this.cumulativeDeferred.promise;
-        const newState = await stateAction.actionDef(this, actionPayload);
-        await this.setState(newState);
-        return this.getState();
+        return this.mutationQueue = this.mutationQueue.then(async () => {
+            const newState = await stateAction.actionDef(this, actionPayload);
+            return this.applyState(newState);
+        }, async () => {
+            const newState = await stateAction.actionDef(this, actionPayload);
+            return this.applyState(newState);
+        });
     }
     /**
-     * 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) {
+            if (value !== undefined && value !== null && !resolved) {
                 resolved = true;
                 done.resolve(value);
             }
@@ -152,6 +247,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 +268,9 @@ export class StatePart {
             subscription.unsubscribe();
             if (timeoutId)
                 clearTimeout(timeoutId);
+            if (signal && abortHandler) {
+                signal.removeEventListener('abort', abortHandler);
+            }
         }
     }
     /**
@@ -170,5 +281,20 @@ export class StatePart {
         this.cumulativeDeferred.addPromise(resultPromise);
         await this.setState(await resultPromise);
     }
+    /**
+     * disposes the state part, completing the Subject and cleaning up resources
+     */
+    dispose() {
+        this.state.complete();
+        if (this.pendingCumulativeNotification) {
+            clearTimeout(this.pendingCumulativeNotification);
+            this.pendingCumulativeNotification = null;
+        }
+        this.middlewares.length = 0;
+        this.selectorCache = new WeakMap();
+        this.defaultSelectObservable = null;
+        this.webStore = null;
+        this.smartstateRef = undefined;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdGF0ZS5jbGFzc2VzLnN0YXRlcGFydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c3RhdGUuY2xhc3Nlcy5zdGF0ZXBhcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsV0FBVyxFQUFtQixNQUFNLHFDQUFxQyxDQUFDO0FBRW5GLE1BQU0sT0FBTyxTQUFTO0lBV3BCLFlBQVksT0FBdUIsRUFBRSxrQkFBc0Q7UUFUcEYsVUFBSyxHQUFHLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFpQixDQUFDO1FBRXpELHVCQUFrQixHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsZUFBZSxFQUFFLENBQUM7UUFFNUQsa0NBQTZCLEdBQXlDLElBQUksQ0FBQztRQUczRSxhQUFRLEdBQW9ELElBQUksQ0FBQyxDQUFDLHdCQUF3QjtRQUdoRyxJQUFJLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQztRQUVwQixzREFBc0Q7UUFDdEQsSUFBSSxrQkFBa0IsRUFBRSxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxlQUFlLEdBQUcsa0JBQWtCLENBQUM7UUFDNUMsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDekIsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFnQixJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDbkYsTUFBTSxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQzNCLE1BQU0sV0FBVyxHQUFHLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQy9ELElBQUksV0FBVyxJQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztnQkFDbkQsSUFBSSxDQUFDLFVBQVUsR0FBRyxXQUFXLENBQUM7Z0JBQzlCLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQzVCLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0ksUUFBUTtRQUNiLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksS0FBSyxDQUFDLFFBQVEsQ0FBQyxXQUEwQjtRQUM5QywyQkFBMkI7UUFDM0IsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztZQUNyQyxNQUFNLElBQUksS0FBSyxDQUFDLDJDQUEyQyxJQUFJLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQztRQUMzRSxDQUFDO1FBRUQsNkZBQTZGO1FBQzdGLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2xCLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUMxRCxDQUFDO1FBRUQsc0RBQXNEO1FBQ3RELElBQUksQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDO1FBQzlCLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBRTFCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7OztPQUdHO0lBQ08sYUFBYSxDQUFDLFFBQWE7UUFDbkMsd0RBQXdEO1FBQ3hELHVEQUF1RDtRQUN2RCxPQUFPLFFBQVEsS0FBSyxJQUFJLElBQUksUUFBUSxLQUFLLFNBQVMsQ0FBQztJQUNyRCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsWUFBWTtRQUN2QixJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3JCLE9BQU87UUFDVCxDQUFDO1FBQ0QsTUFBTSxlQUFlLEdBQUcsS0FBSyxFQUFFLFFBQWEsRUFBRSxFQUFFO1lBQzlDLE9BQU8sTUFBTSxPQUFPLENBQUMsWUFBWSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMscUJBQXFCLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUN4RyxDQUFDLENBQUM7UUFDRixNQUFNLFdBQVcsR0FBRyxNQUFNLGVBQWUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDM0QsSUFDRSxJQUFJLENBQUMsZ0NBQWdDO1lBQ3JDLFdBQVcsS0FBSyxJQUFJLENBQUMsZ0NBQWdDLEVBQ3JELENBQUM7WUFDRCxPQUFPO1FBQ1QsQ0FBQzthQUFNLENBQUM7WUFDTixJQUFJLENBQUMsZ0NBQWdDLEdBQUcsV0FBVyxDQUFDO1FBQ3RELENBQUM7UUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDbkMsQ0FBQztJQUdEOztPQUVHO0lBQ0ksc0JBQXNCO1FBQzNCLDJDQUEyQztRQUMzQyxJQUFJLElBQUksQ0FBQyw2QkFBNkIsRUFBRSxDQUFDO1lBQ3ZDLFlBQVksQ0FBQyxJQUFJLENBQUMsNkJBQTZCLENBQUMsQ0FBQztRQUNuRCxDQUFDO1FBRUQsSUFBSSxDQUFDLDZCQUE2QixHQUFHLFVBQVUsQ0FBQyxLQUFLLElBQUksRUFBRTtZQUN6RCxJQUFJLENBQUMsNkJBQTZCLEdBQUcsSUFBSSxDQUFDO1lBQzFDLElBQUksSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUNwQixNQUFNLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUM1QixDQUFDO1FBQ0gsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ1IsQ0FBQztJQUVEOztPQUVHO0lBQ0ksTUFBTSxDQUNYLFVBQXdDO1FBRXhDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNoQixVQUFVLEdBQUcsQ0FBQyxLQUFvQixFQUFFLEVBQUUsQ0FBVSxLQUFNLENBQUM7UUFDekQsQ0FBQztRQUNELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUM1QixPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQyxFQUNuRCxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxFQUE2QixFQUFFLENBQUMsUUFBUSxLQUFLLFNBQVMsQ0FBQyxFQUNoRyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUU7WUFDeEMsSUFBSSxDQUFDO2dCQUNILE9BQU8sVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQzlCLENBQUM7WUFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO2dCQUNYLE9BQU8sQ0FBQyxLQUFLLENBQUMsaUNBQWlDLElBQUksQ0FBQyxJQUFJLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQztnQkFDakUsT0FBTyxTQUFTLENBQUM7WUFDbkIsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUNILENBQUM7UUFDRixPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxZQUFZLENBQ2pCLFNBQW9EO1FBRXBELE9BQU8sSUFBSSxXQUFXLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxjQUFjLENBQUksV0FBMEMsRUFBRSxhQUFnQjtRQUN6RixNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUM7UUFDdEMsTUFBTSxRQUFRLEdBQUcsTUFBTSxXQUFXLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxhQUFhLENBQUMsQ0FBQztRQUNsRSxNQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDOUIsT0FBTyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxLQUFLLENBQUMsZ0JBQWdCLENBQzNCLFVBQXdDLEVBQ3hDLFNBQWtCO1FBRWxCLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFLLENBQUM7UUFDN0MsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ25ELElBQUksUUFBUSxHQUFHLEtBQUssQ0FBQztRQUVyQixNQUFNLFlBQVksR0FBRyxrQkFBa0IsQ0FBQyxTQUFTLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtZQUMxRCxJQUFJLEtBQUssSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN2QixRQUFRLEdBQUcsSUFBSSxDQUFDO2dCQUNoQixJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3RCLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUVILElBQUksU0FBb0QsQ0FBQztRQUN6RCxJQUFJLFNBQVMsRUFBRSxDQUFDO1lBQ2QsU0FBUyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQzFCLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztvQkFDZCxRQUFRLEdBQUcsSUFBSSxDQUFDO29CQUNoQixZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7b0JBQzNCLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxLQUFLLENBQUMsb0NBQW9DLFNBQVMsSUFBSSxDQUFDLENBQUMsQ0FBQztnQkFDNUUsQ0FBQztZQUNILENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQztRQUNoQixDQUFDO1FBRUQsSUFBSSxDQUFDO1lBQ0gsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDO1lBQ2xDLE9BQU8sTUFBTSxDQUFDO1FBQ2hCLENBQUM7Z0JBQVMsQ0FBQztZQUNULFlBQVksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUMzQixJQUFJLFNBQVM7Z0JBQUUsWUFBWSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3pDLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsVUFBVSxDQUNyQixPQUFpRjtRQUVqRixNQUFNLGFBQWEsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDcEMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUNsRCxNQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxhQUFhLENBQUMsQ0FBQztJQUMzQyxDQUFDO0NBQ0YifQ==
+//# 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==

package/npmextra.json

@@ -16,7 +16,7 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartstate",
-      "description": "A package for handling and managing state in applications.",
+      "description": "A TypeScript-first reactive state management library with middleware, computed state, batching, persistence, and Web Component Context Protocol support.",
       "npmPackagename": "@push.rocks/smartstate",
       "license": "MIT",
       "keywords": [
@@ -29,7 +29,13 @@
         "state selection",
         "state notification",
         "asynchronous state",
-        "cumulative notification"
+        "cumulative notification",
+        "middleware",
+        "computed state",
+        "batch updates",
+        "context protocol",
+        "web components",
+        "AbortSignal"
       ]
     },
     "release": {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartstate",
-  "version": "2.0.31",
+  "version": "2.1.1",
   "private": false,
-  "description": "A package for handling and managing state in applications.",
+  "description": "A TypeScript-first reactive state management library with middleware, computed state, batching, persistence, and Web Component Context Protocol support.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -22,7 +22,6 @@
     "@types/node": "^25.3.2"
   },
   "dependencies": {
-    "@push.rocks/lik": "^6.2.2",
     "@push.rocks/smarthash": "^3.2.6",
     "@push.rocks/smartjson": "^6.0.0",
     "@push.rocks/smartpromise": "^4.2.3",
@@ -54,7 +53,13 @@
     "state selection",
     "state notification",
     "asynchronous state",
-    "cumulative notification"
+    "cumulative notification",
+    "middleware",
+    "computed state",
+    "batch updates",
+    "context protocol",
+    "web components",
+    "AbortSignal"
   ],
   "homepage": "https://code.foss.global/push.rocks/smartstate",
   "repository": {

package/readme.hints.md

@@ -1,6 +1,6 @@
 # Smartstate Implementation Notes
 
-## Current API (as of v2.0.28+)
+## Current API (as of v2.0.31)
 
 ### State Part Initialization
 - State parts can be created with different init modes: 'soft' (default), 'mandatory', 'force', 'persistent'
@@ -8,53 +8,70 @@
   - 'mandatory' - requires state part to not exist, fails if it does
   - 'force' - always creates new state part, overwriting any existing
   - 'persistent' - like 'soft' but with WebStore persistence (IndexedDB)
-- Persistent mode automatically calls init() internally - no need to call it manually
+- Persistent mode automatically calls init() internally
 - State merge order fixed: initial state takes precedence over stored state
 
 ### Actions
 - Actions are created with `createAction()` method
-- Two ways to dispatch actions:
-  1. `stateAction.trigger(payload)` - returns Promise<TStatePayload>
-  2. `await statePart.dispatchAction(stateAction, payload)` - returns Promise<TStatePayload>
-- Both methods return the same Promise, providing flexibility in usage
+- Two ways to dispatch: `stateAction.trigger(payload)` or `statePart.dispatchAction(stateAction, payload)`
+- Both return Promise<TStatePayload>
 
 ### State Management Methods
-- `select()` - returns Observable with startWith current state, filters undefined states
-- `waitUntilPresent()` - waits for specific state condition
+- `select(fn?, { signal? })` - returns Observable, memoized by selector fn ref, supports AbortSignal
+- `waitUntilPresent(fn?, number | { timeoutMs?, signal? })` - waits for state condition, backward compat with number arg
 - `stateSetup()` - async state initialization with cumulative defer
 - `notifyChangeCumulative()` - defers notification to end of call stack
 - `getState()` - returns current state or undefined
-- `setState()` - validates state before setting, notifies only on actual changes
+- `setState()` - runs middleware, validates, persists, notifies
+- `addMiddleware(fn)` - intercepts setState, returns removal function
+
+### Middleware
+- Type: `(newState, oldState) => newState | Promise<newState>`
+- Runs sequentially in insertion order before validation/persistence
+- Throw to reject state changes (atomic — state unchanged on error)
+- Does NOT run during initial createStatePart() hydration
+
+### Selector Memoization
+- Uses WeakMap<Function, Observable> for fn-keyed cache
+- `defaultSelectObservable` for no-arg select()
+- Wrapped in `shareReplay({ bufferSize: 1, refCount: true })`
+- NOT cached when AbortSignal is provided
+
+### Batch Updates
+- `smartstate.batch(async () => {...})` — defers notifications until batch completes
+- Supports nesting — only flushes at outermost level
+- StatePart has `smartstateRef` set by `createStatePart()` for batch awareness
+- State parts created via `new StatePart()` directly work without batching
+
+### Computed State
+- `computed(sources, fn)` — standalone function using `combineLatest` + `map`
+- Also available as `smartstate.computed(sources, fn)`
+- Lazy — only subscribes when subscribed to
+
+### Context Protocol Bridge
+- `attachContextProvider(element, { context, statePart, selectorFn? })` — returns cleanup fn
+- Listens for `context-request` CustomEvent on element
+- Supports one-shot and subscription modes
+- Works with Lit @consume(), FAST, or any Context Protocol consumer
 
 ### State Hash Detection
 - Uses SHA256 hash to detect actual state changes
-- Fixed: Hash comparison now properly awaits async hash calculation
+- Hash comparison properly awaits async hash calculation
 - Prevents duplicate notifications for identical state values
-- `notifyChange()` is now async to support proper hash comparison
 
 ### State Validation
 - Basic validation ensures state is not null/undefined
-- `validateState()` method can be overridden in subclasses for custom validation
-- Validation runs on both setState() and when loading from persistent storage
-
-### Type System
-- Can use either enums or string literal types for state part names
-- Test uses simple string types: `type TMyStateParts = 'testStatePart'`
-- State can be undefined initially, handled properly in select() and other methods
-
-## Recent Fixes (v2.0.24+)
-1. Fixed state hash bug - now properly compares hash values instead of promises
-2. Fixed state initialization merge order - initial state now takes precedence
-3. Ensured stateStore is properly typed as potentially undefined
-4. Simplified init mode logic with clear behavior for each mode
-5. Added state validation with extensible validateState() method
-6. Made notifyChange() async to support proper hash comparison
-7. Updated select() to filter undefined states
-
-## Dependency Versions (v2.0.30)
+- `validateState()` can be overridden in subclasses
+
+### Key Notes
+- `smartstateRef` creates circular ref between StatePart and Smartstate
+- Use `===` not deep equality for StatePart comparison in tests
+- Direct rxjs imports used for: Observable, shareReplay, takeUntil, combineLatest, map
+
+## Dependency Versions (v2.0.31)
 - @git.zone/tsbuild: ^4.1.2
 - @git.zone/tsbundle: ^2.9.0
 - @git.zone/tsrun: ^2.0.1
 - @git.zone/tstest: ^3.1.8
 - @push.rocks/smartjson: ^6.0.0
-- @types/node: ^25.3.2
+- @types/node: ^25.3.2