storion 0.11.1 → 0.11.2

package/dist/{effect-1beiYe_c.js → effect-BfoYEdFF.js}

@@ -2,6 +2,7 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { e as emitter } from "./emitter-j4rC71vY.js";
+import { i as isPromiseLike$1 } from "./isPromiseLike-bFkfHAbm.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;
@@ -3137,10 +3138,72 @@ function abortable(fn) {
   });
   return wrapper;
 }
-function isPromiseLike(value) {
-  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+const retryStrategy = {
+  /** Exponential backoff: 1s, 2s, 4s, 8s... (max 30s) */
+  backoff: (attempt) => Math.min(1e3 * 2 ** attempt, 3e4),
+  /** Linear: 1s, 2s, 3s, 4s... (max 30s) */
+  linear: (attempt) => Math.min(1e3 * (attempt + 1), 3e4),
+  /** Fixed 1 second delay */
+  fixed: () => 1e3,
+  /** Fibonacci: 1s, 1s, 2s, 3s, 5s, 8s... (max 30s) */
+  fibonacci: (attempt) => {
+    const fib = [1, 1, 2, 3, 5, 8, 13, 21, 30];
+    return Math.min(fib[attempt] ?? 30, 30) * 1e3;
+  },
+  /** Immediate retry (no delay) */
+  immediate: () => 0,
+  /** Add jitter (±30%) to any strategy */
+  withJitter: (strategy) => (attempt) => {
+    const base = strategy(attempt);
+    const jitter = base * 0.3 * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(base + jitter));
+  }
+};
+class AsyncNotReadyError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "AsyncNotReadyError";
+  }
+}
+class AsyncAggregateError extends Error {
+  constructor(message, errors2) {
+    super(message);
+    this.errors = errors2;
+    this.name = "AsyncAggregateError";
+  }
+}
+function createAsyncContext(abortController, isCancelledOrAborted, cancel, resolver) {
+  const safe = createSafe(
+    () => abortController.signal,
+    isCancelledOrAborted
+  );
+  return {
+    signal: abortController.signal,
+    get(specOrFactory) {
+      const instance = resolver.get(specOrFactory);
+      if (isSpec(specOrFactory)) {
+        const store2 = instance;
+        return storeTuple(store2);
+      }
+      return instance;
+    },
+    safe,
+    cancel
+  };
+}
+const pendingPromises = /* @__PURE__ */ new WeakMap();
+const promiseStates = /* @__PURE__ */ new WeakMap();
+function getPendingPromise(state) {
+  if (state.status === "pending" && "__key" in state && state.__key) {
+    return pendingPromises.get(state.__key);
+  }
+  return void 0;
 }
 function toPromise(value) {
+  if (isPromiseLike$1(value)) {
+    return Promise.resolve(value);
+  }
   if (typeof value === "function") {
     try {
       const result = value();
@@ -3149,11 +3212,607 @@ function toPromise(value) {
       return Promise.reject(e);
     }
   }
-  if (isPromiseLike(value)) {
-    return Promise.resolve(value);
-  }
   return Promise.resolve(value);
 }
+function promiseTry(fn) {
+  return new Promise((resolve) => {
+    resolve(fn());
+  });
+}
+function createCancellablePromise(promise, cancel) {
+  const cancellable = promise;
+  cancellable.cancel = cancel;
+  return cancellable;
+}
+function stateToJSON() {
+  if (this.mode === "stale") {
+    return { status: "success", mode: "stale", data: this.data };
+  }
+  if (this.status === "success") {
+    return { status: "success", mode: "fresh", data: this.data };
+  }
+  return null;
+}
+function wrapAbortable(fn) {
+  return (ctx, ...args) => {
+    return fn.withSignal(ctx.signal, ...args);
+  };
+}
+function asyncWithFocus(focus, handler, options) {
+  if (!focus._storeContext.isSetupPhase()) {
+    throw new SetupPhaseError(
+      "async.action",
+      "async.action() must be called during store setup phase."
+    );
+  }
+  const [getState, setState] = focus;
+  const asyncKey = {};
+  let lastCancel = null;
+  let lastArgs = null;
+  let invocationCount = 0;
+  function dispatch(...args) {
+    return untrack(() => {
+      if (lastCancel && (options == null ? void 0 : options.autoCancel) !== false) {
+        lastCancel();
+      }
+      const abortController = new AbortController();
+      let isCancelled = false;
+      const requestId = {};
+      let rejectOnCancel = null;
+      const cancelPromise = new Promise((_, reject) => {
+        rejectOnCancel = reject;
+      });
+      const cancel2 = () => {
+        if (!isCancelled) {
+          isCancelled = true;
+          abortController.abort();
+          pendingPromises.delete(asyncKey);
+          rejectOnCancel == null ? void 0 : rejectOnCancel(new DOMException("Aborted", "AbortError"));
+        }
+      };
+      lastCancel = cancel2;
+      lastArgs = args;
+      invocationCount++;
+      const prevState = getState();
+      const mode = prevState.mode;
+      const staleData = mode === "stale" ? prevState.data : prevState.status === "success" ? prevState.data : void 0;
+      const autoCancel = (options == null ? void 0 : options.autoCancel) !== false;
+      const isStateExternallyModified = () => {
+        if (!autoCancel) {
+          const currentState2 = getState();
+          return currentState2.__requestId === void 0;
+        }
+        const currentState = getState();
+        return currentState.__requestId !== requestId;
+      };
+      const execute = async () => {
+        try {
+          const isCancelledOrAborted = () => isCancelled || abortController.signal.aborted;
+          const asyncContext = createAsyncContext(
+            abortController,
+            isCancelledOrAborted,
+            cancel2,
+            focus._resolver
+          );
+          const result = await promiseTry(() => handler(asyncContext, ...args));
+          if (isCancelled) {
+            throw new DOMException("Aborted", "AbortError");
+          }
+          if (isStateExternallyModified()) {
+            return result;
+          }
+          setState({
+            status: "success",
+            mode,
+            data: result,
+            error: void 0,
+            timestamp: Date.now(),
+            __requestId: requestId,
+            toJSON: stateToJSON
+          });
+          if (lastCancel === cancel2) {
+            lastCancel = null;
+          }
+          return result;
+        } catch (error) {
+          if (isCancelled || abortController.signal.aborted) {
+            throw error instanceof Error ? error : new DOMException("Aborted", "AbortError");
+          }
+          const errorObj = error instanceof Error ? error : new Error(String(error));
+          if (!abortController.signal.aborted) {
+            abortController.abort();
+          }
+          if (isStateExternallyModified()) {
+            throw errorObj;
+          }
+          setState({
+            status: "error",
+            mode,
+            data: mode === "stale" ? staleData : void 0,
+            error: errorObj,
+            timestamp: void 0,
+            __requestId: requestId,
+            toJSON: stateToJSON
+          });
+          if (lastCancel === cancel2) {
+            lastCancel = null;
+          }
+          throw errorObj;
+        }
+      };
+      const executionPromise = execute();
+      const promise = Promise.race([executionPromise, cancelPromise]);
+      pendingPromises.set(asyncKey, executionPromise);
+      setState({
+        status: "pending",
+        mode,
+        data: mode === "stale" ? staleData : void 0,
+        error: void 0,
+        timestamp: void 0,
+        __key: asyncKey,
+        __requestId: requestId,
+        toJSON: stateToJSON
+      });
+      promise.then(
+        () => pendingPromises.delete(asyncKey),
+        () => pendingPromises.delete(asyncKey)
+      );
+      return createCancellablePromise(promise, cancel2);
+    });
+  }
+  function refresh() {
+    if (lastArgs === null) {
+      return void 0;
+    }
+    return dispatch(...lastArgs);
+  }
+  function cancel() {
+    if (lastCancel) {
+      lastCancel();
+      lastCancel = null;
+    }
+  }
+  function reset() {
+    cancel();
+    lastArgs = null;
+    const currentState = getState();
+    const mode = currentState.mode;
+    const resetRequestId = {};
+    if (mode === "stale") {
+      setState({
+        status: "idle",
+        mode: "stale",
+        data: currentState.data,
+        error: void 0,
+        timestamp: void 0,
+        __requestId: resetRequestId,
+        toJSON: stateToJSON
+      });
+    } else {
+      setState({
+        status: "idle",
+        mode: "fresh",
+        data: void 0,
+        error: void 0,
+        timestamp: void 0,
+        __requestId: resetRequestId,
+        toJSON: stateToJSON
+      });
+    }
+  }
+  function last() {
+    const hasDispatched = !!lastArgs;
+    if (!hasDispatched) {
+      return void 0;
+    }
+    return {
+      args: lastArgs,
+      nth: invocationCount,
+      // Read state to trigger reactivity (via focus getter) - this is the only tracked read
+      state: getState()
+    };
+  }
+  if (options == null ? void 0 : options.autoCancel) {
+    focus._storeContext.onDispose(() => {
+      cancel();
+    });
+  }
+  return {
+    dispatch,
+    refresh,
+    cancel,
+    reset,
+    last
+  };
+}
+function asyncState(mode, status, dataOrError, errorOrExtra, extra) {
+  let state;
+  if (mode === "fresh") {
+    switch (status) {
+      case "idle":
+        state = {
+          status: "idle",
+          mode: "fresh",
+          data: void 0,
+          error: void 0,
+          timestamp: void 0,
+          toJSON: stateToJSON
+        };
+        break;
+      case "pending":
+        state = {
+          status: "pending",
+          mode: "fresh",
+          data: void 0,
+          error: void 0,
+          timestamp: void 0,
+          ...dataOrError,
+          toJSON: stateToJSON
+        };
+        break;
+      case "success":
+        state = {
+          status: "success",
+          mode: "fresh",
+          data: dataOrError,
+          error: void 0,
+          timestamp: Date.now(),
+          toJSON: stateToJSON
+        };
+        break;
+      case "error":
+        state = {
+          status: "error",
+          mode: "fresh",
+          data: void 0,
+          error: dataOrError,
+          timestamp: void 0,
+          ...errorOrExtra,
+          toJSON: stateToJSON
+        };
+        break;
+    }
+  } else {
+    switch (status) {
+      case "idle":
+        state = {
+          status: "idle",
+          mode: "stale",
+          data: dataOrError,
+          error: void 0,
+          timestamp: void 0,
+          toJSON: stateToJSON
+        };
+        break;
+      case "pending":
+        state = {
+          status: "pending",
+          mode: "stale",
+          data: dataOrError,
+          error: void 0,
+          timestamp: void 0,
+          ...errorOrExtra,
+          toJSON: stateToJSON
+        };
+        break;
+      case "success":
+        state = {
+          status: "success",
+          mode: "stale",
+          data: dataOrError,
+          error: void 0,
+          timestamp: Date.now(),
+          toJSON: stateToJSON
+        };
+        break;
+      case "error":
+        state = {
+          status: "error",
+          mode: "stale",
+          data: dataOrError,
+          error: errorOrExtra,
+          timestamp: void 0,
+          ...extra,
+          toJSON: stateToJSON
+        };
+        break;
+    }
+  }
+  return Object.freeze(state);
+}
+function asyncStateFrom(prev, status, dataOrError) {
+  const mode = prev.mode;
+  const staleData = mode === "stale" ? prev.data : void 0;
+  if (mode === "stale") {
+    switch (status) {
+      case "idle":
+        return asyncState("stale", "idle", staleData);
+      case "pending":
+        return asyncState("stale", "pending", staleData);
+      case "success":
+        return asyncState("stale", "success", dataOrError);
+      case "error":
+        return asyncState(
+          "stale",
+          "error",
+          staleData,
+          dataOrError
+        );
+    }
+  } else {
+    switch (status) {
+      case "idle":
+        return asyncState("fresh", "idle");
+      case "pending":
+        return asyncState("fresh", "pending");
+      case "success":
+        return asyncState("fresh", "success", dataOrError);
+      case "error":
+        return asyncState("fresh", "error", dataOrError);
+    }
+  }
+}
+asyncState.from = asyncStateFrom;
+var async;
+((async2) => {
+  function fresh() {
+    return asyncState("fresh", "idle");
+  }
+  async2.fresh = fresh;
+  function stale(initialData) {
+    return asyncState("stale", "idle", initialData);
+  }
+  async2.stale = stale;
+  function action(focus, handlerOrAbortable, options) {
+    const handler = isAbortable(handlerOrAbortable) ? wrapAbortable(handlerOrAbortable) : handlerOrAbortable;
+    return asyncWithFocus(focus, handler, options);
+  }
+  async2.action = action;
+  function mixin(handlerOrAbortable, options) {
+    const handler = isAbortable(handlerOrAbortable) ? wrapAbortable(handlerOrAbortable) : handlerOrAbortable;
+    const initialState = (options == null ? void 0 : options.initial) ?? asyncState("fresh", "idle");
+    const asyncSpec = store({
+      name: (options == null ? void 0 : options.name) ?? `async:${handler.name || "anonymous"}`,
+      state: { result: initialState },
+      meta: options == null ? void 0 : options.meta,
+      setup(storeContext) {
+        const { focus } = storeContext;
+        const actions = asyncWithFocus(
+          focus("result"),
+          (asyncContext, ...args) => {
+            return handler(asyncContext, ...args);
+          },
+          options
+        );
+        return actions;
+      }
+    });
+    return (context) => {
+      const [state2, actions] = context.scoped(asyncSpec);
+      return [state2.result, actions];
+    };
+  }
+  async2.mixin = mixin;
+  function delay(ms, resolved) {
+    let timeout;
+    return createCancellablePromise(
+      new Promise((resolve) => {
+        timeout = setTimeout(resolve, ms, resolved);
+      }),
+      () => {
+        clearTimeout(timeout);
+      }
+    );
+  }
+  async2.delay = delay;
+  async2.invoke = promiseTry;
+  function wait(state2) {
+    if (state2.status === "success") {
+      return state2.data;
+    }
+    if (state2.mode === "stale" && state2.data !== void 0) {
+      return state2.data;
+    }
+    if (state2.status === "error") {
+      throw state2.error;
+    }
+    if (state2.status === "pending") {
+      const promise = getPendingPromise(state2);
+      if (promise) {
+        throw promise;
+      }
+    }
+    const message = state2.status === "idle" ? `Cannot wait: state is idle. Call dispatch() or use trigger() to start the async operation before calling async.wait().` : `Cannot wait: state is ${state2.status}`;
+    throw new AsyncNotReadyError(message, state2.status);
+  }
+  async2.wait = wait;
+  function race(states) {
+    for (const key in states) {
+      if (Object.prototype.hasOwnProperty.call(states, key)) {
+        const state2 = states[key];
+        if (state2.status === "success") {
+          return [key, state2.data];
+        }
+      }
+    }
+    for (const key in states) {
+      if (Object.prototype.hasOwnProperty.call(states, key)) {
+        const state2 = states[key];
+        if (state2.mode === "stale" && state2.data !== void 0) {
+          return [key, state2.data];
+        }
+      }
+    }
+    for (const key in states) {
+      if (Object.prototype.hasOwnProperty.call(states, key)) {
+        const state2 = states[key];
+        if (state2.status === "error") {
+          throw state2.error;
+        }
+      }
+    }
+    throw new AsyncNotReadyError(
+      "No async state has resolved successfully",
+      "pending"
+    );
+  }
+  async2.race = race;
+  function withState(promise) {
+    const s = state(promise);
+    return Object.assign(promise, { state: s });
+  }
+  async2.withState = withState;
+  function state(promise) {
+    const state2 = promiseStates.get(promise);
+    if (state2) {
+      return state2;
+    }
+    const newState = {
+      status: "pending",
+      resolved: void 0,
+      rejected: void 0
+    };
+    promise.then(
+      (value) => {
+        newState.status = "fulfilled";
+        newState.resolved = value;
+      },
+      (error) => {
+        newState.status = "rejected";
+        newState.rejected = error;
+      }
+    );
+    promiseStates.set(promise, newState);
+    return newState;
+  }
+  async2.state = state;
+  function all(...states) {
+    const results = [];
+    for (let i = 0; i < states.length; i++) {
+      const state2 = states[i];
+      if (state2.status === "success") {
+        results.push(state2.data);
+        continue;
+      }
+      if (state2.mode === "stale" && state2.data !== void 0) {
+        results.push(state2.data);
+        continue;
+      }
+      if (state2.status === "error") {
+        throw state2.error;
+      }
+      throw new AsyncNotReadyError(
+        `State at index ${i} is ${state2.status}`,
+        state2.status
+      );
+    }
+    return results;
+  }
+  async2.all = all;
+  function any(...states) {
+    const errors2 = [];
+    for (const state2 of states) {
+      if (state2.status === "success") {
+        return state2.data;
+      }
+    }
+    for (const state2 of states) {
+      if (state2.mode === "stale" && state2.data !== void 0) {
+        return state2.data;
+      }
+      if (state2.status === "error") {
+        errors2.push(state2.error);
+      }
+    }
+    if (errors2.length === states.length) {
+      throw new AsyncAggregateError("All async states have errors", errors2);
+    }
+    throw new AsyncNotReadyError(
+      "No async state has resolved successfully",
+      "pending"
+    );
+  }
+  async2.any = any;
+  function settled(...states) {
+    const results = [];
+    for (const state2 of states) {
+      switch (state2.status) {
+        case "success":
+          results.push({ status: "success", data: state2.data });
+          break;
+        case "error":
+          results.push({
+            status: "error",
+            error: state2.error,
+            data: state2.mode === "stale" ? state2.data : void 0
+          });
+          break;
+        case "pending":
+          results.push({
+            status: "pending",
+            data: state2.mode === "stale" ? state2.data : void 0
+          });
+          break;
+        case "idle":
+          results.push({
+            status: "idle",
+            data: state2.mode === "stale" ? state2.data : void 0
+          });
+          break;
+      }
+    }
+    return results;
+  }
+  async2.settled = settled;
+  function hasData(state2) {
+    if (state2.status === "success") return true;
+    if (state2.mode === "stale" && state2.data !== void 0) return true;
+    return false;
+  }
+  async2.hasData = hasData;
+  function isLoading(state2) {
+    return state2.status === "pending";
+  }
+  async2.isLoading = isLoading;
+  function isError(state2) {
+    return state2.status === "error";
+  }
+  async2.isError = isError;
+  function derive(focus, computeFn) {
+    const [getState, setState] = focus;
+    let hasSetPending = false;
+    return effect((ctx) => {
+      const currentState = untrack(getState);
+      try {
+        const result = computeFn();
+        if (result !== null && result !== void 0 && typeof result.then === "function") {
+          throw new AsyncFunctionError(
+            "async.derive computeFn",
+            "Use async.wait() for async values, not async/await or returning promises."
+          );
+        }
+        hasSetPending = false;
+        setState(asyncState.from(currentState, "success", result));
+      } catch (ex) {
+        if (ex !== null && ex !== void 0 && typeof ex.then === "function") {
+          if (!hasSetPending) {
+            hasSetPending = true;
+            setState(asyncState.from(currentState, "pending"));
+          }
+          ctx.safe(ex).then(ctx.refresh, ctx.refresh);
+        } else {
+          hasSetPending = false;
+          const error = ex instanceof Error ? ex : new Error(String(ex));
+          setState(asyncState.from(currentState, "error", error));
+        }
+      }
+    });
+  }
+  async2.derive = derive;
+})(async || (async = {}));
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+}
 class AggregateErrorImpl extends Error {
   constructor(errors2, message) {
     super(message);
@@ -3317,41 +3976,6 @@ function createSafe(getSignal, isCancelled) {
     delay
   });
 }
