@zelgadis87/utils-core 4.6.0 → 4.6.2

package/dist/Logger.d.ts

@@ -0,0 +1,21 @@
+declare const LEVELS: readonly ["log", "debug", "info", "warn", "error"];
+type TLogLevel = keyof Console & typeof LEVELS[number];
+export type TLoggerOpts = {
+    console: Console;
+    enabled: boolean;
+    minLevel: Uppercase<TLogLevel>;
+};
+export declare class Logger {
+    readonly name: string;
+    private enabled;
+    private console;
+    private minLevel;
+    constructor(name: string, args?: Partial<TLoggerOpts>);
+    get log(): (...args: any[]) => void;
+    get debug(): (...args: any[]) => void;
+    get info(): (...args: any[]) => void;
+    get warn(): (...args: any[]) => void;
+    get error(): (...args: any[]) => void;
+    private logWrap;
+}
+export default Logger;

package/dist/Optional.d.ts

@@ -0,0 +1,70 @@
+import { TConsumer, TFunction, TPredicate, TProducer, TVoidFunction } from "./utils/functions.js";
+export declare class Optional<T> implements TOptional<T> {
+    private _present;
+    private _value;
+    private constructor();
+    get rawValue(): T | undefined;
+    get(): T | never;
+    set(t: T): void;
+    clear(): void;
+    isEmpty(): this is TEmptyOptional<T>;
+    isPresent(): this is TPresentOptional<T>;
+    ifEmpty(callback: TVoidFunction): void;
+    ifPresent(callback: TConsumer<T>): void;
+    apply(callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction): void;
+    orElse(newValue: T | null | undefined): any;
+    orElseGet(produceValue: TProducer<T | null | undefined>): TOptional<T>;
+    orElseThrow(produceError: TProducer<Error>): TPresentOptional<T>;
+    mapTo<R>(mapper: TFunction<T, R | null | undefined>): any;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): any;
+    filter(predicate: TPredicate<T>): this | TEmptyOptional<T>;
+    static empty<T>(): TEmptyOptional<T>;
+    static of<T>(t: T): TPresentOptional<T>;
+    static ofNullable<T>(t: T | null | undefined): TOptional<T>;
+}
+export default Optional;
+export type TOptional<T> = {
+    readonly rawValue: T | undefined;
+    /**
+     * @returns the currently stored value, if any; throws {@link ErrorGetEmptyOptional} otherwise;
+     */
+    get(): T | never;
+    /**
+     * Places a new value inside this optional. Throws {@link ErrorSetEmptyOptional} if t is null or undefined.
+     */
+    set(t: T): void;
+    /**
+     * Clears the current value from this optional, if any.
+     */
+    clear(): void;
+    isEmpty(): boolean;
+    isPresent(): boolean;
+    ifEmpty: (callback: TVoidFunction) => void;
+    ifPresent: (callback: TConsumer<T>) => void;
+    apply(callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction): void;
+    orElse: ((newValue: T | null | undefined) => TOptional<T>);
+    orElseGet: (produceValue: TProducer<T | null | undefined>) => TOptional<T>;
+    orElseThrow: (produceError: TProducer<Error>) => TPresentOptional<T>;
+    mapTo<R>(mapper: TFunction<T, R>): TOptional<R>;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R>;
+    filter(predicate: TPredicate<T>): TOptional<T>;
+};
+export type TEmptyOptional<T> = TOptional<T> & {
+    readonly rawValue: undefined;
+    isEmpty(): true;
+    isPresent(): false;
+};
+export type TPresentOptional<T> = TOptional<T> & {
+    readonly rawValue: T;
+    isEmpty(): false;
+    isPresent(): true;
+};
+export declare class ErrorGetEmptyOptional extends Error {
+    constructor();
+}
+export declare class ErrorSetEmptyOptional extends Error {
+    constructor();
+}
+export declare class ErrorCannotInstantiatePresentOptionalWithEmptyValue extends Error {
+    constructor();
+}

package/dist/async/CancelableDeferred.d.ts

