@tstdl/base 0.92.145 → 0.92.148

package/utils/backoff.js

@@ -1,101 +1,177 @@
 import { CancellationToken } from '../cancellation/token.js';
-import { noop } from './noop.js';
+import { NEVER } from 'rxjs';
+import { randomFloat } from './math.js';
 import { cancelableTimeout } from './timing.js';
 import { isDefined } from './type-guards.js';
+/**
+ * Default options for a robust backoff strategy.
+ */
+export const DEFAULT_BACKOFF_OPTIONS = {
+    strategy: 'exponential',
+    initialDelay: 1000,
+    increase: 2,
+    maximumDelay: 30_000, // 30 seconds
+    jitter: 0.15,
+};
+/**
+ * A helper class to manage the state of a backoff strategy.
+ */
 export class BackoffHelper {
-    strategy;
-    initialDelay;
-    increase;
-    maximumDelay;
-    delay;
-    constructor({ strategy, initialDelay, increase, maximumDelay }) {
-        this.strategy = strategy;
-        this.initialDelay = initialDelay;
-        this.increase = increase;
-        this.maximumDelay = maximumDelay ?? Number.MAX_SAFE_INTEGER;
-        this.reset();
+    options;
+    currentDelay;
+    /**
+     * Creates a new BackoffHelper.
+     * @param options Partial backoff options, which will be merged with sane defaults.
+     */
+    constructor(options) {
+        this.options = { ...DEFAULT_BACKOFF_OPTIONS, ...options };
+        const { initialDelay, increase, jitter, strategy } = this.options;
+        if (initialDelay < 0) {
+            throw new Error('initialDelay must be non-negative.');
+        }
+        if (increase < 0) {
+            throw new Error('increase must be non-negative.');
+        }
+        if ((jitter < 0) || (jitter > 1)) {
+            throw new Error('jitter must be between 0 and 1.');
+        }
+        if (strategy == 'exponential' && increase <= 1) {
+            console.warn('Using an exponential backoff with an increase factor <= 1 is not recommended as the delay will not grow.');
+        }
+        this.currentDelay = this.options.initialDelay;
     }
+    /**
+     * Resets the current delay to the initial delay.
+     */
     reset() {
-        this.delay = this.initialDelay;
+        this.currentDelay = this.options.initialDelay;
     }
-    backoff() {
-        this.delay = getNewDelay(this.strategy, this.delay, this.increase, this.maximumDelay);
-        return this.delay;
+    /**
+     * Calculates and returns the next backoff delay based on the configured strategy.
+     * This also updates the internal state for the subsequent call.
+     * @returns The next delay in milliseconds.
+     */
+    getNextDelay() {
+        const newDelay = getNewDelay(this.options.strategy, this.currentDelay, this.options.increase, this.options.maximumDelay);
+        this.currentDelay = newDelay;
+        if (this.options.jitter > 0) {
+            const jitterAmount = newDelay * randomFloat(-this.options.jitter, this.options.jitter); // ±jitter
+            return Math.max(0, newDelay + jitterAmount);
+        }
+        return newDelay;
     }
 }
 /**
- * runs a function until token is set or controller returns and automatically backsoff if function throws. Warning: swallows errors
- * @param options backoff options
- * @param cancellationToken token to cancel loop
- * @param loopFunction function to call
+ * Runs a function in a loop, automatically backing off on errors.
+ *
+ * This function is a convenient wrapper that catches any errors from `loopFunction`,
+ * triggers a backoff, and continues the loop.
+ *
+ * @param loopFunction The asynchronous function to execute in each iteration.
+ * @param options Additional options for backoff configuration, cancellation, and error handling.
  */
-export async function autoBackoffLoop(options, loopFunction, extras) {
-    const errorHandler = extras?.errorHandler ?? noop;
-    return backoffLoop(options, async (controller) => {
+export async function autoBackoffLoop(loopFunction, options = {}) {
+    const { errorHandler, ...loopOptions } = options;
+    await backoffLoop(async (controller, signal) => {
         try {
-            await loopFunction(controller);
+            await loopFunction(controller, signal);
         }
         catch (error) {
-            errorHandler(error);
+            errorHandler?.(error);
             controller.backoff();
         }
-    }, { cancellationSignal: extras?.cancellationSignal });
+    }, loopOptions);
 }
 /**
- * runs a function until token is set or controller returns.
- * @param options backoff options
- * @param cancellationToken signal to cancel loop
- * @param loopFunction function to call
+ * Runs a function in a loop, allowing manual control over backoff and breaking.
+ * The loop continues until it is explicitly broken via the controller or the cancellation signal is set.
+ * If `controller.backoff()` is not called in an iteration, the delay is reset for the next backoff.
+ *
+ * @param loopFunction The function to execute, receiving a controller to manage the loop.
+ * @param options Additional options for backoff configuration and cancellation.
  */
-export async function backoffLoop(options, loopFunction, extras) {
-    const backoffHelper = new BackoffHelper(options);
-    const loopCancellationToken = extras?.cancellationSignal?.createChild({ unset: false, complete: false }) ?? new CancellationToken();
-    let backoff = false;
+export async function backoffLoop(loopFunction, options = {}) {
+    const { cancellationSignal, ...backoffOptions } = options;
+    const backoffHelper = new BackoffHelper(backoffOptions);
+    const loopToken = new CancellationToken();
+    let shouldBackoff = false;
+    if (isDefined(cancellationSignal)) {
+        loopToken.inherit(cancellationSignal, { set: true, unset: false, complete: false, error: false });
+    }
     const controller = {
-        backoff: () => backoff = true,
-        break: () => loopCancellationToken.set()
+        backoff: () => shouldBackoff = true,
+        break: () => loopToken.set(),
     };
-    while (!loopCancellationToken.isSet) {
-        await loopFunction(controller);
-        if (loopCancellationToken.isSet) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    while (loopToken.isUnset) {
+        await loopFunction(controller, loopToken.signal);
+        // Exit immediately if the loop function requested a break.
+        if (loopToken.isSet) {
             return;
         }
-        if (backoff) {
-            backoff = false;
-            const milliseconds = backoffHelper.backoff();
-            await cancelableTimeout(milliseconds, loopCancellationToken);
+        if (shouldBackoff) {
+            shouldBackoff = false;
+            const delay = backoffHelper.getNextDelay();
+            await cancelableTimeout(delay, loopToken.signal);
         }
         else {
+            // If an iteration completes successfully without a backoff request, reset the delay.
             backoffHelper.reset();
         }
     }
 }
 /**
- * generates endless function which, when called, backs off next iteration
- * @param options backoff options
- * @param cancellationSignal signal to cancel loop
+ * Creates an async generator that yields a callback to trigger a backoff.
+ * This is useful for `for-await-of` loops where you need fine-grained control.
+ * The generator terminates when the `cancellationSignal` is set or the loop is terminated by break.
+ *
+ * @param options Options for backoff configuration and an optional cancellation signal.
  * @example
- * for await (const backoff of backoffGenerator(options, token)) {
- *  if (iWantToBackoff) {
- *    backoff();
- *  }
+ * ```ts
+ * const token = new CancellationToken();
+ *
+ * // with a cancellation signal
+ * for await (const backoff of backoffGenerator({ cancellationSignal: token.signal })) {
+ *   const success = await doSomeWork();
+ *   if (!success) {
+ *     backoff(); // Schedule a backoff before the next iteration.
+ *   }
  * }
+ *
+ * // without a cancellation signal (loop is broken manually)
+ * for await (const backoff of backoffGenerator()) {
+ *   const success = await doSomeWork();
+ *   if (success) {
+ *     break; // Exit the loop
+ *   }
+ *   backoff();
+ * }
+ * ```
  */
-export async function* backoffGenerator(options, cancellationSignal) {
-    const backoffHelper = new BackoffHelper(options);
-    while (cancellationSignal.isUnset) {
-        let backoff = false;
-        let timeoutToken = cancellationSignal;
-        const backoffFunction = (continueToken) => {
-            backoff = true;
+export async function* backoffGenerator(options = {}) {
+    const { cancellationSignal, ...backoffOptions } = options;
+    const backoffHelper = new BackoffHelper(backoffOptions);
+    // Loop indefinitely if no cancellation signal is provided.
+    // The consumer is responsible for breaking the loop.
+    while (cancellationSignal?.isUnset ?? true) {
+        let backoffTriggered = false;
+        let timeoutSignal = cancellationSignal;
+        const backoffCallback = (backoffOptions) => {
+            backoffTriggered = true;
+            const continueToken = backoffOptions?.continueToken;
             if (isDefined(continueToken)) {
-                timeoutToken = cancellationSignal.createChild().inherit(continueToken);
+                timeoutSignal = isDefined(cancellationSignal)
+                    ? cancellationSignal.createChild().inherit(continueToken)
+                    : continueToken;
             }
         };
-        yield backoffFunction;
-        if (backoff) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-            const milliseconds = backoffHelper.backoff();
-            await cancelableTimeout(milliseconds, timeoutToken);
+        yield backoffCallback;
+        // Break immediately if the cancellation signal (if provided) is set.
+        if (cancellationSignal?.isSet == true) {
+            break;
+        }
+        if (backoffTriggered) {
+            const delay = backoffHelper.getNextDelay();
+            await cancelableTimeout(delay, timeoutSignal ?? NEVER);
         }
         else {
             backoffHelper.reset();
@@ -112,8 +188,7 @@ function getNewDelay(strategy, currentDelay, increase, maximumDelay) {
             newDelay = currentDelay * increase;
             break;
         default:
-            throw new Error('unknown backoff-strategy');
+            throw new Error(`Unknown backoff strategy: ${strategy}`);
     }
-    newDelay = Math.min(newDelay, maximumDelay);
-    return newDelay;
+    return Math.min(newDelay, maximumDelay);
 }

package/utils/base64.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 export declare function encodeBase64(array: BinaryData, bytesOffset?: number, bytesLength?: number): string;
 export declare function decodeBase64(base64: string): Uint8Array;
 export declare function encodeBase64Url(array: BinaryData, bytesOffset?: number, length?: number): string;

package/utils/base64.js

@@ -36,7 +36,7 @@ export function decodeBase64Url(base64Url) {
 }
 export function base64ToBase64Url(input) {
     return input
-        .replace(/=/ug, '') // eslint-disable-line no-div-regex
+        .replace(/=/ug, '')
         .replace(/\+/ug, '-')
         .replace(/\//ug, '_');
 }
@@ -98,7 +98,6 @@ export function utf8ArrayToString(bytes) {
     }
     return string;
 }
-// eslint-disable-next-line max-lines-per-function, max-statements
 export function stringToUtf8Array(string) {
     let bytesLength = 0;
     for (let i = 0; i < string.length; i++) {

package/utils/binary.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData, Type } from '../types.js';
+import type { BinaryData, Type } from '../types/index.js';
 /**
  * Get ArrayBuffer from binary data
  * @param data data to get ArrayBuffer from

package/utils/comparison.d.ts

@@ -1,8 +1,8 @@
-export declare function compareByValueSelection<T>(...selectors: ((item: T) => unknown)[]): (a: T, b: T) => number;
-export declare function compareByValueSelectionDescending<T>(...selectors: ((item: T) => unknown)[]): (a: T, b: T) => number;
-export declare function compareByValueSelectionOrdered<T>(...selectors: (readonly [(item: T) => unknown, 1 | -1])[]): (a: T, b: T) => number;
+export declare function compareByValueSelection<T, C extends string | number>(...selectors: ((item: T) => C)[]): (a: T, b: T) => number;
+export declare function compareByValueSelectionDescending<T, C extends string | number>(...selectors: ((item: T) => C)[]): (a: T, b: T) => number;
+export declare function compareByValueSelectionOrdered<T, C extends string | number>(...selectors: (readonly [(item: T) => C, 1 | -1])[]): (a: T, b: T) => number;
 export declare function compareByValueToOrder<T>(order: T[]): (a: T, b: T) => number;
 export declare const orderRest: unique symbol;
 export declare function compareByValueSelectionToOrder<T, TSelect>(order: (TSelect | typeof orderRest)[], selector: (item: T) => TSelect): (a: T, b: T) => number;
-export declare function compareByValue<T>(a: T, b: T, strict?: boolean): number;
-export declare function compareByValueDescending<T>(a: T, b: T, strict?: boolean): number;
+export declare function compareByValue<T>(a: T, b: NoInfer<T>, strict?: boolean): number;
+export declare function compareByValueDescending<T>(a: T, b: NoInfer<T>, strict?: boolean): number;

package/utils/comparison.js

@@ -1,3 +1,5 @@
+import { isNullOrUndefined } from './type-guards.js';
+import { typeOf } from './type-of.js';
 export function compareByValueSelection(...selectors) {
     return (a, b) => {
         for (const selector of selectors) {
@@ -51,7 +53,7 @@ export function compareByValueSelectionToOrder(order, selector) {
         const selectedB = selector(b);
         const indexA = indexMap.get(selectedA) ?? indexMap.get(orderRest);
         const indexB = indexMap.get(selectedB) ?? indexMap.get(orderRest);
-        if (indexA == undefined || indexB == undefined) {
+        if (isNullOrUndefined(indexA) || isNullOrUndefined(indexB)) {
             throw new Error('Value not defined in order.');
         }
         return compareByValue(indexA, indexB);
@@ -70,7 +72,7 @@ export function compareByValue(a, b, strict = true) {
     if (!strict) {
         return 0;
     }
-    throw new Error('Objects not comparable');
+    throw new Error(`Values of type ${typeOf(a)} and ${typeOf(b)} are not comparable.`);
 }
 export function compareByValueDescending(a, b, strict = true) {
     if (a === b) {
@@ -85,5 +87,5 @@ export function compareByValueDescending(a, b, strict = true) {
     if (!strict) {
         return 0;
     }
-    throw new Error('Objects not comparable');
+    throw new Error(`Values of type ${typeOf(a)} and ${typeOf(b)} are not comparable.`);
 }

package/utils/cryptography.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData, TypedExtract } from '../types.js';
+import type { BinaryData, TypedExtract } from '../types/index.js';
 import type { ReadonlyTuple } from 'type-fest';
 export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
 export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';

package/utils/encoding.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 /**
  * Encodes text to utf8
  * @param text text to encode

package/utils/enum.d.ts

@@ -1,4 +1,4 @@
-import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types.js';
+import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types/index.js';
 export declare function enumValueName<T extends EnumerationObject>(enumeration: T, value: T[keyof T]): EnumerationKey<T>;
 export declare function enumEntries<T extends EnumerationObject>(enumeration: T): EnumerationEntries<T>;
 export declare function enumKeys<T extends EnumerationObject>(enumeration: T): EnumerationKey<T>[];

package/utils/equals.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 import type { Comparator } from './sort.js';
 export interface Equals<T = unknown> {
     [Equals.symbol](other: T): boolean;

package/utils/format-error.d.ts

@@ -1,4 +1,4 @@
-import type { UndefinableJson } from '../types.js';
+import type { UndefinableJson } from '../types/index.js';
 export type FormatErrorOptions = {
     /**
      * Include error name in message

package/utils/function/class.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 declare class EmptyClass {
 }
 export declare function getClassOfName(name: string): typeof EmptyClass;

package/utils/function/memoize.d.ts

@@ -1,4 +1,4 @@
-import type { Constructor } from '../../types.js';
+import type { Constructor } from '../../types/index.js';
 export type MemoizeOptions = {
     /** Use WeakMap instead of Map for caching. Can be used with object parameters only */
     weak?: boolean;

package/utils/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { DeepArray, Record } from '../types.js';
+import type { DeepArray, Record } from '../types/index.js';
 /**
  * Create an structured clone of an value using Notification if available, otherwise history state (may alters history)
  *

package/utils/helpers.js

@@ -1,5 +1,5 @@
-import { supportsNotification } from '../supports.js';
 import { DetailsError } from '../errors/details.error.js';
+import { supportsNotification } from '../supports.js';
 import { decycle } from './object/decycle.js';
 /**
  * Create an structured clone of an value using Notification if available, otherwise history state (may alters history)
@@ -64,7 +64,7 @@ export function parseFirstAndFamilyName(name) {
     const firstName = parts.map((part) => part.trim()).join(' ');
     return {
         firstName: firstName.length > 0 ? firstName : undefined,
-        familyName: familyName.length > 0 ? familyName : undefined
+        familyName: familyName.length > 0 ? familyName : undefined,
     };
 }
 export function iif(condition, trueFn, falseFn) {

package/utils/jwt.d.ts

@@ -1,11 +1,11 @@
-import type { OneOrMany, StringMap } from '../types.js';
+import type { OneOrMany, Record } from '../types/index.js';
 import type { Key } from './cryptography.js';
 export type JwtTokenAlgorithm = 'HS256' | 'HS384' | 'HS512';
-export type JwtTokenHeader<T extends StringMap = StringMap> = {
+export type JwtTokenHeader<T extends Record<string> = Record<string>> = {
     alg: JwtTokenAlgorithm;
     typ: 'JWT';
 } & T;
-export type JwtToken<TPayload = StringMap, THeader extends JwtTokenHeader = JwtTokenHeader> = {
+export type JwtToken<TPayload = Record<string>, THeader extends JwtTokenHeader = JwtTokenHeader> = {
     readonly header: THeader;
     readonly payload: TPayload;
 };

package/utils/merge.d.ts

@@ -1,5 +1,5 @@
 import type { IsEqual, MergeDeep, MergeDeepOptions as TypeFestMergeDeepOptions } from 'type-fest';
-import type { If, Merge, Record, TypedOmit } from '../types.js';
+import type { If, Merge, Record, TypedOmit } from '../types/index.js';
 type BaseType = Record | any[] | Map<any, any> | Set<any>;
 export declare function merge<A extends BaseType, B extends BaseType>(a: A | undefined, b: B | undefined): A extends (infer T)[] ? B extends (infer U)[] ? (T | U)[] : never : A extends Map<infer K, infer V> ? B extends Map<infer K2, infer V2> ? Map<K | K2, V | V2> : never : A extends Set<infer T> ? B extends Set<infer U> ? Set<T | U> : never : A extends Record ? B extends Record ? Merge<A, B> : never : never;
 export type MergeDeepOptions = TypedOmit<TypeFestMergeDeepOptions, 'arrayMergeMode'> & {

package/utils/middleware.js

@@ -32,11 +32,11 @@ export function composeAsyncMiddleware(middlewares, options = {}) {
                 if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
                     throw new Error('next() called multiple times');
                 }
-                return dispatch(index + 1);
+                await dispatch(index + 1);
             }
-            return middleware(context, next); // eslint-disable-line consistent-return
+            await middleware(context, next);
         }
-        return dispatch(0);
+        await dispatch(0);
     }
     return composedMiddleware;
 }

package/utils/object/decycle.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 export type Decycled<T> = {
     __type: T;
 } & Record<string>;

package/utils/object/forward-ref.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 declare const isForwardRef: unique symbol;
 export type ForwardRefTypeHint = 'object' | 'function' | AbstractConstructor;
 export type ForwardRefOptions<T extends object = object> = {

package/utils/object/lazy-property.d.ts

@@ -1,4 +1,4 @@
-import type { Function, IfUnknown } from '../../types.js';
+import type { Function, IfUnknown } from '../../types/index.js';
 declare const lazyObjectValueSymbol: unique symbol;
 export type LazyPropertyInitializer<T, K extends keyof T> = (this: T, key: K) => T[K];
 export type LazyPropertyObjectDefinition<T extends object, P extends keyof T> = LazyPropertyDescriptor & {

package/utils/object/object.d.ts

@@ -1,5 +1,5 @@
 import { type JsonPathInput } from '../../json-path/json-path.js';
-import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types.js';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
 export declare function hasOwnProperty<T extends Record, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**

package/utils/object/property-name.d.ts

@@ -1,4 +1,4 @@
-import type { DeepFlatten, DeepNonNullable, Record } from '../../types.js';
+import type { DeepFlatten, DeepNonNullable, Record } from '../../types/index.js';
 export declare const propertyName: unique symbol;
 export declare const cast: unique symbol;
 export type PropertyName = {

package/utils/patch-worker.d.ts

@@ -1,5 +1,5 @@
 import { type Observable } from 'rxjs';
-import type { Record, StringMap } from '../types.js';
+import type { Record, StringMap } from '../types/index.js';
 export type PatchWorkerOptions<T extends StringMap> = {
     debounceTime?: number;
     retryDelay?: number;

package/utils/reactive-value-to-signal.d.ts

@@ -1,5 +1,5 @@
 import { type Signal, type ToSignalOptions } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
+import type { ReactiveValue } from '../types/index.js';
 export type ReactiveValueToSignalOptions<T> = ToSignalOptions<T>;
 export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>): Signal<T | undefined>;
 export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | undefined> & {

package/utils/reflection.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata/lite';
-import type { Type } from '../types.js';
+import type { Type } from '../types/index.js';
 export declare function getDesignType(target: object, propertyKey?: string | symbol): Type;
 export declare function hasDesignType(target: object, propertyKey?: string | symbol): boolean;
 export declare function getParameterTypes(target: object, propertyKey?: string | symbol): Type[] | undefined;

package/utils/repl.d.ts

@@ -1,5 +1,5 @@
 import type { ReplOptions } from 'node:repl';
-import type { Record } from '../types.js';
+import type { Record } from '../types/index.js';
 /**
  * Starts an interactive (repl) session (node only)
  * @param context context to set the repl context to

package/utils/singleton.d.ts

@@ -1,4 +1,4 @@
-import type { ObjectLiteral } from '../types.js';
+import type { ObjectLiteral } from '../types/index.js';
 export type Builder<T> = () => T;
 export type AsyncBuilder<T> = () => Promise<T>;
 export declare function singleton<T>(type: ObjectLiteral, builder: Builder<T>): T;

package/utils/stream/size-limited-stream.d.ts

@@ -1,2 +1,2 @@
-import type { BinaryData } from '../../types.js';
+import type { BinaryData } from '../../types/index.js';
 export declare function sizeLimitTransform<T extends BinaryData>(maxBytes: number, writableStrategy?: QueuingStrategy<T>, readableStrategy?: QueuingStrategy<T>): TransformStream<T, T>;

package/utils/type/extends.d.ts

@@ -1,3 +1,3 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 export declare function typeExtends<Type extends AbstractConstructor, Base extends Type>(type: Type, base: Base): type is Base;
 export declare function typeExtends<Base extends AbstractConstructor>(type: AbstractConstructor, base: Base): type is Base;

package/utils/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types/index.js';
 export type AssertionMessage = string | (() => string);
 export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
 export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;

package/utils/url-builder.d.ts

@@ -1,4 +1,4 @@
-import type { UndefinableJsonObject, UndefinableJsonPrimitive } from '../types.js';
+import type { UndefinableJsonObject, UndefinableJsonPrimitive } from '../types/index.js';
 export type UrlBuilderParameterValue = UndefinableJsonPrimitive;
 export type UrlBuilderParameters = UndefinableJsonObject;
 export type UrlBuilderOptions = {

package/utils/z-base32.d.ts

@@ -1,3 +1,3 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 export declare function zBase32Encode(buffer: BinaryData): string;
 export declare function zBase32Decode(input: string): Uint8Array;

package/module/utils.d.ts

@@ -1,4 +0,0 @@
-import type { Logger } from '../logger/index.js';
-import type { Module } from './module.js';
-export declare function runModules(modules: Module[], logger?: Logger): Promise<void>;
-export declare function stopModules(modules: Module[], logger?: Logger): Promise<void>;

package/module/utils.js

@@ -1,21 +0,0 @@
-export async function runModules(modules, logger) {
-    const promises = modules.map(async (module) => {
-        if (logger != undefined) {
-            logger.verbose(`starting module ${module.name}`);
-        }
-        await module.run();
-    });
-    await Promise.all(promises);
-}
-export async function stopModules(modules, logger) {
-    const promises = modules.map(async (module) => {
-        if (logger != undefined) {
-            logger.verbose(`stopping module ${module.name}`);
-        }
-        await module.stop();
-        if (logger != undefined) {
-            logger.verbose(`stopped module ${module.name}`);
-        }
-    });
-    await Promise.all(promises);
-}