superlib 1.0.21 → 1.2.0

package/dist/random/SeededRandom.js

@@ -0,0 +1,15 @@
+import { AbstractRandom } from "./Random.js";
+export class SeededRandom extends AbstractRandom {
+    m = 2 ** 31;
+    a = 1103515245;
+    c = 12345;
+    state;
+    constructor(seed = 4202137) {
+        super();
+        this.state = seed >>> 0; // force to uint32
+    }
+    next() {
+        this.state = (this.a * this.state + this.c) % this.m;
+        return this.state / this.m;
+    }
+}

package/dist/random/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Random";
+export { RealRandom } from "./RealRandom";
+export { SeededRandom } from "./SeededRandom";
+export { FixedRandom } from "./FixedRandom";
+//# sourceMappingURL=index.d.ts.map

package/dist/random/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/random/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/random/index.js

@@ -0,0 +1,4 @@
+export * from "./Random.js";
+export { RealRandom } from "./RealRandom.js";
+export { SeededRandom } from "./SeededRandom.js";
+export { FixedRandom } from "./FixedRandom.js";

package/dist/schema/StandardSchema.d.ts

@@ -0,0 +1,60 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//# sourceMappingURL=StandardSchema.d.ts.map

package/dist/schema/StandardSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardSchema.d.ts","sourceRoot":"","sources":["../../src/schema/StandardSchema.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CAC5D;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,gDAAgD;IAChD,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,0CAA0C;QAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;QACnB,6CAA6C;QAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,sCAAsC;QACtC,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,KAC/B,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;QAC7C,iDAAiD;QACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;KAClD;IAED,qDAAqD;IACrD,KAAY,MAAM,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAA;IAElE,mDAAmD;IACnD,UAAiB,aAAa,CAAC,MAAM;QACnC,8BAA8B;QAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;QACtB,oDAAoD;QACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAC5B;IAED,UAAiB,OAAO;QACtB,6EAA6E;QAC7E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;KAC9D;IAED,gDAAgD;IAChD,UAAiB,aAAa;QAC5B,uCAAuC;QACvC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;KACtC;IAED,iDAAiD;IACjD,UAAiB,KAAK;QACpB,sCAAsC;QACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;QACxB,qCAAqC;QACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAA;KACrE;IAED,+CAA+C;IAC/C,UAAiB,WAAW;QAC1B,2CAA2C;QAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;KAC1B;IAED,2CAA2C;IAC3C,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,oCAAoC;QACpC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;QACrB,qCAAqC;QACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KACxB;IAED,kDAAkD;IAClD,KAAY,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACnE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAA;IAEV,mDAAmD;IACnD,KAAY,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACpE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAA;CACZ"}

package/dist/schema/StandardSchema.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/validateSchema.d.ts

@@ -0,0 +1,9 @@
+import type { StandardSchemaV1 } from "./StandardSchema";
+import { type Result } from "../basic";
+export type ValidationError = {
+    type: "schema/validate";
+    issue: ReadonlyArray<StandardSchemaV1.Issue>;
+};
+export type ValidateSchemaResult<T> = Result<T, ValidationError>;
+export declare function validateSchema<T>(schema: StandardSchemaV1<T>, value: unknown): ValidateSchemaResult<T>;
+//# sourceMappingURL=validateSchema.d.ts.map

package/dist/schema/validateSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSchema.d.ts","sourceRoot":"","sources":["../../src/schema/validateSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,OAAO,EAAmB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAA;AAEvD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,iBAAiB,CAAA;IACvB,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAA;CAC7C,CAAA;AACD,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,eAAe,CAAC,CAAA;AAEhE,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,KAAK,EAAE,OAAO,GACb,oBAAoB,CAAC,CAAC,CAAC,CAUzB"}

package/dist/schema/validateSchema.js

@@ -0,0 +1,9 @@
+import { assert, Err, Ok } from "../basic/index.js";
+export function validateSchema(schema, value) {
+    const result = schema["~standard"].validate(value);
+    assert(!(result instanceof Promise), "Only sync validation supported at the moment");
+    if (result.issues) {
+        return Err({ type: "schema/validate", issue: result.issues });
+    }
+    return Ok(result.value);
+}

