@tstdl/base 0.92.123 → 0.92.124

package/types/utils/event-loop.d.ts

@@ -0,0 +1,4 @@
+import type { CancellationSignal } from '../../cancellation/token.js';
+import type { Logger } from '../../logger/index.js';
+export declare function measureEventLoopDelay(): Promise<number>;
+export declare function runEventLoopWatcher(logger: Logger, cancellationSignal: CancellationSignal): void;

package/types/utils/format-error.d.ts

@@ -0,0 +1,24 @@
+import type { UndefinableJson } from '../../types.js';
+export type FormatErrorOptions = {
+    /**
+     * Include error name in message
+     */
+    includeName?: boolean;
+    /**
+     * Include all error properties beside name and message
+     */
+    includeRest?: boolean | 'if-no-extra-info';
+    /**
+     * Include extraInfo from errors implementing {@link ErrorExtraInfo}
+     */
+    includeExtraInfo?: boolean;
+    /**
+     * Include stack trace
+     */
+    includeStack?: boolean;
+};
+export interface ErrorExtraInfo {
+    /** Format extra data (without message and stack) as JSON */
+    getExtraInfo(): UndefinableJson | undefined;
+}
+export declare function formatError(error: any, options?: FormatErrorOptions): string;

package/types/utils/function/class.d.ts

@@ -0,0 +1,6 @@
+import type { AbstractConstructor } from '../../../types.js';
+declare class EmptyClass {
+}
+export declare function getClassOfName(name: string): typeof EmptyClass;
+export declare function getClassOfName<T extends AbstractConstructor>(name: string, extend: T): T;
+export {};

package/types/utils/function/index.d.ts

@@ -0,0 +1,3 @@
+export * from './class.js';
+export * from './memoize.js';
+export * from './throttle.js';

package/types/utils/function/memoize.d.ts

@@ -0,0 +1,36 @@
+import type { Constructor } from '../../../types.js';
+export type MemoizeOptions = {
+    /** Use WeakMap instead of Map for caching. Can be used with object parameters only */
+    weak?: boolean;
+};
+/**
+ * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
+ * @param fn function memoize
+ * @returns memoized function
+ */ export declare function memoize<Fn extends (...parameters: any[]) => any>(fn: Fn, options?: MemoizeOptions): Fn;
+/**
+ * Memoizes a function with a single parameter. Faster than {@link memoize}
+ * @param fn function memoize
+ * @returns memoized function
+ */
+export declare function memoizeSingle<Fn extends (parameter: any) => any>(fn: Fn, options?: MemoizeOptions): Fn;
+export declare function memoizeClass<T extends Constructor>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
+export declare function memoizeClassSingle<T extends Constructor<any, [any]>>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
+/**
+ * Memoizes an accessor (getter)
+ *
+ * @example
+ * ```typescript
+ * class MyClass {
+ *   @Memoize()
+ *   get myValue() {
+ *     // expensive calculation
+ *     return 123;
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * The getter will be called only once for each instance of the class.
+ */
+export declare function Memoize(): MethodDecorator;

package/types/utils/iterable-helpers/take-until.d.ts

@@ -0,0 +1,2 @@
+import type { CancellationSignal } from '../../../cancellation/token.js';
+export declare function takeUntil<T>(iterable: Iterable<T>, cancellationSignal: CancellationSignal): IterableIterator<T>;

package/types/utils/jwt.d.ts

@@ -0,0 +1,32 @@
+import type { OneOrMany, StringMap } from '../types.js';
+import type { Key } from './cryptography.js';
+export type JwtTokenAlgorithm = 'HS256' | 'HS384' | 'HS512';
+export type JwtTokenHeader<T extends StringMap = StringMap> = {
+    alg: JwtTokenAlgorithm;
+    typ: 'JWT';
+} & T;
+export type JwtToken<TPayload = StringMap, THeader extends JwtTokenHeader = JwtTokenHeader> = {
+    readonly header: THeader;
+    readonly payload: TPayload;
+};
+export type JwtTokenParseResult<T extends JwtToken = JwtToken> = {
+    raw: string;
+    token: T;
+    encoded: {
+        header: string;
+        payload: string;
+        signature: string;
+    };
+    bytes: {
+        header: Uint8Array;
+        payload: Uint8Array;
+        signature: Uint8Array;
+    };
+    string: {
+        header: string;
+        payload: string;
+    };
+};
+export declare function parseJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string): JwtTokenParseResult<T>;
+export declare function createJwtTokenString(jwtToken: JwtToken, key: Key | string): Promise<string>;
+export declare function parseAndValidateJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string, allowedAlgorithms: OneOrMany<JwtTokenAlgorithm>, key: Key | string): Promise<T>;