@@ -0,0 +1,17 @@
+import Deferred from "./Deferred.js";
+interface ICancelablePromise<T> extends Promise<T> {
+    cancel(): void;
+}
+/** @deprecated use Deferred instead. */
+export default class CancelableDeferred<T = void> extends Deferred<T> implements ICancelablePromise<T> {
+    private _canceled;
+    get canceled(): boolean;
+    constructor();
+    cancel(): void;
+    protected createInternals(): {
+        promise: Promise<T>;
+        resolve: (value: T) => void;
+        reject: (reason: Error) => void;
+    };
+}
+export {};

package/dist/async/Deferred.d.ts

@@ -0,0 +1,34 @@
+export interface ICancelable {
+    cancel(): void;
+}
+export interface ICancelablePromise<T> extends Promise<T>, ICancelable {
+}
+export declare class DeferredCanceledError extends Error {
+    constructor();
+}
+export declare class Deferred<T = void> implements ICancelablePromise<T> {
+    private _pending;
+    private readonly _internals;
+    get pending(): boolean;
+    /** @deprecated: Use resolve, then and catch directly; use asPromise to return a promise type. */
+    get promise(): Promise<T>;
+    constructor();
+    resolve(val: T): void;
+    reject(reason: Error): void;
+    cancel(): void;
+    resolveIfPending(val: T): void;
+    rejectIfPending(reason: Error): void;
+    cancelIfPending(): void;
+    then<R = T, S = T>(onFulfilled: ((value: T) => R | PromiseLike<R>) | null | undefined, onRejected?: ((reason: Error) => S | PromiseLike<S>) | null | undefined): Promise<R | S>;
+    catch<R = T>(onRejected: ((reason: Error) => R | PromiseLike<R>) | null | undefined): Promise<T | R>;
+    finally(onfinally: (() => void) | null | undefined): Promise<T>;
+    asPromise(): Promise<T>;
+    asCancelablePromise(): ICancelablePromise<T>;
+    protected createInternals(): {
+        promise: Promise<T>;
+        resolve: (value: T) => void;
+        reject: (reason: Error) => void;
+    };
+    get [Symbol.toStringTag](): string;
+}
+export default Deferred;

package/dist/async/RateThrottler.d.ts

@@ -0,0 +1,13 @@
+import { TFunction, TPromisable } from "..";
+import TimeFrequency from "../time/TimeFrequency";
+type TPromiseFactory<T, R> = TFunction<T, Promise<R>>;
+export declare class RateThrottler {
+    private readonly _frequency;
+    private readonly _availableSlots;
+    private readonly _waitingRequests;
+    constructor(_frequency: TimeFrequency);
+    get cooldown(): import("..").TimeDuration;
+    execute<T>(fn: TPromiseFactory<void, T>): Promise<T>;
+}
+export default RateThrottler;
+export declare function throttle<TParams extends unknown[], R>(fn: (...params: TParams) => TPromisable<R>, frequence: TimeFrequency): (...params: TParams) => Promise<R>;

package/dist/async/Semaphore.d.ts

@@ -0,0 +1,17 @@
+import { TAsyncProducer, TProducer, TimeDuration } from "..";
+export declare class Semaphore {
+    private _availableSlots;
+    private readonly _queuedRequests;
+    private _inProgress;
+    /** Creates a new Semaphore with a single slot. */
+    constructor();
+    /** Creates a new Semaphore with the specified amounts of slots. */
+    constructor(availableSlots: number);
+    private _awaitSlot;
+    private _releaseSlot;
+    execute<T>(fn: TAsyncProducer<T> | TProducer<T>, cooldown?: TimeDuration): Promise<T>;
+    get availableSlots(): number;
+    get queueSize(): number;
+    get inProgressSize(): number;
+}
+export default Semaphore;

package/dist/async/index.d.ts

@@ -0,0 +1,4 @@
+export * from './CancelableDeferred.ts';
+export * from './Deferred';
+export * from './RateThrottler';
+export * from './Semaphore';

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './async/index.js';
+export * from './lazy/index.js';
+export * from './Logger.js';
+export * from './Optional.js';
+export * from './sorting/index.js';
+export * from './time/index.js';
+export * from './upgrade/index.js';
+export * from './utils/index.js';

