@effuse/store 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -833,99 +833,6 @@ var withRetry = (fn, config) => {
     return effect.Effect.runPromise(effect$1);
   };
 };
-var takeLatest = (fn) => {
-  let pending = false;
-  let currentToken = createCancellationToken();
-  let callId = 0;
-  const action = async (...args) => {
-    currentToken.cancel();
-    currentToken = createCancellationToken();
-    const myToken = currentToken;
-    const myCallId = ++callId;
-    pending = true;
-    try {
-      const result = await fn(...args);
-      if (myToken.isCancelled || myCallId !== callId) {
-        throw new CancellationError({ message: "Superseded by newer call" });
-      }
-      return result;
-    } finally {
-      if (myCallId === callId) {
-        pending = false;
-      }
-    }
-  };
-  Object.defineProperty(action, "pending", {
-    get: () => pending,
-    enumerable: true
-  });
-  Object.defineProperty(action, "cancel", {
-    value: () => {
-      currentToken.cancel();
-      pending = false;
-    },
-    enumerable: true
-  });
-  return action;
-};
-var takeFirst = (fn) => {
-  let pending = false;
-  const action = async (...args) => {
-    if (pending) {
-      return void 0;
-    }
-    pending = true;
-    try {
-      return await fn(...args);
-    } finally {
-      pending = false;
-    }
-  };
-  Object.defineProperty(action, "pending", {
-    get: () => pending,
-    enumerable: true
-  });
-  return action;
-};
-var debounceAction = (fn, delayMs) => {
-  let timeout = null;
-  let currentToken = createCancellationToken();
-  return (...args) => {
-    if (timeout) {
-      clearTimeout(timeout);
-      currentToken.cancel();
-    }
-    currentToken = createCancellationToken();
-    const myToken = currentToken;
-    return new Promise((resolve, reject) => {
-      timeout = setTimeout(() => {
-        if (myToken.isCancelled) return;
-        Promise.resolve(fn(...args)).then((result) => {
-          if (!myToken.isCancelled) resolve(result);
-        }).catch((error) => {
-          if (!myToken.isCancelled) reject(error);
-        });
-      }, delayMs);
-    });
-  };
-};
-var throttleAction = (fn, intervalMs) => {
-  let lastCallTime = 0;
-  let pending = false;
-  return async (...args) => {
-    const now = Date.now();
-    if (now - lastCallTime < intervalMs || pending) {
-      return void 0;
-    }
-    lastCallTime = now;
-    pending = true;
-    try {
-      return await fn(...args);
-    } finally {
-      pending = false;
-    }
-  };
-};
 var dispatch = (store, actionName, ...args) => {
   const storeRecord = store;
   const action = storeRecord[actionName];
@@ -960,6 +867,86 @@ var withAbortSignal = (fn) => {
     return effect.Effect.runPromise(runWithAbortSignal(effect$1, signal6));
   };
 };
+function useConcurrency(action, options = {}) {
+  const { strategy = "switch", debounceMs, throttleMs } = options;
+  let runningFiber = null;
+  let debounceTimeout = null;
+  let lastCallTime = 0;
+  const queue = strategy === "concat" ? effect.Effect.runSync(effect.Queue.unbounded()) : null;
+  if (queue) {
+    effect.Effect.runFork(
+      effect.Effect.forever(
+        effect.Effect.gen(function* () {
+          const args = yield* effect.Queue.take(queue);
+          yield* effect.Effect.catchAll(action(...args), () => effect.Effect.void);
+        })
+      )
+    );
+  }
+  const execute = (...args) => {
+    switch (strategy) {
+      case "switch":
+        if (runningFiber) {
+          effect.Effect.runFork(effect.Fiber.interrupt(runningFiber));
+        }
+        runningFiber = effect.Effect.runFork(
+          effect.Effect.match(action(...args), {
+            onFailure: () => {
+              runningFiber = null;
+            },
+            onSuccess: () => {
+              runningFiber = null;
+            }
+          })
+        );
+        break;
+      case "exhaust":
+        if (runningFiber) {
+          return;
+        }
+        runningFiber = effect.Effect.runFork(
+          effect.Effect.match(action(...args), {
+            onFailure: () => {
+              runningFiber = null;
+            },
+            onSuccess: () => {
+              runningFiber = null;
+            }
+          })
+        );
+        break;
+      case "merge":
+        effect.Effect.runFork(
+          effect.Effect.catchAll(action(...args), () => effect.Effect.void)
+        );
+        break;
+      case "concat":
+        if (queue) {
+          effect.Effect.runFork(effect.Queue.offer(queue, args));
+        }
+        break;
+    }
+  };
+  return (...args) => {
+    const now = Date.now();
+    if (throttleMs !== void 0 && throttleMs > 0) {
+      if (now - lastCallTime < throttleMs) {
+        return;
+      }
+      lastCallTime = now;
+    }
+    if (debounceMs !== void 0 && debounceMs > 0) {
+      if (debounceTimeout) {
+        clearTimeout(debounceTimeout);
+      }
+      debounceTimeout = setTimeout(() => {
+        execute(...args);
+      }, debounceMs);
+      return;
+    }
+    execute(...args);
+  };
+}
 var validateState = (schema, state) => {
   const result = effect.Effect.runSync(
     effect.Schema.decodeUnknown(schema)(state).pipe(
@@ -1198,7 +1185,7 @@ var hydrateStores = (serialized) => effect.Effect.try({
       );
     }
   },
-  catch: () => new HydrationError({})
+  catch: () => new HydrationError()
 }).pipe(effect.Effect.catchAll(() => effect.Effect.void));
 var hydrateStoresSync = (serialized) => {
   effect.Effect.runSync(
@@ -1507,7 +1494,6 @@ exports.createSelectorAsync = createSelectorAsync;
 exports.createStore = createStore;
 exports.createStoreStream = createStoreStream;
 exports.createValidatedSetter = createValidatedSetter;
-exports.debounceAction = debounceAction;
 exports.defineSlice = defineSlice;
 exports.deriveFrom = deriveFrom;
 exports.deriveFromAsync = deriveFromAsync;
@@ -1538,9 +1524,7 @@ exports.runInScope = runInScope;
 exports.serializeStores = serializeStores;
 exports.shallowEqual = shallowEqual;
 exports.streamAll = streamAll;
-exports.takeFirst = takeFirst;
-exports.takeLatest = takeLatest;
-exports.throttleAction = throttleAction;
+exports.useConcurrency = useConcurrency;
 exports.validateState = validateState;
 exports.validateStateAsync = validateStateAsync;
 exports.withAbortSignal = withAbortSignal;