-const retryStrategy = {
-  /** Exponential backoff: 1s, 2s, 4s, 8s... (max 30s) */
-  backoff: (attempt) => Math.min(1e3 * 2 ** attempt, 3e4),
-  /** Linear: 1s, 2s, 3s, 4s... (max 30s) */
-  linear: (attempt) => Math.min(1e3 * (attempt + 1), 3e4),
-  /** Fixed 1 second delay */
-  fixed: () => 1e3,
-  /** Fibonacci: 1s, 1s, 2s, 3s, 5s, 8s... (max 30s) */
-  fibonacci: (attempt) => {
-    const fib = [1, 1, 2, 3, 5, 8, 13, 21, 30];
-    return Math.min(fib[attempt] ?? 30, 30) * 1e3;
-  },
-  /** Immediate retry (no delay) */
-  immediate: () => 0,
-  /** Add jitter (±30%) to any strategy */
-  withJitter: (strategy) => (attempt) => {
-    const base = strategy(attempt);
-    const jitter = base * 0.3 * (Math.random() * 2 - 1);
-    return Math.max(0, Math.round(base + jitter));
-  }
-};
-class AsyncNotReadyError extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "AsyncNotReadyError";
-  }
-}
-class AsyncAggregateError extends Error {
-  constructor(message, errors2) {
-    super(message);
-    this.errors = errors2;
-    this.name = "AsyncAggregateError";
-  }
-}
 function createEffectContext(nth, onRefresh) {
   let cleanupEmitter = null;
   let abortController = null;
@@ -3613,40 +4237,41 @@ function effect(fn, options) {
 }
 export {
   AsyncNotReadyError as A,
-  LocalStoreDependencyError as B,
-  pool as C,
-  tryDispose as D,
+  StoreDisposedError as B,
+  LocalStoreDependencyError as C,
+  pool as D,
   EffectRefreshError as E,
-  unwrapFn as F,
+  tryDispose as F,
+  unwrapFn as G,
   HooksContextError as H,
   InvalidActionError as I,
   LifetimeMismatchError as L,
   ProviderMissingError as P,
-  SetupPhaseError as S,
-  store as a,
-  AsyncAggregateError as b,
+  ScopedOutsideSelectorError as S,
+  async as a,
+  abortable as b,
   createSafe as c,
-  AsyncFunctionError as d,
-  effect as e,
-  isAbortable as f,
-  abortable as g,
-  strictEqual as h,
-  isSpec as i,
-  ScopedOutsideSelectorError as j,
-  STORION_TYPE as k,
-  dev as l,
-  resolveEquality as m,
-  is$1 as n,
-  batch as o,
+  AsyncAggregateError as d,
+  AsyncFunctionError as e,
+  storeTuple as f,
+  isSpec as g,
+  STORION_TYPE as h,
+  isAbortable as i,
+  dev as j,
+  resolveEquality as k,
+  store as l,
+  is$1 as m,
+  batch as n,
+  effect as o,
   pick as p,
   equality as q,
   retryStrategy as r,
-  storeTuple as s,
+  strictEqual as s,
   tryStabilize as t,
   untrack as u,
   shallowEqual as v,
   withHooks as w,
   deepEqual as x,
   StorionError as y,
-  StoreDisposedError as z
+  SetupPhaseError as z
 };