storion 0.7.10 → 0.8.1

package/dist/{emitter-XwTUpyGv.js → emitter-j4rC71vY.js}

@@ -1,142 +1,3 @@
-class StorionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "StorionError";
-  }
-}
-class SetupPhaseError extends StorionError {
-  constructor(method, hint) {
-    super(
-      `${method}() can only be called during setup phase. Do not call ${method}() inside actions or async callbacks.` + (hint ? ` ${hint}` : "")
-    );
-    this.name = "SetupPhaseError";
-  }
-}
-class LifetimeMismatchError extends StorionError {
-  constructor(parentName, childName, operation) {
-    super(
-      `Lifetime mismatch: Store "${parentName}" (keepAlive) cannot ${operation} store "${childName}" (autoDispose). A long-lived store cannot ${operation} a store that may be disposed. Either change "${parentName}" to autoDispose, or change "${childName}" to keepAlive.`
-    );
-    this.name = "LifetimeMismatchError";
-  }
-}
-class AsyncFunctionError extends StorionError {
-  constructor(context, hint) {
-    super(`${context} must be synchronous. ${hint}`);
-    this.name = "AsyncFunctionError";
-  }
-}
-class StoreDisposedError extends StorionError {
-  constructor(storeId) {
-    super(`Cannot call action on disposed store: ${storeId}`);
-    this.name = "StoreDisposedError";
-  }
-}
-class InvalidActionError extends StorionError {
-  constructor(actionName, actualType) {
-    super(
-      `Action "${actionName}" must be a function, got ${actualType}. If using focus(), destructure it and return the getter/setter separately: const [get, set] = focus("path"); return { get, set };`
-    );
-    this.name = "InvalidActionError";
-  }
-}
-class HooksContextError extends StorionError {
-  constructor(method, requiredContext) {
-    super(
-      `${method}() must be called inside ${requiredContext}. It requires an active tracking context.`
-    );
-    this.name = "HooksContextError";
-  }
-}
-class ProviderMissingError extends StorionError {
-  constructor(hook, provider) {
-    super(`${hook} must be used within a ${provider}`);
-    this.name = "ProviderMissingError";
-  }
-}
-class LocalStoreDependencyError extends StorionError {
-  constructor(storeName, dependencyCount) {
-    super(
-      `Local store must not have dependencies, but "${storeName}" has ${dependencyCount} dependencies. Use useStore() with a global container for stores with dependencies.`
-    );
-    this.name = "LocalStoreDependencyError";
-  }
-}
-class EffectRefreshError extends StorionError {
-  constructor() {
-    super("Effect is already running, cannot refresh");
-    this.name = "EffectRefreshError";
-  }
-}
-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;
@@ -285,24 +146,5 @@ function emitter(initialListeners) {
   };
 }
 export {
-  AsyncFunctionError as A,
-  EffectRefreshError as E,
-  HooksContextError as H,
-  InvalidActionError as I,
-  LocalStoreDependencyError as L,
-  ProviderMissingError as P,
-  StorionError as S,
-  SetupPhaseError as a,
-  batch as b,
-  LifetimeMismatchError as c,
-  StoreDisposedError as d,
-  emitter as e,
-  hasWriteHook as f,
-  getHooks as g,
-  hasReadHook as h,
-  trackWrite as i,
-  scheduleNotification as s,
-  trackRead as t,
-  untrack as u,
-  withHooks as w
+  emitter as e
 };