storion 0.6.0 → 0.7.0

package/dist/effect-DPAYSuW3.js

@@ -0,0 +1,294 @@
+import { g as getHooks, w as withHooks, s as scheduleNotification, e as emitter } from "./emitter-BA44OHdL.js";
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function createEffectContext(nth, onRefresh) {
+  let cleanupEmitter = null;
+  let abortController = null;
+  let isStale = false;
+  const runCleanups = () => {
+    if (isStale) return;
+    isStale = true;
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    if (cleanupEmitter && cleanupEmitter.size > 0) {
+      cleanupEmitter.emitAndClearLifo();
+    }
+  };
+  function wrapPromise(promise) {
+    return new Promise((resolve, reject) => {
+      promise.then(
+        (value) => {
+          if (!isStale) {
+            resolve(value);
+          }
+        },
+        (error) => {
+          if (!isStale) {
+            reject(error);
+          }
+        }
+      );
+    });
+  }
+  const context = {
+    nth,
+    get signal() {
+      if (!abortController) {
+        abortController = new AbortController();
+      }
+      return abortController.signal;
+    },
+    onCleanup(listener) {
+      if (!cleanupEmitter) {
+        cleanupEmitter = emitter();
+      }
+      return cleanupEmitter.on(listener);
+    },
+    safe(promiseOrCallback) {
+      if (promiseOrCallback instanceof Promise) {
+        return wrapPromise(promiseOrCallback);
+      }
+      return (...args) => {
+        if (!isStale) {
+          const result = promiseOrCallback(
+            ...args
+          );
+          if (isPromiseLike(result)) {
+            return wrapPromise(result);
+          }
+          return result;
+        }
+        return void 0;
+      };
+    },
+    refresh() {
+      if (!isStale) {
+        onRefresh();
+      }
+    }
+  };
+  return Object.assign(context, { _runCleanups: runCleanups });
+}
+class CannotRefreshError extends Error {
+  constructor() {
+    super("Effect is already running, cannot refresh");
+  }
+}
+function resolveErrorStrategy(effectOptions) {
+  return (effectOptions == null ? void 0 : effectOptions.onError) ?? "keepAlive";
+}
+function getRetryDelay(config, attempt) {
+  if (typeof config.delay === "function") {
+    return config.delay(attempt);
+  }
+  return config.delay ?? 100 * Math.pow(2, attempt);
+}
+function effect(fn, options) {
+  let currentContext = null;
+  let subscriptionEmitter = null;
+  let isStarted = false;
+  let isRunning = false;
+  let isDisposed = false;
+  let runGeneration = 0;
+  let retryCount = 0;
+  let retryTimeout = null;
+  let errorStrategy = "keepAlive";
+  let onErrorCallback = null;
+  let prevTrackedDeps = /* @__PURE__ */ new Map();
+  let prevSubscriptionEmitter = null;
+  let trackedDeps = /* @__PURE__ */ new Map();
+  const writtenProps = /* @__PURE__ */ new Set();
+  let newTrackedDeps = null;
+  const getSubscriptionEmitter = () => {
+    if (!subscriptionEmitter) {
+      subscriptionEmitter = emitter();
+    }
+    return subscriptionEmitter;
+  };
+  const clearSubscriptions = () => {
+    if (subscriptionEmitter && subscriptionEmitter.size > 0) {
+      subscriptionEmitter.emitAndClear();
+    }
+  };
+  const areDepsChanged = (prev, next) => {
+    if (prev.size !== next.size) return true;
+    for (const key of next.keys()) {
+      if (!prev.has(key)) return true;
+    }
+    return false;
+  };
+  const subscribeToTrackedDeps = () => {
+    for (const [key, dep] of trackedDeps) {
+      if (writtenProps.has(key)) continue;
+      const unsub = dep.subscribe(() => {
+        scheduleNotification(execute, fn);
+      });
+      getSubscriptionEmitter().on(unsub);
+    }
+  };
+  const handleError = (error) => {
+    onErrorCallback == null ? void 0 : onErrorCallback(error);
+    if (errorStrategy === "failFast") {
+      throw error;
+    }
+    if (errorStrategy === "keepAlive") {
+      console.error("Effect error (keepAlive):", error);
+      if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
+        trackedDeps = new Map(prevTrackedDeps);
+        subscriptionEmitter = prevSubscriptionEmitter;
+        prevSubscriptionEmitter = null;
+        return;
+      }
+      if (newTrackedDeps && newTrackedDeps.size > 0) {
+        trackedDeps = newTrackedDeps;
+      }
+      subscribeToTrackedDeps();
+      return;
+    }
+    if (typeof errorStrategy === "function") {
+      const retry = () => {
+        retryCount++;
+        execute();
+      };
+      errorStrategy({ error, retry, retryCount });
+      return;
+    }
+    const retryConfig = errorStrategy;
+    if (retryCount < retryConfig.maxRetries) {
+      const delay = getRetryDelay(retryConfig, retryCount);
+      retryCount++;
+      retryTimeout = setTimeout(() => {
+        retryTimeout = null;
+        execute();
+      }, delay);
+    } else {
+      console.error(
+        `Effect failed after ${retryConfig.maxRetries} retries:`,
+        error
+      );
+    }
+  };
+  let cachedHooks = null;
+  const getTrackingHooks = (current) => {
+    if (!cachedHooks) {
+      cachedHooks = {
+        ...current,
+        onRead: (event) => {
+          var _a;
+          (_a = current.onRead) == null ? void 0 : _a.call(current, event);
+          if (!newTrackedDeps.has(event.key)) {
+            newTrackedDeps.set(event.key, {
+              key: event.key,
+              value: event.value,
+              subscribe: event.subscribe
+            });
+          }
+        },
+        onWrite: (event) => {
+          var _a;
+          (_a = current.onWrite) == null ? void 0 : _a.call(current, event);
+          writtenProps.add(event.key);
+        },
+        scheduleNotification: current.scheduleNotification,
+        scheduleEffect: current.scheduleEffect
+      };
+    }
+    return cachedHooks;
+  };
+  const execute = () => {
+    if (isDisposed || isRunning) return;
+    isRunning = true;
+    let shouldRefresh = false;
+    const currentGeneration = ++runGeneration;
+    try {
+      currentContext == null ? void 0 : currentContext._runCleanups();
+      currentContext = null;
+      if (subscriptionEmitter && subscriptionEmitter.size > 0) {
+        prevTrackedDeps = new Map(trackedDeps);
+        prevSubscriptionEmitter = subscriptionEmitter;
+        subscriptionEmitter = null;
+      }
+      newTrackedDeps = /* @__PURE__ */ new Map();
+      writtenProps.clear();
+      let lazyContext = null;
+      if (fn.length) {
+        lazyContext = createEffectContext(currentGeneration, () => {
+          if (isRunning) {
+            throw new CannotRefreshError();
+          }
+          execute();
+        });
+      }
+      withHooks(getTrackingHooks, () => {
+        const result = fn(lazyContext);
+        if (result !== null && result !== void 0 && typeof result.then === "function") {
+          throw new Error(
+            "Effect function must be synchronous. Use ctx.safe(promise) for async operations instead of returning a Promise."
+          );
+        }
+        if (lazyContext && lazyContext.refresh === result) {
+          shouldRefresh = true;
+        }
+      });
+      currentContext = lazyContext;
+      retryCount = 0;
+      const depsChanged = areDepsChanged(trackedDeps, newTrackedDeps);
+      if (depsChanged) {
+        if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
+          prevSubscriptionEmitter.emitAndClear();
+        }
+        trackedDeps = newTrackedDeps;
+        subscribeToTrackedDeps();
+      } else {
+        if (prevSubscriptionEmitter) {
+          subscriptionEmitter = prevSubscriptionEmitter;
+        }
+      }
+      prevTrackedDeps.clear();
+      prevSubscriptionEmitter = null;
+    } catch (error) {
+      if (error instanceof Error && error instanceof CannotRefreshError) {
+        throw error;
+      }
+      handleError(error);
+    } finally {
+      isRunning = false;
+    }
+    if (shouldRefresh) {
+      execute();
+    }
+  };
+  const dispose = () => {
+    if (isDisposed) return;
+    isDisposed = true;
+    runGeneration++;
+    if (retryTimeout) {
+      clearTimeout(retryTimeout);
+      retryTimeout = null;
+    }
+    currentContext == null ? void 0 : currentContext._runCleanups();
+    currentContext = null;
+    clearSubscriptions();
+    if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
+      prevSubscriptionEmitter.emitAndClear();
+    }
+  };
+  const start = (runOptions) => {
+    if (isStarted) return;
+    isStarted = true;
+    errorStrategy = resolveErrorStrategy(options);
+    onErrorCallback = (runOptions == null ? void 0 : runOptions.onError) ?? null;
+    execute();
+  };
+  getHooks().scheduleEffect((runOptions) => {
+    start(runOptions);
+    return dispose;
+  });
+  return dispose;
+}
+export {
+  effect as e
+};