package/types/utils/math.d.ts

@@ -0,0 +1,93 @@
+import { type RandomNumberGeneratorFn } from '../../random/number-generator/random-number-generator-function.js';
+/**
+ * Generate a random float in interval [min, max).
+ * @param min minimum value
+ * @param max maximum value
+ * @param generator Random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1).
+ * @returns random number (float)
+ */
+export declare function randomFloat(min: number, max: number, generator?: RandomNumberGeneratorFn): number;
+/**
+ * Generate a random integer in interval [min, max].
+ * @param min minimum value
+ * @param max maximum value
+ * @param generator random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1)
+ * @returns random number (integer)
+ */
+export declare function randomInt(min: number, max: number, generator?: RandomNumberGeneratorFn): number;
+/**
+ * Calculate the sum of all values.
+ * @param values values to sum
+ * @returns sum
+ */
+export declare function sum(values: number[]): number;
+/**
+ * Calculate the average of all values.
+ * @param values values to average
+ * @returns average
+ */
+export declare function average(values: number[]): number;
+/**
+ * Calculate the minimum value.
+ * @param values values to get minimum from
+ * @returns minimum
+ */
+export declare function minimum(values: number[]): number;
+/**
+ * Calculate the maximum value.
+ * @param values values to get maximum from
+ * @returns maximum
+ */
+export declare function maximum(values: number[]): number;
+/**
+ * Round number to specified decimals.
+ * @param value value to round
+ * @param decimals number of decimals to round to
+ * @returns rounded number
+ */
+export declare function round(value: number, decimals: number): number;
+/**
+ * Linearly interpolate the interval [fromLow, fromHigh] into [toLow, toHigh].
+ * @param value value to interpolate
+ * @param fromLow source lower bound
+ * @param fromHigh source upper bound
+ * @param toLow target lower bound
+ * @param toHigh target upper bound
+ * @returns interpolated value
+ */
+export declare function linearInterpolate(value: number, fromLow: number, fromHigh: number, toLow: number, toHigh: number): number;
+/**
+ * Linearly interpolate [0, 1] into an interval.
+ * @param value value to interpolate in interval [0, 1]
+ * @param low lower bound
+ * @param high upper bound
+ * @returns interpolated value
+ */
+export declare function linearInterpolateFloat(value: number, low: number, high: number): number;
+/**
+ * Clamps a number between two numbers.
+ * @param value value to clamp
+ * @param minimum lower bound
+ * @param maximum upper bound
+ * @returns clamped value
+ */
+export declare function clamp(value: number, minimum: number, maximum: number): number;
+/**
+ * Calculates the nth-root of a number.
+ *
+ * Warning: negative values are handled as if they were positive but returned with an negative sign.
+ * @param base base
+ * @param root root
+ * @returns nth-root of base
+ */
+export declare function nthRoot(base: number, root: number): number;
+/**
+ *
+ * @param t Time in interval [0, 1]
+ * @param attenuationExponentStart Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param attenuationExponentEnd Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param deadzoneWidthStart Deadzone width to add in front of 0.5. Sensible values are between 0 and 0.5
+ * @param deadzoneWidthEnd Deadzone width to add to interval [0.5, 1]. Sensible values are between 0 and 0.5
+ * @returns Coefficient in interval [0, 1]
+ */
+export declare function getAttenuationCoefficient(t: number, attenuationExponentStart: number | null, attenuationExponentEnd: number | null, deadzoneWidthStart?: number, deadzoneWidthEnd?: number): number;

package/types/utils/merge.d.ts

@@ -0,0 +1,19 @@
+import type { IsEqual, MergeDeep, MergeDeepOptions as TypeFestMergeDeepOptions } from 'type-fest';
+import type { If, Merge, Record, TypedOmit } from '../../types.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'> & {
+    arrayMergeMode?: TypeFestMergeDeepOptions['arrayMergeMode'] | 'mergeItems';
+};
+export declare function mergeDeep<A extends Record, B extends Record, Options extends MergeDeepOptions = {
+    arrayMergeMode: 'spread';
+    recurseIntoArrays: true;
+}>(a: A, b: B, options?: Options): MergeDeep<A, B, {
+    arrayMergeMode: If<IsEqual<Options['arrayMergeMode'], 'mergeItems'>, 'spread', Exclude<Options['arrayMergeMode'], 'mergeItems'>>;
+    recurseIntoArrays: Options['recurseIntoArrays'];
+}>;
+export declare function mergeArray<A extends readonly any[], B extends readonly any[], Mode extends NonNullable<MergeDeepOptions['arrayMergeMode']>>(a: A, b: B, mode: Mode): MergeDeep<A, B, {
+    recurseIntoArrays: true;
+    arrayMergeMode: If<IsEqual<Mode, 'mergeItems'>, 'spread', Exclude<Mode, 'mergeItems'>>;
+}>;
+export {};