package/dist/task/all.d.ts

@@ -0,0 +1,14 @@
+import type { Task } from "./types";
+export type AllOptions = {
+    concurrency: number | `batches-of-${number}` | "unbounded";
+};
+export declare function all<T extends unknown[]>(tasks: {
+    [K in keyof T]: Task<T[K]>;
+}, options: AllOptions): Promise<{
+    [K in keyof T]: Awaited<T[K]>;
+}>;
+export declare function all<K extends PropertyKey, R extends Record<K, Task<unknown>>>(tasks: R, options: AllOptions): Promise<{
+    [P in keyof R]: Awaited<ReturnType<R[P]>>;
+}>;
+export declare function allWithArray<T>(tasks: ReadonlyArray<Task<T>>, options: AllOptions): Promise<T[]>;
+//# sourceMappingURL=all.d.ts.map

package/dist/task/all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../src/task/all.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAInC,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,GAAG,cAAc,MAAM,EAAE,GAAG,WAAW,CAAA;CAC3D,CAAA;AAED,wBAAsB,GAAG,CAAC,CAAC,SAAS,OAAO,EAAE,EAC3C,KAAK,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,EACrC,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAA;AAE7C,wBAAsB,GAAG,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EACjF,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAA;AA4BzD,wBAAsB,YAAY,CAAC,CAAC,EAClC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAC7B,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,CAAC,EAAE,CAAC,CAsDd"}

package/dist/task/all.js

@@ -0,0 +1,61 @@
+import { chunk, zip } from "remeda";
+import { assert } from "../basic/index.js";
+export async function all(taskArrayOrObject, options) {
+    if (Array.isArray(taskArrayOrObject)) {
+        return allWithArray(taskArrayOrObject, options);
+    }
+    const entries = Object.entries(taskArrayOrObject);
+    const keys = entries.map((e) => e[0]);
+    const values = entries.map((e) => e[1]);
+    const result = await allWithArray(values, options);
+    const resultObject = Object.fromEntries(zip(keys, result));
+    return resultObject;
+}
+function assertPositiveIntegerConcurrency(value) {
+    assert(value > 0 && Number.isFinite(value) && Number.isInteger(value), `options.concurrency must be a positive integer (got ${value})`);
+}
+export async function allWithArray(tasks, options) {
+    if (options.concurrency === "unbounded" || options.concurrency === Number.POSITIVE_INFINITY) {
+        return Promise.all(tasks.map((t) => t()));
+    }
+    if (typeof options.concurrency === "string" && options.concurrency.startsWith("batches-of-")) {
+        const batchSizeRaw = Number(options.concurrency.slice("batches-of-".length));
+        assertPositiveIntegerConcurrency(batchSizeRaw);
+        const batchSize = batchSizeRaw;
+        const chunks = chunk(tasks, batchSize);
+        let result = [];
+        for (const c of chunks) {
+            result = result.concat(await allWithArray(c, { concurrency: "unbounded" }));
+        }
+        return result;
+    }
+    const concurrency = options.concurrency;
+    assertPositiveIntegerConcurrency(concurrency);
+    if (tasks.length === 0) {
+        return [];
+    }
+    const results = Array.from({ length: tasks.length });
+    let nextIndex = 0;
+    let cancelled = false; // prevent extra scheduling after a failure
+    async function worker() {
+        while (true) {
+            if (cancelled) {
+                return;
+            }
+            const i = nextIndex++;
+            if (i >= tasks.length) {
+                return;
+            }
+            try {
+                results[i] = await tasks[i]();
+            }
+            catch (err) {
+                cancelled = true;
+                throw err;
+            }
+        }
+    }
+    const workerCount = Math.min(concurrency, tasks.length);
+    await Promise.all(Array.from({ length: workerCount }, worker));
+    return results;
+}

package/dist/task/index.d.ts

