@actuallab/core 13.0.4 → 13.0.14

package/dist/index.cjs

@@ -29,21 +29,34 @@ __export(index_exports, {
   LogLevel: () => LogLevel,
   LogLevelController: () => LogLevelController,
   PromiseSource: () => PromiseSource,
+  PromiseSourceWithTimeout: () => PromiseSourceWithTimeout,
+  ResolvedPromise: () => ResolvedPromise,
   Result: () => Result,
   RetryDelayLimitExceeded: () => RetryDelayLimitExceeded,
   RetryDelayNone: () => RetryDelayNone,
   RetryDelaySeq: () => RetryDelaySeq,
   RetryDelayer: () => RetryDelayer,
   RingBuffer: () => RingBuffer,
+  TimedOut: () => TimedOut,
+  TimeoutError: () => TimeoutError,
+  abortPromise: () => abortPromise,
   abortSignalKey: () => abortSignalKey,
+  catchErrors: () => catchErrors,
   createLogProvider: () => createLogProvider,
+  debounce: () => debounce,
+  delayAsync: () => delayAsync,
+  delayAsyncWith: () => delayAsyncWith,
   errorResult: () => errorResult,
   initLogging: () => initLogging,
   initWorkerLogging: () => initWorkerLogging,
   resolvedVoidPromise: () => resolvedVoidPromise,
   result: () => result,
   resultFrom: () => resultFrom,
-  resultFromAsync: () => resultFromAsync
+  resultFromAsync: () => resultFromAsync,
+  retry: () => retry,
+  serialize: () => serialize,
+  throttle: () => throttle,
+  withTimeout: () => withTimeout
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -642,6 +655,7 @@ var AsyncLock = class {
 // src/promise-source.ts
 var PromiseSource = class {
   promise;
+  [Symbol.toStringTag] = "Promise";
   _resolve;
   _reject;
   _isCompleted = false;
@@ -666,6 +680,15 @@ var PromiseSource = class {
     this._reject(reason);
     return true;
   }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.promise.finally(onfinally);
+  }
 };
 var resolvedVoidPromise = Promise.resolve();
 
@@ -694,10 +717,235 @@ var EventHandlerSet = class {
       ps.resolve(arg);
     };
     this._handlers.add(handler);
-    return ps.promise;
+    return ps;
+  }
+};
+
+// src/withTimeout.ts
+var TimeoutError = class extends Error {
+  name = "TimeoutError";
+  constructor(message = "Operation timed out") {
+    super(message);
+  }
+};
+async function withTimeout(promise, ms, message) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new TimeoutError(message ?? `Operation timed out after ${ms}ms`)),
+      ms
+    );
+  });
+  timeoutPromise.catch(() => {
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+
+// src/promise-source-with-timeout.ts
+var PromiseSourceWithTimeout = class extends PromiseSource {
+  _timer;
+  hasTimeout() {
+    return this._timer !== void 0;
+  }
+  /**
+   * Install (or replace) a timeout. Pass `null` to remove without setting a
+   * new one. `callback` is invoked when the timer fires — if omitted, the
+   * promise is rejected with a generic "timed out" error.
+   */
+  setTimeout(ms, callback) {
+    this.clearTimeout();
+    if (ms === null || this.isCompleted) return;
+    this._timer = setTimeout(() => {
+      this._timer = void 0;
+      if (callback) callback();
+      else this.reject(new TimeoutError(`The promise has timed out after ${ms}ms.`));
+    }, ms);
+  }
+  clearTimeout() {
+    if (this._timer === void 0) return;
+    clearTimeout(this._timer);
+    this._timer = void 0;
+  }
+  resolve(value) {
+    const didSettle = super.resolve(value);
+    if (didSettle) this.clearTimeout();
+    return didSettle;
+  }
+  reject(reason) {
+    const didSettle = super.reject(reason);
+    if (didSettle) this.clearTimeout();
+    return didSettle;
   }
 };
 
+// src/resolved-promise.ts
+var ResolvedPromise = {
+  Void: Promise.resolve(),
+  True: Promise.resolve(true),
+  False: Promise.resolve(false)
+};
+
+// src/timed-out.ts
+var TimedOut = class _TimedOut {
+  static instance = new _TimedOut();
+};
+
+// src/delay.ts
+function delayAsync(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function delayAsyncWith(ms, value) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(value), ms);
+  });
+}
+
+// src/abort-promise.ts
+var abortPromiseCache = /* @__PURE__ */ new WeakMap();
+function abortPromise(signal) {
+  if (signal.aborted) return Promise.reject(signal.reason);
+  let cached = abortPromiseCache.get(signal);
+  if (!cached) {
+    cached = new Promise((_, reject) => {
+      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+    });
+    cached.catch(() => {
+    });
+    abortPromiseCache.set(signal, cached);
+  }
+  return cached;
+}
+
+// src/internal-logging.ts
+var scopeDefaults = {
+  retry: 3 /* Warn */,
+  throttle: 3 /* Warn */
+};
+var getLogs = createLogProvider("core.", scopeDefaults);
+
+// src/throttle.ts
+var { errorLog } = getLogs("throttle");
+var Call = class {
+  constructor(func, self, parameters) {
+    this.func = func;
+    this.self = self;
+    this.parameters = parameters;
+  }
+  invoke() {
+    return this.func.apply(this.self, this.parameters);
+  }
+  invokeSilently() {
+    try {
+      return this.invoke();
+    } catch (error) {
+      errorLog?.log("Call.invokeSilently: unhandled error:", error);
+    }
+  }
+};
+function throttle(func, intervalMs, mode = "default") {
+  let lastCall = null;
+  let nextFireTime = 0;
+  let timeoutHandle = null;
+  const reset2 = () => {
+    if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+    timeoutHandle = null;
+    lastCall = null;
+    nextFireTime = 0;
+  };
+  const fire = () => {
+    if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+    if (lastCall !== null) {
+      const call = lastCall;
+      lastCall = null;
+      nextFireTime = Date.now() + intervalMs;
+      timeoutHandle = setTimeout(fire, intervalMs);
+      call.invokeSilently();
+    } else {
+      timeoutHandle = null;
+      nextFireTime = 0;
+    }
+  };
+  const wrapped = function(...args) {
+    const call = new Call(func, this, args);
+    const fireDelay = nextFireTime - Date.now();
+    if (timeoutHandle !== null && fireDelay <= 0) {
+      fire();
+    }
+    if (timeoutHandle === null) {
+      nextFireTime = Date.now() + intervalMs;
+      timeoutHandle = setTimeout(fire, intervalMs);
+      if (mode === "delayHead") {
+        lastCall = call;
+      } else {
+        call.invokeSilently();
+      }
+    } else if (mode !== "skip") {
+      lastCall = call;
+    }
+  };
+  wrapped.reset = reset2;
+  return wrapped;
+}
+function debounce(func, intervalMs) {
+  let lastCall = null;
+  let nextFireTime = 0;
+  let timeoutHandle = null;
+  const reset2 = () => {
+    timeoutHandle = null;
+    lastCall = null;
+    nextFireTime = 0;
+  };
+  const fire = () => {
+    if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+    timeoutHandle = null;
+    const fireDelay = nextFireTime - Date.now();
+    if (fireDelay <= 0) {
+      nextFireTime = 0;
+      if (lastCall !== null) {
+        const call = lastCall;
+        lastCall = null;
+        call.invokeSilently();
+      }
+    } else {
+      timeoutHandle = setTimeout(fire, fireDelay);
+    }
+  };
+  const wrapped = function(...args) {
+    lastCall = new Call(func, this, args);
+    nextFireTime = Date.now() + intervalMs;
+    timeoutHandle ??= setTimeout(fire, intervalMs);
+  };
+  wrapped.reset = reset2;
+  return wrapped;
+}
+
+// src/serialize.ts
+function serialize(func, limit = null) {
+  let lastCall = Promise.resolve(null);
+  let queueSize = 0;
+  return function(...args) {
+    if (limit !== null && queueSize >= limit) return lastCall;
+    queueSize++;
+    const prevCall = lastCall;
+    const invoke = () => func.apply(this, args);
+    return lastCall = (async () => {
+      try {
+        await prevCall.catch(() => {
+        });
+        return await invoke();
+      } finally {
+        queueSize--;
+      }
+    })();
+  };
+}
+
 // src/ring-buffer.ts
 var RingBuffer = class {
   _buffer;
@@ -888,6 +1136,34 @@ var RetryDelayer = class {
     this.cancelDelaysChanged.trigger();
   }
 };
