@tstdl/base 0.92.124 → 0.92.125

package/utils/backoff.d.ts

@@ -0,0 +1,77 @@
+import type { CancellationSignal } from '../cancellation/token.js';
+import { CancellationToken } from '../cancellation/token.js';
+export type BackoffStrategy = 'linear' | 'exponential';
+export type BackoffOptions = {
+    /**
+     * how to increase delay
+     */
+    strategy: BackoffStrategy;
+    /**
+     * delay to start with
+     */
+    initialDelay: number;
+    /**
+     * amount to increase/multiply delay by/with
+     */
+    increase: number;
+    /**
+     * miaxmum time to back off
+     */
+    maximumDelay?: number;
+};
+export type BackoffLoopController = {
+    /**
+     * backoff before next iteration
+     */
+    backoff: () => void;
+    /**
+     * break out of loop
+     */
+    break: () => void;
+};
+export type BackoffLoopFunction = (controller: BackoffLoopController) => void | Promise<void>;
+/**
+ * @param continueToken token to continue loop immediately
+ */
+export type BackoffGeneratorYield = (continueToken?: CancellationToken) => void;
+export declare class BackoffHelper {
+    private readonly strategy;
+    private readonly initialDelay;
+    private readonly increase;
+    private readonly maximumDelay;
+    private delay;
+    constructor({ strategy, initialDelay, increase, maximumDelay }: BackoffOptions);
+    reset(): void;
+    backoff(): number;
+}
+/**
+ * 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
+ */
+export declare function autoBackoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
+    cancellationSignal?: CancellationSignal;
+    errorHandler?: (error: Error) => void;
+}): Promise<void>;
+/**
+ * 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
+ */
+export declare function backoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
+    cancellationSignal?: CancellationSignal;
+}): Promise<void>;
+/**
+ * generates endless function which, when called, backs off next iteration
+ * @param options backoff options
+ * @param cancellationSignal signal to cancel loop
+ * @example
+ * for await (const backoff of backoffGenerator(options, token)) {
+ *  if (iWantToBackoff) {
+ *    backoff();
+ *  }
+ * }
+ */
+export declare function backoffGenerator(options: BackoffOptions, cancellationSignal: CancellationSignal): AsyncIterableIterator<BackoffGeneratorYield>;

package/utils/binary.d.ts

@@ -0,0 +1,16 @@
+import type { BinaryData, Type } from '../types.js';
+/**
+ * Get ArrayBuffer from binary data
+ * @param data data to get ArrayBuffer from
+ * @param clone force cloning (might still clone if datas underlying buffer is larger than its view)
+ */
+export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayBufferLike;
+/**
+ * Convert to Uint8Array
+ * @param data binary data
+ * @param clone whether to clone buffer or not
+ */
+export declare function toUint8Array(data: BinaryData, clone?: boolean): Uint8Array;
+export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBufferLike;
+export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: T[], totalLength?: number): T;
+export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: ArrayBufferView[], targetType: Type<T, [ArrayBufferLike, number, number]>, totalLength?: number): T;

package/utils/cryptography.d.ts

