@ngstato/core 0.1.2 → 0.3.0

package/dist/index.js

@@ -1,5 +1,29 @@
 'use strict';
 
+// src/action-bus.ts
+var listenersByAction = /* @__PURE__ */ new WeakMap();
+function emitActionEvent(event) {
+  const set = listenersByAction.get(event.action);
+  if (!set?.size) return;
+  for (const listener of set) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+function subscribeToAction(action, listener) {
+  let set = listenersByAction.get(action);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    listenersByAction.set(action, set);
+  }
+  set.add(listener);
+  return () => {
+    set?.delete(listener);
+  };
+}
+
 // src/store.ts
 var StatoStore = class {
   // Le state interne — jamais accessible directement
@@ -10,12 +34,46 @@ var StatoStore = class {
   _actions = {};
   // Les computed enregistrés
   _computed = {};
+  _selectors = {};
   // Les cleanups à appeler à la destruction
   _cleanups = [];
   // Les hooks lifecycle
   _hooks;
+  _publicStore = null;
+  _publicActions = {};
+  _initialized = false;
+  _effects = [];
+  _createMemoizedSelector(fn) {
+    let initialized = false;
+    let cachedResult;
+    let trackedKeys = [];
+    let trackedValues = [];
+    return () => {
+      if (initialized && trackedKeys.length) {
+        const unchanged = trackedKeys.every(
+          (key, index) => Object.is(this._state[key], trackedValues[index])
+        );
+        if (unchanged) return cachedResult;
+      }
+      const reads = /* @__PURE__ */ new Set();
+      const trackingState = new Proxy(this._state, {
+        get: (target, prop, receiver) => {
+          if (typeof prop === "string" && prop in target) {
+            reads.add(prop);
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+      const result = fn(trackingState);
+      trackedKeys = Array.from(reads);
+      trackedValues = trackedKeys.map((key) => this._state[key]);
+      cachedResult = result;
+      initialized = true;
+      return result;
+    };
+  }
   constructor(config) {
-    const { actions, computed, hooks, ...initialState } = config;
+    const { actions, computed, selectors, effects, hooks, ...initialState } = config;
     this._state = initialState;
     this._hooks = hooks ?? {};
     if (actions) {
@@ -30,6 +88,27 @@ var StatoStore = class {
         }
       }
     }
+    if (selectors) {
+      for (const [name, fn] of Object.entries(selectors)) {
+        if (typeof fn === "function") {
+          this._selectors[name] = this._createMemoizedSelector(fn);
+        }
+      }
+    }
+    if (effects) {
+      for (const entry of effects) {
+        const [deps, run] = entry;
+        if (typeof deps === "function" && typeof run === "function") {
+          this._effects.push({
+            deps,
+            run,
+            hasRun: false,
+            running: false,
+            rerunRequested: false
+          });
+        }
+      }
+    }
   }
   // ── Lire le state ──────────────────────────────────
   getState() {
@@ -38,8 +117,56 @@ var StatoStore = class {
   // ── Modifier le state — usage interne uniquement ───
   _setState(partial) {
     this._state = { ...this._state, ...partial };
+    this._runEffects();
     this._notify();
   }
+  _normalizeDeps(value) {
+    return Array.isArray(value) ? value : [value];
+  }
+  _depsChanged(prev, next) {
+    if (!prev) return true;
+    if (prev.length !== next.length) return true;
+    for (let i = 0; i < next.length; i++) {
+      if (!Object.is(prev[i], next[i])) return true;
+    }
+    return false;
+  }
+  _runEffects(force = false) {
+    for (const effect of this._effects) {
+      const depsValue = effect.deps(this._state);
+      const depsArray = this._normalizeDeps(depsValue);
+      const shouldRun = force || this._depsChanged(effect.prevDeps, depsArray);
+      if (!shouldRun) continue;
+      const execute = async () => {
+        if (effect.running) {
+          effect.rerunRequested = true;
+          return;
+        }
+        effect.running = true;
+        effect.rerunRequested = false;
+        const prevDepsValue = effect.prevDeps;
+        effect.prevDeps = depsArray;
+        try {
+          effect.cleanup?.();
+          const maybeCleanup = await effect.run(depsValue, {
+            state: { ...this._state },
+            store: this._publicStore,
+            prevDepsValue
+          });
+          effect.cleanup = typeof maybeCleanup === "function" ? maybeCleanup : void 0;
+          effect.hasRun = true;
+        } catch (error) {
+          this._hooks.onError?.(error, "effect");
+        } finally {
+          effect.running = false;
+          if (effect.rerunRequested) {
+            this._runEffects();
+          }
+        }
+      };
+      void execute();
+    }
+  }
   // ── Notifier tous les abonnés ──────────────────────
   _notify() {
     for (const subscriber of this._subscribers) {
@@ -57,6 +184,7 @@ var StatoStore = class {
     if (!action) {
       throw new Error(`[Stato] Action "${actionName}" introuvable`);
     }
+    const publicAction = this._publicActions[actionName];
     this._hooks.onAction?.(actionName, args);
     const start = Date.now();
     const prevState = { ...this._state };
@@ -69,10 +197,32 @@ var StatoStore = class {
     });
     try {
       await action(stateProxy, ...args);
-      this._hooks.onActionDone?.(actionName, Date.now() - start);
+      const duration = Date.now() - start;
+      this._hooks.onActionDone?.(actionName, duration);
       this._hooks.onStateChange?.(prevState, { ...this._state });
+      if (publicAction) {
+        emitActionEvent({
+          action: publicAction,
+          name: actionName,
+          args,
+          store: this._publicStore,
+          status: "success",
+          duration
+        });
+      }
     } catch (error) {
       this._hooks.onError?.(error, actionName);
+      if (publicAction) {
+        emitActionEvent({
+          action: publicAction,
+          name: actionName,
+          args,
+          store: this._publicStore,
+          status: "error",
+          duration: Date.now() - start,
+          error
+        });
+      }
       throw error;
     }
   }
@@ -82,21 +232,46 @@ var StatoStore = class {
     if (!fn) throw new Error(`[Stato] Computed "${name}" introuvable`);
     return fn();
   }
+  getSelector(name) {
+    const fn = this._selectors[name];
+    if (!fn) throw new Error(`[Stato] Selector "${name}" introuvable`);
+    return fn();
+  }
   // ── Enregistrer un cleanup (pour fromStream) ───────
   registerCleanup(fn) {
     this._cleanups.push(fn);
   }
+  registerPublicAction(name, fn) {
+    this._publicActions[name] = fn;
+  }
+  hydrate(partial) {
+    this._setState(partial);
+  }
+  setPublicStore(publicStore) {
+    this._publicStore = publicStore;
+    this._runEffects(true);
+  }
   // ── Lifecycle — appelé par l'adaptateur Angular ────
   init(publicStore) {
-    this._hooks.onInit?.(publicStore);
+    this._publicStore = publicStore;
+    if (!this._initialized) {
+      this._initialized = true;
+      this._hooks.onInit?.(publicStore);
+    }
+    this._runEffects(true);
   }
   destroy(publicStore) {
     this._hooks.onDestroy?.(publicStore);
+    for (const effect of this._effects) {
+      effect.cleanup?.();
+      effect.cleanup = void 0;
+    }
     for (const cleanup of this._cleanups) {
       cleanup();
     }
     this._cleanups = [];
     this._subscribers.clear();
+    this._initialized = false;
   }
 };
 function createStore(config) {
@@ -119,10 +294,12 @@ function createStore(config) {
       configurable: true
     });
   }
-  const { actions, computed } = config;
+  const { actions, computed, selectors } = config;
   if (actions) {
     for (const name of Object.keys(actions)) {
-      publicStore[name] = (...args) => store.dispatch(name, ...args);
+      const fn = (...args) => store.dispatch(name, ...args);
+      publicStore[name] = fn;
+      store.registerPublicAction(name, fn);
     }
   }
   if (computed) {
@@ -134,8 +311,32 @@ function createStore(config) {
       });
     }
   }
+  if (selectors) {
+    for (const name of Object.keys(selectors)) {
+      Object.defineProperty(publicStore, name, {
+        get: () => store.getSelector(name),
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  store.init(publicStore);
   return publicStore;
 }
+function on(sourceAction, handler) {
+  return subscribeToAction(sourceAction, (event) => {
+    try {
+      void handler(event.store, {
+        name: event.name,
+        args: event.args,
+        status: event.status,
+        duration: event.duration,
+        error: event.error
+      });
+    } catch {
+    }
+  });
+}
 
 // src/types.ts
 var StatoHttpError = class extends Error {
@@ -366,6 +567,1020 @@ function optimistic(immediate, confirm) {
   };
 }
 
+// src/helpers/exclusive.ts
+function exclusive(fn) {
+  let running = false;
+  let current = null;
+  return (state, ...args) => {
+    if (running && current) return current;
+    running = true;
+    current = (async () => {
+      try {
+        await fn(state, ...args);
+      } finally {
+        running = false;
+        current = null;
+      }
+    })();
+    return current;
+  };
+}
+
+// src/helpers/queued.ts
+function queued(fn) {
+  const queue = [];
+  let processing = false;
+  const processNext = () => {
+    if (processing) return;
+    processing = true;
+    const run = async () => {
+      while (queue.length) {
+        const item = queue.shift();
+        if (!item) break;
+        try {
+          await fn(item.state, ...item.args);
+          item.resolve();
+        } catch (err) {
+          item.reject(err);
+          while (queue.length) {
+            const rest = queue.shift();
+            rest?.reject(err);
+          }
+          return;
+        }
+      }
+    };
+    void run().finally(() => {
+      processing = false;
+    });
+  };
+  return (state, ...args) => {
+    return new Promise((resolve, reject) => {
+      queue.push({ state, args, resolve, reject });
+      processNext();
+    });
+  };
+}
+
+// src/helpers/distinct-until-changed.ts
+function distinctUntilChanged(fn, keySelector, comparator = Object.is) {
+  let initialized = false;
+  let prevKey;
+  return async (state, ...args) => {
+    const nextKey = keySelector(...args);
+    if (initialized && comparator(prevKey, nextKey)) {
+      return;
+    }
+    initialized = true;
+    prevKey = nextKey;
+    await fn(state, ...args);
+  };
+}
+
+// src/helpers/fork-join.ts
+async function forkJoin(tasks, options) {
+  const controller = new AbortController();
+  const signal = options?.signal;
+  if (signal) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+  const entries = Object.entries(tasks);
+  const results = await Promise.all(entries.map(async ([key, task]) => {
+    const value = await task({ signal: controller.signal });
+    return [key, value];
+  }));
+  return Object.fromEntries(results);
+}
+
+// src/helpers/race.ts
+async function race(tasks, options) {
+  const controller = new AbortController();
+  const outer = options?.signal;
+  if (outer) {
+    if (outer.aborted) controller.abort();
+    else outer.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+  const wrapped = tasks.map((task) => (async () => task({ signal: controller.signal }))());
+  try {
+    return await Promise.race(wrapped);
+  } finally {
+    controller.abort();
+  }
+}
+
+// src/helpers/combine-latest.ts
+function combineLatest() {
+  return (...deps) => {
+    return (state) => deps.map((fn) => fn(state));
+  };
+}
+
+// src/helpers/combine-latest-stream.ts
+function combineLatestStream(...sources) {
+  return {
+    subscribe(observer) {
+      const n = sources.length;
+      if (!n) {
+        observer.complete?.();
+        return { unsubscribe() {
+        } };
+      }
+      const hasValue = new Array(n).fill(false);
+      const values = new Array(n);
+      let completed = 0;
+      let closed = false;
+      const subs = [];
+      const tryEmit = () => {
+        if (closed) return;
+        if (hasValue.every(Boolean)) {
+          observer.next?.(values.slice());
+        }
+      };
+      const closeAll = () => {
+        if (closed) return;
+        closed = true;
+        for (const s of subs) {
+          try {
+            s.unsubscribe();
+          } catch {
+          }
+        }
+      };
+      sources.forEach((src, index) => {
+        const sub = src.subscribe({
+          next: (v) => {
+            if (closed) return;
+            values[index] = v;
+            hasValue[index] = true;
+            tryEmit();
+          },
+          error: (err) => {
+            if (closed) return;
+            observer.error?.(err);
+            closeAll();
+          },
+          complete: () => {
+            if (closed) return;
+            completed++;
+            if (completed >= n) {
+              observer.complete?.();
+              closeAll();
+            }
+          }
+        });
+        subs.push(sub);
+      });
+      return {
+        unsubscribe() {
+          closeAll();
+        }
+      };
+    }
+  };
+}
+
+// src/helpers/entity-adapter.ts
+function defaultSelectId(entity) {
+  return entity.id;
+}
+function idKey(id) {
+  return String(id);
+}
+function ensureSort(state, sortComparer) {
+  if (!sortComparer) return;
+  state.ids.sort((a, b) => {
+    const ea = state.entities[idKey(a)];
+    const eb = state.entities[idKey(b)];
+    if (!ea || !eb) return 0;
+    return sortComparer(ea, eb);
+  });
+}
+function createEntityAdapter(options = {}) {
+  const selectId = options.selectId ?? defaultSelectId;
+  const sortComparer = options.sortComparer;
+  const getInitialState = (extra) => {
+    return {
+      ids: [],
+      entities: {},
+      ...extra ?? {}
+    };
+  };
+  const addOne = (entity, state) => {
+    const id = selectId(entity);
+    const key = idKey(id);
+    if (state.entities[key]) return;
+    state.ids.push(id);
+    state.entities[key] = entity;
+    ensureSort(state, sortComparer);
+  };
+  const addMany = (entities, state) => {
+    for (const entity of entities) addOne(entity, state);
+  };
+  const setAll = (entities, state) => {
+    state.ids = [];
+    state.entities = {};
+    for (const entity of entities) {
+      const id = selectId(entity);
+      state.ids.push(id);
+      state.entities[idKey(id)] = entity;
+    }
+    ensureSort(state, sortComparer);
+  };
+  const upsertOne = (entity, state) => {
+    const id = selectId(entity);
+    const key = idKey(id);
+    const exists = !!state.entities[key];
+    state.entities[key] = entity;
+    if (!exists) state.ids.push(id);
+    ensureSort(state, sortComparer);
+  };
+  const upsertMany = (entities, state) => {
+    for (const entity of entities) upsertOne(entity, state);
+  };
+  const updateOne = (update, state) => {
+    const key = idKey(update.id);
+    const current = state.entities[key];
+    if (!current) return;
+    state.entities[key] = { ...current, ...update.changes };
+    ensureSort(state, sortComparer);
+  };
+  const removeOne = (id, state) => {
+    const key = idKey(id);
+    if (!state.entities[key]) return;
+    delete state.entities[key];
+    state.ids = state.ids.filter((x) => !Object.is(x, id));
+  };
+  const removeMany = (ids, state) => {
+    const removeSet = new Set(ids.map(idKey));
+    for (const key of Object.keys(state.entities)) {
+      if (removeSet.has(key)) delete state.entities[key];
+    }
+    state.ids = state.ids.filter((id) => !removeSet.has(idKey(id)));
+  };
+  const removeAll = (state) => {
+    state.ids = [];
+    state.entities = {};
+  };
+  const getSelectors = (selectState) => {
+    const pick = (state) => selectState ? selectState(state) : state;
+    return {
+      selectIds: (state) => pick(state).ids,
+      selectEntities: (state) => pick(state).entities,
+      selectAll: (state) => {
+        const s = pick(state);
+        return s.ids.map((id) => s.entities[idKey(id)]).filter(Boolean);
+      },
+      selectTotal: (state) => pick(state).ids.length,
+      selectById: (state, id) => pick(state).entities[idKey(id)]
+    };
+  };
+  return {
+    selectId,
+    sortComparer,
+    getInitialState,
+    addOne,
+    addMany,
+    setAll,
+    upsertOne,
+    upsertMany,
+    updateOne,
+    removeOne,
+    removeMany,
+    removeAll,
+    getSelectors
+  };
+}
+
+// src/helpers/with-entities.ts
+function cloneEntityState(state) {
+  return {
+    ids: [...state.ids],
+    entities: { ...state.entities }
+  };
+}
+function withEntities(config, options) {
+  const { key, adapter, initial } = options;
+  const initialSlice = adapter.getInitialState();
+  if (initial?.length) {
+    adapter.setAll(initial, initialSlice);
+  }
+  const baseSelectors = config.selectors ?? {};
+  const baseActions = config.actions ?? {};
+  const scopedSelectors = adapter.getSelectors((s) => s[key]);
+  const selectorNames = {
+    ids: options.selectors?.ids ?? `${key}Ids`,
+    entities: options.selectors?.entities ?? `${key}Entities`,
+    all: options.selectors?.all ?? `${key}All`,
+    total: options.selectors?.total ?? `${key}Total`,
+    byId: options.selectors?.byId ?? `${key}ById`
+  };
+  const actionNames = {
+    addOne: options.actions?.addOne ?? `${key}AddOne`,
+    addMany: options.actions?.addMany ?? `${key}AddMany`,
+    setAll: options.actions?.setAll ?? `${key}SetAll`,
+    upsertOne: options.actions?.upsertOne ?? `${key}UpsertOne`,
+    upsertMany: options.actions?.upsertMany ?? `${key}UpsertMany`,
+    updateOne: options.actions?.updateOne ?? `${key}UpdateOne`,
+    removeOne: options.actions?.removeOne ?? `${key}RemoveOne`,
+    removeMany: options.actions?.removeMany ?? `${key}RemoveMany`,
+    removeAll: options.actions?.removeAll ?? `${key}RemoveAll`
+  };
+  const nextSelectors = {
+    ...baseSelectors,
+    [selectorNames.ids]: (state) => scopedSelectors.selectIds(state),
+    [selectorNames.entities]: (state) => scopedSelectors.selectEntities(state),
+    [selectorNames.all]: (state) => scopedSelectors.selectAll(state),
+    [selectorNames.total]: (state) => scopedSelectors.selectTotal(state),
+    [selectorNames.byId]: (state) => (id) => scopedSelectors.selectById(state, id)
+  };
+  const nextActions = {
+    ...baseActions,
+    [actionNames.addOne]: (state, entity) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.addOne(entity, next);
+      state[key] = next;
+    },
+    [actionNames.addMany]: (state, entities) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.addMany(entities, next);
+      state[key] = next;
+    },
+    [actionNames.setAll]: (state, entities) => {
+      const next = adapter.getInitialState();
+      adapter.setAll(entities, next);
+      state[key] = next;
+    },
+    [actionNames.upsertOne]: (state, entity) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.upsertOne(entity, next);
+      state[key] = next;
+    },
+    [actionNames.upsertMany]: (state, entities) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.upsertMany(entities, next);
+      state[key] = next;
+    },
+    [actionNames.updateOne]: (state, update) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.updateOne(update, next);
+      state[key] = next;
+    },
+    [actionNames.removeOne]: (state, id) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.removeOne(id, next);
+      state[key] = next;
+    },
+    [actionNames.removeMany]: (state, ids) => {
+      const prev = state[key];
+      const next = cloneEntityState(prev);
+      adapter.removeMany(ids, next);
+      state[key] = next;
+    },
+    [actionNames.removeAll]: (state) => {
+      state[key] = adapter.getInitialState();
+    }
+  };
+  return {
+    ...config,
+    [key]: config[key] ?? initialSlice,
+    actions: nextActions,
+    selectors: nextSelectors
+  };
+}
+
+// src/helpers/stream-operators.ts
+function pipeStream(source, ...ops) {
+  return ops.reduce((acc, op) => op(acc), source);
+}
+function isObservable(value) {
+  return !!value && typeof value === "object" && typeof value.subscribe === "function";
+}
+function toObservable(value) {
+  if (isObservable(value)) return value;
+  return {
+    subscribe(observer) {
+      let closed = false;
+      Promise.resolve(value).then((resolved) => {
+        if (closed) return;
+        observer.next?.(resolved);
+        observer.complete?.();
+      }).catch((error) => {
+        if (closed) return;
+        observer.error?.(error);
+      });
+      return { unsubscribe: () => {
+        closed = true;
+      } };
+    }
+  };
+}
+function mapStream(mapFn) {
+  return (source) => ({
+    subscribe(observer) {
+      return source.subscribe({
+        next: (value) => observer.next?.(mapFn(value)),
+        error: (error) => observer.error?.(error),
+        complete: () => observer.complete?.()
+      });
+    }
+  });
+}
+function filterStream(predicate) {
+  return (source) => ({
+    subscribe(observer) {
+      return source.subscribe({
+        next: (value) => {
+          if (predicate(value)) observer.next?.(value);
+        },
+        error: (error) => observer.error?.(error),
+        complete: () => observer.complete?.()
+      });
+    }
+  });
+}
+function closeSubs(subs) {
+  for (const sub of subs) {
+    try {
+      sub.unsubscribe();
+    } catch {
+    }
+  }
+}
+function switchMapStream(mapper) {
+  return (source) => ({
+    subscribe(observer) {
+      let closed = false;
+      let sourceDone = false;
+      let innerSub = null;
+      let innerActive = false;
+      let controller = null;
+      const maybeComplete = () => {
+        if (!closed && sourceDone && !innerActive) {
+          closed = true;
+          observer.complete?.();
+        }
+      };
+      const sourceSub = source.subscribe({
+        next: (value) => {
+          if (closed) return;
+          controller?.abort();
+          innerSub?.unsubscribe();
+          controller = new AbortController();
+          innerActive = true;
+          innerSub = toObservable(mapper(value, { signal: controller.signal })).subscribe({
+            next: (v) => {
+              if (!closed) observer.next?.(v);
+            },
+            error: (error) => {
+              if (closed) return;
+              closed = true;
+              observer.error?.(error);
+              sourceSub.unsubscribe();
+              innerSub?.unsubscribe();
+            },
+            complete: () => {
+              innerActive = false;
+              maybeComplete();
+            }
+          });
+        },
+        error: (error) => {
+          if (closed) return;
+          closed = true;
+          observer.error?.(error);
+          controller?.abort();
+          innerSub?.unsubscribe();
+        },
+        complete: () => {
+          sourceDone = true;
+          maybeComplete();
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          controller?.abort();
+          sourceSub.unsubscribe();
+          innerSub?.unsubscribe();
+        }
+      };
+    }
+  });
+}
+function concatMapStream(mapper) {
+  return (source) => ({
+    subscribe(observer) {
+      let closed = false;
+      let sourceDone = false;
+      const queue = [];
+      let running = false;
+      let currentSub = null;
+      let currentController = null;
+      const maybeComplete = () => {
+        if (!closed && sourceDone && !running && queue.length === 0) {
+          closed = true;
+          observer.complete?.();
+        }
+      };
+      const runNext = () => {
+        if (closed || running || queue.length === 0) {
+          maybeComplete();
+          return;
+        }
+        running = true;
+        const value = queue.shift();
+        currentController = new AbortController();
+        currentSub = toObservable(mapper(value, { signal: currentController.signal })).subscribe({
+          next: (v) => {
+            if (!closed) observer.next?.(v);
+          },
+          error: (error) => {
+            if (closed) return;
+            closed = true;
+            observer.error?.(error);
+            sourceSub.unsubscribe();
+            currentController?.abort();
+            currentSub?.unsubscribe();
+            queue.length = 0;
+          },
+          complete: () => {
+            running = false;
+            runNext();
+          }
+        });
+      };
+      const sourceSub = source.subscribe({
+        next: (value) => {
+          if (closed) return;
+          queue.push(value);
+          runNext();
+        },
+        error: (error) => {
+          if (closed) return;
+          closed = true;
+          observer.error?.(error);
+          currentController?.abort();
+          currentSub?.unsubscribe();
+          queue.length = 0;
+        },
+        complete: () => {
+          sourceDone = true;
+          maybeComplete();
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          sourceSub.unsubscribe();
+          currentController?.abort();
+          currentSub?.unsubscribe();
+          queue.length = 0;
+        }
+      };
+    }
+  });
+}
+function exhaustMapStream(mapper) {
+  return (source) => ({
+    subscribe(observer) {
+      let closed = false;
+      let sourceDone = false;
+      let running = false;
+      let currentSub = null;
+      let controller = null;
+      const maybeComplete = () => {
+        if (!closed && sourceDone && !running) {
+          closed = true;
+          observer.complete?.();
+        }
+      };
+      const sourceSub = source.subscribe({
+        next: (value) => {
+          if (closed || running) return;
+          running = true;
+          controller = new AbortController();
+          currentSub = toObservable(mapper(value, { signal: controller.signal })).subscribe({
+            next: (v) => {
+              if (!closed) observer.next?.(v);
+            },
+            error: (error) => {
+              if (closed) return;
+              closed = true;
+              observer.error?.(error);
+              sourceSub.unsubscribe();
+              controller?.abort();
+              currentSub?.unsubscribe();
+            },
+            complete: () => {
+              running = false;
+              maybeComplete();
+            }
+          });
+        },
+        error: (error) => {
+          if (closed) return;
+          closed = true;
+          observer.error?.(error);
+          controller?.abort();
+          currentSub?.unsubscribe();
+        },
+        complete: () => {
+          sourceDone = true;
+          maybeComplete();
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          sourceSub.unsubscribe();
+          controller?.abort();
+          currentSub?.unsubscribe();
+        }
+      };
+    }
+  });
+}
+function mergeMapStream(mapper, options) {
+  const concurrency = Math.max(1, options?.concurrency ?? Number.POSITIVE_INFINITY);
+  return (source) => ({
+    subscribe(observer) {
+      let closed = false;
+      let sourceDone = false;
+      const queue = [];
+      const active = /* @__PURE__ */ new Set();
+      const controllers = /* @__PURE__ */ new Set();
+      const maybeComplete = () => {
+        if (!closed && sourceDone && active.size === 0 && queue.length === 0) {
+          closed = true;
+          observer.complete?.();
+        }
+      };
+      const spawn = (value) => {
+        const controller = new AbortController();
+        controllers.add(controller);
+        const sub = toObservable(mapper(value, { signal: controller.signal })).subscribe({
+          next: (v) => {
+            if (!closed) observer.next?.(v);
+          },
+          error: (error) => {
+            if (closed) return;
+            closed = true;
+            observer.error?.(error);
+            sourceSub.unsubscribe();
+            closeSubs(Array.from(active));
+            active.clear();
+            for (const c of controllers) c.abort();
+            controllers.clear();
+            queue.length = 0;
+          },
+          complete: () => {
+            active.delete(sub);
+            controllers.delete(controller);
+            drain();
+            maybeComplete();
+          }
+        });
+        active.add(sub);
+      };
+      const drain = () => {
+        while (!closed && active.size < concurrency && queue.length > 0) {
+          spawn(queue.shift());
+        }
+      };
+      const sourceSub = source.subscribe({
+        next: (value) => {
+          if (closed) return;
+          queue.push(value);
+          drain();
+        },
+        error: (error) => {
+          if (closed) return;
+          closed = true;
+          observer.error?.(error);
+          closeSubs(Array.from(active));
+          active.clear();
+          for (const c of controllers) c.abort();
+          controllers.clear();
+          queue.length = 0;
+        },
+        complete: () => {
+          sourceDone = true;
+          maybeComplete();
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          sourceSub.unsubscribe();
+          closeSubs(Array.from(active));
+          active.clear();
+          for (const c of controllers) c.abort();
+          controllers.clear();
+          queue.length = 0;
+        }
+      };
+    }
+  });
+}
+function distinctUntilChangedStream(keySelector, comparator = Object.is) {
+  return (source) => ({
+    subscribe(observer) {
+      let initialized = false;
+      let prevKey;
+      return source.subscribe({
+        next: (value) => {
+          const nextKey = keySelector ? keySelector(value) : value;
+          if (initialized && comparator(prevKey, nextKey)) return;
+          initialized = true;
+          prevKey = nextKey;
+          observer.next?.(value);
+        },
+        error: (error) => observer.error?.(error),
+        complete: () => observer.complete?.()
+      });
+    }
+  });
+}
+function debounceStream(ms) {
+  return (source) => ({
+    subscribe(observer) {
+      let timer = null;
+      let sourceDone = false;
+      let lastValue;
+      let hasValue = false;
+      let closed = false;
+      const flush = () => {
+        if (!hasValue || closed) return;
+        observer.next?.(lastValue);
+        hasValue = false;
+        lastValue = void 0;
+      };
+      const maybeComplete = () => {
+        if (sourceDone && !timer && !closed) {
+          closed = true;
+          observer.complete?.();
+        }
+      };
+      const sub = source.subscribe({
+        next: (value) => {
+          if (closed) return;
+          lastValue = value;
+          hasValue = true;
+          if (timer) clearTimeout(timer);
+          timer = setTimeout(() => {
+            timer = null;
+            flush();
+            maybeComplete();
+          }, ms);
+        },
+        error: (error) => {
+          if (closed) return;
+          closed = true;
+          if (timer) clearTimeout(timer);
+          observer.error?.(error);
+        },
+        complete: () => {
+          sourceDone = true;
+          if (!timer) {
+            maybeComplete();
+          }
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          if (timer) clearTimeout(timer);
+          sub.unsubscribe();
+        }
+      };
+    }
+  });
+}
+function throttleStream(ms) {
+  return (source) => ({
+    subscribe(observer) {
+      let throttled2 = false;
+      let timer = null;
+      let closed = false;
+      const sub = source.subscribe({
+        next: (value) => {
+          if (closed || throttled2) return;
+          observer.next?.(value);
+          throttled2 = true;
+          timer = setTimeout(() => {
+            throttled2 = false;
+            timer = null;
+          }, ms);
+        },
+        error: (error) => {
+          if (closed) return;
+          closed = true;
+          if (timer) clearTimeout(timer);
+          observer.error?.(error);
+        },
+        complete: () => {
+          if (closed) return;
+          closed = true;
+          if (timer) clearTimeout(timer);
+          observer.complete?.();
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          if (timer) clearTimeout(timer);
+          sub.unsubscribe();
+        }
+      };
+    }
+  });
+}
+function catchErrorStream(handler) {
+  return (source) => ({
+    subscribe(observer) {
+      let closed = false;
+      let fallbackSub = null;
+      const sourceSub = source.subscribe({
+        next: (value) => {
+          if (!closed) observer.next?.(value);
+        },
+        error: (error) => {
+          if (closed) return;
+          fallbackSub = toObservable(handler(error)).subscribe({
+            next: (value) => {
+              if (!closed) observer.next?.(value);
+            },
+            error: (innerErr) => {
+              if (closed) return;
+              closed = true;
+              observer.error?.(innerErr);
+            },
+            complete: () => {
+              if (closed) return;
+              closed = true;
+              observer.complete?.();
+            }
+          });
+        },
+        complete: () => {
+          if (closed) return;
+          closed = true;
+          observer.complete?.();
+        }
+      });
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          sourceSub.unsubscribe();
+          fallbackSub?.unsubscribe();
+        }
+      };
+    }
+  });
+}
+function retryStream(options = {}) {
+  const attempts = Math.max(1, options.attempts ?? 3);
+  const delay = Math.max(0, options.delay ?? 0);
+  const backoff = options.backoff ?? "fixed";
+  return (source) => ({
+    subscribe(observer) {
+      let closed = false;
+      let attempt = 0;
+      let activeSub = null;
+      let retryTimer = null;
+      const subscribeOnce = () => {
+        if (closed) return;
+        attempt++;
+        activeSub = source.subscribe({
+          next: (value) => {
+            if (!closed) observer.next?.(value);
+          },
+          complete: () => {
+            if (closed) return;
+            closed = true;
+            observer.complete?.();
+          },
+          error: (error) => {
+            if (closed) return;
+            if (attempt >= attempts) {
+              closed = true;
+              observer.error?.(error);
+              return;
+            }
+            const wait = backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay;
+            retryTimer = setTimeout(() => {
+              retryTimer = null;
+              subscribeOnce();
+            }, wait);
+          }
+        });
+      };
+      subscribeOnce();
+      return {
+        unsubscribe() {
+          if (closed) return;
+          closed = true;
+          if (retryTimer) clearTimeout(retryTimer);
+          activeSub?.unsubscribe();
+        }
+      };
+    }
+  });
+}
+
+// src/helpers/with-persist.ts
+function resolveStorage(custom) {
+  if (custom) return custom;
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function pickState(state, keys) {
+  if (!keys?.length) return state;
+  const picked = {};
+  for (const key of keys) {
+    picked[key] = state[key];
+  }
+  return picked;
+}
+function withPersist(config, options) {
+  const {
+    key,
+    version = 1,
+    storage: customStorage,
+    pick,
+    migrate,
+    onError
+  } = options;
+  const storage = resolveStorage(customStorage);
+  const userHooks = config.hooks ?? {};
+  const mergedHooks = {
+    ...userHooks,
+    onInit(store) {
+      try {
+        if (!storage) return userHooks.onInit?.(store);
+        const raw = storage.getItem(key);
+        if (!raw) return userHooks.onInit?.(store);
+        const parsed = JSON.parse(raw);
+        const data = parsed.v === version ? parsed.data : migrate ? migrate(parsed.data, parsed.v) : parsed.data;
+        if (data && typeof data === "object") {
+          store.__store__?.hydrate?.(data);
+        }
+      } catch (error) {
+        onError?.(error);
+      }
+      return userHooks.onInit?.(store);
+    },
+    onStateChange(prev, next) {
+      try {
+        if (storage) {
+          const payload = {
+            v: version,
+            data: pickState(next, pick)
+          };
+          storage.setItem(key, JSON.stringify(payload));
+        }
+      } catch (error) {
+        onError?.(error);
+      }
+      userHooks.onStateChange?.(prev, next);
+    },
+    onDestroy(store) {
+      return userHooks.onDestroy?.(store);
+    },
+    onAction(name, args) {
+      return userHooks.onAction?.(name, args);
+    },
+    onActionDone(name, duration) {
+      return userHooks.onActionDone?.(name, duration);
+    },
+    onError(error, actionName) {
+      return userHooks.onError?.(error, actionName);
+    }
+  };
+  return {
+    ...config,
+    hooks: mergedHooks
+  };
+}
+
 // src/devtools.ts
 function createDevTools(maxLogs = 50) {
   let counter = 0;
@@ -455,17 +1670,40 @@ function connectDevTools(store, storeName) {
 exports.StatoHttp = StatoHttp;
 exports.StatoHttpError = StatoHttpError;
 exports.abortable = abortable;
+exports.catchErrorStream = catchErrorStream;
+exports.combineLatest = combineLatest;
+exports.combineLatestStream = combineLatestStream;
+exports.concatMapStream = concatMapStream;
 exports.configureHttp = configureHttp;
 exports.connectDevTools = connectDevTools;
 exports.createDevTools = createDevTools;
+exports.createEntityAdapter = createEntityAdapter;
 exports.createHttp = createHttp;
 exports.createStore = createStore;
+exports.debounceStream = debounceStream;
 exports.debounced = debounced;
 exports.devTools = devTools;
+exports.distinctUntilChanged = distinctUntilChanged;
+exports.distinctUntilChangedStream = distinctUntilChangedStream;
+exports.exclusive = exclusive;
+exports.exhaustMapStream = exhaustMapStream;
+exports.filterStream = filterStream;
+exports.forkJoin = forkJoin;
 exports.fromStream = fromStream;
 exports.http = http;
+exports.mapStream = mapStream;
+exports.mergeMapStream = mergeMapStream;
+exports.on = on;
 exports.optimistic = optimistic;
+exports.pipeStream = pipeStream;
+exports.queued = queued;
+exports.race = race;
+exports.retryStream = retryStream;
 exports.retryable = retryable;
+exports.switchMapStream = switchMapStream;
+exports.throttleStream = throttleStream;
 exports.throttled = throttled;
+exports.withEntities = withEntities;
+exports.withPersist = withPersist;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map