+
+// src/retry.ts
+var { warnLog } = getLogs("retry");
+var defaultRetryDelays = () => 50;
+async function retry(tryCount, fn, retryDelays = defaultRetryDelays) {
+  if (tryCount <= 0)
+    throw new Error("retry: tryCount must be positive.");
+  let lastError;
+  for (let tryIndex = 0; ; ) {
+    if (tryIndex >= tryCount) throw lastError;
+    try {
+      return await fn(tryIndex, lastError);
+    } catch (e) {
+      lastError = e;
+    }
+    ++tryIndex;
+    if (tryIndex >= tryCount) throw lastError;
+    warnLog?.log(`retry(${tryIndex}/${tryCount}): error:`, lastError);
+    await delayAsync(retryDelays(tryIndex));
+  }
+}
+async function catchErrors(fn, onError) {
+  try {
+    return await fn();
+  } catch (e) {
+    return onError ? onError(e) : void 0;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AsyncContext,
@@ -899,20 +1175,33 @@ var RetryDelayer = class {
   LogLevel,
   LogLevelController,
   PromiseSource,
+  PromiseSourceWithTimeout,
+  ResolvedPromise,
   Result,
   RetryDelayLimitExceeded,
   RetryDelayNone,
   RetryDelaySeq,
   RetryDelayer,
   RingBuffer,
+  TimedOut,
+  TimeoutError,
+  abortPromise,
   abortSignalKey,
+  catchErrors,
   createLogProvider,
+  debounce,
+  delayAsync,
+  delayAsyncWith,
   errorResult,
   initLogging,
   initWorkerLogging,
   resolvedVoidPromise,
   result,
   resultFrom,
-  resultFromAsync
+  resultFromAsync,
+  retry,
+  serialize,
+  throttle,
+  withTimeout
 });
 //# sourceMappingURL=index.cjs.map