@@ -0,0 +1,15 @@
+import { all } from "./all";
+import { pipe } from "./pipe";
+import { retry } from "./retry";
+import { timeout } from "./timeout";
+import { type Task as TaskTypeReexport } from "./types";
+export declare const Task: {
+    all: typeof all;
+    pipe: typeof pipe;
+    retry: typeof retry;
+    timeout: typeof timeout;
+};
+export declare namespace Task {
+    type Task<T> = TaskTypeReexport<T>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/task/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,KAAK,IAAI,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAEvD,eAAO,MAAM,IAAI;;;;;CAKhB,CAAA;AAED,yBAAiB,IAAI,CAAC;IACpB,KAAY,IAAI,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAA;CAC1C"}

package/dist/task/index.js

@@ -0,0 +1,11 @@
+import { all } from "./all.js";
+import { pipe } from "./pipe.js";
+import { retry } from "./retry.js";
+import { timeout } from "./timeout.js";
+import {} from "./types.js";
+export const Task = {
+    all,
+    pipe,
+    retry,
+    timeout,
+};

package/dist/task/pipe.d.ts

@@ -0,0 +1,8 @@
+import type { Task, TaskMapper } from "./types";
+export declare function pipe<A>(task: Task<A>): Promise<A>;
+export declare function pipe<A, B>(task: Task<A>, m1: TaskMapper<A, B> | undefined): Promise<B>;
+export declare function pipe<A, B, C>(task: Task<A>, m1: TaskMapper<A, B> | undefined, m2: TaskMapper<B, C> | undefined): Promise<C>;
+export declare function pipe<A, B, C, D>(task: Task<A>, m1: TaskMapper<A, B> | undefined, m2: TaskMapper<B, C> | undefined, m3: TaskMapper<C, D> | undefined): Promise<D>;
+export declare function pipe<A, B, C, D, E>(task: Task<A>, m1: TaskMapper<A, B> | undefined, m2: TaskMapper<B, C> | undefined, m3: TaskMapper<C, D> | undefined, m4: TaskMapper<D, E> | undefined): Promise<E>;
+export declare function pipe<A, B, C, D, E, F>(task: Task<A>, m1: TaskMapper<A, B> | undefined, m2: TaskMapper<B, C> | undefined, m3: TaskMapper<C, D> | undefined, m4: TaskMapper<D, E> | undefined, m5: TaskMapper<E, F> | undefined): Promise<F>;
+//# sourceMappingURL=pipe.d.ts.map

package/dist/task/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../src/task/pipe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE/C,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAClD,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AACvF,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,GAC/B,OAAO,CAAC,CAAC,CAAC,CAAA;AACb,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,GAC/B,OAAO,CAAC,CAAC,CAAC,CAAA;AACb,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,GAC/B,OAAO,CAAC,CAAC,CAAC,CAAA;AACb,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,GAC/B,OAAO,CAAC,CAAC,CAAC,CAAA"}

package/dist/task/pipe.js

@@ -0,0 +1,11 @@
+export function pipe(task, ...steps) {
+    let acc = task;
+    for (const map of steps) {
+        // @note: mappers can be undefined which makes applying mappers conditionally easy
+        if (!map) {
+            continue;
+        }
+        acc = map(acc);
+    }
+    return acc();
+}

package/dist/task/retry.d.ts

@@ -0,0 +1,27 @@
+import type { Task, TaskMapper } from "./types";
+import { ErrResult, Result } from "../basic";
+import { type IRandom } from "../random";
+import { type DurationLike } from "../time";
+export type ErrResultOrError<T> = T extends Result<any, infer E> ? ErrResult<unknown, E> : unknown;
+export interface RetryOptions<R> {
+    until?: (error: ErrResultOrError<R>) => boolean;
+    times: number;
+    delay: DurationLike | RetryDelayPolicy;
+}
+export type RetryDelayPolicy = (attempt: number) => DurationLike;
+export interface RetryDependencies {
+    random: IRandom;
+}
+export declare function retry<T>(task: Task<T>, options: RetryOptions<T>, dependencies?: RetryDependencies): Promise<T>;
+export declare function retry<T>(options: RetryOptions<T>, dependencies?: RetryDependencies): TaskMapper<T, T>;
+export declare function ExponentialBackoffRetryPolicy(base: DurationLike): RetryDelayPolicy;
+interface JitteredRetryOptions {
+    minFactor?: number;
+    maxFactor?: number;
+}
+interface JitteredRetryDependencies {
+    random: IRandom;
+}
+export declare function JitteredRetryPolicy(base: DurationLike | RetryDelayPolicy, options?: JitteredRetryOptions, dependencies?: JitteredRetryDependencies): RetryDelayPolicy;
+export {};
+//# sourceMappingURL=retry.d.ts.map

package/dist/task/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/task/retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAU,SAAS,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACpD,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,WAAW,CAAA;AACpD,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AAEpE,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,OAAO,CAAA;AAElG,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAA;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,YAAY,GAAG,gBAAgB,CAAA;CACvC;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,YAAY,CAAA;AAEhE,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,wBAAgB,KAAK,CAAC,CAAC,EACrB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EACxB,YAAY,CAAC,EAAE,iBAAiB,GAC/B,OAAO,CAAC,CAAC,CAAC,CAAA;AACb,wBAAgB,KAAK,CAAC,CAAC,EACrB,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EACxB,YAAY,CAAC,EAAE,iBAAiB,GAC/B,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAqDnB,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,CAKlF;AAED,UAAU,oBAAoB;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,UAAU,yBAAyB;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,GAAG,gBAAgB,EACrC,OAAO,CAAC,EAAE,oBAAoB,EAC9B,YAAY,CAAC,EAAE,yBAAyB,GACvC,gBAAgB,CAgBlB"}

package/dist/task/retry.js

@@ -0,0 +1,61 @@
+import { assert, ErrResult, Result } from "../basic/index.js";
+import { RealRandom } from "../random/index.js";
+import { multiplyDuration, sleep } from "../time/index.js";
+export function retry(taskOrOptions, optionsOrDependencies, dependencies) {
+    if (typeof taskOrOptions === "function") {
+        return runRetry(taskOrOptions, optionsOrDependencies, dependencies);
+    }
+    return (task) => () => runRetry(task, taskOrOptions, optionsOrDependencies);
+}
+async function runRetry(task, options, dependencies) {
+    const until = options.until ?? (() => true);
+    const delay = options.delay instanceof Function
+        ? options.delay
+        : JitteredRetryPolicy(ExponentialBackoffRetryPolicy(options.delay), {}, dependencies);
+    let attempt = 0;
+    while (true) {
+        let thrownError = undefined;
+        let resultError = undefined;
+        try {
+            const result = await task();
+            if (!(result instanceof Result) || result.isOk()) {
+                return result;
+            }
+            resultError = result;
+        }
+        catch (error) {
+            thrownError = error;
+        }
+        assert(!!(thrownError || resultError));
+        if (attempt < options.times && until(thrownError || resultError)) {
+            const sleepDuration = delay(attempt++);
+            await sleep(sleepDuration);
+        }
+        else {
+            if (thrownError) {
+                throw thrownError;
+            }
+            else {
+                return resultError;
+            }
+        }
+    }
+}
+export function ExponentialBackoffRetryPolicy(base) {
+    const baseDuration = Temporal.Duration.from(base);
+    return (attempt) => {
+        return multiplyDuration(baseDuration, 2 ** attempt);
+    };
+}
+export function JitteredRetryPolicy(base, options, dependencies) {
+    const random = dependencies?.random ?? new RealRandom();
+    const minFactor = options?.minFactor ?? 0;
+    const maxFactor = options?.maxFactor ?? 1;
+    assert(minFactor >= 0 && maxFactor > minFactor, `invalid jitter range: min=${minFactor} max=${maxFactor}`);
+    const basePolicy = base instanceof Function ? base : () => base;
+    return (attempt) => {
+        const baseDuration = Temporal.Duration.from(basePolicy(attempt));
+        const factor = random.nextNumber(minFactor, maxFactor);
+        return multiplyDuration(baseDuration, factor);
+    };
+}

package/dist/task/timeout.d.ts

@@ -0,0 +1,21 @@
+import type { Task, TaskMapper } from "./types";
+import { BaseError, Result } from "../basic";
+import { type DurationLike } from "../time";
+export interface TimeoutOptions {
+    timeout: DurationLike;
+    useResult?: boolean;
+}
+export type TimeoutErr = {
+    type: "timeout";
+    timeout: Temporal.Duration;
+};
+type TimeoutAsResult<Return, Options> = Options extends {
+    useResult: true;
+} ? Return extends Result<infer V, infer E> ? Result<V, E | TimeoutErr> : never : Return;
+export declare function timeout<T, O extends TimeoutOptions>(task: Task<T>, options: O): Promise<TimeoutAsResult<T, O>>;
+export declare function timeout<T, O extends TimeoutOptions>(options: O): TaskMapper<T, TimeoutAsResult<T, O>>;
+export declare class TimeoutError extends BaseError {
+    constructor(duration: Temporal.Duration);
+}
+export {};
+//# sourceMappingURL=timeout.d.ts.map

package/dist/task/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/task/timeout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,SAAS,EAAkB,MAAM,EAAE,MAAM,UAAU,CAAA;AAC5D,OAAO,EAAqC,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AAI9E,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,YAAY,CAAA;IACrB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAA;CAAE,CAAA;AAExE,KAAK,eAAe,CAAC,MAAM,EAAE,OAAO,IAAI,OAAO,SAAS;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,GACvE,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GACrC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,GACzB,KAAK,GACP,MAAM,CAAA;AAGV,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc,EACjD,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AACjC,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc,EACjD,OAAO,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AA4CvC,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,QAAQ,EAAE,QAAQ,CAAC,QAAQ;CAGxC"}

package/dist/task/timeout.js

@@ -0,0 +1,39 @@
+import { BaseError, Err, ErrResult, Result } from "../basic/index.js";
+import { durationToMs, prettyPrintDuration } from "../time/index.js";
+const { setTimeout, clearTimeout: cancelTimeout } = globalThis;
+export function timeout(taskOrOptions, options) {
+    if (typeof taskOrOptions === "function") {
+        return runTimeout(taskOrOptions, options);
+    }
+    return (task) => () => runTimeout(task, taskOrOptions);
+}
+async function runTimeout(task, options) {
+    const useResult = !!options.useResult;
+    const timeoutDuration = Temporal.Duration.from(options.timeout);
+    const timeoutMs = durationToMs(timeoutDuration);
+    // note: we can't use sleep here because we want to ensure timeoutPromise cancellation
+    let timeoutId = undefined;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new TimeoutError(timeoutDuration));
+        }, timeoutMs);
+    });
+    try {
+        return (await Promise.race([task(), timeoutPromise]).catch((e) => {
+            if (useResult) {
+                return Err({ type: "timeout", timeout: timeoutDuration });
+            }
+            throw e;
+        }));
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            cancelTimeout(timeoutId);
+        }
+    }
+}
+export class TimeoutError extends BaseError {
+    constructor(duration) {
+        super(`Task has timeout after ${prettyPrintDuration(duration)}`);
+    }
+}

