sussy-util/build/index.d.ts

Util package made by me

/// <reference types="node" />
export * from './Classes';
export * from './Error';
export * from './Functions';
export * from './Types';
import * as classes from './Classes';
import * as errorClasses from './Error';
import * as functions from './Functions';
import * as types from './Types';
export { classes, functions, types };
declare const _default: {
    addProperty: <T>(obj: types.MutableObject<T>, prop: string, value: T) => types.MutableObject<T>;
    asyncTimeout: (ms: number) => Promise<number | NodeJS.Timeout>;
    attributesToArray: <T_1>(obj: types.MutableObject<T_1>, removeNull?: boolean | undefined) => T_1[];
    b64ToString: (val: string) => string;
    bytesToSize: (bytes: number) => string;
    callbackify: <T_2, E extends Error>(func: (...args: any[]) => types.PromiseOr<T_2>, callback: (result: T_2 | null, error: E | null) => types.PromiseOr<void>, ...params: any[]) => Promise<void>;
    callIfFunction: (func: any, ...params: any[]) => any;
    debounce: (fn: Function, wait?: number | undefined, immediate?: boolean) => (...args: any) => void;
    deepClone: (obj: types.MutableObject<any> | types.MutableObject<any>[]) => types.MutableObject<any> | types.MutableObject<any>[];
    deepCompare: (obj: types.MutableObject<any>, obj2: types.MutableObject<any>) => boolean;
    fibonacci: (index: number) => number;
    getProjectRoot: (dirPath: string) => string;
    getObjectKeys: <T_3 extends Object>(obj: T_3) => (keyof T_3)[];
    getTypeString: (arg: any) => string | undefined;
    hasProperty: (obj: Object, prop: string) => boolean;
    hasValue: (a: any) => boolean;
    mapObjectValues: <T_4 extends object, R>(obj: T_4, mapper: (value: T_4[keyof T_4], key: keyof T_4, object: T_4) => R) => { [K in keyof T_4]: R; };
    measureTime: (label: string, func: (...args: any) => any, ...params: any[]) => void;
    merge: (a: object, b: object) => object;
    objectToString: (o: any) => string;
    parseArgs: (args: string[]) => (string | {
        flag: string;
        value?: string | undefined;
    })[];
    removeFirstDigit: (n: number) => number;
    removeLastDigit: (n: number) => number;
    removeProperty: (obj: types.MutableObject<any>, prop: string) => types.MutableObject<any>;
    removeXDigits: (n: number, pos: number) => number;
    strictJSONParse: (str: string) => Object;
    stringToB64: (value: String) => String;
    syncTimeout: (milliseconds: number) => void;
    toOrdinal: (n: number) => string;
    AbstractClassInstanceCallError: typeof errorClasses.AbstractClassInstanceCallError;
    IndexOutOfBoundsError: typeof errorClasses.IndexOutOfBoundsError;
    AbstractClass: typeof classes.AbstractClass;
    ArrayUtils: {
        flat<T_5>(arr: (T_5 | T_5[])[]): T_5[];
        intersection<T_6>(a: T_6[], b: T_6[]): T_6[];
        union<T_7>(a: T_7[], b: T_7[]): T_7[];
        difference<T_8>(a: T_8[], b: T_8[]): T_8[];
        shuffle<X, T_9 extends X[]>(array: X[] | T_9): void;
        countOccurrences<T_10>(array: T_10[], value: T_10): number;
        clear(array: any[]): void;
        clone<T_11>(array: T_11[]): T_11[];
        deepClone<T_12>(array: T_12[]): T_12[];
        removeDuplicates<T_13>(arr: T_13[]): T_13[];
        sortByKey<T_14 extends Object>(arr: T_14[], key: keyof T_14): T_14[];
        remove<T_15>(arr: T_15[], item: T_15): T_15[];
        zip<T_16, U>(arr1: T_16[], arr2: U[]): [T_16, U][];
        insert<T_17>(arr: T_17[], index: number, ...items: T_17[]): T_17[];
        uniqueSubArrays(arr: any[][]): any[][];
        quickSelect(arr: number[], k: number): number;
        quickSort<T_18>(arr: T_18[], compareFn: (a: T_18, b: T_18) => number): T_18[];
        chunks<T_19>(array: T_19[], chunkSize: number): T_19[][];
        findByPropertyValue<T_20>(array: T_20[], property: keyof T_20, value: any): classes.Optional<T_20>;
        findIndexByPropertyValue<T_21>(array: T_21[], property: keyof T_21, value: any): number;
        findAllIndices<T_22>(array: T_22[], condition: (element: T_22) => boolean): number[];
    };
    BetterMath: {
        round(value: number, digit: number): number;
        square(num: number): number;
        cube(num: number): number;
        distance: (path: classes.Point[], index?: number) => number;
        greatestCommonDivisor(a: number, b: number): number;
        gcd(a: number, b: number): number;
        lowestCommonDenominator(a: number, b: number): number;
        lcd(a: number, b: number): number;
        average(numbers: number[]): number;
        avg(numbers: number[]): number;
        factorial(num: number): number;
        factorialIterative(num: number): number;
        median(values: number[]): number;
        nthRoot(number: number, n: number): number;
        logarithm(number: number, base: number): number;
        permutations(n: number, r: number): number;
        combinations(n: number, r: number): number;
        degreesToRadians(degrees: number): number;
        radiansToDegrees(radians: number): number;
        factorialWithMemoization(num: number, memo?: Map<number, number>): number;
        countDecimalDigits(number: number): number;
    };
    BuilderBuilder: typeof classes.BuilderBuilder;
    Collection: typeof classes.Collection;
    DataConverter: typeof classes.DataConverter;
    DateUtil: {
        getCurrentDate(): Date;
        today(): Date;
        tomorrow(): Date;
        yesterday(): Date;
        compareDates<T_23 extends Date>(dt1: number | Date | T_23, dt2: number | Date | T_23): number;
        equals<T_24 extends Date>(dt1: number | Date | T_24, dt2: number | Date | T_24): boolean;
        getMonthAbbr(number: number): string;
        getMonthFullName(number: number): string;
        getDayAbbr(number: number): string;
        getDayFullName(number: number): string;
        isLeapYear(year: number): boolean;
        weekFirstDay(): Date;
        weekLastDay(): Date;
        leapYearsInRange(startYear: number, endYear: number): number[];
        getMonthFirstDay(): Date;
        getMonthLastDay(): Date;
        toDate<T_25 extends Date>(input: Number | T_25): Date;
        isAfter<T_26 extends Date>(date1: number | Date | T_26, date2: number | Date | T_26): boolean;
        isBefore<T_27 extends Date>(date1: number | Date | T_27, date2: number | Date | T_27): boolean;
        yearsToMonths(years: number): number;
        isWeekend<T_28 extends Date>(dt: number | Date | T_28): boolean;
        getDaysDiff<T_29 extends Date>(dt1: number | Date | T_29, dt2: number | Date | T_29): number;
        addDays<T_30 extends Date>(dt: number | Date | T_30, days: number): Date;
        formatDate<T_31 extends Date>(dt: number | Date | T_31, format: string): string;
        getCurrentTimestamp(): number;
    };
    ImmutableClass: typeof classes.ImmutableClass;
    ImprovedArray: typeof classes.ImprovedArray;
    IsSomething: {
        isArray(arg: any): boolean;
        isBoolean(arg: any): boolean;
        isClass(arg: any): boolean;
        isDate(arg: any): boolean;
        isDefined(arg: any): boolean;
        isEmpty(arg: any): boolean;
        isError(arg: any): boolean;
        isEven(num: number): boolean | null;
        isFunction(a: any): boolean;
        isInfinite(arg: any): boolean;
        isNullorUndefined(arg: any): boolean;
        isNumber(arg: any): boolean;
        isObject(arg: any): boolean;
        isPrime(num: number): boolean | null;
        isPrimitive(arg: any): boolean;
        isRegExp(arg: any): boolean;
        isString(args: any): boolean;
        isSymbol(arg: any): boolean;
        isType(arg: any, type: String): boolean;
        isInstanceOf(value: any, constructor: Function): boolean | null;
        isDateValid(date: Date): boolean;
    };
    LRUCache: typeof classes.LRUCache;
    MatrixOperations: typeof classes.MatrixOperations;
    ObjectPool: typeof classes.ObjectPool;
    Optional: typeof classes.Optional;
    Point: typeof classes.Point;
    Point3d: typeof classes.Point3d;
    PrimeNumbers: typeof classes.PrimeNumbers;
    PromiseUtil: {
        readonly "__#1@#resFirst": <R_1, E_1>(resolve: Function, reject: Function, result: R_1, error: E_1 | null) => any;
        readonly "__#1@#resReplace": <R_2, E_2>(resolve: Function, reject: Function, result: R_2 | E_2) => any;
        readonly "__#1@#resLast": <R_3, E_3>(resolve: Function, reject: Function, error: E_3 | null, result: R_3) => any;
        readonly "__#1@#MAPPINGS": types.MutableObject<{
            args: (args: any[], callback: Function) => any[];
            function1: Function;
        }>;
        executeSequentially<T_32>(promises: types.PromiseOr<T_32>[]): Promise<[(T_32 | null)[], Error[]]>;
        handler<R_4, E_4 extends Error>(promise: types.PromiseOr<R_4> | (() => types.PromiseOr<R_4>)): Promise<[R_4 | null, E_4 | null]>;
        retry<T_33>(func: () => types.PromiseOr<T_33>, maxRetries?: number): Promise<[T_33 | null, Error[]]>;
        delay(milliseconds: number): Promise<void>;
        filter<T_34>(values: T_34[], asyncFilterFunc: (value: T_34) => types.PromiseOr<boolean>): Promise<T_34[]>;
        timeout<T_35>(promise: types.PromiseOr<T_35>, milliseconds: number): Promise<T_35>;
        batchPromises<T_36, R_5>(values: T_36[], batchSize: number, asyncFunc: (value: T_36) => types.PromiseOr<R_5>): Promise<R_5[]>;
        promisify<T_37, R_6>(func: Function, { callBackPosition, errorPosition }?: {
            callBackPosition: "front" | "back";
            errorPosition: "replace" | "first" | "last";
        }): (...args: T_37[]) => Promise<R_6>;
        mapPromises<T_38, R_7>(values: T_38[], asyncMapFunc: (value: T_38) => types.PromiseOr<R_7>): Promise<R_7[]>;
        concurrentMap<T_39, R_8>(values: T_39[], asyncMapFunc: (value: T_39) => types.PromiseOr<R_8>, concurrency: number): Promise<R_8[]>;
        executeConcurrently<T_40>(promises: types.PromiseOr<T_40>[], concurrency: number): Promise<[(T_40 | null)[], Error[]]>;
    };
    Queue: typeof classes.Queue;
    Random: {
        readonly defaultCharset: string;
        randomInt(lower?: number, upper?: number): number;
        randomDouble(lower: number, upper: number): number;
        randomChar(charset?: string): string;
        randomString(length?: number, charset?: string): string;
        randomElement<T_41>(arr: T_41[]): T_41;
        randomElementInRange<T_42>(arr: T_42[], start: number, end: number): T_42;
        randomProperty<T_43 extends Object>(obj: T_43): T_43[keyof T_43];
        randomBoolean(): boolean;
        randomColor(): string;
        randomRgbColor(): number[];
        randomUUID(): string;
        randomDate(startDate: Date, endDate: Date): Date;
    };
    Set: typeof classes.Set;
    Stack: typeof classes.Stack;
    StopWatch: typeof classes.StopWatch;
    StringUtil: typeof classes.StringUtil;
    UnitConverter: typeof classes.UnitConverter;
    UrlUtil: {
        isUrl(url: string): boolean;
        parseUrl(url: string): URL;
        getDomainName(url: string): string;
        getPath(url: string): string;
        addQueryParams(url: string, params: types.MutableObject<string>): string;
        removeQueryParam(url: string, param: string): string;
        editQueryParams(url: string, params: types.MutableObject<string>): string;
        getQueryParams(url: string): types.MutableObject<string>;
        getQueryParamValue(url: string, param: string): string | null;
        updatePath(url: string, newPath: string): string;
        hasQueryParams(url: string): boolean;
        hasQueryParam(url: string, param: string): boolean;
        updateQueryParams(url: string, params: types.MutableObject<string>): string;
        replaceQueryParams(url: string, replacements: types.MutableObject<string>): string;
        removeQueryParams(url: string, paramsToRemove: string[]): string;
        mergeQueryParams(url1: string, url2: string): string;
    };
    Vector2d: typeof classes.Vector2d;
    Vector3d: typeof classes.Vector3d;
};
export default _default;