package/dist/lazy/Lazy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Class that stores a value that is computationally/memory intensive to initialize.
+ * The initialization of the value is done once and only if required (lazy initialization).
+ * @author gtomberli
+ */
+export declare class Lazy<T> {
+    private _value;
+    private _initialized;
+    private _generator;
+    private constructor();
+    get value(): T | undefined;
+    getOrCreate(): T;
+    getOrThrow(errorMessage?: "Value not initialized"): T;
+    or(t: T): T;
+    isPresent(): boolean;
+    isEmpty(): boolean;
+    ifPresent(fn: (t: T) => void): void;
+    ifEmpty(fn: () => void): void;
+    apply(fnPresent: (t: T) => void, fnEmpty: () => void): void;
+    static of<T>(generator: () => T): Lazy<T>;
+}
+export default Lazy;

package/dist/lazy/LazyAsync.d.ts

@@ -0,0 +1,24 @@
+export declare class LazyAsync<T> {
+    private _promise;
+    private _pending;
+    private _resolvedValue;
+    private _error;
+    private _generator;
+    private constructor();
+    getOrCreate(): Promise<T>;
+    isPresent(): boolean;
+    isEmpty(): boolean;
+    isPending(): boolean;
+    isReady(): boolean;
+    isResolved(): boolean;
+    isError(): boolean;
+    ifPresent(fn: (t: Promise<T>) => void): void;
+    ifEmpty(fn: () => void): void;
+    ifPending(fn: (t: Promise<T>) => void): void;
+    ifReady(fn: (t: Promise<T>) => void): void;
+    ifResolved(fn: (t: T) => void): void;
+    ifError(fn: (err: Error) => void): void;
+    getOrThrow(errorMessage?: "Value not initialized"): Promise<T> | never;
+    static of<T>(generator: () => Promise<T>): LazyAsync<T>;
+}
+export default LazyAsync;

package/dist/lazy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Lazy.js';
+export * from './LazyAsync.js';

package/dist/sorting/ComparisonChain.d.ts

