@zelgadis87/utils-core 4.0.0

package/dist/utils/asError.d.ts

@@ -0,0 +1 @@
+export default function asError(e: unknown): Error;

package/dist/utils/bindThis.d.ts

@@ -0,0 +1 @@
+export default function bindThis<F extends Function>(this: void, fn: F, _this: object): F;

package/dist/utils/constant.d.ts

@@ -0,0 +1,8 @@
+export declare function constant<T>(v: T): () => T;
+export declare function identity<T>(t: T): T;
+export default constant;
+export declare const constantNull: () => null;
+export declare const constantTrue: () => boolean;
+export declare const constantFalse: () => boolean;
+export declare const constantZero: () => number;
+export declare const constantOne: () => number;

package/dist/utils/entries.d.ts

@@ -0,0 +1,4 @@
+import { TFunction } from "../types";
+export declare function dictToEntries<V, K extends string = string>(obj: Record<K, V>): [K, V][];
+export declare function entriesToDict<V, K extends string = string>(entries: [K, V][]): Record<K, V>;
+export declare function mapEntries<K1 extends string, V1, K2 extends string, V2>(dict: Record<K1, V1>, mapper: TFunction<[K1, V1], [K2, V2]>): Record<K2, V2>;

package/dist/utils/groupBy.d.ts

@@ -0,0 +1,7 @@
+import { TFunction, TKeysOfType } from "../types";
+export declare function groupByString<V, K extends TKeysOfType<V, string>>(arr: V[], field: K): Record<V[K] & string, V[]>;
+export declare function groupByNumber<V, K extends TKeysOfType<V, number>>(arr: V[], field: K): Record<V[K] & number, V[]>;
+export declare function groupBySymbol<V, K extends TKeysOfType<V, symbol>>(arr: V[], field: K): Record<V[K] & symbol, V[]>;
+export declare function groupByStringWith<V, K extends string>(arr: V[], getter: TFunction<V, K>): Record<K, V[]>;
+export declare function groupByNumberWith<V, K extends number>(arr: V[], getter: TFunction<V, K>): Record<K, V[]>;
+export declare function groupBySymbolWith<V, K extends symbol>(arr: V[], getter: TFunction<V, K>): Record<K, V[]>;

package/dist/utils/iff.d.ts

@@ -0,0 +1,8 @@
+import { TPredicate } from "../types";
+type TBooleanOrPredicate = boolean | TPredicate<void>;
+type TIff<T> = {
+    elseIf<R>(pred: TBooleanOrPredicate, valueIfTrue: R): TIff<T | R>;
+    otherwise<R>(valueIfElse: R): T | R;
+};
+export default function iff<T>(firstPredicate: TBooleanOrPredicate, valueIfTrue: T): TIff<T>;
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,22 @@
+export { default as asError } from './asError';
+export { default as bindThis } from './bindThis';
+export * from './constant.js';
+export * from './entries.js';
+export * from './groupBy.js';
+export { default as iff } from './iff';
+export * from './indexBy.js';
+export { default as jsonCloneDeep } from './jsonCloneDeep';
+export * from './math.js';
+export { default as noop } from './noop';
+export { default as omit } from './omit';
+export { default as pad } from './pad';
+export { default as pluralize } from './pluralize';
+export * from './round.js';
+export { default as sortBy } from './sortBy';
+export { default as throttle } from './throttle';
+export { default as uniq } from './uniq';
+export { default as uniqBy } from './uniqBy';
+export { default as uniqByKey } from './uniqByKey';
+export { default as withTryCatch } from './withTryCatch';
+export { default as withTryCatchAsync } from './withTryCatchAsync';
+export { default as wrap } from './wrap';

package/dist/utils/indexBy.d.ts

@@ -0,0 +1,7 @@
+import { TFunction, TKeysOfType } from "../types";
+export declare function indexByString<V, K extends TKeysOfType<V, string>>(arr: V[], field: K): Record<V[K] & string, V>;
+export declare function indexByNumber<V, K extends TKeysOfType<V, number>>(arr: V[], field: K): Record<V[K] & number, V>;
+export declare function indexBySymbol<V, K extends TKeysOfType<V, symbol>>(arr: V[], field: K): Record<V[K] & symbol, V>;
+export declare function indexByStringWith<V>(arr: V[], getter: TFunction<V, string>): Record<string, V>;
+export declare function indexByNumberWith<V>(arr: V[], getter: TFunction<V, number>): Record<number, V>;
+export declare function indexBySymbolWith<V>(arr: V[], getter: TFunction<V, symbol>): Record<symbol, V>;

