law-common 10.18.1-beta.6 → 10.18.1-beta.8

package/dist/src/utils/helper.fn.util.d.ts

@@ -1,243 +0,0 @@
-import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData } from "../entities";
-import { Modify } from "../misc";
-export declare function groupByFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T[]>;
-export declare function groupByOneToOneFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T>;
-export declare function convertMapToObject<K, T>(map: Map<K, T>): {
-    [key: string]: T;
-};
-export declare function removeSamePropertyValues(source: any, target: any): void;
-export declare function getChangedProperties<T>(source: T, target: T): Partial<T>;
-export declare function compareObjects<T extends Record<string, any>>(obj1: T, obj2: T): boolean;
-/**
- * Removes elements from the target array that are present in the source array.
- *
- * @template T - The type of elements in the arrays.
- * @param {T[]} source - The array containing elements to be excluded from the target array.
- * @param {T[]} target - The array from which elements will be filtered out.
- * @returns {T[]} A new array containing elements from the target array that are not present in the source array.
- *
- * @example
- * const source = [1, 2, 3];
- * const target = [1, 2, 3, 4, 5, 6];
- * const result = removeElementsFromArray(source, target);
- * console.log(result); // Output: [4, 5, 6]
- */
-export declare function removeElementsFromArray<T>(source: T[], target: T[]): T[];
-/**
- * Returns a new array with elements from the target array that are not present in the source array.
- *
- * @template T - The type of elements in the arrays.
- * @param {T[]} source - The array containing elements to be excluded from the target array.
- * @param {T[]} target - The array from which elements will be filtered out.
- * @returns {T[]} A new array containing elements from the target array that are not present in the source array.
- *
- * @example
- * const source = [1, 2, 3];
- * const target = [1, 2, 3, 4, 5, 6];
- * const result = arrayDifference(source, target);
- * console.log(result); // Output: [4, 5, 6]
- */
-export declare function arrayDifference<T>(source: T[], target: T[]): T[];
-/**
- * Returns a new array containing elements that are present in both the source and target arrays.
- *
- * @template T - The type of elements in the arrays.
- * @param {T[]} source - The first array to compare.
- * @param {T[]} target - The second array to compare.
- * @returns {T[]} A new array containing elements that are present in both the source and target arrays.
- *
- * @example
- * const source = [1, 2, 3];
- * const target = [2, 3, 4];
- * const result = arrayIntersection(source, target);
- * console.log(result); // Output: [2, 3]
- */
-export declare function arrayIntersection<T>(source: T[], target: T[]): T[];
-/**
- * Returns a new array containing elements that are present in both the source and target arrays.
- *
- * @template T - The type of elements in the arrays.
- * @param {T[]} source - The first array to compare.
- * @param {T[]} target - The second array to compare.
- * @param {(a: T, b: T) => boolean} comparator - The function to determine if two elements are equal.
- * @returns {T[]} A new array containing elements that are present in both the source and target arrays.
- *
- * @example
- * const source = [{ id: 1, name: "John" }, { id: 2, name: "Jane" }];
- * const target = [{ id: 2, name: "Jane" }, { id: 3, name: "Doe" }];
- * const result = arrayIntersectionWith(source, target, (a, b) => a.id === b.id);
- * console.log(result); // Output: [{ id: 2, name: "Jane" }]
- */
-export declare function arrayIntersectionWith<T>(source: T[], target: T[], comparator: (a: T, b: T) => boolean): T[];
-/**
- * Returns a new array containing elements that are present in either the source or target arrays.
- *
- * @template T - The type of elements in the arrays.
- * @param {T[]} source - The first array to compare.
- * @param {T[]} target - The second array to compare.
- * @returns {T[]} A new array containing elements that are present in either the source or target arrays.
- *
- * @example
- * const source = [1, 2, 3];
- * const target = [2, 3, 4];
- * const result = arrayUnion(source, target);
- * console.log(result); // Output: [1, 2, 3, 4]
- */
-export declare function arrayUnion<T>(source: T[], target: T[]): T[];
-export declare function sumArray<T>(array: T[], key: keyof T): number;
-/**
- * Compares existing and incoming arrays and returns the added, deleted, and present elements.
- *
- * @template T - The type of elements in the arrays.
- * @param {T[]} existing - The existing array.
- * @param {T[]} incoming - The incoming array.
- * @returns {{ added: T[]; deleted: T[]; present: T[] }} An object containing arrays of added, deleted, and present elements.
- *
- * @example
- * const existing = [1, 2, 3];
- * const incoming = [2, 3, 4];
- * const result = newRemoved(existing, incoming);
- * console.log(result); // Output: { added: [4], deleted: [1], present: [2, 3, 4] }
- */
-export declare function newRemoved<T>(existing: T[], incoming: T[]): {
-    added: T[];
-    deleted: T[];
-    present: T[];
-};
-export declare function getEnumNames(enumType: object): string[];
-export declare function getFilterByPermission<T extends EnumEntityType<EntityEnum>>(permissionFilterConfig: {
-    [key: string]: IEntityFilterData<T>;
-}, propertyName: keyof T, userPermission: string, filterDto: IEntityFilterData<T>, emptyValue?: any): {
-    [x: string]: any;
-};
-export declare function getFilterByPermissionFn<T extends EnumEntityType<EntityEnum>>(permissionFilterConfig: {
-    [key: string]: () => Promise<IEntityFilterData<T>>;
-}, propertyName: keyof T, userPermission: string, filterDto: IEntityFilterData<T>, emptyValue?: any): Promise<{
-    [x: string]: any;
-}>;
-export declare function getPropertyFilterByPermissionFn<T extends EnumEntityType<EntityEnum>>(permissionFilterConfig: {
-    [key: string]: () => Promise<IEntityFilterData<T>>;
-}, propertyNames: (keyof T)[], userPermission: string, filterDto: IEntityFilterData<T>, emptyValue?: any): Promise<IEntityFilterData<T>>;
-/**
- * Sets a property value on an object with proper TypeScript type safety.
- *
- * @template T - The type of the target object.
- * @template K - The type of the key, constrained to the keys of T.
- * @param {T} obj - The object on which the value should be set.
- * @param {K} key - The key of the property to update.
- * @param {T[K]} value - The new value to assign to the property.
- *
- * @example
- * interface User {
- *   name: string;
- *   age: number;
- * }
- *
- * const user: User = { name: 'Alice', age: 25 };
- * setResponseValue(user, 'age', 30);
- * console.log(user); // Output: { name: 'Alice', age: 30 }
- */
-export declare function setResponseValue<K extends keyof T, T>(obj: T, key: K, value: T[K]): void;
-/**
- * Converts a numeric string into words following the Indian numbering system.
- *
- * @param {string} numStr - The number in string format. Can contain commas (e.g., "1,23,456").
- *
- * @returns {string} The number expressed in words using the Indian format (e.g., Crores, Lakhs).
- *
- * @example
- * const ones = ["", "One", "Two", "Three", ..., "Nineteen"];
- * const tens = ["", "", "Twenty", "Thirty", ..., "Ninety"];
- *
- * numberToWordsIndian("1,23,456", ones, tens);
- * // Output: "One Lakh Twenty Three Thousand Four Hundred Fifty Six"
- */
-export declare function numberToWordsIndian(numStr: string): string;
-/**
- * Converts a total number of minutes into a formatted "HH:MM" string.
- *
- * @param {number} totalMinutes - The total number of minutes to convert.
- *
- * @returns {string} A string representing the equivalent time in "HH:MM" format,
- * with hours and minutes padded to two digits.
- *
- * @example
- * minutesToHoursMinutes(75); // Output: "01:15"
- * minutesToHoursMinutes(5);  // Output: "00:05"
- * minutesToHoursMinutes(135);// Output: "02:15"
- */
-export declare function minutesToHoursMinutes(totalMinutes: number): string;
-export declare function createKeyLabelMap<Entity>(): Record<keyof Entity, string>;
-export declare function transformDate<T extends {
-    date: Date;
-}>(obj: T): Modify<T, {
-    date: string;
-}>;
-export declare function capitalizeFirstWord(str: string): string;
-export declare function getEntitiesFromSearchV2Response<E extends EntityEnum, // Enum key like EntityEnum.USER, EntityEnum.PROJECT, etc.
-T extends EnumEntityType<E>>(searchResponseV2: IBaseEntityServiceResponse<EnumEntityType<EntityEnum>>, entityEnumKey: E, EntityClass: new () => T): T[];
-/**
- * Checks if two decimal numbers are approximately equal within a given tolerance.
- *
- * @param {number} firstValue - The first number to compare.
- * @param {number} secondValue - The second number to compare.
- * @param {number} allowedDifference - The maximum difference allowed for the numbers
- *                                     to be considered equal.
- *
- * @returns {boolean} Returns `true` if the numbers are within the allowed difference;
- * otherwise, returns `false`.
- *
- * @example
- * areDecimalNumbersEqual(5483.86, 5483.87, 0.5); // true
- * areDecimalNumbersEqual(5483.86, 5484.5, 0.5);  // false
- */
-export declare function areDecimalNumbersEqual(firstValue: number, secondValue: number, allowedDifference?: number): boolean;
-/**
- * Formats a number into the Indian numbering system with commas.
- *
- * - Ensures **two decimal places**.
- * - Applies Indian digit grouping: last 3 digits, then groups of 2 (e.g., 1,23,456.00).
- * - Accepts both `number` and `string` input.
- * - Returns an empty string if the input is not a valid number.
- *
- * @param {number | string} amount - The number or numeric string to format.
- * @returns {string} The formatted number as a string in Indian number format.
- *
- * @example
- * formatIndianNumber(123456);     // "1,23,456.00"
- * formatIndianNumber(1891250);    // "18,91,250.00"
- * formatIndianNumber("21250");    // "21,250.00"
- * formatIndianNumber("abc");      // ""
- */
-export declare function formatIndianNumber(amount: number | string): string;
-export declare function findDuplicateIds(ids: number[]): number[];
-export declare function getDecimalNumberFromString(value: string | number, placesAfterDecimal?: number): number;
-/**
- * Recursively checks if a specified property exists in an object or its nested objects.
- * Skips properties with array values and does not check their contents.
- * The property is considered present if it exists in the object and its value is not undefined.
- *
- * @template T - The type of the input object, constrained to be an object.
- * @param obj - The object to check for the property. Can be null or undefined.
- * @param propName - The name of the property to search for.
- * @returns True if the property exists in the object or any nested non-array object and is not undefined; false otherwise.
- *
- * @example
- * ```typescript
- * interface MyObject {
- *   name?: string;
- *   details?: { age?: number; tags?: string[] };
- * }
- *
- * const obj: MyObject = {
- *   name: "Alice",
- *   details: { age: 30, tags: ["test"] }
- * };
- *
- * console.log(hasProperty(obj, "name")); // true
- * console.log(hasProperty(obj, "age")); // true (nested in details)
- * console.log(hasProperty(obj, "tags")); // false (tags is an array, skipped)
- * console.log(hasProperty(obj, "unknown")); // false
- * ```
- */
-export declare function hasProperty<T extends object>(obj: T | null | undefined, propName: string): boolean;