storion 0.9.0 → 0.10.1

package/dist/async/index.js

@@ -1,17 +1,23 @@
-import { e as effect, u as untrack, A as AsyncFunctionError } from "../effect-C6h0PDDI.js";
-class AsyncNotReadyError extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "AsyncNotReadyError";
-  }
-}
-class AsyncAggregateError extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "AsyncAggregateError";
-  }
+import { c as createSafe, i as isSpec, s as storeTuple, a as store, A as AsyncNotReadyError, b as AsyncAggregateError, e as effect, u as untrack, d as AsyncFunctionError, S as SetupPhaseError, f as isAbortable, r as retryStrategy } from "../effect-BDQU8Voz.js";
+import { g } from "../effect-BDQU8Voz.js";
+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();
 function getPendingPromise(state) {
@@ -39,95 +45,67 @@ function stateToJSON() {
   }
   return null;
 }
-function getRetryCount(retry) {
-  if (typeof retry === "number") return retry;
-  if (retry && typeof retry === "object") return retry.count;
-  return 0;
+function wrapAbortable(fn) {
+  return (ctx, ...args) => {
+    return fn.withSignal(ctx.signal, ...args);
+  };
 }
-function getRetryDelay(retry, attempt, error) {
-  if (typeof retry === "number") return 1e3;
-  if (retry && typeof retry === "object") {
-    if (typeof retry.delay === "function") return retry.delay(attempt, error);
-    return retry.delay ?? 1e3;
+function asyncWithFocus(focus, handler, options) {
+  if (!focus._storeContext.isSetupPhase()) {
+    throw new SetupPhaseError(
+      "async.action",
+      "async.action() must be called during store setup phase."
+    );
   }
-  return 1e3;
-}
-function async(focus, handler, options) {
   const [getState, setState] = focus;
   const asyncKey = {};
   let lastCancel = null;
   let lastArgs = null;
   let invocationCount = 0;
   function dispatch(...args) {
-    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"));
+    return untrack(() => {
+      if (lastCancel && (options == null ? void 0 : options.autoCancel) !== false) {
+        lastCancel();
       }
-    };
-    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 retryCount = getRetryCount(options == null ? void 0 : options.retry);
-    const executeWithRetry = async () => {
-      let lastError = null;
-      for (let attempt = 0; attempt <= retryCount; attempt++) {
+      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 = {
-            signal: abortController.signal,
-            safe(promiseOrCallback) {
-              if (promiseOrCallback instanceof Promise) {
-                return new Promise((resolve, reject) => {
-                  promiseOrCallback.then(
-                    (value) => {
-                      if (!isCancelledOrAborted()) {
-                        resolve(value);
-                      }
-                    },
-                    (error) => {
-                      if (!isCancelledOrAborted()) {
-                        reject(error);
-                      }
-                    }
-                  );
-                });
-              }
-              return (...args2) => {
-                if (!isCancelledOrAborted()) {
-                  return promiseOrCallback(
-                    ...args2
-                  );
-                }
-                return void 0;
-              };
-            },
-            cancel: cancel2
-          };
+          const asyncContext = createAsyncContext(
+            abortController,
+            isCancelledOrAborted,
+            cancel2,
+            focus._resolver
+          );
           const result = await promiseTry(() => handler(asyncContext, ...args));
           if (isCancelled) {
             throw new DOMException("Aborted", "AbortError");
@@ -152,55 +130,47 @@ function async(focus, handler, options) {
           if (isCancelled || abortController.signal.aborted) {
             throw error instanceof Error ? error : new DOMException("Aborted", "AbortError");
           }
-          lastError = error instanceof Error ? error : new Error(String(error));
-          if (attempt < retryCount) {
-            const delay = getRetryDelay(options == null ? void 0 : options.retry, attempt + 1, lastError);
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            continue;
+          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;
         }
-      }
-      if (!abortController.signal.aborted) {
-        abortController.abort();
-      }
-      if (isStateExternallyModified()) {
-        throw lastError;
-      }
+      };
+      const executionPromise = execute();
+      const promise = Promise.race([executionPromise, cancelPromise]);
+      pendingPromises.set(asyncKey, executionPromise);
       setState({
-        status: "error",
+        status: "pending",
         mode,
         data: mode === "stale" ? staleData : void 0,
-        error: lastError,
+        error: void 0,
         timestamp: void 0,
+        __key: asyncKey,
         __requestId: requestId,
         toJSON: stateToJSON
       });
-      if (lastCancel === cancel2) {
-        lastCancel = null;
-      }
-      if ((options == null ? void 0 : options.onError) && lastError) {
-        options.onError(lastError);
-      }
-      throw lastError;
-    };
-    const executionPromise = executeWithRetry();
-    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);
     });
-    promise.then(
-      () => pendingPromises.delete(asyncKey),
-      () => pendingPromises.delete(asyncKey)
-    );
-    return createCancellablePromise(promise, cancel2);
   }
   function refresh() {
     if (lastArgs === null) {
@@ -254,6 +224,11 @@ function async(focus, handler, options) {
       state: getState()
     };
   }
+  if (options == null ? void 0 : options.autoCancel) {
+    focus._storeContext.onDispose(() => {
+      cancel();
+    });
+  }
   return {
     dispatch,
     refresh,
@@ -390,6 +365,7 @@ function asyncStateFrom(prev, status, dataOrError) {
   }
 }
 asyncState.from = asyncStateFrom;
+var async;
 ((async2) => {
   function fresh() {
     return asyncState("fresh", "idle");
@@ -399,14 +375,44 @@ asyncState.from = asyncStateFrom;
     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 [state, actions] = context.scoped(asyncSpec);
+      return [state.result, actions];
+    };
+  }
+  async2.mixin = mixin;
   function delay(ms, resolved) {
-    let timeout;
+    let timeout2;
     return createCancellablePromise(
       new Promise((resolve) => {
-        timeout = setTimeout(resolve, ms, resolved);
+        timeout2 = setTimeout(resolve, ms, resolved);
       }),
       () => {
-        clearTimeout(timeout);
+        clearTimeout(timeout2);
       }
     );
   }
@@ -587,11 +593,275 @@ asyncState.from = asyncStateFrom;
   }
   async2.derive = derive;
 })(async || (async = {}));
+function retry(retriesOrStrategyOrOptions) {
+  const options = typeof retriesOrStrategyOrOptions === "number" ? { retries: retriesOrStrategyOrOptions } : typeof retriesOrStrategyOrOptions === "string" ? { delay: retriesOrStrategyOrOptions } : retriesOrStrategyOrOptions ?? {};
+  const retries = options.retries ?? 3;
+  const delayOption = options.delay ?? "backoff";
+  const getDelay = typeof delayOption === "function" ? delayOption : typeof delayOption === "number" ? () => delayOption : retryStrategy[delayOption];
+  return (next) => async (ctx, ...args) => {
+    let lastError;
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        return await next(ctx, ...args);
+      } catch (error) {
+        lastError = error;
+        if (ctx.signal.aborted) {
+          throw error;
+        }
+        if (attempt < retries - 1) {
+          const delayResult = getDelay(attempt, lastError);
+          if (typeof delayResult === "number") {
+            await new Promise((resolve, reject) => {
+              const timer = setTimeout(resolve, delayResult);
+              const onAbort = () => {
+                clearTimeout(timer);
+                reject(ctx.signal.reason ?? new Error("Aborted"));
+              };
+              if (ctx.signal.aborted) {
+                onAbort();
+              } else {
+                ctx.signal.addEventListener("abort", onAbort, { once: true });
+              }
+            });
+          } else {
+            await delayResult;
+          }
+        }
+      }
+    }
+    throw lastError;
+  };
+}
+function catchError(callback) {
+  return (next) => async (ctx, ...args) => {
+    try {
+      return await next(ctx, ...args);
+    } catch (error) {
+      callback(error, ctx, ...args);
+      throw error;
+    }
+  };
+}
+function timeout(ms, message = "Operation timed out") {
+  return (next) => async (ctx, ...args) => {
+    const timeoutPromise = new Promise((_, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(message));
+      }, ms);
+      ctx.signal.addEventListener("abort", () => clearTimeout(timer));
+    });
+    return ctx.safe.race([next(ctx, ...args), timeoutPromise]);
+  };
+}
+function logging(name, logger = console) {
+  return (next) => async (ctx, ...args) => {
+    logger.log(`[${name}] calling with:`, args);
+    try {
+      const result = await next(ctx, ...args);
+      logger.log(`[${name}] success:`, result);
+      return result;
+    } catch (error) {
+      logger.error(`[${name}] error:`, error);
+      throw error;
+    }
+  };
+}
+function debounce(ms) {
+  let timeoutId;
+  return (next) => async (ctx, ...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    return new Promise((resolve, reject) => {
+      timeoutId = setTimeout(async () => {
+        try {
+          const result = await next(ctx, ...args);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      }, ms);
+      ctx.signal.addEventListener("abort", () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          reject(new Error("Debounced operation cancelled"));
+        }
+      });
+    });
+  };
+}
+function throttle(ms) {
+  let lastCall = 0;
+  let lastResult;
+  let pending;
+  return (next) => async (ctx, ...args) => {
+    const now = Date.now();
+    if (now - lastCall < ms) {
+      if (pending) {
+        return pending;
+      }
+      if (lastResult !== void 0) {
+        return lastResult;
+      }
+    }
+    lastCall = now;
+    pending = next(ctx, ...args);
+    try {
+      lastResult = await pending;
+      return lastResult;
+    } finally {
+      pending = void 0;
+    }
+  };
+}
+function fallback(value) {
+  return (next) => async (ctx, ...args) => {
+    try {
+      return await next(ctx, ...args);
+    } catch (error) {
+      if (ctx.signal.aborted) {
+        throw error;
+      }
+      return typeof value === "function" ? value(error, ctx, ...args) : value;
+    }
+  };
+}
+function cache(ttlOrOptions) {
+  const options = typeof ttlOrOptions === "number" ? { ttl: ttlOrOptions } : ttlOrOptions;
+  const { ttl, key: keyFn = (...args) => JSON.stringify(args) } = options;
+  const cacheMap = /* @__PURE__ */ new Map();
+  return (next) => async (ctx, ...args) => {
+    const cacheKey = keyFn(...args);
+    const now = Date.now();
+    const cached = cacheMap.get(cacheKey);
+    if (cached && cached.expires > now) {
+      return cached.value;
+    }
+    const result = await next(ctx, ...args);
+    cacheMap.set(cacheKey, { value: result, expires: now + ttl });
+    return result;
+  };
+}
+function rateLimit(options) {
+  const { limit, window } = options;
+  const timestamps = [];
+  const queue = [];
+  let processing = false;
+  const processQueue = async () => {
+    if (processing || queue.length === 0) return;
+    processing = true;
+    while (queue.length > 0) {
+      const now = Date.now();
+      while (timestamps.length > 0 && timestamps[0] <= now - window) {
+        timestamps.shift();
+      }
+      if (timestamps.length < limit) {
+        const item = queue.shift();
+        if (item.ctx.signal.aborted) {
+          item.reject(item.ctx.signal.reason ?? new Error("Aborted"));
+          continue;
+        }
+        timestamps.push(now);
+        try {
+          const result = await item.next(item.ctx, ...item.args);
+          item.resolve(result);
+        } catch (error) {
+          item.reject(error);
+        }
+      } else {
+        const waitTime = timestamps[0] + window - now;
+        await new Promise((r) => setTimeout(r, waitTime));
+      }
+    }
+    processing = false;
+  };
+  return (next) => async (ctx, ...args) => {
+    const now = Date.now();
+    while (timestamps.length > 0 && timestamps[0] <= now - window) {
+      timestamps.shift();
+    }
+    if (timestamps.length < limit) {
+      timestamps.push(now);
+      return next(ctx, ...args);
+    }
+    return new Promise((resolve, reject) => {
+      queue.push({ resolve, reject, ctx, args, next });
+      ctx.signal.addEventListener(
+        "abort",
+        () => {
+          const index = queue.findIndex((item) => item.ctx === ctx);
+          if (index !== -1) {
+            queue.splice(index, 1);
+            reject(ctx.signal.reason ?? new Error("Aborted"));
+          }
+        },
+        { once: true }
+      );
+      processQueue();
+    });
+  };
+}
+function circuitBreaker(options = {}) {
+  const { threshold = 5, resetTimeout = 3e4 } = options;
+  let state = "closed";
+  let failures = 0;
+  let lastFailure = 0;
+  return (next) => async (ctx, ...args) => {
+    const now = Date.now();
+    if (state === "open" && now - lastFailure >= resetTimeout) {
+      state = "half-open";
+    }
+    if (state === "open") {
+      throw new Error(
+        `Circuit breaker is open. Retry after ${Math.ceil(
+          (lastFailure + resetTimeout - now) / 1e3
+        )}s`
+      );
+    }
+    try {
+      const result = await next(ctx, ...args);
+      if (state === "half-open") {
+        state = "closed";
+        failures = 0;
+      } else if (failures > 0) {
+        failures--;
+      }
+      return result;
+    } catch (error) {
+      if (ctx.signal.aborted) {
+        throw error;
+      }
+      failures++;
+      lastFailure = now;
+      if (failures >= threshold) {
+        state = "open";
+      }
+      throw error;
+    }
+  };
+}
+function map(mapper) {
+  return (next) => async (ctx, ...newArgs) => {
+    return mapper((...args) => next(ctx, ...args), ...newArgs);
+  };
+}
 export {
   AsyncAggregateError,
   AsyncNotReadyError,
+  g as abortable,
   async,
-  asyncState,
-  asyncStateFrom,
-  getPendingPromise
+  cache,
+  catchError,
+  circuitBreaker,
+  createSafe,
+  debounce,
+  fallback,
+  isAbortable,
+  logging,
+  map,
+  rateLimit,
+  retry,
+  retryStrategy,
+  throttle,
+  timeout
 };