package/dist/task/types.d.ts

@@ -0,0 +1,3 @@
+export type Task<T> = () => Promise<T>;
+export type TaskMapper<I, O> = (i: Task<I>) => Task<O>;
+//# sourceMappingURL=types.d.ts.map

package/dist/task/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/task/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;AAEtC,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAA"}

package/dist/task/types.js

@@ -0,0 +1 @@
+export {};

package/dist/time/Clock.d.ts

@@ -0,0 +1,18 @@
+import type { PublicInterface } from "../types";
+import type { DurationLike } from "./index";
+export type IClock = PublicInterface<AbstractClock>;
+export declare abstract class AbstractClock implements IClock {
+    abstract now(): Temporal.Instant;
+    nowDate(): Date;
+}
+export declare class Clock extends AbstractClock {
+    now(): Temporal.Instant;
+}
+export declare class TestClock extends AbstractClock {
+    private _now;
+    constructor(_now: Temporal.Instant);
+    now(): Temporal.Instant;
+    advance(duration: DurationLike): void;
+    reset(now: Temporal.Instant): void;
+}
+//# sourceMappingURL=Clock.d.ts.map

package/dist/time/Clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Clock.d.ts","sourceRoot":"","sources":["../../src/time/Clock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C,MAAM,MAAM,MAAM,GAAG,eAAe,CAAC,aAAa,CAAC,CAAA;AAEnD,8BAAsB,aAAc,YAAW,MAAM;IACnD,QAAQ,CAAC,GAAG,IAAI,QAAQ,CAAC,OAAO;IAEhC,OAAO,IAAI,IAAI;CAGhB;AAED,qBAAa,KAAM,SAAQ,aAAa;IACtC,GAAG,IAAI,QAAQ,CAAC,OAAO;CAGxB;AAED,qBAAa,SAAU,SAAQ,aAAa;IAC9B,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,QAAQ,CAAC,OAAO;IAI1C,GAAG,IAAI,QAAQ,CAAC,OAAO;IAIvB,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAIrC,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,OAAO,GAAG,IAAI;CAGnC"}