@@ -0,0 +1,122 @@
+import type { BinaryData, TypedExtract } from '../types.js';
+import type { ReadonlyTuple } from 'type-fest';
+export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
+export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
+export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+export type SymmetricAlgorithm = `AES-${AesMode}`;
+export type AsymmetricAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP' | 'ECDSA' | 'ECDH' | 'NODE-DSA' | 'NODE-DH' | 'NODE-ED25519' | 'NODE-ED448';
+export type CryptionAlgorithm = Parameters<typeof globalThis.crypto.subtle.encrypt>[0];
+export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
+export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
+export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
+export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
+export type Key = JsonWebKey | BinaryData;
+export type ScryptOptions = {
+    cost?: number;
+    blockSize?: number;
+    parallelization?: number;
+    maximumMemory?: number;
+};
+export interface CryptionResult {
+    toBuffer(): Promise<ArrayBuffer>;
+    toHex(): Promise<string>;
+    toBase64(): Promise<string>;
+    toBase64Url(): Promise<string>;
+    toZBase32(): Promise<string>;
+}
+export interface DecryptionResult extends CryptionResult {
+    toUtf8(): Promise<string>;
+}
+export type DigestResult = CryptionResult;
+export type SignResult = CryptionResult;
+/**
+ * Encrypt data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param data data to encrypt. Encodes string to utf8
+ */
+export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData | string): CryptionResult;
+/**
+ * Decrypt data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param data data to decrypt
+ */
+export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData): DecryptionResult;
+/**
+ * Hashes data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param data data to encrypt. Encodes string to utf8
+ */
+export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData | string): DigestResult;
+/**
+ * Signs data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param data data to sign
+ */
+export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData | string): SignResult;
+/**
+ * Verifies data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param signature signature
+ * @param data data to verify using provided signature
+ */
+export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData | string, data: BinaryData | string): Promise<boolean>;
+/**
+ * Imports a HMAC CryptoKey
+ * @param algorithm hash algorithm
+ * @param key JWK or binary key
+ * @param extractable whether the key can be used for exportKey
+ */
+export declare function importHmacKey(algorithm: HashAlgorithmIdentifier, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Imports a CryptoKey for symmetric encryption
+ * @param algorithm symmetric algorithm
+ * @param length key length
+ * @param key JWK or binary key
+ * @param extractable whether the key can be used for exportKey
+ */
+export declare function importSymmetricKey(algorithm: SymmetricAlgorithm, length: 128 | 192 | 256, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Imports an ECDSA CryptoKey
+ * @param curve ECDSA curve
+ * @param key JWK or DER encoded key
+ * @param extractable whether the key can be used for exportKey
+ */
+export declare function importEcdsaKey(curve: EcdsaCurve, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Import a pbkdf2 CryptoKey
+ * @param key binary key
+ * @param extractable whether the key can be used for exportKey
+ */
+export declare function importPbkdf2Key(key: BinaryData | string, extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Generates a new ECDSA CryptoKeyPair
+ * @param curve ECDSA cruve to use
+ * @param extractable whether the key can be used for exportKey
+ * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
+ */
+export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolean, usages?: TypedExtract<KeyUsage, 'sign' | 'verify'>[]): Promise<CryptoKeyPair>;
+/**
+ * Generates a pbkdf2 CryptoKey
+ * @param extractable whether the key can be used for exportKey
+ */
+export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
+/**
+ * Derive byte array from key
+ * @param length length in bytes
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ */
+export declare function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: number): Promise<Uint8Array>;
+/**
+ * Derive multiply byte arrays from key
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array
+ * @param count how many Uint8Arrays to derive
+ */
+export declare function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array, Lengths['length']>>;
+export declare function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array, C>>;

package/utils/encoding.d.ts

@@ -0,0 +1,36 @@
+import type { BinaryData } from '../types.js';
+/**
+ * Encodes text to utf8
+ * @param text text to encode
+ * @returns utf8 encoded text
+ */
+export declare function encodeUtf8(text: string): Uint8Array;
+/**
+ * Encodes text stream to utf8 bytes stream
+ */
+export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array>;
+/**
+ * Decodes buffer to string
+ * @param buffer buffer to decode
+ * @param encoding encoding, defaults to utf8
+ * @returns decoded string
+ */
+export declare function decodeText(buffer: BinaryData, encoding?: string, options?: TextDecoderOptions): string;
+/**
+ * Transforms binary stream to string stream
+ * @param encoding encoding, defaults to utf8
+ * @returns stream of decoded string
+ */
+export declare function decodeTextStream(encoding?: string, options?: TextDecoderOptions): TransformStream<BinaryData, string>;
+/**
+ * Encodes buffer to hex
+ * @param buffer buffer to encode
+ * @returns hex encoded string
+ */
+export declare function encodeHex(buffer: BinaryData): string;
+/**
+ * Decodes hex string to buffer
+ * @param hex hex string to decode
+ * @returns decoded buffer
+ */
+export declare function decodeHex(hex: string): Uint8Array;

package/utils/enum.d.ts

@@ -0,0 +1,9 @@
+import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types.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>[];
+export declare function enumValues<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>[];
+export declare function randomEnumValue<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>;
+export declare function reversedEnum<T extends EnumerationObject>(enumeration: T): {
+    [P in keyof T as T[P]]: P;
+};

package/utils/equals.d.ts

@@ -0,0 +1,30 @@
+import type { BinaryData } from '../types.js';
+import type { Comparator } from './sort.js';
+export interface Equals<T = unknown> {
+    [Equals.symbol](other: T): boolean;
+}
+declare const equalsSymbol: unique symbol;
+export declare const Equals: {
+    readonly symbol: typeof equalsSymbol;
+};
+export type ArrayEqualsComparator<A, B> = (a: A, b: B) => boolean;
+export type ArrayEqualsOptions<A, B> = {
+    sort?: Comparator<A | B>;
+    comparator?: ArrayEqualsComparator<A, B>;
+};
+export declare function strictEquals(a: any, b: any): boolean;
+export declare function arrayEquals<A, B>(a: readonly A[], b: readonly B[], options?: ArrayEqualsOptions<A, B>): boolean;
+export type EqualsOptions = {
+    deep?: boolean;
+    arrayDeep?: boolean;
+    sortArray?: boolean;
+    coerceStrings?: boolean;
+    checkPrototype?: boolean;
+};
+export declare function equals(a: any, b: any, options?: EqualsOptions): boolean;
+export declare function equals(a: any, b: any, options?: EqualsOptions, __internal?: any): boolean;
+/**
+ * compares to binary types for equal content
+ */
+export declare function binaryEquals(bufferA: BinaryData, bufferB: BinaryData): boolean;
+export {};

package/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/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/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/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/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/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/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/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/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/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/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/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>>;