package/dist/emitter-BA44OHdL.js

@@ -0,0 +1,228 @@
+let globalHooks = {
+  scheduleNotification(notify) {
+    notify();
+  },
+  scheduleEffect(runEffect) {
+    runEffect();
+  }
+};
+function getHooks() {
+  return globalHooks;
+}
+function hasReadHook() {
+  return globalHooks.onRead !== void 0;
+}
+function hasWriteHook() {
+  return globalHooks.onWrite !== void 0;
+}
+function withHooks(hooksOrSetup, fn, onFinish) {
+  const prev = globalHooks;
+  if (typeof hooksOrSetup === "function") {
+    globalHooks = {
+      ...globalHooks,
+      ...hooksOrSetup(prev)
+    };
+  } else {
+    globalHooks = { ...prev, ...hooksOrSetup };
+  }
+  try {
+    return fn();
+  } finally {
+    globalHooks = prev;
+    onFinish == null ? void 0 : onFinish();
+  }
+}
+function trackRead(storeId, prop, value, subscribe) {
+  var _a;
+  const key = `${storeId}.${prop}`;
+  (_a = globalHooks.onRead) == null ? void 0 : _a.call(globalHooks, { key, value, subscribe });
+}
+function trackWrite(storeId, prop, next, prev) {
+  var _a;
+  const key = `${storeId}.${prop}`;
+  (_a = globalHooks.onWrite) == null ? void 0 : _a.call(globalHooks, { key, next, prev });
+}
+function untrack(fn) {
+  return withHooks({ onRead: void 0, onWrite: void 0 }, fn);
+}
+function scheduleNotification(notify, key) {
+  globalHooks.scheduleNotification(notify, key);
+}
+function batch(fn) {
+  const pending = /* @__PURE__ */ new Map();
+  return withHooks(
+    (current) => ({
+      ...current,
+      scheduleNotification: (notify, key) => {
+        const actualKey = key ?? notify;
+        pending.set(actualKey, notify);
+      }
+    }),
+    fn,
+    // Flush on finish
+    () => {
+      for (const notify of pending.values()) {
+        notify();
+      }
+    }
+  );
+}
+function emitter(initialListeners) {
+  const listeners = /* @__PURE__ */ new Set([]);
+  let settledPayload;
+  let isSettled = false;
+  const noop = () => {
+  };
+  const doEmit = (payload, clear, lifo = false) => {
+    const copy = Array.from(listeners);
+    if (clear) {
+      listeners.clear();
+    }
+    const len = copy.length;
+    if (lifo) {
+      for (let i = len - 1; i >= 0; i--) {
+        copy[i](payload);
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        copy[i](payload);
+      }
+    }
+  };
+  return {
+    get size() {
+      return listeners.size;
+    },
+    get settled() {
+      return isSettled;
+    },
+    /**
+     * Adds one or more listeners to the emitter.
+     *
+     * The listener(s) will be called whenever `emit()` is called.
+     * Returns an unsubscribe function that removes the listener(s).
+     *
+     * **Important**: The unsubscribe function is idempotent - calling it multiple
+     * times is safe and won't cause errors. If the same listener is added multiple
+     * times, it will only be called once per emit (Set deduplication).
+     *
+     * **Settled behavior**: If the emitter is settled, listeners are called
+     * immediately with the settled payload and a no-op unsubscribe is returned.
+     *
+     * @param newListeners - Single listener or array of listeners to add
+     * @returns An unsubscribe function that removes the listener(s)
+     */
+    on(...args) {
+      let newListeners = [];
+      if (args.length < 2) {
+        newListeners = Array.isArray(args[0]) ? args[0] : [args[0]];
+      } else {
+        const map = args[0];
+        const sourceListeners = Array.isArray(args[1]) ? args[1] : [args[1]];
+        newListeners = [
+          (value) => {
+            const mappedValue = map(value);
+            if (mappedValue) {
+              for (const listener of sourceListeners) {
+                listener(mappedValue.value);
+              }
+            }
+          }
+        ];
+      }
+      if (isSettled) {
+        for (const listener of newListeners) {
+          listener(settledPayload);
+        }
+        return noop;
+      }
+      for (const listener of newListeners) {
+        listeners.add(listener);
+      }
+      return () => {
+        for (const listener of newListeners) {
+          listeners.delete(listener);
+        }
+      };
+    },
+    /**
+     * Emits an event to all registered listeners.
+     *
+     * **Important**: Creates a snapshot of listeners before iterating to ensure
+     * that modifications during emission (adding/removing listeners) don't affect
+     * the current emission cycle. This prevents:
+     * - New listeners added during emission from being called immediately
+     * - Issues with listeners that unsubscribe during emission
+     *
+     * Performance: For typical use cases (< 20 listeners), Array.from() overhead
+     * is negligible compared to calling the listener functions themselves.
+     *
+     * **Settled behavior**: After `settle()` is called, `emit()` becomes a no-op.
+     *
+     * @param payload - The value to pass to all listeners
+     */
+    emit(payload) {
+      if (isSettled) return;
+      doEmit(payload, false);
+    },
+    emitLifo(payload) {
+      if (isSettled) return;
+      doEmit(payload, false, true);
+    },
+    /**
+     * Removes all registered listeners.
+     *
+     * After calling `clear()`, no listeners will be notified until new ones
+     * are added via `on()`.
+     */
+    clear() {
+      listeners.clear();
+    },
+    /**
+     * Emits an event to all registered listeners and then clears all listeners.
+     *
+     * **Settled behavior**: After `settle()` is called, `emitAndClear()` becomes a no-op.
+     *
+     * @param payload - The value to pass to all listeners
+     */
+    emitAndClear(payload) {
+      if (isSettled) return;
+      doEmit(payload, true);
+    },
+    emitAndClearLifo(payload) {
+      if (isSettled) return;
+      doEmit(payload, true, true);
+    },
+    /**
+     * Emit to all listeners, clear, and "settle" the emitter.
+     *
+     * After settling:
+     * - Any new `on()` call immediately invokes the listener with the settled payload
+     * - Returns a no-op unsubscribe function
+     * - `emit()` and `emitAndClear()` become no-ops
+     *
+     * **Important**: `isSettled` is set BEFORE emitting so that listeners
+     * added during emission see the settled state and get called immediately.
+     *
+     * @param payload - The final value to pass to all listeners
+     */
+    settle(payload) {
+      if (isSettled) return;
+      settledPayload = payload;
+      isSettled = true;
+      doEmit(payload, true);
+    }
+  };
+}
+export {
+  hasWriteHook as a,
+  batch as b,
+  trackWrite as c,
+  emitter as e,
+  getHooks as g,
+  hasReadHook as h,
+  scheduleNotification as s,
+  trackRead as t,
+  untrack as u,
+  withHooks as w
+};