package/dist/time/Clock.js

@@ -0,0 +1,26 @@
+export class AbstractClock {
+    nowDate() {
+        return new Date(this.now().epochMilliseconds);
+    }
+}
+export class Clock extends AbstractClock {
+    now() {
+        return Temporal.Now.instant();
+    }
+}
+export class TestClock extends AbstractClock {
+    _now;
+    constructor(_now) {
+        super();
+        this._now = _now;
+    }
+    now() {
+        return this._now;
+    }
+    advance(duration) {
+        this._now = this._now.add(Temporal.Duration.from(duration));
+    }
+    reset(now) {
+        this._now = now;
+    }
+}

package/dist/time/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./sleep";
+export * from "./Clock";
+export * from "./temporal";
+//# sourceMappingURL=index.d.ts.map

package/dist/time/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/time/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA"}

package/dist/time/index.js

@@ -0,0 +1,3 @@
+export * from "./sleep.js";
+export * from "./Clock.js";
+export * from "./temporal.js";

package/dist/time/sleep.d.ts

@@ -0,0 +1,3 @@
+import { type DurationLike } from "./index";
+export declare function sleep(duration: DurationLike): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/time/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/time/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AAEzD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAI3D"}

package/dist/time/sleep.js

@@ -0,0 +1,5 @@
+import { durationToMs } from "./index.js";
+export function sleep(duration) {
+    const ms = durationToMs(Temporal.Duration.from(duration));
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/time/temporal.d.ts

@@ -0,0 +1,5 @@
+export type DurationLike = Omit<Temporal.DurationLike, "microseconds" | "nanoseconds"> | Omit<Temporal.Duration, "microseconds" | "nanoseconds">;
+export declare function multiplyDuration(base: Temporal.Duration, factor: number): Temporal.Duration;
+export declare function durationToMs(duration: Temporal.Duration): number;
+export declare function prettyPrintDuration(duration: Temporal.Duration): string;
+//# sourceMappingURL=temporal.d.ts.map

package/dist/time/temporal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.ts","sourceRoot":"","sources":["../../src/time/temporal.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GACpB,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,cAAc,GAAG,aAAa,CAAC,GAC3D,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa,CAAC,CAAA;AAE3D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAW3F;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAIhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAEvE"}

package/dist/time/temporal.js

@@ -0,0 +1,20 @@
+export function multiplyDuration(base, factor) {
+    return Temporal.Duration.from({
+        years: Math.round(base.years * factor),
+        months: Math.round(base.months * factor),
+        weeks: Math.round(base.weeks * factor),
+        days: Math.round(base.days * factor),
+        hours: Math.round(base.hours * factor),
+        minutes: Math.round(base.minutes * factor),
+        seconds: Math.round(base.seconds * factor),
+        milliseconds: Math.round(base.milliseconds * factor),
+    });
+}
+export function durationToMs(duration) {
+    const now = Temporal.Now.instant();
+    const target = now.add(Temporal.Duration.from(duration));
+    return target.epochMilliseconds - now.epochMilliseconds;
+}
+export function prettyPrintDuration(duration) {
+    return new Intl.DurationFormat("en", { style: "narrow" }).format(duration); // @todo polyfill typings are off
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export type PublicInterface<T> = {
+    [K in keyof T]: T[K];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAA"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};