@zajno/common 2.3.18 → 2.4.0

package/types/math/object/ops.d.ts

@@ -0,0 +1,20 @@
+import { SkipCondition, SkipOptions } from '../../fields/skip';
+import { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types';
+import { IObjectOps, NumKey } from './types';
+type Keys<T extends AnyObject> = NumKey<T>[];
+export declare class ObjectOps<T extends AnyObject> implements IObjectOps<T> {
+    readonly keys: Keys<T>;
+    readonly Empty: Readonly<T>;
+    protected _validator: Predicate<DeepReadonly<T>> | undefined;
+    constructor(keys: Keys<T>);
+    addValidator(validator: Predicate<DeepReadonly<T>>): this;
+    getEmpty(): T;
+    clone(o: DeepReadonly<T>): T;
+    isEmpty(o: DeepReadonly<T>): boolean;
+    isValid(o: DeepReadonly<T>): boolean;
+    isEquals(a: DeepReadonly<T>, b: DeepReadonly<T>): boolean;
+    strip(v: DeepReadonly<T>, condition?: SkipCondition<T, NumKey<T>>): DeepPartial<T>;
+    toStringData(v: DeepReadonly<T>, labels: Readonly<Record<Keys<T>[number], string>>, strip?: SkipOptions): [number, string][];
+    assign(to: T, other: DeepReadonly<T>): void;
+}
+export {};

package/types/math/object/types.d.ts

@@ -0,0 +1,36 @@
+import { AnyObject, DeepReadonly, TypedKeys } from '../../types';
+export type NumKey<T extends AnyObject> = TypedKeys<T, number>;
+export type AbsOptions = false | 'remove' | 'zero';
+export type RoundOptions = 'floor' | 'ceil' | 'round';
+export type DELETE_TYPE = 'delete';
+export interface IObjectOps<T extends AnyObject> {
+    readonly Empty: Readonly<T>;
+    isEmpty(o: DeepReadonly<T>): boolean;
+    getEmpty(): T;
+    clone(o: DeepReadonly<T>): T;
+    isValid(o: DeepReadonly<T>): boolean;
+    isEquals(a: DeepReadonly<T>, b: DeepReadonly<T>): boolean;
+    assign(to: T, other: DeepReadonly<T>): void;
+}
+export interface IObjectMath<T extends AnyObject> extends IObjectOps<T> {
+    contains(base: DeepReadonly<T>, target: DeepReadonly<T>): boolean;
+    inverse(o: DeepReadonly<T>): T;
+    abs(o: DeepReadonly<T>, options?: AbsOptions): T | null;
+    round(o: DeepReadonly<T>, options?: RoundOptions): T | null;
+    add(o1: DeepReadonly<T>, o2: DeepReadonly<T>): T;
+    subtract(base: DeepReadonly<T>, amount: DeepReadonly<T> | number): T;
+    multiply(o1: DeepReadonly<T>, o2: DeepReadonly<T> | number): T;
+    div(o1: DeepReadonly<T>, o2: DeepReadonly<T> | number): number;
+}
+export type BasePair<T extends AnyObject, TKey extends string & keyof T = string & keyof T, TOps extends IObjectOps<T[TKey]> = IObjectOps<T[TKey]>> = {
+    key: TKey;
+    ops: TOps;
+};
+export type OpsPair<T extends AnyObject, TKey extends string & keyof T = string & keyof T> = BasePair<T, TKey, IObjectOps<T[TKey]>>;
+export type MathPair<T extends AnyObject, TKey extends string & keyof T = string & keyof T> = BasePair<T, TKey, IObjectMath<T[TKey]>>;
+export type OpsPairsMap<T extends AnyObject> = {
+    [K in keyof T]?: IObjectOps<T[K]>;
+};
+export type MathPairsMap<T extends AnyObject> = {
+    [K in keyof T]?: IObjectMath<T[K]>;
+};

package/types/models/EntityWithStatus.d.ts

@@ -0,0 +1,17 @@
+export type StatusWithDate<TStatus extends string = string> = {
+    status: TStatus | null;
+    date: number;
+};
+type HistoryItem<TStatus extends string> = {
+    d: number;
+    s: TStatus | null;
+};
+export type EntityWithStatus<TStatus extends string> = StatusWithDate<TStatus> & {
+    history?: HistoryItem<TStatus>[];
+};
+export declare namespace EntityWithStatus {
+    function changeStatus<T extends EntityWithStatus<TStatus>, TStatus extends string>(entity: Partial<T>, status: TStatus, date?: number | null, allowStatusUpdate?: boolean): boolean;
+    function getLastStatusDate<T extends EntityWithStatus<TStatus>, TStatus extends string>(entity: T, ...statuses: TStatus[]): number | null;
+    function getFullHistory<T extends EntityWithStatus<TStatus>, TStatus extends string>(entity: T): StatusWithDate<TStatus>[];
+}
+export {};

package/types/models/File.d.ts

@@ -0,0 +1,9 @@
+export type FileMetadata = {
+    name: string;
+    /** size in bytes */
+    size: number;
+    /** refers to MIME type */
+    type: string;
+    format?: string;
+    lang?: string;
+};

package/types/models/Model.d.ts

@@ -0,0 +1,12 @@
+import type { IValueModel } from './types';
+import { Getter } from '../types/getter';
+import { Nullable } from '../types/misc';
+export declare class Model<T> implements IValueModel<Nullable<T>> {
+    private _value;
+    private readonly _defaultValue;
+    constructor(v?: Getter<Nullable<T>>);
+    get value(): T;
+    set value(v: T);
+    setValue(value: Getter<Nullable<T>>): void;
+    reset(): void;
+}

package/types/models/ValuesCollector.d.ts

@@ -0,0 +1,25 @@
+import type { IValueModel } from './types';
+export interface IValueCollector<TSource, TValue> {
+    getValue(source: TSource): TValue;
+    setValue(source: TSource, value: TValue): void;
+}
+type SimpleCollector<T> = {
+    get: () => T;
+    set: (t: T) => void;
+};
+export type ModelCollectorsMap<T> = {
+    [P in keyof T]?: IValueModel<T[P]>;
+};
+export type CollectorsMap<T> = {
+    [P in keyof T]?: SimpleCollector<T[P]>;
+};
+export declare class ModelCollector<T extends object> {
+    private readonly _collectors;
+    addModels(models: ModelCollectorsMap<T>): this;
+    addModel<TKey extends keyof T, TSource extends IValueModel<T[TKey]>>(key: TKey, source: TSource): this;
+    addCollector<TKey extends keyof T, TModel, TCollector extends IValueCollector<TModel, T[TKey]>>(key: TKey, model: TModel, collector: TCollector): this;
+    remove(key: keyof T): this;
+    collect(): T;
+    populate(data: T): void;
+}
+export {};

package/types/models/types.d.ts

@@ -0,0 +1,24 @@
+export interface IValueModelReadonly<TValue> {
+    readonly value: TValue;
+}
+export interface IValueModel<TValue> extends IValueModelReadonly<TValue> {
+    value: TValue;
+}
+export interface ILabel<T> {
+    readonly label: T;
+}
+export interface IResetableModel {
+    readonly reset: () => void;
+    readonly isDefault?: boolean;
+}
+export interface IFocusableModel {
+    focused: boolean;
+}
+export interface IErrorModel {
+    readonly error: string;
+}
+export interface ICountableModel {
+    readonly count: number;
+    readonly selectedCount?: number;
+    readonly isEmpty: boolean;
+}

package/types/models/wrappers.d.ts

@@ -0,0 +1,17 @@
+import { Getter } from '../types/getter';
+import type { ILabel, IValueModel } from './types';
+export declare function withLabel<T, TModel extends IValueModel<T>, TLabel = string>(model: TModel, label: Getter<TLabel>): TModel & ILabel<TLabel>;
+export declare function inject<T, TModel extends IValueModel<T>>(model: TModel, source: IValueModel<T>): TModel;
+/**
+ * Adds callbacks to setter and getter of the 'value' property of a model. DOES NOT override previous spies (all spies are in charge).
+ *
+ * Useful mostly for debugging.
+ * */
+export declare function spyModel<T, TModel extends (IValueModel<T> & object)>(model: TModel, spySetter: (v: T) => void, spyGetter?: (v: T) => void): void;
+export declare function wrap<TSource, TRes>(model: TSource, getter: (m: TSource) => TRes, setter: (v: TRes, model: TSource) => void): IValueModel<TRes>;
+type LabeledModel<T, TModel extends IValueModel<T>, TLabel = string> = TModel & ILabel<TLabel>;
+interface LabeledModelCtor<T, TModel extends IValueModel<T>, TLabel = string> {
+    new (label?: Getter<TLabel>, initial?: T): LabeledModel<T, TModel, TLabel>;
+}
+export declare function mixinLabel<T, TModel extends IValueModel<T>, TLabel = string>(Superclass: new (initial?: T) => TModel): LabeledModelCtor<T, TModel, TLabel>;
+export {};

package/types/observing/event.d.ts

@@ -0,0 +1,25 @@
+import type { Predicate } from '../types';
+import { ILogger } from '../logger';
+export type EventHandler<T = any> = (data?: T) => void | Promise<void>;
+type Unsubscribe = () => void;
+export interface IEvent<T = any> {
+    on(handler: EventHandler<T>): () => void;
+    off(handler: EventHandler<T>): void;
+}
+export declare class Event<T = any> implements IEvent<T> {
+    private _handlers;
+    private _logger;
+    constructor(withDefaultLogger?: boolean);
+    withLogger(logger?: ILogger | null): this;
+    withLogger(name?: string | null): this;
+    /** Clears handlers list */
+    resetHandlers: () => void;
+    on(handler: EventHandler<T>): Unsubscribe;
+    off(handler: EventHandler<T>): void;
+    trigger(data?: T): void;
+    triggerAsync(data?: T): Promise<Error[]>;
+    expose(): IEvent<T>;
+    private logError;
+}
+export declare function oneTimeSubscription<T>(e: IEvent<T>, filter?: Predicate<T | undefined>): Promise<T | undefined>;
+export {};

package/types/observing/event.late.d.ts

@@ -0,0 +1,10 @@
+import { Event, EventHandler } from './event';
+export declare class OneTimeLateEvent<T = any> extends Event<T> {
+    private _triggeredWith;
+    private _triggered;
+    trigger(data?: T): void;
+    triggerAsync(data?: T): Promise<Error[]>;
+    on(handler: EventHandler<T>): () => void;
+    /** Allows this event to be triggered again and existing subscribers to receive it */
+    reset: () => void;
+}

package/types/observing/progressTracker.d.ts

@@ -0,0 +1,27 @@
+import { ILogger } from '../logger';
+export declare class ProgressTracker {
+    readonly log: boolean | ILogger;
+    private readonly _firstTimestamp;
+    private _lastTimestamp;
+    private _lastCompleted;
+    private _completed;
+    private _total;
+    private _currentProgress;
+    private readonly _deltas;
+    private readonly _changed;
+    constructor(log?: boolean | ILogger);
+    get changed(): import("./event").IEvent<{
+        completed: number;
+        total: number;
+        currentProgress: number;
+        totalElapsedMs: number;
+        totalEstimatedMs: number;
+    }>;
+    get total(): number;
+    get completed(): number;
+    get current(): number;
+    private get logger();
+    setTotal(total: number): this;
+    add(amount?: number, restart?: boolean): void;
+    track(completed: number, total: number): void;
+}

package/types/observing/throttledEvent.d.ts

@@ -0,0 +1,7 @@
+import { Event } from './event';
+export declare class ThrottledEvent extends Event {
+    private readonly _throttle;
+    setTimeout(timeout: number): this;
+    trigger(): void;
+    triggerAsync(): Promise<Error[]>;
+}

package/types/observing/timer.d.ts

@@ -0,0 +1,41 @@
+import { IDisposable } from '../functions/disposer';
+import { EventHandler, IEvent } from './event';
+export type TimerState = {
+    timer: Timer;
+    elapsed: number;
+    left: number;
+    now: number;
+};
+export declare class Timer implements IDisposable, IEvent<TimerState> {
+    readonly interval: number;
+    private readonly _event;
+    private readonly _onFinished;
+    private _now;
+    private _elapsed;
+    private _left;
+    private _duration;
+    private _handle;
+    /**
+     * @param interval timer firing interval in milliseconds
+     * @param start whether to start the timer immediately. default is `true`
+     */
+    constructor(interval?: number, start?: boolean);
+    /** the timestamp when the timer last fired  */
+    get now(): number;
+    /** the duration of the timer in milliseconds. If was not set, `Number.MAX_SAFE_INTEGER` */
+    get duration(): number;
+    /** the elapsed milliseconds since the timer started */
+    get elapsed(): number;
+    /** left milliseconds for this timer. If duration was not set, `Number.MAX_SAFE_INTEGER` */
+    get left(): number;
+    /** Fired when the timer has finished by duration, if set */
+    get onFinished(): IEvent<TimerState>;
+    /** Adds duration in milliseconds for the timer so it will auto-stop when elapsed is >= duration */
+    withDuration(duration: number): this;
+    on(handler: EventHandler<TimerState>): () => void;
+    off(handler: EventHandler<TimerState>): void;
+    /** (Re-)Starts the timer */
+    restart(): void;
+    /** Stops the timer but does not clean all counters. */
+    dispose(): void;
+}

package/types/storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './wrappers';

package/types/storage/types.d.ts

@@ -0,0 +1,12 @@
+import type { RemoveFirstParameter, Awaitify } from '../types/functions';
+export interface IStorage<T = string> {
+    getValue(key: string): Promise<T | null>;
+    setValue(key: string, value: T): Promise<void>;
+    hasValue(key: string): Promise<boolean>;
+    removeValue(key: string): Promise<boolean>;
+}
+export type IKeyedStorage<T = string> = {
+    [P in keyof IStorage<T>]: RemoveFirstParameter<IStorage<T>[P]>;
+};
+export type IStorageSync<T = string> = Awaitify<IStorage<T>>;
+export type IKeyedStorageSync<T = string> = Awaitify<IKeyedStorage<T>>;

package/types/storage/wrappers.d.ts

@@ -0,0 +1,10 @@
+import type { IKeyedStorage, IKeyedStorageSync, IStorage, IStorageSync } from './types';
+export declare namespace Storages {
+    function toAsync<T = string>(storage: IStorageSync<T>): IStorage<T>;
+    function toKeyed<T = string>(storage: IStorage<T>, storageKey: string): IKeyedStorage<T>;
+    function toKeyed<T = string>(storage: IStorageSync<T>, storageKey: string): IKeyedStorageSync<T>;
+    function toConverted<T, C = string>(storage: IStorage<C>, convertOutput: (s: C | null) => T, convertInput: (v: T) => C): IStorage<T>;
+    function toConverted<T, C = string>(storage: IStorageSync<C>, convertOutput: (s: C | null) => T, convertInput: (v: T) => C): IStorageSync<T>;
+    function toJSONConverted<T>(storage: IStorage<string>): IStorage<T>;
+    function toJSONConverted<T>(storage: IStorageSync<string>): IStorageSync<T>;
+}

package/types/structures/expire.d.ts

@@ -0,0 +1,13 @@
+export interface IExpireTracker {
+    readonly isExpired: boolean;
+    restart(): void;
+}
+export declare class ExpireTracker implements IExpireTracker {
+    readonly lifetimeMs: number;
+    private _expiringAt;
+    constructor(lifetimeMs: number);
+    get isExpired(): boolean;
+    restart(): void;
+    get remainingMs(): number;
+    expire(): void;
+}

package/types/structures/helpers/enum.d.ts

@@ -0,0 +1,36 @@
+export declare class EnumStringHelper<T extends string> {
+    protected readonly _obj: any;
+    private readonly _valuesToStrings;
+    readonly Keys: string[];
+    readonly Values: T[];
+    constructor(_obj: any, _valuesToStrings?: {
+        [val: string]: string;
+    } | null);
+    keyToString(key: string): string;
+    valueToString(v: T): string;
+    validateValue(v: string | null): T | null;
+}
+type ValueToStringMap = {
+    [val: number]: string;
+};
+export default class EnumHelper<T extends number> {
+    protected readonly _obj: any;
+    private readonly _valuesToStrings;
+    readonly Keys: string[];
+    readonly Values: T[];
+    constructor(_obj: any, _valuesToStrings?: ValueToStringMap | null);
+    keyToString(key: string, overrideMap?: ValueToStringMap | null): string;
+    keyToValue(key: string): T | null;
+    valueToString(v: T, overrideMap?: ValueToStringMap | null): string;
+    validateValue(v: number | null): T | null;
+}
+export declare class EnumBitwiseHelper<T extends number> extends EnumHelper<T> {
+    toStrings(value: T, overrideMap?: ValueToStringMap | null): string[];
+    toString(value: T, separator?: string, overrideMap?: ValueToStringMap | null): string;
+    contains(base: T, target: T): boolean;
+    combine(...values: T[]): number;
+    add(value: T, other: T): number;
+    intersection(v1: T, v2: T): number;
+    remove(value: T, other: T): number;
+}
+export {};

package/types/structures/helpers/name.d.ts

@@ -0,0 +1,15 @@
+export type DisplayName = {
+    displayName: string;
+};
+export type SplittedName = {
+    firstName: string;
+    lastName: string;
+};
+export type FullName = DisplayName & SplittedName;
+export declare const NamesHelper: {
+    split(name: Partial<DisplayName>): SplittedName;
+    join(name: Partial<SplittedName>): DisplayName;
+    ensure(name: Partial<FullName>): FullName;
+    ensureFromUsers(user: Partial<FullName>, authUser: Partial<DisplayName>): FullName;
+};
+export default NamesHelper;

package/types/structures/linkedList.d.ts

@@ -0,0 +1,38 @@
+export interface ILinkedListItem<T> {
+    readonly value: T;
+    readonly next?: ILinkedListItem<T> | undefined;
+    readonly prev?: ILinkedListItem<T> | undefined;
+    readonly position: number;
+    readonly list: LinkedList<T>;
+}
+export interface ILinkedList<T> extends Iterable<ILinkedListItem<T>> {
+    readonly root: ILinkedListItem<T> | undefined;
+    readonly last: ILinkedListItem<T> | undefined;
+    readonly length: number;
+    add(value: T): ILinkedListItem<T>;
+    remove(item: ILinkedListItem<T>): void;
+    removeLast(): void;
+    removeFirst(): void;
+    clear(): void;
+}
+interface LinkedListItem<T> extends ILinkedListItem<T> {
+    next?: LinkedListItem<T>;
+    prev?: LinkedListItem<T>;
+    position: number;
+    list: LinkedList<T>;
+}
+export declare class LinkedList<T> implements ILinkedList<T> {
+    private _root;
+    private _last;
+    private _length;
+    get root(): ILinkedListItem<T> | undefined;
+    get last(): ILinkedListItem<T> | undefined;
+    get length(): number;
+    [Symbol.iterator](): Generator<LinkedListItem<T>, void, unknown>;
+    add(value: T): ILinkedListItem<T>;
+    remove(item: ILinkedListItem<T> | null | undefined): void;
+    removeLast(): void;
+    removeFirst(): void;
+    clear(): void;
+}
+export {};

package/types/structures/nameof.d.ts

@@ -0,0 +1,13 @@
+export declare function nameof<TObject>(obj: TObject, key: keyof TObject): string;
+export declare function nameof<TObject>(key: keyof TObject): string;
+export declare namespace nameof {
+    type StringKeyOf<T> = keyof T & string;
+    type Builder<T> = {
+        key<TKey extends StringKeyOf<T>>(key: TKey): BuilderRes<T[TKey]>;
+    };
+    type BuilderRes<T> = Builder<T> & {
+        result: string;
+    };
+    export function full<T>(_obj?: T): Builder<T>;
+    export {};
+}

package/types/structures/path/builder.d.ts

@@ -0,0 +1,15 @@
+import { BaseInput, CombineBuilders, StaticBuilder, SwitchBuilder } from './types';
+export * from './types';
+/** Tagged template literal to create a path builder */
+export declare function build<TArgs extends string[]>(strings: TemplateStringsArray, ...params: TArgs): SwitchBuilder<TArgs>;
+export declare const Empty: StaticBuilder;
+/**
+ * For input, use any amount of arguments, each one can be:
+ *
+ * - static `string | string[]` args to make the path part static
+ * - pre-built `Builder` to make the path part dynamic, which can be created by:
+ *   - `build` tagged template literal
+ *   - manually implementing `Builder<string[]>`
+ *   - another `construct` call
+*/
+export declare function construct<TArr extends BaseInput[]>(...inputs: TArr): CombineBuilders<TArr>;

package/types/structures/path/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * as Path from './builder';

package/types/structures/path/types.d.ts

@@ -0,0 +1,61 @@
+import type { LengthArray, Nullable } from '../../types/misc';
+import type { CombineOptions } from './utils';
+export type ArgValue = string | number;
+export type ObjectBuilderArgs<TArgs extends string> = Record<TArgs, ArgValue>;
+export type BuilderArgs<TArgs extends string, L extends number = number> = LengthArray<ArgValue, L> | Record<TArgs, ArgValue>;
+export type TemplatePrefixing = Nullable<string | ((key: string, index: number) => string)>;
+interface BaseBuilder<A extends readonly string[], B, P = TemplatePrefixing> {
+    /**
+     * Builds the path using provided args.
+     *
+     * Each arg is always a `ArgValue` (`string | number`), and args are provided as an array which should use the same order and length as the keys in the template.
+     *
+     * Also, args can be provided as an object with args as they were in the template and values as strings.
+     */
+    build: (args?: B, options?: CombineOptions) => string;
+    /**
+     * Template builder that will build the path using args names but also can:
+     * - keep args as they were in the template
+     * - add a prefix for each key in case `prefix` is provided as string
+     * - format each key in case `prefix` is provided as function
+     *
+     * For now it's recommended to cache the result, internally it doesn't care about it.
+     */
+    template: (prefix?: P, options?: CombineOptions) => string;
+    /** args as they were in the template */
+    readonly args: A;
+    /**
+     * Types helper method to easily cast all kinds of builders to generic IBuilder or others.
+     * It just always returns the passed object, so it's the implementation's responsibility to ensure the compatibility.
+     *
+     * Currently their signature is totally compatible with each other so this cast is safe.
+     *
+     * In future probably some extra conversion may be required.
+    */
+    as<TOther>(marker?: TOther): TOther extends readonly string[] ? SwitchBuilder<TOther> : (TOther extends BaseBuilder<any, any> ? TOther : never);
+    /** Allows to specify default combine options for the current builder instance. */
+    withDefaults: (defaults: CombineOptions) => this;
+    /** Allows to specify **build** transformation per key for the current builder instance. */
+    withBuildTransform: (transforms: TransformMap<A>) => this;
+    /** Allows to specify **template** transformation per key for the current builder instance. */
+    withTemplateTransform: (transforms: TransformMap<A>) => this;
+}
+export type TransformMap<A extends readonly string[]> = {
+    [K in A[number]]?: (v: ArgValue) => string;
+};
+type EmptyBuilderArgs = [] | Record<PropertyKey, never>;
+type ReadonlyArr<TArr extends ReadonlyArray<any>> = TArr extends ReadonlyArray<infer T> ? ReadonlyArray<T> : never;
+export interface Builder<TArgs extends readonly string[]> extends BaseBuilder<ReadonlyArr<TArgs>, BuilderArgs<TArgs[number], TArgs['length']>> {
+}
+export interface StaticBuilder extends BaseBuilder<readonly [], EmptyBuilderArgs> {
+}
+export interface IBuilder extends BaseBuilder<readonly string[], BuilderArgs<string>> {
+}
+export type StaticInput = string | readonly string[];
+export type BaseInput = StaticInput | BaseBuilder<any, any, any>;
+export type Output<TInput> = TInput extends StaticBuilder ? StaticBuilder : (TInput extends Builder<infer TArgs> ? Builder<TArgs> : StaticBuilder);
+export type SwitchBuilder<TArg extends readonly string[]> = [TArg] extends [never] ? StaticBuilder : ([] extends TArg ? StaticBuilder : (readonly string[] extends TArg ? IBuilder : Builder<TArg>));
+export type ExtractArgs<T> = T extends Builder<infer TArgs> ? TArgs : readonly string[];
+type CombineTwo<T1 extends BaseInput, T2 extends BaseInput> = Output<T1> extends StaticBuilder ? Output<T2> : (Output<T2> extends StaticBuilder ? Output<T1> : (Output<T1> extends Builder<infer Arr1> ? (Output<T2> extends Builder<infer Arr2> ? Builder<[...Arr1, ...Arr2]> : never) : never));
+export type CombineBuilders<T extends BaseInput[]> = T extends [infer T1 extends BaseInput, infer T2 extends BaseInput, ...infer Rest] ? (CombineTwo<T1, T2> extends infer C extends BaseBuilder<any, any> & BaseInput ? (Rest extends BaseInput[] ? CombineBuilders<[C, ...Rest]> : never) : never) : (T extends [infer T1] ? Output<T1> : StaticBuilder);
+export {};

package/types/structures/path/utils.d.ts

@@ -0,0 +1,14 @@
+import { Nullable } from '../../types/misc';
+export declare function indexTrim(str: string | null | undefined, ch: string): string;
+export type CombineOptions = {
+    noTrim?: boolean;
+    addTrail?: boolean | string;
+    addStart?: boolean | string;
+    separator?: string;
+    trimSymbol?: string;
+};
+export declare namespace CombineOptions {
+    function merge(...options: Nullable<CombineOptions>[]): CombineOptions;
+}
+export declare function combineUrls(options: Nullable<CombineOptions>, ...parts: Nullable<string>[]): string;
+export declare function combineUrls(...parts: Nullable<string>[]): string;

package/types/structures/pool.d.ts

@@ -0,0 +1,16 @@
+import type { IDisposable } from '../functions/disposer';
+export declare class Pool<T> {
+    readonly factory: () => T;
+    private readonly _container;
+    constructor(factory: () => T);
+    get(): T;
+    release(e: T | T[]): void;
+}
+type Initializer<T> = (item: T) => void;
+export declare class PoolDisposable<T extends IDisposable> extends Pool<T> {
+    readonly initializer: null | Initializer<T>;
+    constructor(factory: () => T, initializer?: null | Initializer<T>);
+    get(): T;
+    release(e: T | T[]): void;
+}
+export {};

package/types/structures/promiseCache.d.ts

@@ -0,0 +1,85 @@
+import { ILogger } from '../logger';
+export type DeferredGetter<T> = {
+    readonly current: T | null | undefined;
+    readonly promise: Promise<T | null>;
+    readonly busy: boolean | undefined;
+};
+export declare namespace DeferredGetter {
+    const Empty: {
+        readonly current: null;
+        readonly promise: Promise<null>;
+        readonly busy: boolean;
+    };
+}
+/** Caches items by key which are resolve by a promise.
+ *
+ * Supports:
+ *  - custom key adapter and parser for non-string keys.
+ *  - batching of fetches.
+ *  - auto-invalidation of cached items.
+*/
+export declare class PromiseCache<T, K = string> {
+    private readonly fetcher;
+    private readonly keyAdapter?;
+    private readonly keyParser?;
+    protected _itemsCache: Record<string, T | null | undefined>;
+    protected _itemsStatus: Record<string, boolean>;
+    private _fetchCache;
+    private _timestamps;
+    private _batch;
+    private _invalidationTimeMs;
+    private _keepInstanceDuringInvalidation;
+    private _logger;
+    private _version;
+    protected _busyCount: number;
+    constructor(fetcher: (id: K) => Promise<T>, keyAdapter?: (K extends string ? null : (k: K) => string) | undefined, keyParser?: (K extends string ? null : (id: string) => K) | undefined);
+    get busyCount(): number;
+    private _pk;
+    useLogger(nameOrLogger?: string | ILogger): this;
+    /**
+     * Provide a fetcher function that takes multiple ids and returns multiple results at once. Will be called with a slight delay to allow multiple ids to be collected.
+     *
+     * Warning: resolved array should have the same order as the input array.
+     *
+     * When provided, effectively replaces the main fetcher; but in case of fail, fallbacks to the main fetcher.
+    */
+    useBatching(fetcher: (ids: K[]) => Promise<T[]>, delay?: number): this;
+    /**
+     * Enables auto-invalidation of cached items.
+     *
+     * @param ms Time in milliseconds after which the item will be considered invalid. If null, auto-invalidation is disabled.
+    */
+    useInvalidationTime(ms: number | null, keepInstance?: boolean): this;
+    getDeferred(key: K): DeferredGetter<T>;
+    getIsBusy(id: K): boolean | undefined;
+    protected _getCurrent(id: K): {
+        item: T | null | undefined;
+        key: string;
+        isInvalid: boolean;
+    };
+    getCurrent(id: K, initiateFetch?: boolean): T | null | undefined;
+    get(id: K): Promise<T | null>;
+    protected _doFetchAsync: (id: K, key: string) => Promise<T | null>;
+    invalidate(id: K): void;
+    updateValueDirectly(id: K, value: T | null): void;
+    hasKey(id: K): boolean;
+    keys(): string[];
+    keysParsed(): K[] | null;
+    clear(): void;
+    protected _set(key: string, item: T | null | undefined, promise: Promise<T> | undefined, busy: boolean | undefined): void;
+    protected getIsInvalidated(key: string): boolean;
+    /** @override */
+    protected setStatus(key: string, status: boolean): void;
+    /** @override */
+    protected setPromise(key: string, promise: Promise<T | null>): void;
+    /** @override */
+    protected storeResult(key: string, res: T | null): void;
+    /** @override */
+    protected onBeforeFetch(_key: string): void;
+    /** @override */
+    protected prepareResult(res: T | null): NonNullable<T> | null;
+    /** @override */
+    protected onFetchComplete(key: string): void;
+    /** @pure */
+    protected tryFetchInBatch(id: K): Promise<T | null>;
+}