@@ -0,0 +1,57 @@
+import { TFunction, TKeysOfType, TReadableArray } from "../utils/index.js";
+import { TComparisonDirection, TComparisonFunction, TComparisonResult } from "./types.js";
+type TCompareValueOptions = {
+    nullsFirst: boolean;
+    direction: TComparisonDirection;
+};
+type TLooseCompareValueOptions = Partial<TCompareValueOptions> | TComparisonDirection;
+declare function compareStrings(options?: TLooseCompareValueOptions & {
+    ignoreCase?: boolean;
+}): TComparisonFunction<string>;
+declare function compareBooleans(options: Partial<TCompareValueOptions> & {
+    truesFirst: boolean;
+}): TComparisonFunction<boolean>;
+/**
+ * Creates a ComparisonChain V1.
+ * Usage: ComparisonChain.createWith<number>( c => c.compareUsingNumbers() ).sort( [ 100, 1, 10, 5 ] );
+ * @deprecated[2023-10-22]: Use createSorterFor instead.
+ **/
+export declare class ComparisonChain<T> {
+    private readonly _fns;
+    private readonly _reversed;
+    private constructor();
+    compare: (a: T, b: T) => TComparisonResult;
+    sort: <A extends TReadableArray<T>>(arr: A) => A extends Array<T> ? Array<T> : ReadonlyArray<T>;
+    then(getFn: (compare: TChain<T>) => TComparisonFunction<T>): ComparisonChain<T>;
+    thenBy(cmp: ComparisonChain<T> | TComparisonFunction<T>): ComparisonChain<T>;
+    thenChain<R>(transform: TFunction<T, R>, getFn: (compare: TChain<R>) => TComparisonFunction<R>): ComparisonChain<T>;
+    thenChainBy<R>(transform: TFunction<T, R>, cmp: ComparisonChain<R> | TComparisonFunction<R>): ComparisonChain<T>;
+    reversed(): ComparisonChain<T>;
+    private doCompare;
+    static create<T>(): {
+        using: (getFn: (chainable: TChain<T>) => TComparisonFunction<T>) => ComparisonChain<T>;
+        usingTransformation: <R>(transform: TFunction<T, R>, getFn: (chainable: TChain<R>) => TComparisonFunction<R>) => ComparisonChain<T>;
+    };
+    static createWith<T>(getFn: (chainable: TChain<T>) => TComparisonFunction<T>): ComparisonChain<T>;
+    static createWithTransformation<T, R>(transform: TFunction<T, R>, getFn: (chainable: TChain<R>) => TComparisonFunction<R>): ComparisonChain<T>;
+}
+export default ComparisonChain;
+declare function createCompare<T>(): {
+    compareUsingGetter: {
+        (getter: TFunction<T, string>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
+        (getter: TFunction<T, number>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
+        (getter: TFunction<T, Date>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
+    };
+    compareUsingField: (field: keyof T & TKeysOfType<T, string | number | Date>, options?: TLooseCompareValueOptions) => TComparisonFunction<T>;
+    compareUsingStrings: typeof compareStrings;
+    compareUsingStringsIgnoringCase: (options?: TLooseCompareValueOptions) => TComparisonFunction<string>;
+    compareUsingBooleans: typeof compareBooleans;
+    compareUsingNumbers: (options?: TLooseCompareValueOptions) => TComparisonFunction<number>;
+    compareUsingDates: (options?: TLooseCompareValueOptions) => TComparisonFunction<Date>;
+    compareUsingFunction: (fn: TComparisonFunction<T>) => TComparisonFunction<T>;
+    placeFirst: (arr: Array<T>) => TComparisonFunction<T>;
+    placeFirstInOrder: (arr: Array<T>) => TComparisonFunction<T>;
+    placeLast: (arr: Array<T>) => TComparisonFunction<T>;
+    placeLastInOrder: (arr: Array<T>) => TComparisonFunction<T>;
+};
+type TChain<T> = ReturnType<typeof createCompare<T>>;

package/dist/sorting/Sorter.d.ts

@@ -0,0 +1,100 @@
+import { TConditionalParameterOptions, TFunction, TKeysOfType, TPositiveNumber, TReadableArray } from "../utils/index.js";
+import { TComparisonFunction } from "./types.js";
+type TComparable<T> = {
+    compare: TComparisonFunction<T>;
+};
+export type TSorter<T> = {
+    get then(): TSorterStep<T, TSorter<T>>;
+    reversed: () => TSorter<T>;
+    compare: TComparisonFunction<T>;
+    sort: (arr: TReadableArray<T>) => Array<T>;
+    top: (arr: TReadableArray<T>, n: TPositiveNumber) => Array<T>;
+    bottom: (arr: TReadableArray<T>, n: TPositiveNumber) => Array<T>;
+    first: (arr: TReadableArray<T>) => T | null;
+    last: (arr: TReadableArray<T>) => T | null;
+};
+type TSorterStepForRecords<T, Ret> = {
+    usingStrings: (field: TKeysOfType<T, string>) => TSorterStep<string, Ret>;
+    usingNumbers: (field: TKeysOfType<T, number>) => TSorterStep<number, Ret>;
+    usingBooleans: (field: TKeysOfType<T, boolean>) => TSorterStep<boolean, Ret>;
+    usingDates: (field: TKeysOfType<T, Date>) => TSorterStep<Date, Ret>;
+};
+type TSorterStepForNumbers<_T, Ret> = {
+    inAscendingOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inDescendingOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForStrings<_T, Ret> = {
+    inLexographicalOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inLexographicalOrderIgnoringCase(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inReverseLexographicalOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inReverseLexographicalOrderIgnoringCase(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForBooleans<_T, Ret> = {
+    truesFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    falsesFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForDates<_T, Ret> = {
+    mostAncientFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    mostRecentFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForChainables<T, Ret> = {
+    chain: (chain: TComparable<T>) => Ret;
+};
+type TSorterStepForUsing<T, Ret> = {
+    using: <X>(transform: TFunction<T, X>) => TSorterStep<X, Ret>;
+};
+type TSorterStepForPrioritizable<T extends string | number, Ret> = {
+    prioritizing(arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
+    deprioritizing(arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
+    prioritizingWithEqualWeight(arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
+    deprioritizingWithEqualWeight(arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
+};
+type TSorterStep<T, Ret> = {} & (T extends Record<string | number | symbol, unknown> ? TSorterStepForRecords<T, Ret> : {}) & (T extends number ? TSorterStepForNumbers<T, Ret> : {}) & (T extends string ? TSorterStepForStrings<T, Ret> : {}) & (T extends boolean ? TSorterStepForBooleans<T, Ret> : {}) & (T extends Date ? TSorterStepForDates<T, Ret> : {}) & (T extends string ? TSorterStepForPrioritizable<string, Ret> : {}) & (T extends number ? TSorterStepForPrioritizable<number, Ret> : {}) & TSorterStepForChainables<T, Ret> & TSorterStepForUsing<T, Ret>;
+type TSorterStarter<T> = TSorterStep<T, TSorter<T>>;
+export type TSorterBuilder<T> = (builder: TSorterStarter<T>) => TSorter<T>;
+type TPrioritizeOptions = {};
+declare const defaultPrioritizeOptions: {};
+/**
+ * @deprecated[2023-10-19]: Use {@link Sorter.createFor} instead.
+ **/
+export declare function createSorterFor<T>(): TSorterStarter<T>;
+export declare const Sorter: {
+    createFor: <T>() => TSorterStarter<T>;
+    sort: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T[];
+    top: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
+    bottom: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
+    first: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
+    last: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
+};
+/**
+ * @deprecated[2023-11-01]: Use {@link Sorter} instead.
+ **/
+export declare const Sorting: {
+    createFor: <T>() => TSorterStarter<T>;
+    sort: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T[];
+    top: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
+    bottom: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
+    first: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
+    last: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
+};
+export default Sorter;

package/dist/sorting/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export { default as ComparisonChain } from './ComparisonChain.js';
+export * from './Sorter.js';
+export * from './types.js';

package/dist/sorting/types.d.ts

@@ -0,0 +1,5 @@
+import { TBiFunction } from "../utils/functions.js";
+export type TComparisonResult = -1 | 0 | 1;
+export type TStrictComparisonResult = -1 | 1;
+export type TComparisonFunction<T> = TBiFunction<T, T, TComparisonResult>;
+export type TComparisonDirection = 'ASC' | 'DESC';

package/dist/time/RandomTimeDuration.d.ts

@@ -0,0 +1,9 @@
+import TimeDuration from "./TimeDuration.js";
+export default class RandomTimeDuration {
+    private constructor();
+    static ms: (a: number, b: number) => TimeDuration;
+    static seconds: (a: number, b: number) => TimeDuration;
+    static minutes: (a: number, b: number) => TimeDuration;
+    static hours: (a: number, b: number) => TimeDuration;
+    static days: (a: number, b: number) => TimeDuration;
+}

package/dist/time/TimeBase.d.ts

@@ -0,0 +1,38 @@
+import TimeUnit from "./TimeUnit";
+export default abstract class TimeBase<T> {
+    private readonly _ms;
+    protected constructor(value: number, unit: TimeUnit);
+    protected abstract create(value: number, unit: TimeUnit): T;
+    get ms(): number;
+    get seconds(): number;
+    get minutes(): number;
+    get hours(): number;
+    get days(): number;
+    addMs(milliseconds: number): T;
+    addSeconds(seconds: number): T;
+    addMinutes(minutes: number): T;
+    addHours(hours: number): T;
+    addDays(days: number): T;
+    removeDays(days: number): T;
+    addUnits(n: number, unit: TimeUnit): T;
+    removeMs(milliseconds: number): T;
+    removeSeconds(seconds: number): T;
+    removeMinutes(minutes: number): T;
+    removeHours(hours: number): T;
+    removeUnits(n: number, unit: TimeUnit): T;
+    getUnit(unit: TimeUnit): number;
+    protected toUnits(): {
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+    protected static toMs(units: {
+        days?: number;
+        hours?: number;
+        minutes?: number;
+        seconds?: number;
+        ms?: number;
+    }): number;
+    toJSON(): number;
+}

package/dist/time/TimeDuration.d.ts

@@ -0,0 +1,81 @@
+import { ICancelable, ICancelablePromise } from "../async/Deferred.js";
+import { TComparisonResult } from "../sorting/index.js";
+import { TIntervalHandle, TTimeoutHandle } from "../utils/index.js";
+import TimeBase from "./TimeBase";
+import TimeInstant from "./TimeInstant";
+import TimeUnit from "./TimeUnit";
+export declare class TimeDuration extends TimeBase<TimeDuration> {
+    protected constructor(value: number, unit: TimeUnit);
+    protected create(value: number, unit: TimeUnit): TimeDuration;
+    addDuration(duration: TimeDuration): TimeDuration;
+    removeDuration(duration: TimeDuration): TimeDuration;
+    removeUnits(n: number, unit: TimeUnit): TimeDuration;
+    /** @deprecated: Use multiplyBy instead **/
+    multiply(times: number): TimeDuration;
+    multiplyBy(times: number): TimeDuration;
+    divideBy(times: number): TimeDuration;
+    /**
+        * Returns the current duration in a human readable format, prioritizing the most significant unit of time and excluding the rest.
+        * @todo[2023-06] Should allow more customization options
+        * @todo[2023-06] By default should show the secondary unit only when actually needed (eg, 1h 20m & 3h, instead of 1h 20m & 3h 28m)
+        * @todo[2023-06] Should not allow negative durations, as this is a duration and not an instant.
+        * @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
+    */
+    get formatted(): string;
+    /**
+        * @deprecated[2023-06] this method makes no sense, as durations are positive by default.
+        */
+    absolute(): TimeDuration;
+    interval(cb: () => unknown): TIntervalHandle;
+    timeout(cb: () => unknown): TTimeoutHandle;
+    cancelablePromise(): ICancelablePromise<void>;
+    promise(): Promise<void>;
+    delay(cb: () => unknown): void;
+    cancelableDelay(cb: () => unknown): ICancelable;
+    debounce<T>(fn: (t: T) => void): (t: T) => void;
+    toDigitalClock(): string;
+    get asSeconds(): string;
+    fromNow(): TimeInstant;
+    differenceFrom(other: TimeDuration): TimeDuration;
+    /** @deprecated: Use fromNow instead **/
+    addCurrentTime(): TimeInstant;
+    isGreaterThan(other: TimeDuration): boolean;
+    isLessThan(other: TimeDuration): boolean;
+    compareTo(other: TimeDuration): TComparisonResult;
+    atLeast(other: TimeDuration): TimeDuration;
+    atMost(other: TimeDuration): TimeDuration;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    /**
+        * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
+        */
+    protected get _duration(): string;
+    toString(): string;
+    static parseHumanTime(humanTime: string): TimeDuration;
+    static compare(a: TimeDuration, b: TimeDuration): TComparisonResult;
+    static ms: IDurationConstructor;
+    static seconds: IDurationConstructor;
+    static minutes: IDurationConstructor;
+    static hours: IDurationConstructor;
+    static days: IDurationConstructor;
+    static shamefulUnref: (ms: TAllowedTimeDuration) => number;
+    static shamefulRef: (ms: TAllowedTimeDuration) => TimeDuration;
+    static unref: (ms: TValidTimeDuration) => TPredefinedTimeDuration;
+    static ref: (ms: TValidTimeDuration) => TimeDuration;
+    static fromMs(ms: number): TimeDuration;
+    static distanceFromNow(instant: TimeInstant): TimeDuration;
+    static distance(instant1: TimeInstant, instant2: TimeInstant): TimeDuration;
+    static greatest(duration1: TimeDuration, duration2: TimeDuration): TimeDuration;
+    static lowest(duration1: TimeDuration, duration2: TimeDuration): TimeDuration;
+    static ZERO: TimeDuration;
+    static fromJSON(ms: number): TimeDuration;
+}
+interface IDurationConstructor {
+    (a: number): TimeDuration;
+    /** @deprecated[2023-06] Use RandomTimeDuration instead */ (a: number, b?: number): TimeDuration;
+}
+export type TPredefinedTimeDuration = 0 | 50 | 100 | 150 | 200 | 250 | 300 | 500 | 1000 | 1500 | 2000 | 2500 | 5000;
+export type TValidTimeDuration = TimeDuration | TPredefinedTimeDuration;
+type TAllowedTimeDuration = TValidTimeDuration | number;
+export declare function isAllowedTimeDuration(t: unknown): t is TAllowedTimeDuration;
+export default TimeDuration;

package/dist/time/TimeFrequency.d.ts

@@ -0,0 +1,10 @@
+import { TPositiveNumber } from "../utils";
+import TimeDuration from "./TimeDuration";
+export default class TimeFrequency {
+    readonly times: TPositiveNumber;
+    readonly period: TimeDuration;
+    constructor(times: TPositiveNumber, period: TimeDuration);
+    get frequency(): TimeDuration;
+    static onceEvery(period: TimeDuration): TimeFrequency;
+    static twiceEvery(period: TimeDuration): TimeFrequency;
+}