package/dist/react/index.js

@@ -3,10 +3,13 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { memo, useMemo, createElement, createContext, useContext, useReducer, useRef, useEffect, useLayoutEffect, useState, forwardRef } from "react";
 import { container } from "../storion.js";
-import { applyExcept, applyFor, compose, createLoggingMiddleware, createResolver, createValidationMiddleware, effect, forStores, pick, trigger, when } from "../storion.js";
-import { w as withHooks, i as isSpec, S as STORION_TYPE, r as resolveEquality, s as store } from "../store-DS-4XdM6.js";
-import { m, p, n, g, a, j, d, h, l, f, k, b, x, o, q, u, v, t } from "../store-DS-4XdM6.js";
+import { applyExcept, applyFor, compose, createLoggingMiddleware, createResolver, createValidationMiddleware, forStores, pick, trigger, when } from "../storion.js";
+import { i as isSpec, S as STORION_TYPE, r as resolveEquality, s as store } from "../store-BroaE7p4.js";
+import { n, l, g, a, h, d, f, k, e, j, b, p, m, o, u, w } from "../store-BroaE7p4.js";
+import { w as withHooks } from "../emitter-BA44OHdL.js";
+import { b as b2, u as u2 } from "../emitter-BA44OHdL.js";
 import { jsx } from "react/jsx-runtime";