package/types/utils/object/decycle.d.ts

@@ -0,0 +1,16 @@
+import type { Record } from '../../../types.js';
+export type Decycled<T> = {
+    __type: T;
+} & Record<string>;
+/**
+ * Replaces cycles (circular references) in objects with JSONPath
+ * @param value object to decycle
+ * @param replacer replace values. Like JSON.stringify(value, *replacer*)
+ */
+export declare function decycle<T>(value: T, replacer?: (value: any) => any): Decycled<T>;
+/**
+ * Replaces JSONPath in objects with their reference
+ * @param value object to recycle
+ */
+export declare function recycle<T = any>(value: Decycled<T>, clone?: boolean): T;
+export declare function recycle<T = any>(value: any, clone?: boolean): T;

package/types/utils/object/dereference.d.ts

@@ -0,0 +1,34 @@
+import { type JsonPathInput } from '../../../json-path/index.js';
+export type DereferenceOptions = {
+    optional?: boolean;
+};
+/**
+ * Compiles a dereferencer for a specific reference
+ * @param object object to dereference
+ * @param reference path to property in dot notation or {@link JsonPath}
+ * @returns referenced value
+ */
+export declare function compileDereferencer(reference: JsonPathInput, options?: DereferenceOptions): (object: object) => unknown;
+/**
+ * Dereference a reference
+ *
+ * @description useful if you dereference a reference a few times at most
+ *
+ * also take a look at {@link getCachedDereference} and {@link compileDereferencer} if you need to dereference multiple times
+ * @param object object to dereference
+ * @param reference path to property in dot notation or {@link JsonPath}
+ * @returns referenced value
+ */
+export declare function dereference(object: object, reference: JsonPathInput, options?: DereferenceOptions): unknown;
+/**
+ * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
+ *
+ * @description
+ * useful if you dereference multiple references, each multiple times
+ *
+ * also take a look at {@link dereference} and {@link compileDereferencer} for other use cases
+ * @param object object to dereference
+ * @param reference path to property in dot notation or {@link JsonPath}
+ * @returns referenced value
+ */
+export declare function getCachedDereference(options?: DereferenceOptions): typeof dereference;

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

@@ -0,0 +1,21 @@
+import type { AbstractConstructor } from '../../../types.js';
+declare const isForwardRef: unique symbol;
+export type ForwardRefTypeHint = 'object' | 'function' | AbstractConstructor;
+export type ForwardRefOptions<T extends object = object> = {
+    reference?: T;
+    initializer?: () => T;
+    /** Due to limitations of Proxy, there can be some issues if proxy is created with a target of the "wrong" type. If possible, you should specify the type the forward ref is going to forward to. */
+    typeHint?: ForwardRefTypeHint;
+};
+export type ForwardRef<T extends object = object> = T & {
+    [isForwardRef]: true;
+};
+export declare const ForwardRef: {
+    create<T extends object>(options?: ForwardRefOptions<T>): ForwardRef<T>;
+    isForwardRef<T extends object = object>(value: any): value is ForwardRef<T>;
+    hasRef<T extends object>(forwardRef: ForwardRef<T> | T): boolean;
+    deref<T extends object>(forwardRef: ForwardRef<T> | T): T;
+    tryDeref<T extends object>(forwardRef: ForwardRef<T> | T): T | undefined;
+    setRef<T extends object>(forwardRef: ForwardRef<T> | T, reference: T | undefined): void;
+};
+export {};

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

