@ngstato/core 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,3 +1,27 @@
+// 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
@@ -14,6 +38,8 @@ var StatoStore = class {
   // Les hooks lifecycle
   _hooks;
   _publicStore = null;
+  _publicActions = {};
+  _initialized = false;
   _effects = [];
   _createMemoizedSelector(fn) {
     let initialized = false;
@@ -156,6 +182,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 };
@@ -168,10 +195,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;
     }
   }
@@ -190,6 +239,9 @@ var StatoStore = class {
   registerCleanup(fn) {
     this._cleanups.push(fn);
   }
+  registerPublicAction(name, fn) {
+    this._publicActions[name] = fn;
+  }
   hydrate(partial) {
     this._setState(partial);
   }
@@ -200,7 +252,10 @@ var StatoStore = class {
   // ── Lifecycle — appelé par l'adaptateur Angular ────
   init(publicStore) {
     this._publicStore = publicStore;
-    this._hooks.onInit?.(publicStore);
+    if (!this._initialized) {
+      this._initialized = true;
+      this._hooks.onInit?.(publicStore);
+    }
     this._runEffects(true);
   }
   destroy(publicStore) {
@@ -214,6 +269,7 @@ var StatoStore = class {
     }
     this._cleanups = [];
     this._subscribers.clear();
+    this._initialized = false;
   }
 };
 function createStore(config) {
@@ -239,7 +295,9 @@ function createStore(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) {
@@ -260,9 +318,23 @@ function createStore(config) {
       });
     }
   }
-  store.setPublicStore(publicStore);
+  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 {
@@ -493,6 +565,941 @@ 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;
@@ -658,6 +1665,6 @@ function connectDevTools(store, storeName) {
   };
 }
 
-export { StatoHttp, StatoHttpError, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled, withPersist };
+export { StatoHttp, StatoHttpError, abortable, catchErrorStream, combineLatest, combineLatestStream, concatMapStream, configureHttp, connectDevTools, createDevTools, createEntityAdapter, createHttp, createStore, debounceStream, debounced, devTools, distinctUntilChanged, distinctUntilChangedStream, exclusive, exhaustMapStream, filterStream, forkJoin, fromStream, http, mapStream, mergeMapStream, on, optimistic, pipeStream, queued, race, retryStream, retryable, switchMapStream, throttleStream, throttled, withEntities, withPersist };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map