package/dist/utils/jsonCloneDeep.d.ts

@@ -0,0 +1,2 @@
+import { TJsonSerializable } from "../types";
+export default function jsonCloneDeep<A extends TJsonSerializable>(a: A): A;

package/dist/utils/math.d.ts

@@ -0,0 +1,9 @@
+import { TReadableArray } from "../types/arrays.js";
+export declare function clamp(n: number, min: number, max: number): number;
+export declare function average(arr: TReadableArray<number>): number;
+export declare function sum(arr: TReadableArray<number>): number;
+export declare function sumBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
+export declare function min(arr: TReadableArray<number>): number;
+export declare function minBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
+export declare function max(arr: TReadableArray<number>): number;
+export declare function maxBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;

package/dist/utils/noop.d.ts

@@ -0,0 +1 @@
+export default function noop(): void;

package/dist/utils/omit.d.ts

@@ -0,0 +1,2 @@
+import { TJsonObject } from "../types";
+export default function omit<T extends TJsonObject, K extends keyof T>(o: T, ...keys: K[]): Omit<T, K>;

package/dist/utils/pad.d.ts

@@ -0,0 +1,3 @@
+export default function pad(str: string, n: number, char: string, where?: 'left' | 'right'): string;
+export declare function padLeft(str: string, n: number, char: string): string;
+export declare function padRight(str: string, n: number, char: string): string;

package/dist/utils/pluralize.d.ts

@@ -0,0 +1 @@
+export default function pluralize(n: number, singular: string, plural?: string): string;

package/dist/utils/round.d.ts

@@ -0,0 +1,8 @@
+type TRoundMode = 'toNearest' | 'toLower' | 'toUpper' | 'towardsZero' | 'awayFromZero';
+export declare function round(n: number, precision?: number, mode?: TRoundMode): number;
+export default round;
+export declare const roundToNearest: (n: number, precision?: number) => number;
+export declare const roundToLower: (n: number, precision?: number) => number;
+export declare const roundToUpper: (n: number, precision?: number) => number;
+export declare const roundTowardsZero: (n: number, precision?: number) => number;
+export declare const roundAwayFromZero: (n: number, precision?: number) => number;

package/dist/utils/sortBy.d.ts

@@ -0,0 +1,7 @@
+import { TFunction, TKeysOfType } from "../types";
+type TKeyOrGetter<T> = T extends Record<string, unknown> ? TKeysOfType<T, number> & keyof T | TFunction<T, number | null> : TFunction<T, number | null>;
+/**
+ * @deprecated[2023-11-01]: Use {@link Sorter} instead.
+ */
+export default function sortBy<T>(keyOrGetter: TKeyOrGetter<T>, direction?: 'ASC' | 'DESC', nulls?: 'FIRST' | 'LAST'): (a: T, b: T) => number;
+export {};

package/dist/utils/throttle.d.ts

@@ -0,0 +1,3 @@
+import TimeFrequency from "../time/TimeFrequency";
+import { TPromisable } from "../types";
+export default function throttle<TParams extends unknown[], R>(fn: (...params: TParams) => TPromisable<R>, frequence: TimeFrequency): (...params: TParams) => Promise<R>;

package/dist/utils/uniq.d.ts

@@ -0,0 +1 @@
+export default function uniq<T>(arr: T[]): T[];

package/dist/utils/uniqBy.d.ts

@@ -0,0 +1,2 @@
+import { TFunction } from "../types";
+export default function uniqBy<T, K>(arr: T[], getter: TFunction<T, K>): T[];

package/dist/utils/uniqByKey.d.ts

@@ -0,0 +1 @@
+export default function uniqByKey<T, K extends keyof T>(arr: T[], key: K): T[];

package/dist/utils/withTryCatch.d.ts

@@ -0,0 +1,2 @@
+import { TFunction } from "../types";
+export default function withTryCatch<R>(fn: TFunction<void, R>): R | Error;

package/dist/utils/withTryCatchAsync.d.ts

@@ -0,0 +1,2 @@
+import { TFunction } from "../types";
+export default function withTryCatchAsync<R>(fn: TFunction<void, Promise<R>>): Promise<R | Error>;

package/dist/utils/wrap.d.ts

@@ -0,0 +1 @@
+export default function wrap(str: string, delimiter: string): string;