@@ -0,0 +1,49 @@
+import type { Function, IfUnknown } from '../../../types.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 & {
+    /** Define property with existing value */
+    value?: T[P];
+    /** Define property with getter */
+    get?: (this: T) => T[P];
+    /** Define property with setter */
+    set?: (this: T, value: T[P]) => void;
+    /** Lazily define property with initializer */
+    initializer?: LazyPropertyInitializer<T, P>;
+};
+export type LazyObjectValue<T> = {
+    [lazyObjectValueSymbol]: typeof lazyObjectValueSymbol;
+    value: T;
+};
+export type LazyInitializerItem<T extends object, P extends keyof T> = Exclude<IfUnknown<T[P], never, T[P]>, Function | object> | LazyPropertyInitializer<T, P> | LazyPropertyObjectDefinition<T, P> | LazyObjectValue<T[P]>;
+export type LazyPropertyDescriptor = {
+    /**
+     * True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object
+     * @default true
+     */
+    configurable?: boolean;
+    /**
+     * True if and only if this property shows up during enumeration of the properties on the corresponding object
+     * @default true
+     */
+    enumerable?: boolean;
+    /**
+     * True if the value associated with the property may be changed with an assignment operator
+     * @default true
+     */
+    writable?: boolean;
+};
+/**
+ *
+ * @param object object to define lazy property on
+ * @param propertyKey property key
+ * @param initializer
+ * @param descriptor
+ */
+export declare function lazyProperty<T extends object, K extends keyof T>(object: T, propertyKey: K, initializer: LazyPropertyInitializer<T, K>, descriptor?: LazyPropertyDescriptor): void;
+export declare function lazyObject<T extends object>(initializers: {
+    [P in keyof T]: LazyInitializerItem<T, P>;
+}): T;
+export declare function lazyObjectValue<T>(value: T): LazyObjectValue<T>;
+export declare function isLazyObjectValue<T>(value: any): value is LazyObjectValue<T>;
+export {};

package/types/utils/object/object.d.ts

@@ -0,0 +1,30 @@
+import { type JsonPathInput } from '../../../json-path/json-path.js';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../../types.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;
+/**
+ * Returns object entries including those with symbols keys (which Object.entries does not)
+ */
+export declare function objectEntries<T extends ObjectLiteral>(object: T): [keyof T, T[keyof T]][];
+/**
+ * Returns object keys including symbols (which Object.keys does not)
+ */
+export declare function objectKeys<T extends ObjectLiteral>(object: T): (keyof T)[];
+export declare function objectValues<T extends ObjectLiteral>(object: T): (T[keyof T])[];
+export declare function fromEntries<A>(entries: A): FromEntries<A>;
+export declare function fromEntries<K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>): Record<K, T>;
+export declare function mapObject<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
+export declare function mapObjectAsync<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
+export declare function mapObjectValues<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => V): Record<keyof T, V>;
+export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<V>): Promise<Record<keyof T, V>>;
+export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
+export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
+export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
+export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
+export declare function copyObjectProperties<T extends ObjectLiteral>(source: T, target: T): void;
+export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: U, bind: boolean): () => T[U];
+export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];
+export declare function fromDeepObjectEntries(entries: readonly (readonly [JsonPathInput, any])[]): ObjectLiteral;
+export declare function omit<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Omit<T, K>>;
+export declare function pick<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Pick<T, K>>;

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

@@ -0,0 +1,61 @@
+import type { DeepFlatten, DeepNonNullable, Record } from '../../../types.js';
+export declare const propertyName: unique symbol;
+export declare const cast: unique symbol;
+export type PropertyName = {
+    [propertyName]: string;
+};
+export type PropertyNameProxy<T extends Record> = {
+    [P in keyof DeepNonNullable<T>]: PropertyNameProxyChild<T[P]>;
+};
+export type PropertyNameProxyChild<T> = (T extends Record ? (PropertyNameProxy<T> & PropertyName) : (PropertyName)) & {
+    [cast]<U extends T>(): PropertyNameProxyChild<U>;
+};
+export type PropertyNameOfExpressionObject<T> = {
+    [P in keyof T]: PropertyNameOfExpressionObject<DeepNonNullable<T>[P]> & {
+        [cast]<U extends T[P]>(): PropertyNameOfExpressionObject<DeepNonNullable<U>>;
+    };
+};
+export type FlatPropertyNameOfExpressionObject<T> = {
+    [P in keyof DeepFlatten<T>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
+        [cast]<U extends DeepFlatten<T>[P]>(): FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
+    };
+};
+export declare function getPropertyName(name: string): PropertyName;
+export declare function isPropertyName(value: any): value is PropertyName;
+/**
+ * Get the path to a property
+ *
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @param options.flat Ignore array accesses (properties consiting only of numbers)
+ * @param options.prefix Name prefix
+ *
+ * @example
+ * import { getPropertyNameProxy, propertyName } from '@tstdl/base/utils/object.js';
+ *
+ * const name = getPropertyNameProxy<MyType>().foo.bar[propertyName];
+ *
+ * name == 'foo.bar' // true
+ */
+export declare function getPropertyNameProxy<T extends Record = Record>(options?: {
+    deep?: boolean;
+    flat?: boolean;
+    prefix?: string;
+}): PropertyNameProxy<T>;
+/**
+ * Get the path to a property
+ * @param expression Property selection expression
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @returns Property name
+ */
+export declare function propertyNameOf<T extends Record = Record>(expression: (instance: PropertyNameOfExpressionObject<T>) => any, options?: {
+    deep?: boolean;
+}): string;
+/**
+ * Get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
+ * @param expression Property selection expression
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @returns Property name
+ */
+export declare function flatPropertyNameOf<T extends Record = Record>(expression: (instance: FlatPropertyNameOfExpressionObject<T>) => any, options?: {
+    deep?: boolean;
+}): string;

