@zelgadis87/utils-core 5.3.0 → 5.3.1

package/.rollup/index.d.ts

@@ -754,12 +754,12 @@ declare function groupByNumberWith<V, K extends number>(arr: TReadableArray<V>,
 declare function groupByBooleanWith<V, K extends boolean>(arr: TReadableArray<V>, getter: TFunction<V, K>): Record<"true" | "false", V[]>;
 declare function groupBySymbolWith<V, K extends symbol>(arr: TReadableArray<V>, getter: TFunction<V, K>): Record<K, V[]>;
 
-declare function indexByString<V, K extends TKeysOfType<V, string>>(arr: V[], field: K): Record<V[K] & string, V>;
-declare function indexByNumber<V, K extends TKeysOfType<V, number>>(arr: V[], field: K): Record<V[K] & number, V>;
-declare function indexBySymbol<V, K extends TKeysOfType<V, symbol>>(arr: V[], field: K): Record<V[K] & symbol, V>;
-declare function indexByStringWith<V>(arr: V[], getter: TFunction<V, string>): Record<string, V>;
-declare function indexByNumberWith<V>(arr: V[], getter: TFunction<V, number>): Record<number, V>;
-declare function indexBySymbolWith<V>(arr: V[], getter: TFunction<V, symbol>): Record<symbol, V>;
+declare function indexByString<V, K extends TKeysOfType<V, string>, R = V>(arr: V[], field: K, valueMapper?: TFunction<V, R>): Record<V[K] & string, R>;
+declare function indexByNumber<V, K extends TKeysOfType<V, number>, R = V>(arr: V[], field: K, valueMapper?: TFunction<V, R>): Record<V[K] & number, R>;
+declare function indexBySymbol<V, K extends TKeysOfType<V, symbol>, R = V>(arr: V[], field: K, valueMapper?: TFunction<V, R>): Record<V[K] & symbol, R>;
+declare function indexByStringWith<V, R = V>(arr: V[], keyGetter: TFunction<V, string>, valueMapper?: TFunction<V, R>): Record<string, R>;
+declare function indexByNumberWith<V, R = V>(arr: V[], keyGetter: TFunction<V, number>, valueMapper?: TFunction<V, R>): Record<number, R>;
+declare function indexBySymbolWith<V, R = V>(arr: V[], keyGetter: TFunction<V, symbol>, valueMapper?: TFunction<V, R>): Record<symbol, R>;
 
 declare function average(arr: TReadableArray<number>): number;
 declare function sum(arr: TReadableArray<number>): number;
@@ -1177,6 +1177,7 @@ declare class Lazy<T> {
     ifPresent(fn: (t: T) => void): void;
     ifEmpty(fn: () => void): void;
     apply(fnPresent: (t: T) => void, fnEmpty: () => void): void;
+    protected empty(): void;
     static of<T>(generator: () => T): Lazy<T>;
 }
 
@@ -1201,6 +1202,7 @@ declare class LazyAsync<T> {
     ifResolved(fn: (t: T) => void): void;
     ifError(fn: (err: Error) => void): void;
     getOrThrow(errorMessage?: "Value not initialized"): Promise<T> | never;
+    protected empty(): void;
     static of<T>(generator: () => Promise<T>): LazyAsync<T>;
 }
 
@@ -1213,6 +1215,110 @@ declare class LazyDictionary<K extends string | number | symbol, T> {
     getOrThrow(key: K, errorMessage?: "Value not initialized"): T;
 }
 
+/**
+ * A cached value with stale-while-revalidate pattern.
+ * On initialization, the class starts calculating the async result (isPending() === true).
+ * When complete, the class will store the generated value (isReady() === true).
+ * After maxStale duration, the value becomes stale and will refresh in background on next access (isStale() === true).
+ * After maxAge has passed, the cached value is no longer used (isExpired() === true).
+ */
+declare class Cached<T> {
+    /** Current promise for the value generation. */
+    private _promise;
+    /** Flag indicating if a generation is currently in progress. */
+    private _pending;
+    /** The last successfully generated value. */
+    private _resolvedValue;
+    /** Function that generates the cached value. */
+    private _generator;
+    /** Timestamp of the last successful value generation. */
+    private _generatedAt;
+    /** The duration for which value should be kept cached. After maxAge from the last generated value, this object is considered empty. */
+    private _maxAge;
+    /** The duration for which the value should be served from cache, even if stale. Has no effect if greater or equal to maxAge. */
+    private _maxStale;
+    /** Callback invoked when new data becomes available. */
+    private _onNewDataAvailable;
+    /** Callback invoked when generation fails. */
+    private _onError;
+    private constructor();
+    /**
+     * Gets the cached value.
+     * Returns fresh data if available, stale data while revalidating, or triggers generation if empty/expired.
+     * @returns Promise resolving to the cached value.
+     */
+    get(): Promise<T>;
+    /**
+     * Generates a new value using the generator function.
+     * Sets up promise handlers for success and error cases.
+     * @returns The generation promise.
+     */
+    private generate;
+    /**
+     * Checks if value has been requested at least once.
+     * @returns True if a promise exists.
+     */
+    protected isPresent(): boolean;
+    /**
+     * Checks value has never been requested.
+     * @returns True if empty.
+     */
+    protected isEmpty(): boolean;
+    /**
+     * Checks if value generation is currently in progress.
+     * @returns True if generation is pending.
+     */
+    isPending(): boolean;
+    /**
+     * Checks if value is stored and fresh.
+     * @returns True if stored and fresh.
+     */
+    isReady(): boolean;
+    /**
+     * Checks if cached value is stale (older than maxStale duration).
+     * @returns True if value is stale.
+     */
+    isStale(): boolean;
+    /**
+     * Checks if cached value is expired (older than maxAge duration).
+     * @returns True if value is expired.
+     */
+    isExpired(): boolean;
+    /**
+     * Gets the timestamp when the value was last successfully generated.
+     * @returns The last update timestamp.
+     */
+    getLastUpdated(): TimeInstant;
+    /**
+     * Gets the age of the cached value.
+     * @returns The duration since the value was last generated.
+     */
+    getAge(): TimeDuration;
+    /**
+     * Invalidates the cache by resetting the generation timestamp.
+     * Next access will trigger fresh generation.
+     */
+    invalidate(): void;
+    /**
+     * Sets a callback to be invoked when new data becomes available.
+     * @param callback Function to call with the new value.
+     */
+    onNewDataAvailable(callback: TConsumer<T>): void;
+    /**
+     * Sets a callback to be invoked when generation fails.
+     * @param callback Function to call with the error.
+     */
+    onError(callback: TConsumer<Error>): void;
+    /**
+     * Creates a new Cached instance.
+     * @param generator Function that generates the value to cache.
+     * @param maxAge Maximum duration for which cached value is considered valid.
+     * @param maxStale Maximum duration for which stale value is served while revalidating. Defaults to maxAge.
+     * @returns A new Cached instance.
+     */
+    static of<T>(generator: () => Promise<T>, maxAge: TimeDuration, maxStale?: TimeDuration): Cached<T>;
+}
+
 declare const LEVELS: readonly ["trace", "log", "debug", "info", "warn", "error"];
 type TLogLevel = keyof Console & typeof LEVELS[number];
 type TLoggerOpts = {
@@ -1299,5 +1405,5 @@ declare class DataUpgrader<X extends TUpgradable, XLatest extends X> implements
 }
 declare function isUpgradable(obj: TJsonSerializable): obj is TUpgradable;
 
-export { DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
 export type { ICancelable, ICancelablePromise, IDataUpgrader, TAccumulator, TAllKeysOptional, TAnyFunction, TArrayable, TAsyncAnyFunction, TAsyncBiConsumer, TAsyncBiFunction, TAsyncBiPredicate, TAsyncConsumer, TAsyncFunction, TAsyncOperation, TAsyncOperationTuple, TAsyncPredicate, TAsyncProducer, TAsyncValidation, TAsyncVoidFunction, TBiConsumer, TBiFunction, TBiPredicate, TComparisonDirection, TComparisonFunction, TComparisonResult, TConditionalOptionalType, TConditionalParameter, TConditionalParameterOptions, TConsumer, TCssDeclarationRulesDictionary, TCssSelectorDeclarationRulesDictionary, TDayOfMonth, TDayOfWeek, TDigit, TDigit1_9, TEmpty, TEmptyArray, TEmptyObject, TEmptyOptional, TFourDigits, TFourDigitsMillisecond, TFourDigitsYear, TFunction, THasNever, THourOfDay, THtmlString, TIdentityFunction, TIntervalHandle, TIsEmptyObject, TIso8601DateString, TIso8601DateUtcString, TJsonArray, TJsonObject, TJsonPrimitive, TJsonSerializable, TKeysOfType, TLoggerOpts, TMaybe, TMillisecondOfSecond, TMinuteOfHour, TMonth, TMonthName, TNegativeNumber, TNumber0_10, TNumber0_100, TNumber0_1000, TNumber0_15, TNumber0_20, TNumber0_5, TNumber1_10, TNumericFloatingPointString, TNumericString, TOneDigit, TOperation, TOperationTuple, TOptional, TOptionalKeysForType, TOptionsWithoutDefaults, TParseInt, TParseableInt, TPositiveNumber, TPredefinedTimeDuration, TPredicate, TPresentOptional, TPrettify, TPrimitive, TProducer, TPromisable, TReadableArray, TRelativeUrl, TReplaceType, TRequiredKeysForType, TSecondOfMinute, TSorter, TSorterBuilder, TStrictComparisonResult, TThreeDigits, TThreeDigitsMillisecond, TTimeInUnits, TTimeoutHandle, TTransformer, TTwoDigits, TTwoDigitsDate, TTwoDigitsHour, TTwoDigitsMinute, TTwoDigitsMonth, TTwoDigitsSecond, TTypePredicate, TUpToFourDigits, TUpToThreeDigits, TUpToTwoDigits, TUpgradable, TUrl, TValidTimeDuration, TValidation, TVoidFunction, TWeekNumber, TWithExtras, TWithRequiredProperties, TWithRequiredProperty, TYear, TZero };

package/.rollup/index.mjs

@@ -413,32 +413,32 @@ function doGroupByWith(arr, getter) {
     }, {});
 }
 