+import { e as e2 } from "../effect-DPAYSuW3.js";
 const StoreContext = createContext(null);
 const StoreProvider = memo(
   ({ container: value, children }) => {
@@ -78,7 +81,7 @@ const useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
 const shouldScheduleDispose = !isServer && typeof useLayoutEffect === "function" && dev();
 function useLocalStore(spec) {
   var _a;
-  const [, forceUpdate] = useReducer((x2) => x2 + 1, 0);
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
   const prevControllerRef = useRef(null);
   const controller = useMemo(() => new LocalStoreController(spec), [spec]);
   if (prevControllerRef.current !== controller) {
@@ -188,7 +191,7 @@ class LocalStoreController {
   }
 }
 function useStoreWithContainer(selector, container2) {
-  const [, forceUpdate] = useReducer((x2) => x2 + 1, 0);
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
   const [refs] = useState(() => ({
     fresh: void 0,
     stableFns: /* @__PURE__ */ new Map(),
@@ -386,38 +389,38 @@ export {
   StoreProvider,
   applyExcept,
   applyFor,
-  m as batch,
+  b2 as batch,
   compose,
   container,
   create,
   createLoggingMiddleware,
   createResolver,
   createValidationMiddleware,
-  p as deepEqual,
-  effect,
-  n as equality,
+  n as deepEqual,
+  e2 as effect,
+  l as equality,
   forStores,
   g as getKind,
   a as is,
-  j as isAction,
+  h as isAction,
   d as isContainer,
-  h as isFocus,
-  l as isSelectorContext,
+  f as isFocus,
+  k as isSelectorContext,
   isSpec,
-  f as isStore,
-  k as isStoreContext,
+  e as isStore,
+  j as isStoreContext,
   b as isStorion,
-  x as isWrappedFn,
+  p as isWrappedFn,
   pick,
-  o as shallowEqual,
+  m as shallowEqual,
   store,
-  q as strictEqual,
+  o as strictEqual,
   trigger,
-  u as untrack,
-  v as unwrapFn,
+  u2 as untrack,
+  u as unwrapFn,
   useContainer,
   useStore,
   when,
   withStore,
-  t as wrapFn
+  w as wrapFn
 };