storion 0.6.0 → 0.7.0

package/dist/{store-DS-4XdM6.js → store-BroaE7p4.js}

@@ -1,3 +1,4 @@
+import { e as emitter, w as withHooks, h as hasReadHook, t as trackRead, a as hasWriteHook, c as trackWrite, s as scheduleNotification, b as batch } from "./emitter-BA44OHdL.js";
 const STORION_TYPE = Symbol("STORION");
 function is$1(value, kind) {
   return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && value[STORION_TYPE] === kind;
@@ -1930,6 +1931,11 @@ function createStoreContext(options) {
       return mixin(ctx, ...args);
     },
     focus(path, options2) {
+      if (!isSetupPhase()) {
+        throw new Error(
+          `focus() can only be called during setup phase. Do not call focus() inside actions or async callbacks. Use the .to() method on an existing focus for dynamic sub-paths.`
+        );
+      }
       const focusCtx = {
         getState: getMutableState,
         update: (updater) => {
@@ -1942,75 +1948,6 @@ function createStoreContext(options) {
   };
   return ctx;
 }
-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(
-    (current2) => ({
-      ...current2,
-      scheduleNotification: (notify, key) => {
-        const actualKey = key ?? notify;
-        pending.set(actualKey, notify);
-      }
-    }),
-    fn,
-    // Flush on finish
-    () => {
-      for (const notify of pending.values()) {
-        notify();
-      }
-    }
-  );
-}
 let specIdCounter = 0;
 function generateSpecName() {
   return `spec-${++specIdCounter}`;
@@ -2032,153 +1969,6 @@ function unwrapFn(fn) {
 function isWrappedFn(fn) {
   return ORIGINAL_FN in fn;
 }
-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);
-    }
-  };
-}
 function collection(createItem, initialItems) {
   const map = /* @__PURE__ */ new Map([]);
   return {
@@ -2655,32 +2445,26 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   return instance;
 }
 export {
-  scheduleNotification as A,
   STORION_TYPE as S,
   is$1 as a,
   isStorion as b,
   createStoreInstance as c,
   isContainer as d,
-  emitter as e,
-  isStore as f,
+  isStore as e,
+  isFocus as f,
   getKind as g,
-  isFocus as h,
+  isAction as h,
   isSpec as i,
-  isAction as j,
-  isStoreContext as k,
-  isSelectorContext as l,
-  batch as m,
-  equality as n,
-  shallowEqual as o,
-  deepEqual as p,
-  strictEqual as q,
+  isStoreContext as j,
+  isSelectorContext as k,
+  equality as l,
+  shallowEqual as m,
+  deepEqual as n,
+  strictEqual as o,
+  isWrappedFn as p,
   resolveEquality as r,
   store as s,
-  wrapFn as t,
-  untrack as u,
-  unwrapFn as v,
-  withHooks as w,
-  isWrappedFn as x,
-  tryDispose as y,
-  getHooks as z
+  tryDispose as t,
+  unwrapFn as u,
+  wrapFn as w
 };

package/dist/storion.js

@@ -1,5 +1,8 @@
-import { y as tryDispose, i as isSpec, e as emitter, u as untrack, S as STORION_TYPE, z as getHooks, w as withHooks, r as resolveEquality, A as scheduleNotification, v as unwrapFn, o as shallowEqual } from "./store-DS-4XdM6.js";
-import { m, p, n, g, a, j, d, h, l, f, k, b, x, s, q, t } from "./store-DS-4XdM6.js";
+import { t as tryDispose, i as isSpec, S as STORION_TYPE, r as resolveEquality, u as unwrapFn, m as shallowEqual } from "./store-BroaE7p4.js";
+import { n, l, g, a, h, d, f, k, e, j, b, p, s, o, w } from "./store-BroaE7p4.js";
+import { e as emitter, u as untrack, g as getHooks, w as withHooks } from "./emitter-BA44OHdL.js";
+import { b as b2 } from "./emitter-BA44OHdL.js";
+import { e as e2 } from "./effect-DPAYSuW3.js";
 function extractDisplayName(factory) {
   if (isSpec(factory)) {
     return factory.displayName;
@@ -323,279 +326,6 @@ function pick(selector, equality) {
   });
   return currentValue;
 }
-function isPromiseLike(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function createEffectContext(nth) {
-  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;
-      };
-    }
-  };
-  return Object.assign(context, { _runCleanups: runCleanups });
-}
-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;
-    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;
-      const getOrCreateContext = () => {
-        if (!lazyContext) {
-          lazyContext = createEffectContext(currentGeneration);
-        }
-        return lazyContext;
-      };
-      const lazyContextProxy = new Proxy({}, {
-        get(_, prop) {
-          return getOrCreateContext()[prop];
-        }
-      });
-      withHooks(getTrackingHooks, () => {
-        const result = fn(lazyContextProxy);
-        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."
-          );
-        }
-      });
-      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) {
-      handleError(error);
-    } finally {
-      isRunning = false;
-    }
-  };
-  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;
-}
 function patternToPredicate(pattern) {
   if (pattern instanceof RegExp) {
     return (name) => pattern.test(name);
@@ -723,34 +453,34 @@ export {
   STORION_TYPE,
   applyExcept,
   applyFor,
-  m as batch,
+  b2 as batch,
   compose,
   container,
   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,
   shallowEqual,
   s as store,
-  q as strictEqual,
+  o as strictEqual,
   trigger,
   untrack,
   unwrapFn,
   when,
-  t as wrapFn
+  w as wrapFn
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storion",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Reactive stores for modern apps. Type-safe. Auto-tracked. Effortlessly composable",
   "type": "module",
   "main": "./dist/storion.js",