@tstdl/base 0.83.27 → 0.84.0

package/queue/mongo/queue.js

@@ -216,7 +216,7 @@ let MongoQueue = class MongoQueue2 extends import_queue.Queue {
     return this.cancelMany(jobIds);
   }
   async *getConsumer(cancellationToken) {
-    const continueToken = import_cancellation_token.CancellationToken.fromObservable(this.messageBus.allMessages$);
+    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
     for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
       const job = await this.dequeue();
       if (job != void 0) {
@@ -228,7 +228,7 @@ let MongoQueue = class MongoQueue2 extends import_queue.Queue {
     continueToken.complete();
   }
   async *getBatchConsumer(size, cancellationToken) {
-    const continueToken = import_cancellation_token.CancellationToken.fromObservable(this.messageBus.allMessages$);
+    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
     for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
       const jobs = await this.dequeueMany(size);
       if (jobs.length > 0) {

package/types.d.ts

@@ -112,6 +112,9 @@ export type OmitBy<T, V> = Omit<T, {
  * normalize properties of a type that allow `undefined` to make them optional.
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
+export type Unoptionalize<T extends object> = Simplify<OmitBy<T, undefined> & {
+    [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
+}>;
 export type SimplifiedOptionalize<T extends object> = Simplify<Optionalize<T>>;
 export type Merge<T1, T2> = SimplifyObject<Except<T1, Extract<keyof T1, keyof T2>> & T2>;
 export type Simplify<T> = T extends BuiltIn ? T : T extends readonly any[] ? SimplifyArray<T> : T extends Record ? SimplifyObject<T> : T;

package/utils/cancellation-token.d.ts

@@ -67,7 +67,7 @@ export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribab
     /**
      * Returns an AbortSignal.
      */
-    asAbortSignal: AbortSignal;
+    asAbortSignal(): AbortSignal;
     /**
      * Create a new token and connect it to this instance.
      * @see {@link connect}
@@ -81,7 +81,6 @@ export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribab
 }
 export declare class CancellationToken implements ReadonlyCancellationToken {
     private readonly stateSubject;
-    private abortController;
     readonly state$: Observable<boolean>;
     readonly set$: Observable<void>;
     readonly unset$: Observable<void>;
@@ -90,8 +89,6 @@ export declare class CancellationToken implements ReadonlyCancellationToken {
     get $set(): Promise<void>;
     get $unset(): Promise<void>;
     get $state(): Promise<boolean>;
-    get asReadonly(): ReadonlyCancellationToken;
-    get asAbortSignal(): AbortSignal;
     /**
      * @param initialState which state to initialze this token to
      * - `false`: unset
@@ -100,23 +97,21 @@ export declare class CancellationToken implements ReadonlyCancellationToken {
      */
     constructor(initialState?: boolean);
     /**
-     * Creates a token and sets it whenever the abort signal is aborted.
-     * @param signal abort signal to listen to
-     * @param complete complete token after resolve
+     * Creates a token and sets it whenever the source signals
+     * @param source source to listen to
+     * @param complete complete token after signal
      */
-    static fromAbortSignal(signal: AbortSignal, complete?: boolean): CancellationToken;
+    static from(source: AbortSignal | PromiseLike<any> | Observable<void>, options?: {
+        complete?: boolean;
+    }): CancellationToken;
     /**
-     * Creates a token and sets it whenever the promise is resolved.
-     * @param promise promise to await
-     * @param complete complete token after resolve
-     */
-    static fromPromise(promise: PromiseLike<any>, complete?: boolean): CancellationToken;
-    /**
-     * Creates a token and connets its next, error and complete.
+     * Creates a token and connects the source to its next, error and complete.
      * @param observable observable to subscribe. Takes emitted value as state if type is boolean otherwise sets state to true.
      */
-    static fromObservable(observable: Observable<void | boolean>, config?: ConnectConfig): CancellationToken;
+    static from(source: Observable<boolean>, config?: ConnectConfig): CancellationToken;
     private static connect;
+    asAbortSignal(): AbortSignal;
+    asReadonly(): ReadonlyCancellationToken;
     createChild(config?: ConnectConfig): CancellationToken;
     connect(child: CancellationToken, config?: ConnectConfig): void;
     /**

package/utils/cancellation-token.js

@@ -27,7 +27,6 @@ var import_noop2 = require("./noop.js");
 var import_type_guards = require("./type-guards.js");
 class CancellationToken {
   stateSubject;
-  abortController;
   state$;
   set$;
   unset$;
@@ -46,20 +45,6 @@ class CancellationToken {
   get $state() {
     return (0, import_rxjs.firstValueFrom)(this.state$.pipe((0, import_rxjs.skip)(1)));
   }
-  get asReadonly() {
-    return this;
-  }
-  get asAbortSignal() {
-    if ((0, import_type_guards.isUndefined)(this.abortController)) {
-      const abortController = new AbortController();
-      this.abortController = abortController;
-      this.set$.pipe((0, import_rxjs.first)()).subscribe(() => {
-        abortController.abort();
-        this.unset$.pipe((0, import_rxjs.first)()).subscribe(() => this.abortController = void 0);
-      });
-    }
-    return this.abortController.signal;
-  }
   /**
    * @param initialState which state to initialze this token to
    * - `false`: unset
@@ -72,31 +57,9 @@ class CancellationToken {
     this.set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
     this.unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
   }
-  /**
-   * Creates a token and sets it whenever the abort signal is aborted.
-   * @param signal abort signal to listen to
-   * @param complete complete token after resolve
-   */
-  static fromAbortSignal(signal, complete = true) {
-    const signal$ = (0, import_rxjs.fromEvent)(signal, "abort", () => true);
-    return CancellationToken.fromObservable(signal$, { complete });
-  }
-  /**
-   * Creates a token and sets it whenever the promise is resolved.
-   * @param promise promise to await
-   * @param complete complete token after resolve
-   */
-  static fromPromise(promise, complete = true) {
-    const signal$ = (0, import_rxjs.from)(promise).pipe((0, import_rxjs.map)(() => true));
-    return CancellationToken.fromObservable(signal$, { complete });
-  }
-  /**
-   * Creates a token and connets its next, error and complete.
-   * @param observable observable to subscribe. Takes emitted value as state if type is boolean otherwise sets state to true.
-   */
-  static fromObservable(observable, config) {
+  static from(source, config) {
+    const source$ = source instanceof AbortSignal ? (0, import_rxjs.fromEvent)(source, "abort", () => true) : (0, import_rxjs.isObservable)(source) ? source.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true)) : (0, import_rxjs.from)(source).pipe((0, import_rxjs.map)(() => true));
     const token = new CancellationToken();
-    const source$ = observable.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true));
     CancellationToken.connect(source$, token, config);
     return token;
   }
@@ -113,6 +76,14 @@ class CancellationToken {
       complete: () => subscription.unsubscribe()
     });
   }
+  asAbortSignal() {
+    const abortController = new AbortController();
+    this.set$.pipe((0, import_rxjs.first)()).subscribe(() => abortController.abort());
+    return abortController.signal;
+  }
+  asReadonly() {
+    return this;
+  }
   createChild(config) {
     const child = new CancellationToken();
     this.connect(child, config);

package/utils/index.d.ts

@@ -44,4 +44,5 @@ export * from './type-guards.js';
 export * from './type-of.js';
 export * from './units.js';
 export * from './url-builder.js';
+export * from './value-or-provider.js';
 export * from './z-base32.js';

package/utils/index.js

@@ -61,4 +61,5 @@ __reExport(utils_exports, require("./type-guards.js"), module.exports);
 __reExport(utils_exports, require("./type-of.js"), module.exports);
 __reExport(utils_exports, require("./units.js"), module.exports);
 __reExport(utils_exports, require("./url-builder.js"), module.exports);
+__reExport(utils_exports, require("./value-or-provider.js"), module.exports);
 __reExport(utils_exports, require("./z-base32.js"), module.exports);

package/utils/stream/finalize-stream.d.ts

@@ -1 +1,22 @@
-export declare function finalizeStream<T>(stream: ReadableStream<T>, finalizer: () => void | PromiseLike<void>): ReadableStream<T>;
+export type ReadableStreamFinalizeEvent = {
+    type: 'done';
+} | {
+    type: 'error';
+    error: any;
+} | {
+    type: 'cancel';
+    reason: any;
+};
+/**
+ * Finalizer is called *after* the specific event occurred.
+ */
+export type StreamFinalizerHandler = (event: ReadableStreamFinalizeEvent) => void | Promise<void>;
+export type FinalizeStreamHandlers = {
+    finalizer?: StreamFinalizerHandler;
+    beforeDone?: () => void | Promise<void>;
+    done?: () => void | Promise<void>;
+    error?: (error: Error) => void | Promise<void>;
+    beforeCancel?: (reason: any) => void | Promise<void>;
+    cancel?: (reason: any) => void | Promise<void>;
+};
+export declare function finalizeStream<T>(stream: ReadableStream<T>, finalizerOrHandlers: StreamFinalizerHandler | FinalizeStreamHandlers): ReadableStream<T>;

package/utils/stream/finalize-stream.js

@@ -21,7 +21,9 @@ __export(finalize_stream_exports, {
   finalizeStream: () => finalizeStream
 });
 module.exports = __toCommonJS(finalize_stream_exports);
-function finalizeStream(stream, finalizer) {
+var import_type_guards = require("../type-guards.js");
+function finalizeStream(stream, finalizerOrHandlers) {
+  const handlers = (0, import_type_guards.isFunction)(finalizerOrHandlers) ? { finalizer: finalizerOrHandlers } : finalizerOrHandlers;
   let reader;
   return new ReadableStream({
     start() {
@@ -32,21 +34,29 @@ function finalizeStream(stream, finalizer) {
       try {
         chunk = await reader.read();
       } catch (error) {
-        await finalizer();
+        await handlers.error?.(error);
+        await handlers.finalizer?.({ type: "error", error });
         throw error;
       }
       if (chunk.done) {
+        await handlers.beforeDone?.();
         controller.close();
-        await finalizer();
+        await handlers.done?.();
+        await handlers.finalizer?.({ type: "done" });
       } else {
         controller.enqueue(chunk.value);
       }
     },
     async cancel(reason) {
       try {
+        await handlers.beforeCancel?.(reason);
         await reader.cancel(reason);
+        await handlers.cancel?.(reason);
+      } catch (error) {
+        await handlers.error?.(error);
+        throw error;
       } finally {
-        await finalizer();
+        await handlers.finalizer?.({ type: "cancel", reason });
       }
     }
   });

package/utils/stream/readable-stream-from-promise.d.ts

@@ -1 +1,2 @@
-export declare function readableStreamFromPromise<T>(executor: () => Promise<ReadableStream<T>>): ReadableStream<T>;
+import type { ValueOrProvider } from '../value-or-provider.js';
+export declare function readableStreamFromPromise<T>(promiseOrProvider: ValueOrProvider<Promise<ReadableStream<T>>>): ReadableStream<T>;

package/utils/stream/readable-stream-from-promise.js

@@ -21,8 +21,9 @@ __export(readable_stream_from_promise_exports, {
   readableStreamFromPromise: () => readableStreamFromPromise
 });
 module.exports = __toCommonJS(readable_stream_from_promise_exports);
-function readableStreamFromPromise(executor) {
+var import_value_or_provider = require("../value-or-provider.js");
+function readableStreamFromPromise(promiseOrProvider) {
   const stream = new TransformStream();
-  executor().then(async (readable) => readable.pipeTo(stream.writable)).catch(async (error) => stream.writable.abort(error));
+  (0, import_value_or_provider.resolveValueOrProvider)(promiseOrProvider).then(async (readable) => readable.pipeTo(stream.writable)).catch(async (error) => stream.writable.abort(error));
   return stream.readable;
 }

package/utils/timing.d.ts

@@ -1,12 +1,18 @@
 import type { ReadonlyCancellationToken } from './cancellation-token.js';
+import type { ValueOrProvider } from './value-or-provider.js';
 /** timeout for specified duration */
-export declare function timeout(milliseconds?: number): Promise<void>;
+export declare function timeout(milliseconds?: number, options?: {
+    abortSignal?: AbortSignal;
+}): Promise<void>;
 /** timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** timeout for specified duration */
 export declare function cancelableTimeout(milliseconds: number, cancelToken: ReadonlyCancellationToken): Promise<boolean>;
 /** timeout until specified time */
 export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelToken: ReadonlyCancellationToken): Promise<boolean>;
+export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
+    errorMessage?: string;
+}): Promise<T>;
 export declare function immediate(): Promise<void>;
 export declare function nextTick(): Promise<void>;
 export declare function animationFrame(): Promise<number>;

package/utils/timing.js

@@ -25,12 +25,23 @@ __export(timing_exports, {
   immediate: () => immediate,
   nextTick: () => nextTick,
   timeout: () => timeout,
-  timeoutUntil: () => timeoutUntil
+  timeoutUntil: () => timeoutUntil,
+  withTimeout: () => withTimeout
 });
 module.exports = __toCommonJS(timing_exports);
+var import_timeout_error = require("../error/timeout.error.js");
 var import_rxjs = require("rxjs");
-async function timeout(milliseconds = 0) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+var import_throw = require("./throw.js");
+var import_value_or_provider = require("./value-or-provider.js");
+async function timeout(milliseconds = 0, options) {
+  return new Promise((resolve) => {
+    const abortListener = () => clearTimeout(timeoutRef);
+    const timeoutRef = setTimeout(() => {
+      options?.abortSignal?.removeEventListener("abort", abortListener);
+      resolve();
+    }, milliseconds);
+    options?.abortSignal?.addEventListener("abort", abortListener);
+  });
 }
 async function timeoutUntil(timestamp) {
   const left = timestamp.valueOf() - Date.now();
@@ -47,6 +58,15 @@ async function cancelableTimeoutUntil(timestamp, cancelToken) {
   const left = timestamp.valueOf() - Date.now();
   return cancelableTimeout(left, cancelToken);
 }
+async function withTimeout(milliseconds, promiseOrProvider, options) {
+  const abortController = new AbortController();
+  const promise = (0, import_value_or_provider.resolveValueOrProvider)(promiseOrProvider);
+  void promise.then(() => abortController.abort());
+  return Promise.race([
+    promise,
+    timeout(milliseconds, { abortSignal: abortController.signal }).then(() => (0, import_throw._throw)(new import_timeout_error.TimeoutError(options?.errorMessage)))
+  ]);
+}
 async function immediate() {
   return new Promise(setImmediate);
 }

package/utils/type-guards.d.ts

@@ -238,3 +238,9 @@ export declare function assertReadableStream<T = any>(value: any, message?: Asse
 export declare function assertNotReadableStream<T>(value: T, message?: AssertionMessage): asserts value is InferIsNotType<T, typeof isReadableStream>;
 export declare function assertReadableStreamPass<T = any>(value: any, message?: AssertionMessage): InferIsType<typeof isReadableStream>;
 export declare function assertNotReadableStreamPass<T>(value: T, message?: AssertionMessage): InferIsNotType<T, typeof isReadableStream>;
+export declare function isError(value: any): value is Error;
+export declare function isNotError<T>(value: T): value is InferIsNotType<T, typeof isError>;
+export declare function assertError(value: any, message?: AssertionMessage): asserts value is InferIsType<typeof isError>;
+export declare function assertNotError<T>(value: T, message?: AssertionMessage): asserts value is InferIsNotType<T, typeof isError>;
+export declare function assertErrorPass(value: any, message?: AssertionMessage): InferIsType<typeof isError>;
+export declare function assertNotErrorPass<T>(value: T, message?: AssertionMessage): InferIsNotType<T, typeof isError>;

package/utils/type-guards.js

@@ -43,6 +43,8 @@ __export(type_guards_exports, {
   assertDatePass: () => assertDatePass,
   assertDefined: () => assertDefined,
   assertDefinedPass: () => assertDefinedPass,
+  assertError: () => assertError,
+  assertErrorPass: () => assertErrorPass,
   assertFloat32Array: () => assertFloat32Array,
   assertFloat32ArrayPass: () => assertFloat32ArrayPass,
   assertFloat64Array: () => assertFloat64Array,
@@ -82,6 +84,8 @@ __export(type_guards_exports, {
   assertNotDataViewPass: () => assertNotDataViewPass,
   assertNotDate: () => assertNotDate,
   assertNotDatePass: () => assertNotDatePass,
+  assertNotError: () => assertNotError,
+  assertNotErrorPass: () => assertNotErrorPass,
   assertNotFloat32Array: () => assertNotFloat32Array,
   assertNotFloat32ArrayPass: () => assertNotFloat32ArrayPass,
   assertNotFloat64Array: () => assertNotFloat64Array,
@@ -188,6 +192,7 @@ __export(type_guards_exports, {
   isDataView: () => isDataView,
   isDate: () => isDate,
   isDefined: () => isDefined,
+  isError: () => isError,
   isFloat32Array: () => isFloat32Array,
   isFloat64Array: () => isFloat64Array,
   isFunction: () => isFunction,
@@ -207,6 +212,7 @@ __export(type_guards_exports, {
   isNotBoolean: () => isNotBoolean,
   isNotDataView: () => isNotDataView,
   isNotDate: () => isNotDate,
+  isNotError: () => isNotError,
   isNotFloat32Array: () => isNotFloat32Array,
   isNotFloat64Array: () => isNotFloat64Array,
   isNotFunction: () => isNotFunction,
@@ -1048,3 +1054,23 @@ function assertNotReadableStreamPass(value, message) {
   assertNotReadableStream(value, message);
   return value;
 }
+function isError(value) {
+  return value instanceof Error;
+}
+function isNotError(value) {
+  return !isError(value);
+}
+function assertError(value, message = "Expected value to be Error.") {
+  assert(isError(value), message);
+}
+function assertNotError(value, message = "Expected value to not be Error.") {
+  assert(isNotError(value), message);
+}
+function assertErrorPass(value, message) {
+  assertError(value, message);
+  return value;
+}
+function assertNotErrorPass(value, message) {
+  assertNotError(value, message);
+  return value;
+}

package/utils/value-or-provider.d.ts

@@ -0,0 +1,2 @@
+export type ValueOrProvider<T> = T extends () => any ? never : T | (() => T);
+export declare function resolveValueOrProvider<T>(valueOrProvider: ValueOrProvider<T>): T;

package/utils/value-or-provider.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var value_or_provider_exports = {};
+__export(value_or_provider_exports, {
+  resolveValueOrProvider: () => resolveValueOrProvider
+});
+module.exports = __toCommonJS(value_or_provider_exports);
+var import_type_guards = require("./type-guards.js");
+function resolveValueOrProvider(valueOrProvider) {
+  if ((0, import_type_guards.isFunction)(valueOrProvider)) {
+    return valueOrProvider();
+  }
+  return valueOrProvider;
+}