package/types/utils/patch-worker.d.ts

@@ -0,0 +1,25 @@
+import { type Observable } from 'rxjs';
+import type { Record, StringMap } from '../../types.js';
+export type PatchWorkerOptions<T extends StringMap> = {
+    debounceTime?: number;
+    retryDelay?: number;
+    handleOn?: Observable<any>;
+    completeOn?: Observable<any>;
+    handler(patch: Partial<T>): void | Promise<void>;
+    errorHandler?(error: Error): void | Promise<void>;
+};
+export declare class PatchWorker<T extends Record> {
+    private readonly patchAddedSubject;
+    private readonly handleSubject;
+    private readonly completeToken;
+    private readonly options;
+    private patch;
+    constructor(options: PatchWorkerOptions<T>);
+    handleOn(observable: Observable<any>): void;
+    completeOn(observable: Observable<any>): void;
+    add(patch: Partial<T>): void;
+    add<P extends keyof T>(key: P, value: T[P]): void;
+    handle(): void;
+    complete(): void;
+    private handleLoop;
+}

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

@@ -0,0 +1,20 @@
+import { type Signal, type ToSignalOptions } from '../../signals/api.js';
+import type { ReactiveValue } from '../../types.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> & {
+    initialValue?: undefined;
+    requireSync?: false;
+}): Signal<T | undefined>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | null> & {
+    initialValue?: null;
+    requireSync?: false;
+}): Signal<T | null>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T> & {
+    initialValue?: undefined;
+    requireSync: true;
+}): Signal<T>;
+export declare function reactiveValueToSignal<T, const I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | I> & {
+    initialValue: I;
+    requireSync?: false;
+}): Signal<T | I>;

package/types/utils/reflection.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata/lite';
+import type { Type } from '../../types.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;
+export declare function hasParameterTypes(target: object, propertyKey?: string | symbol): boolean;
+export declare function getReturnType(target: object, propertyKey?: string | symbol): Type;
+export declare function hasReturnType(target: object, propertyKey?: string | symbol): boolean;

package/types/utils/repl.d.ts

@@ -0,0 +1,9 @@
+import type { ReplOptions } from 'node:repl';
+import type { Record } from '../../types.js';
+/**
+ * Starts an interactive (repl) session (node only)
+ * @param context context to set the repl context to
+ */
+export declare function repl(options?: ReplOptions & {
+    context?: Record<string, unknown>;
+}): Promise<void>;

package/types/utils/singleton.d.ts

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

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

@@ -0,0 +1,3 @@
+import { type ValueOrProvider } from '../value-or-provider.js';
+export declare function readableStreamFromPromise<T>(promiseOrProvider: ValueOrProvider<Promise<ReadableStream<T>>>): ReadableStream<T>;
+export declare function transformStreamFromPromise<I, O>(promiseOrProvider: ValueOrProvider<Promise<TransformStream<I, O>>>): TransformStream<I, O>;

package/types/utils/stream/index.d.ts

@@ -0,0 +1,9 @@
+export * from './finalize-stream.js';
+export * from './readable-stream-adapter.js';
+export * from './from-promise.js';
+export * from './size-limited-stream.js';
+export * from './slice.js';
+export * from './stream-helper-types.js';
+export * from './stream-reader.js';
+export * from './to-bytes-stream.js';
+export * from './to-readable-stream.js';

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

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

package/types/utils/timing.d.ts

@@ -0,0 +1,20 @@
+import { type Observable } from 'rxjs';
+import { CancellationSignal } from '../../cancellation/token.js';
+import { type ValueOrProvider } from './value-or-provider.js';
+/** Timeout for specified duration */
+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, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
+/** Timeout until specified time */
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): 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>;
+export declare function idle(timeout?: number): Promise<IdleDeadline>;

package/types/utils/try-ignore.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from '../../logger/logger.js';
+export declare function tryIgnore<R>(fn: () => R): R;
+export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
+export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R;
+export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;

package/types/utils/type/extends.d.ts

@@ -0,0 +1,3 @@
+import type { AbstractConstructor } from '../../../types.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;