@daiso-tech/core 0.6.0 → 0.8.0

package/dist/types/utilities/async/retry/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/retry/retry";

package/dist/types/utilities/async/retry/retry.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @module Utilities
+ */
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_module";
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+import { TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Async utilities
+ */
+export type RetryPolicy = (error: unknown) => boolean;
+/**
+ * @group Async utilities
+ */
+export type RetrySettings = {
+    /**
+     * @default {4}
+     */
+    maxAttempts?: number;
+    backoffPolicy?: BackoffPolicy;
+    retryPolicy?: RetryPolicy;
+    /**
+     * @default 60_000 milliseconds
+     */
+    retryTimeout?: TimeSpan;
+    abortSignal?: AbortSignal;
+};
+/**
+ * The <i>retry</i> function will retry a async function if it throws an error until given <i>settings.maxAttempts</i>.
+ * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
+ * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
+ * @group Async utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ * @example
+ * ```ts
+ * import { retry, TimeSpan, exponentialBackoffPolicy } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   // Will throw RetryAsyncError after failing 4:th attempt
+ *   await retry(async () => {
+ *     throw new Error("My error mesasge");
+ *   }, {
+ *     // You can choose the max retry attempts
+ *     maxAttempts: 4,
+ *     // You can provide a custom backoff policy
+ *     backoffPolicy: exponentialBackoffPolicy(),
+ *     // You can choose what error to retry, this function will retry all errors thrown
+ *     retryPolicy: () => true,
+ *     // You can provide a timeout for each retry
+ *     retryTimeout: TimeSpan.fromMilliseconds(60_000),
+ *   });
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retry, TimeSpan } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   const abortController = new AbortController();
+ *   abortController.abort("My abort message");
+ *
+ *   // Will be aborted by throwing AbortAsyncError
+ *   await retry(async () => {
+ *     throw new Error("My error message");
+ *   }, {
+ *     abortSignal: abortController.signal
+ *   });
+ * })();
+ * ```
+ * @example with custom retry policy
+ * ```ts
+ * import { retry, TimeSpan } from "@daiso-tech/core";
+ *
+ * class ErrorA extends Error {};
+ * class ErrorB extends Error {};
+ *
+ * (async () => {
+ *   // Will not retry and ErrorB will be thrown
+ *   await retry(async () => {
+ *     throw new ErrorB("My error message");
+ *   }, {
+ *     retryPolicy: error => error instanceof ErrorA
+ *   });
+ * })();
+ * ```
+ */
+export declare function retry<TValue = void>(asyncFn: () => PromiseLike<TValue>, settings?: RetrySettings): LazyPromise<TValue>;

package/dist/types/utilities/async/retry-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/retry-iterable/retry-iterable";

package/dist/types/utilities/async/retry-iterable/retry-iterable.d.ts

@@ -0,0 +1,86 @@
+import type { RetrySettings } from "../../../utilities/async/retry/_module";
+/**
+ * The <i>retryIterable</i> function will retry each iteration of {@link AsyncIterable} if it throws an error until given <i>settings.maxAttempts</i>.
+ * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
+ * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
+ * @group Async utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @example
+ * ```ts
+ * import { retryIterable, TimeSpan, exponentialBackoffPolicy } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new Error("My error mesasge");
+ *   }
+ * }
+ *
+ * (async () => {
+ *   // Will throw RetryAsyncError after failing 4:th attempt
+ *   for await (const item of retryIterable(iterable, {
+ *     // You can choose the max retry attempts
+ *     maxAttempts: 4,
+ *     // You can provide a custom backoff policy
+ *     backoffPolicy: exponentialBackoffPolicy(),
+ *     // You can choose what error to retry, this function will retry all errors thrown
+ *     retryPolicy: () => true,
+ *     // You can provide a timeout for each retry
+ *     retryTimeout: TimeSpan.fromMilliseconds(60_000),
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retryIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new Error("My error mesasge");
+ *   }
+ * }
+ *
+ * (async () => {
+ *   const abortController = new AbortController();
+ *   abortController.abort("My abort message");
+ *
+ *   // Will be aborted by throwing AbortAsyncError
+ *   for await (const item of retry(iterable, {
+ *     abortSignal: abortController.signal
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retryIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * class ErrorA extends Error {};
+ * class ErrorB extends Error {};
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new ErrorB("My error mesasge");
+ *   }
+ * }
+ *
+ *
+ * (async () => {
+ *   // Will not retry and ErrorB will be thrown
+ *   for await (const item of retry(iterable, {
+ *     retryPolicy: error => error instanceof ErrorA
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ */
+export declare function retryIterable<TValue>(iterable: AsyncIterable<TValue>, settings?: RetrySettings): AsyncIterable<TValue>;

package/dist/types/utilities/async/timeout/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/timeout/timeout";

package/dist/types/utilities/async/timeout/timeout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module Utilities
+ */
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * The <i>timeout</i> function makes a <i>{@link PromiseLike}</i> object abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
+ * @group Async utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @example
+ * ```ts
+ * import { timeout, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   // Will throw an AbortAsyncError
+ *   await timeout(async () => {
+ *     await delay(TimeSpan.fromSeconds(10));
+ *   }, TimeSpan.fromSeconds(5));
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { timeout, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *   abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * (async () => {
+ *   // Will abort after 1 second by throwing AbortAsyncError
+ *   await timeout(async () => {
+ *     await delay(TimeSpan.fromSeconds(10));
+ *   }, TimeSpan.fromSeconds(5), abortController.signal);
+ * })();
+ * ```
+ */
+export declare function timeout<TValue>(asyncFn: () => PromiseLike<TValue>, time: TimeSpan, abortSignal?: AbortSignal): LazyPromise<TValue>;

package/dist/types/utilities/async/timeout-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async/timeout-iterable/timeout-iterable";

package/dist/types/utilities/async/timeout-iterable/timeout-iterable.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @module Utilities
+ */
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * The <i>timeoutIterable</i> function makes a <i>{@link AsyncIterable}</i> abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
+ * @group Async utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { timeoutIterable, delayIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = delayIterable({
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *     yield 6;
+ *     yield 7;
+ *     yield 8;
+ *   }
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * (async () => {
+ *   // Will throw an AbortAsyncError
+ *   for (const item of timeoutIterable(iterable, TimeSpan.fromSeconds(5))) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { timeoutIterable, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = delayIterable({
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *     yield 6;
+ *     yield 7;
+ *     yield 8;
+ *   }
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *  abortController.abort("My abort message");
+ * }, TimeSpan.fromSeconds(3));
+ *
+ * (async () => {
+ *   // Will abort after 3 second by throwing AbortAsyncError
+ *   for (const item of timeoutIterable(iterable, TimeSpan.fromSeconds(5), abortController.signal)) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ */
+export declare function timeoutIterable<TValue>(iterable: AsyncIterable<TValue>, time: TimeSpan, abortSignal?: AbortSignal): AsyncIterable<TValue>;

package/dist/types/utilities/backof-policies/_module.d.ts

@@ -0,0 +1,5 @@
+export { type BackoffPolicy } from "../../utilities/backof-policies/_shared";
+export * from "../../utilities/backof-policies/constant-backoff-policy/_module";
+export * from "../../utilities/backof-policies/exponential-backoff-policy/_module";
+export * from "../../utilities/backof-policies/linear-backoff-policy/_module";
+export * from "../../utilities/backof-policies/polynomial-backoff-policy/_module";

package/dist/types/utilities/backof-policies/_shared.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module Utilities
+ */
+/**
+ * @returns Amount milliseconds to wait
+ * @group Backoff policies
+ */
+export type BackoffPolicy = (attempt: number, error: unknown) => number;
+/**
+ * @internal
+ */
+export declare function withJitter(jitter: number, value: number, mathRandom: () => number): number;

package/dist/types/utilities/backof-policies/constant-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/constant-backoff-policy/constant-backoff-policy";

package/dist/types/utilities/backof-policies/constant-backoff-policy/constant-backoff-policy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module Utilities
+ */
+import { TimeSpan } from "../../../utilities/_module";
+import { type BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type ConstantBackoffPolicySettings = {
+    /**
+     * @default 1000 milliseconds
+     */
+    delay?: TimeSpan;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Constant backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function constantBackoffPolicy(settings?: ConstantBackoffPolicySettings | ((error: unknown) => ConstantBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/backof-policies/exponential-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/exponential-backoff-policy/exponential-backoff-policy";

package/dist/types/utilities/backof-policies/exponential-backoff-policy/exponential-backoff-policy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Utilities
+ */
+import { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type ExponentialBackoffPolicySettings = {
+    /**
+     * @default 60_000 milliseconds
+     */
+    maxDelay?: TimeSpan;
+    /**
+     * @default 1_000 milliseconds
+     */
+    minDelay?: TimeSpan;
+    /**
+     * @default {2}
+     */
+    multiplier?: number;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Exponential backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function exponentialBackoffPolicy(settings?: ExponentialBackoffPolicySettings | ((error: unknown) => ExponentialBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/backof-policies/linear-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/linear-backoff-policy/linear-backoff-policy";

package/dist/types/utilities/backof-policies/linear-backoff-policy/linear-backoff-policy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module Utilities
+ */
+import { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type LinearBackoffPolicySettings = {
+    /**
+     * @default 6000 milliseconds
+     */
+    maxDelay?: TimeSpan;
+    /**
+     * @default 1_000 milliseconds
+     */
+    minDelay?: TimeSpan;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Linear backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function linearBackoffPolicy(settings?: LinearBackoffPolicySettings | ((error: unknown) => LinearBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/backof-policies/polynomial-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy";

package/dist/types/utilities/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Utilities
+ */
+import { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type PolynomialBackoffPolicySettings = {
+    /**
+     * @default 60_000 milliseconds
+     */
+    maxDelay?: TimeSpan;
+    /**
+     * @default 1_000 milliseconds
+     */
+    minDelay?: TimeSpan;
+    /**
+     * @default {2}
+     */
+    degree?: number;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Polynomial backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function polynomialBackoffPolicy(settings?: PolynomialBackoffPolicySettings | ((error: unknown) => PolynomialBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/time-span/time-span.d.ts

@@ -4,6 +4,7 @@
 /**
  * The <i>TimeSpan</i> class is used for representing time interval that is the difference between two times measured in a number of days, hours, minutes, and seconds.
  * <i>TimeSpan</i> cannot be negative.
+ * @group Time utilities
  */
 export declare class TimeSpan {
     private readonly milliseconds;
@@ -42,9 +43,9 @@ export declare class TimeSpan {
     /**
      * Will return endDate relative to a given <i>startDate</i> argument.
      */
-    toEndDate(startDate: Date): Date;
+    toEndDate(startDate?: Date): Date;
     /**
      * Will return startDate relative to a given <i>endDate</i> argument.
      */
-    toStartDate(endDate: Date): Date;
+    toStartDate(endDate?: Date): Date;
 }

package/dist/types/utilities/validation/_module.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module Utilities
+ */
+import { type ZodSchema, type infer as Infer } from "zod";
+/**
+ * @group Validation
+ */
+export declare class ValidationError extends Error {
+    constructor(message: string, cause: unknown);
+}
+/**
+ * @group Validation
+ * @throws {ValidationError} {@link ValidationError}
+ */
+export type Validator<TType> = (value: unknown) => TType;
+/**
+ * @group Validation
+ * @example
+ * ```ts
+ * import { zodValidator } from "@daiso-tech/core";
+ * import { z } from "zod";
+ *
+ * const validator = zodValidator(z.string().trim());
+ *
+ * // Will throw error
+ * validator(2);
+ *
+ * const validatedValue = validator(" a ");
+ * // Will be "a"
+ * ```
+ */
+export declare function zodValidator<TSchema extends ZodSchema>(schema: TSchema): Validator<Infer<TSchema>>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.6.0",
+    "version": "0.8.0",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",
@@ -64,7 +64,8 @@
         "typedoc-plugin-merge-modules": "^6.0.0",
         "typescript": "^5.5.4",
         "vite-tsconfig-paths": "^4.3.2",
-        "vitest": "^2.0.5"
+        "vitest": "^2.0.5",
+        "zod": "^3.24.1"
     },
     "peerDependencies": {
         "@libsql/client": "^0.4.1",
@@ -84,13 +85,16 @@
         },
         "@libsql/client": {
             "optional": true
+        },
+        "zod": {
+            "optional": true
         }
     },
     "dependencies": {
-        "@libsql/kysely-libsql": "^0.4.1",
+        "@libsql/kysely-libsql": "^0.4.0",
         "escape-string-regexp": "^5.0.0",
-        "kysely": "^0.27.4",
-        "superjson": "^2.2.1",
-        "uuid": "^11.0.2"
+        "kysely": "^0.27.0",
+        "superjson": "^2.2.0",
+        "zod": "^3.24.0"
     }
 }

package/dist/cjs/async/_module.js

@@ -1,30 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unstable_retryIterable = void 0;
-__exportStar(require("../async/_shared"), exports);
-__exportStar(require("../async/abortable/_module"), exports);
-__exportStar(require("../async/abortable-iterable/_module"), exports);
-__exportStar(require("../async/backof-policies/_module"), exports);
-__exportStar(require("../async/delay/_module"), exports);
-__exportStar(require("../async/delay-iterable/_module"), exports);
-__exportStar(require("../async/lazy-promise/_module"), exports);
-__exportStar(require("../async/retry/_module"), exports);
-var _module_1 = require("../async/retry-iterable/_module");
-Object.defineProperty(exports, "unstable_retryIterable", { enumerable: true, get: function () { return _module_1.retryIterable; } });
-__exportStar(require("../async/timeout/_module"), exports);
-__exportStar(require("../async/timeout-iterable/_module"), exports);
-//# sourceMappingURL=_module.js.map

package/dist/cjs/async/_module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../src/async/_module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,4DAA0C;AAC1C,qEAAmD;AACnD,kEAAgD;AAChD,wDAAsC;AACtC,iEAA+C;AAC/C,+DAA6C;AAC7C,wDAAsC;AACtC,0DAAyF;AAAhF,iHAAA,aAAa,OAA0B;AAChD,0DAAwC;AACxC,mEAAiD"}

package/dist/cjs/async/_shared.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_shared.js","sourceRoot":"","sources":["../../../src/async/_shared.ts"],"names":[],"mappings":";;;AAOA,MAAa,UAAW,SAAQ,KAAK;IACjC,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;IAChC,CAAC;CACJ;AALD,gCAKC;AAKD,MAAa,eAAgB,SAAQ,UAAU;IAC3C,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC;IACrC,CAAC;CACJ;AALD,0CAKC;AAKD,MAAa,iBAAkB,SAAQ,UAAU;IAC7C,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC;IACvC,CAAC;CACJ;AALD,8CAKC;AAaD,MAAa,eAAgB,SAAQ,UAAU;IAC3B,WAAW,CAAS;IAEpC,YAAY,OAAe,EAAE,EAAE,KAAK,EAAE,WAAW,EAAuB;QACpE,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC;QACjC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACnC,CAAC;CACJ;AARD,0CAQC"}

package/dist/cjs/async/abortable/_module.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../../async/abortable/abortable"), exports);
-//# sourceMappingURL=_module.js.map

package/dist/cjs/async/abortable/_module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/abortable/_module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8DAA4C"}

package/dist/cjs/async/abortable/abortable.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.abortable = abortable;
-const _shared_1 = require("../../async/_shared");
-const _module_1 = require("../../async/lazy-promise/_module");
-function abortSignalToPromise(abortSignal) {
-    let reject_ = null;
-    function abort() {
-        if (reject_ === null) {
-            return;
-        }
-        reject_(new _shared_1.AbortAsyncError(`Promise was aborted with reason of "${String(abortSignal.reason)}"`, abortSignal.reason));
-    }
-    if (abortSignal.aborted) {
-        return {
-            promise: Promise.reject(new _shared_1.AbortAsyncError(`Promise was aborted with reason of "${String(abortSignal.aborted)}"`, abortSignal.reason)),
-            abort,
-        };
-    }
-    return {
-        promise: new Promise((_resolve, reject) => {
-            reject_ = reject;
-            if (abortSignal.aborted) {
-                abort();
-                return;
-            }
-            abortSignal.addEventListener("abort", abort, {
-                once: true,
-            });
-        }),
-        abort,
-    };
-}
-function abortable(asyncFn, abortSignal) {
-    return new _module_1.LazyPromise(async () => {
-        if (abortSignal.aborted) {
-            throw new _shared_1.AbortAsyncError(`Promise was aborted with reason of "${String(abortSignal.reason)}"`, abortSignal.reason);
-        }
-        const { promise: abortSignalPromise, abort } = abortSignalToPromise(abortSignal);
-        try {
-            return await Promise.race([asyncFn(), abortSignalPromise]);
-        }
-        finally {
-            abortSignal.removeEventListener("abort", abort);
-        }
-    });
-}
-//# sourceMappingURL=abortable.js.map