-function indexByString(arr, field) {
-    return indexByStringWith(arr, t => t[field]);
+function indexByString(arr, field, valueMapper = v => v) {
+    return indexByStringWith(arr, t => t[field], valueMapper);
 }
-function indexByNumber(arr, field) {
-    return indexByNumberWith(arr, t => t[field]);
+function indexByNumber(arr, field, valueMapper = v => v) {
+    return indexByNumberWith(arr, t => t[field], valueMapper);
 }
-function indexBySymbol(arr, field) {
-    return indexBySymbolWith(arr, t => t[field]);
+function indexBySymbol(arr, field, valueMapper = v => v) {
+    return indexBySymbolWith(arr, t => t[field], valueMapper);
 }
-function indexByStringWith(arr, getter) {
-    return doIndexByWith(arr, getter);
+function indexByStringWith(arr, keyGetter, valueMapper = v => v) {
+    return doIndexByWith(arr, keyGetter, valueMapper);
 }
-function indexByNumberWith(arr, getter) {
-    return doIndexByWith(arr, getter);
+function indexByNumberWith(arr, keyGetter, valueMapper = v => v) {
+    return doIndexByWith(arr, keyGetter, valueMapper);
 }
-function indexBySymbolWith(arr, getter) {
-    return doIndexByWith(arr, getter);
+function indexBySymbolWith(arr, keyGetter, valueMapper = v => v) {
+    return doIndexByWith(arr, keyGetter, valueMapper);
 }
-function doIndexByWith(arr, getter) {
+function doIndexByWith(arr, keyGetter, valueMapper = v => v) {
     return arr.reduce((dict, cur) => {
-        const key = getter(cur);
+        const key = keyGetter(cur);
         if (key !== null && key !== undefined) {
             if (dict[key]) {
                 throw new Error(`Multiple values indexed by same key "${String(key)}".`);
             }
-            dict[key] = cur;
+            dict[key] = valueMapper(cur);
         }
         return dict;
     }, {});
@@ -1315,6 +1315,9 @@ class Lazy {
             fnEmpty();
         }
     }
+    empty() {
+        this._initialized = false;
+    }
     static of(generator) {
         return new Lazy(generator);
     }
@@ -1396,6 +1399,9 @@ class LazyAsync {
             throw new Error(errorMessage);
         return this._promise;
     }
+    empty() {
+        this._promise = undefined;
+    }
     static of(generator) {
         return new LazyAsync(generator);
     }
@@ -2610,6 +2616,180 @@ class Logger {
     }
 }
 
+const logger = new Logger('Cached');
+/**
+ * A cached value with stale-while-revalidate pattern.
+ * On initialization, the class starts calculating the async result (isPending() === true).
+ * When complete, the class will store the generated value (isReady() === true).
+ * After maxStale duration, the value becomes stale and will refresh in background on next access (isStale() === true).
+ * After maxAge has passed, the cached value is no longer used (isExpired() === true).
+ */
+class Cached {
+    /** Current promise for the value generation. */
+    _promise = undefined;
+    /** Flag indicating if a generation is currently in progress. */
+    _pending = false;
+    /** The last successfully generated value. */
+    _resolvedValue = undefined;
+    /** Function that generates the cached value. */
+    _generator;
+    /** Timestamp of the last successful value generation. */
+    _generatedAt = TimeInstant.ZERO;
+    /** The duration for which value should be kept cached. After maxAge from the last generated value, this object is considered empty. */
+    _maxAge;
+    /** The duration for which the value should be served from cache, even if stale. Has no effect if greater or equal to maxAge. */
+    _maxStale;
+    /** Callback invoked when new data becomes available. */
+    _onNewDataAvailable = noop;
+    /** Callback invoked when generation fails. */
+    _onError = err => logger.error('Cache generation failed:', err);
+    constructor(generator, maxAge, maxStale) {
+        this._generator = ensureDefined(generator);
+        this._maxAge = ensureDefined(maxAge);
+        this._maxStale = ensureDefined(TimeDuration.lowest(maxAge, maxStale));
+    }
+    /**
+     * Gets the cached value.
+     * Returns fresh data if available, stale data while revalidating, or triggers generation if empty/expired.
+     * @returns Promise resolving to the cached value.
+     */
+    async get() {
+        if (this.isPending()) {
+            return this._promise;
+        }
+        else if (this.isEmpty() || this.isExpired()) {
+            this._promise = this.generate();
+            return this._promise;
+        }
+        else {
+            if (this.isStale()) {
+                // Start re-generating the contents, while serving stale data.
+                void this.generate();
+            }
+            return this._resolvedValue;
+        }
+    }
+    /**
+     * Generates a new value using the generator function.
+     * Sets up promise handlers for success and error cases.
+     * @returns The generation promise.
+     */
+    generate() {
+        if (this._pending)
+            return this._promise;
+        this._pending = true;
+        const deferred = new Deferred();
+        this._generator().then(value => {
+            this._pending = false;
+            this._resolvedValue = value;
+            this._generatedAt = TimeInstant.now();
+            deferred.resolve(value);
+            withTryCatch(() => this._onNewDataAvailable(value));
+        }, error => {
+            const err = asError(error);
+            this._pending = false;
+            deferred.reject(err);
+            withTryCatch(() => this._onError(err));
+        });
+        return deferred.asPromise();
+    }
+    /**
+     * Checks if value has been requested at least once.
+     * @returns True if a promise exists.
+     */
+    isPresent() {
+        return this._promise !== undefined;
+    }
+    /**
+     * Checks value has never been requested.
+     * @returns True if empty.
+     */
+    isEmpty() {
+        return this._promise === undefined;
+    }
+    /**
+     * Checks if value generation is currently in progress.
+     * @returns True if generation is pending.
+     */
+    isPending() {
+        return this.isPresent() && this._pending === true;
+    }
+    /**
+     * Checks if value is stored and fresh.
+     * @returns True if stored and fresh.
+     */
+    isReady() {
+        return this.isPresent() && this.getAge().isLessThan(this._maxAge);
+    }
+    // protected isResolved() {
+    // 	return this.isReady() && this._error === undefined;
+    // }
+    // protected isError() {
+    // 	return this.isReady() && this._error !== undefined;
+    // }
+    /**
+     * Checks if cached value is stale (older than maxStale duration).
+     * @returns True if value is stale.
+     */
+    isStale() {
+        return this.isPresent() && this.getAge().isGreaterThan(this._maxStale);
+    }
+    /**
+     * Checks if cached value is expired (older than maxAge duration).
+     * @returns True if value is expired.
+     */
+    isExpired() {
+        return this.isPresent() && this.getAge().isGreaterThan(this._maxAge);
+    }
+    /**
+     * Gets the timestamp when the value was last successfully generated.
+     * @returns The last update timestamp.
+     */
+    getLastUpdated() {
+        return this._generatedAt;
+    }
+    /**
+     * Gets the age of the cached value.
+     * @returns The duration since the value was last generated.
+     */
+    getAge() {
+        return this._generatedAt.distanceFromNow();
+    }
+    /**
+     * Invalidates the cache by resetting the generation timestamp.
+     * Next access will trigger fresh generation.
+     */
+    invalidate() {
+        this._generatedAt = TimeInstant.ZERO;
+    }
+    /**
+     * Sets a callback to be invoked when new data becomes available.
+     * @param callback Function to call with the new value.
+     */
+    onNewDataAvailable(callback) {
+        this._onNewDataAvailable = ensureDefined(callback);
+    }
+    /**
+     * Sets a callback to be invoked when generation fails.
+     * @param callback Function to call with the error.
+     */
+    onError(callback) {
+        this._onError = ensureDefined(callback);
+    }
+    /**
+     * Creates a new Cached instance.
+     * @param generator Function that generates the value to cache.
+     * @param maxAge Maximum duration for which cached value is considered valid.
+     * @param maxStale Maximum duration for which stale value is served while revalidating. Defaults to maxAge.
+     * @returns A new Cached instance.
+     */
+    static of(generator, maxAge, maxStale = maxAge) {
+        const cached = new Cached(generator, maxAge, maxStale);
+        void cached.get();
+        return cached;
+    }
+}
+
 const defaultCompareValuesOptions = {
     nullsFirst: false,
 };
@@ -3084,5 +3264,5 @@ function isUpgradable(obj) {
     return isDefined(obj) && typeof obj === "object" && VERSION_FIELD in obj && isNumber(obj.$version) && isPositiveNumber(obj.$version);
 }
 
-export { DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first$1 as first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last$1 as last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse$1 as reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first$1 as first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last$1 as last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse$1 as reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
 //# sourceMappingURL=index.mjs.map