storion 0.5.0 → 0.7.0

package/dist/{store-CwA4YTVb.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;
@@ -1729,6 +1730,28 @@ function resolveEquality(e) {
 function equality(shorthand) {
   return resolveEquality(shorthand);
 }
+function tryDispose(value) {
+  if (isDisposable(value)) {
+    const dispose = value.dispose;
+    if (Array.isArray(dispose)) {
+      for (const item of dispose) {
+        if (typeof item === "function") {
+          item();
+        } else {
+          tryDispose(item);
+        }
+      }
+    } else if (typeof dispose === "function") {
+      dispose();
+    }
+  }
+}
+function isDisposable(value) {
+  return (typeof value === "object" || typeof value === "function") && !!value && "dispose" in value;
+}
+function willDispose(value) {
+  return () => tryDispose(value);
+}
 function getAtPath(obj, segments) {
   let current2 = obj;
   for (const key of segments) {
@@ -1864,18 +1887,16 @@ function createStoreContext(options) {
         actions: instance.actions
       });
     },
-    // Implementation handles both StoreSpec and Factory overloads
-    create(specOrFactory) {
+    // Implementation handles StoreSpec, Factory, and parameterized Factory overloads
+    create(specOrFactory, ...args) {
       if (!isSetupPhase()) {
         throw new Error(
           `create() can only be called during setup phase. Do not call create() inside actions or async callbacks. Declare all child stores at the top of your setup function.`
         );
       }
       if (!isSpec(specOrFactory)) {
-        const instance2 = specOrFactory(resolver);
-        if (instance2 && typeof instance2.dispose === "function") {
-          onDispose == null ? void 0 : onDispose(instance2.dispose);
-        }
+        const instance2 = specOrFactory(resolver, ...args);
+        onDispose == null ? void 0 : onDispose(willDispose(instance2));
         return instance2;
       }
       const childSpec = specOrFactory;
@@ -1888,7 +1909,7 @@ function createStoreContext(options) {
         );
       }
       const instance = resolver.create(childSpec);
-      onDispose == null ? void 0 : onDispose(instance.dispose);
+      onDispose == null ? void 0 : onDispose(willDispose(instance));
       return instance;
     },
     update: createUpdateFn(update),
@@ -1910,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) => {
@@ -1922,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}`;
@@ -2012,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 {
@@ -2640,26 +2450,21 @@ export {
   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,
-  getHooks as y,
-  scheduleNotification as z
+  tryDispose as t,
+  unwrapFn as u,
+  wrapFn as w
 };