law-common 10.18.1-beta.8 → 10.18.1

package/dist/src/utils/helper.fn.util.js

@@ -0,0 +1,521 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupByFunction = groupByFunction;
+exports.groupByOneToOneFunction = groupByOneToOneFunction;
+exports.convertMapToObject = convertMapToObject;
+exports.removeSamePropertyValues = removeSamePropertyValues;
+exports.getChangedProperties = getChangedProperties;
+exports.compareObjects = compareObjects;
+exports.removeElementsFromArray = removeElementsFromArray;
+exports.arrayDifference = arrayDifference;
+exports.arrayIntersection = arrayIntersection;
+exports.arrayIntersectionWith = arrayIntersectionWith;
+exports.arrayUnion = arrayUnion;
+exports.sumArray = sumArray;
+exports.newRemoved = newRemoved;
+exports.getEnumNames = getEnumNames;
+exports.getFilterByPermission = getFilterByPermission;
+exports.getFilterByPermissionFn = getFilterByPermissionFn;
+exports.getPropertyFilterByPermissionFn = getPropertyFilterByPermissionFn;
+exports.setResponseValue = setResponseValue;
+exports.numberToWordsIndian = numberToWordsIndian;
+exports.minutesToHoursMinutes = minutesToHoursMinutes;
+exports.createKeyLabelMap = createKeyLabelMap;
+exports.transformDate = transformDate;
+exports.capitalizeFirstWord = capitalizeFirstWord;
+exports.getEntitiesFromSearchV2Response = getEntitiesFromSearchV2Response;
+exports.areDecimalNumbersEqual = areDecimalNumbersEqual;
+exports.formatIndianNumber = formatIndianNumber;
+exports.findDuplicateIds = findDuplicateIds;
+exports.getDecimalNumberFromString = getDecimalNumberFromString;
+exports.hasProperty = hasProperty;
+const util_constants_1 = require("../constants/util.constants");
+const error_key_enum_1 = require("../enums/error.key.enum");
+const exceptions_1 = require("../exceptions");
+function groupByFunction(list, keyGetter) {
+    const map = new Map();
+    list.forEach((item) => {
+        const key = keyGetter(item);
+        const collection = map.get(key);
+        if (!collection) {
+            map.set(key, [item]);
+        }
+        else {
+            collection.push(item);
+        }
+    });
+    return map;
+}
+function groupByOneToOneFunction(list, keyGetter) {
+    const map = new Map();
+    list.forEach((item) => {
+        const key = keyGetter(item);
+        map.set(key, item);
+    });
+    return map;
+}
+function convertMapToObject(map) {
+    return Object.fromEntries(map);
+}
+function removeSamePropertyValues(source, target) {
+    for (let key in target) {
+        // remove if null in source and target
+        if (source[key] === null && target[key] === null) {
+            delete target[key];
+        }
+        if (source[key] && source[key] === target[key]) {
+            delete target[key];
+        }
+    }
+}
+function getChangedProperties(source, target) {
+    const result = {};
+    for (let key in target) {
+        if (source[key] !== target[key]) {
+            result[key] = target[key];
+        }
+    }
+    return result;
+}
+function compareObjects(obj1, obj2) {
+    if (obj1 === obj2)
+        return true;
+    if (!obj1 || !obj2)
+        return false;
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    return keys1.every((key) => {
+        const val1 = obj1[key];
+        const val2 = obj2[key];
+        if (typeof val1 === "object" &&
+            val1 !== null &&
+            typeof val2 === "object" &&
+            val2 !== null) {
+            return compareObjects(val1, val2);
+        }
+        return (val1 !== null && val1 !== void 0 ? val1 : null) === (val2 !== null && val2 !== void 0 ? val2 : null);
+    });
+}
+/**
+ * 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]
+ */
+function removeElementsFromArray(source, target) {
+    return target.filter((element) => !source.includes(element));
+}
+/**
+ * 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]
+ */
+function arrayDifference(source, target) {
+    return target.filter((element) => !source.includes(element));
+}
+/**
+ * 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]
+ */
+function arrayIntersection(source, target) {
+    return target.filter((element) => source.includes(element));
+}
+// js docs
+/**
+ * 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" }]
+ */
+function arrayIntersectionWith(source, target, comparator) {
+    return target.filter((element) => source.some((item) => comparator(item, element)));
+}
+/**
+ * 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]
+ */
+function arrayUnion(source, target) {
+    return [...new Set([...source, ...target])];
+}
+function sumArray(array, key) {
+    return array.reduce((acc, item) => acc + Number(item[key]), 0);
+}
+/**
+ * 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] }
+ */
+function newRemoved(existing, incoming) {
+    existing = existing || [];
+    incoming = incoming || [];
+    const added = arrayDifference(existing, incoming);
+    const deleted = arrayDifference(incoming, existing);
+    const present = arrayUnion(arrayIntersection(existing, incoming), added);
+    return { added, deleted, present };
+}
+function getEnumNames(enumType) {
+    return Object.values(enumType).filter((value) => typeof value === "string");
+}
+function getFilterByPermission(permissionFilterConfig, propertyName, userPermission, filterDto, emptyValue = []) {
+    const dtoFilter = filterDto[propertyName];
+    const permissionFilter = permissionFilterConfig[userPermission][propertyName];
+    const isDtoFilterIdPresent = dtoFilter && dtoFilter.length > 0;
+    const isPermissionFilterIdPresent = permissionFilter && permissionFilter.length > 0;
+    return {
+        [propertyName]: isPermissionFilterIdPresent
+            ? isDtoFilterIdPresent
+                ? arrayIntersection(permissionFilter, dtoFilter).length > 0
+                    ? arrayIntersection(permissionFilter, dtoFilter)
+                    : emptyValue
+                : permissionFilter
+            : dtoFilter,
+    };
+}
+function getFilterByPermissionFn(permissionFilterConfig_1, propertyName_1, userPermission_1, filterDto_1) {
+    return __awaiter(this, arguments, void 0, function* (permissionFilterConfig, propertyName, userPermission, filterDto, emptyValue = []) {
+        const filterData = yield permissionFilterConfig[userPermission]();
+        const dtoFilter = filterDto[propertyName];
+        const permissionFilter = filterData[propertyName];
+        const isDtoFilterIdPresent = dtoFilter && dtoFilter.length > 0;
+        const isPermissionFilterIdPresent = permissionFilter && permissionFilter.length > 0;
+        return {
+            [propertyName]: isPermissionFilterIdPresent
+                ? isDtoFilterIdPresent
+                    ? arrayIntersection(permissionFilter, dtoFilter).length > 0
+                        ? arrayIntersection(permissionFilter, dtoFilter)
+                        : emptyValue
+                    : permissionFilter
+                : dtoFilter,
+        };
+    });
+}
+function getPropertyFilterByPermissionFn(permissionFilterConfig_1, propertyNames_1, userPermission_1, filterDto_1) {
+    return __awaiter(this, arguments, void 0, function* (permissionFilterConfig, propertyNames, userPermission, filterDto, emptyValue = []) {
+        const filterData = yield permissionFilterConfig[userPermission]();
+        const result = {};
+        for (const propertyName of propertyNames) {
+            const dtoFilter = filterDto[propertyName];
+            const permissionFilter = filterData[propertyName];
+            const isDtoFilterIdPresent = dtoFilter && dtoFilter.length > 0;
+            const isPermissionFilterIdPresent = permissionFilter && permissionFilter.length > 0;
+            result[propertyName] =
+                isPermissionFilterIdPresent
+                    ? isDtoFilterIdPresent
+                        ? arrayIntersection(permissionFilter, dtoFilter).length > 0
+                            ? arrayIntersection(permissionFilter, dtoFilter)
+                            : emptyValue
+                        : permissionFilter
+                    : dtoFilter;
+        }
+        return result;
+    });
+}
+/**
+ * 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 }
+ */
+function setResponseValue(obj, key, value) {
+    obj[key] = value;
+}
+/**
+ * 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"
+ */
+function numberToWordsIndian(numStr) {
+    const ones = util_constants_1.onesValues;
+    const tens = util_constants_1.tensValues;
+    function twoDigits(n) {
+        if (n < 20)
+            return ones[n];
+        return tens[Math.floor(n / 10)] + (n % 10 !== 0 ? " " + ones[n % 10] : "");
+    }
+    function threeDigits(n) {
+        if (n < 100)
+            return twoDigits(n);
+        return (ones[Math.floor(n / 100)] +
+            " Hundred" +
+            (n % 100 !== 0 ? " " + twoDigits(n % 100) : ""));
+    }
+    // Remove commas and convert to number
+    const num = parseInt(numStr.replace(/,/g, ""), 10);
+    if (isNaN(num))
+        return "Invalid number";
+    if (num === 0)
+        return "Zero";
+    const crore = Math.floor(num / 10000000);
+    const lakh = Math.floor((num % 10000000) / 100000);
+    const thousand = Math.floor((num % 100000) / 1000);
+    const hundred = num % 1000;
+    let words = "";
+    if (crore)
+        words += threeDigits(crore) + " Crore ";
+    if (lakh)
+        words += threeDigits(lakh) + " Lakh ";
+    if (thousand)
+        words += threeDigits(thousand) + " Thousand ";
+    if (hundred)
+        words += threeDigits(hundred);
+    return words.trim();
+}
+/**
+ * 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"
+ */
+function minutesToHoursMinutes(totalMinutes) {
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    const hoursStr = hours.toString().padStart(2, "0");
+    const minutesStr = minutes.toString().padStart(2, "0");
+    return `${hoursStr}:${minutesStr}`;
+}
+function createKeyLabelMap() {
+    return new Proxy({}, {
+        get: (_, prop) => {
+            // Convert camelCase to words (e.g., employeeId -> Employee ID)
+            return prop
+                .replace(/([a-z])([A-Z])/g, "$1 $2")
+                .split(" ")
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(" ");
+        },
+    });
+}
+function transformDate(obj) {
+    return Object.assign(Object.assign({}, obj), { date: obj.date.toISOString() });
+}
+function capitalizeFirstWord(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function getEntitiesFromSearchV2Response(searchResponseV2, entityEnumKey, EntityClass) {
+    var _a;
+    if (!searchResponseV2.relatedEntities) {
+        throw new exceptions_1.AppBadRequestException({
+            key: error_key_enum_1.ErrorKeyEnum.RELATED_ENTITIES,
+            message: ["Invalid Search Operation"],
+        });
+    }
+    return (((_a = searchResponseV2.relatedEntities[entityEnumKey]) === null || _a === void 0 ? void 0 : _a.baseEntities) || []).map((entity) => Object.assign(new EntityClass(), entity));
+}
+/**
+ * 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
+ */
+function areDecimalNumbersEqual(firstValue, secondValue, allowedDifference = 0.5) {
+    // Calculate the absolute difference between both values
+    const actualDifference = Math.abs(firstValue - secondValue);
+    // Return true if the actual difference is less than or equal to the allowed difference
+    return actualDifference <= allowedDifference;
+}
+/**
+ * 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");      // ""
+ */
+function formatIndianNumber(amount) {
+    let num = Number(amount);
+    if (isNaN(num))
+        return "";
+    // Ensure 2 decimal places
+    let [integerPart, decimalPart] = num.toFixed(2).split(".");
+    // Indian grouping: last 3 digits, then groups of 2
+    let lastThree = integerPart.slice(-3);
+    let otherNumbers = integerPart.slice(0, -3);
+    if (otherNumbers !== "") {
+        lastThree = "," + lastThree;
+    }
+    let formattedInt = otherNumbers.replace(/\B(?=(\d{2})+(?!\d))/g, ",") + lastThree;
+    return formattedInt + "." + decimalPart;
+}
+function findDuplicateIds(ids) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const id of ids) {
+        if (seen.has(id)) {
+            duplicates.add(id);
+        }
+        else {
+            seen.add(id);
+        }
+    }
+    return Array.from(duplicates);
+}
+function getDecimalNumberFromString(value, placesAfterDecimal = 2) {
+    // this method should internally handle if the value is number or string
+    return Number(Number(value).toFixed(placesAfterDecimal));
+}
+/**
+ * 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
+ * ```
+ */
+function hasProperty(obj, propName) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+        return false;
+    }
+    // Check if the property exists at the current level
+    if (propName in obj && obj[propName] !== undefined) {
+        return true;
+    }
+    // Recursively check all nested objects, skipping arrays
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            if (typeof value === "object" &&
+                value !== null &&
+                !Array.isArray(value)) {
+                if (hasProperty(value, propName)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}

package/dist/src/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./date.util";
+export * from "./helper.fn.util";
+export * from "./models/date-code.model.util";
+export * from "./string.util";

package/dist/src/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./date.util"), exports);
+__exportStar(require("./helper.fn.util"), exports);
+__exportStar(require("./models/date-code.model.util"), exports);
+__exportStar(require("./string.util"), exports);

package/dist/src/utils/models/date-code.model.util.d.ts

@@ -0,0 +1,40 @@
+export declare enum Weekday {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6
+}
+export declare class DateCodeModel {
+    dateCode: string;
+    constructor(dateCode: string);
+    getByOffset(offset: number): DateCodeModel;
+    isValid(): boolean;
+    getDate(): Date;
+    static getRange(startDate: DateCodeModel, endDate: DateCodeModel): DateCodeModel[];
+    static fromDate(date: Date): string;
+    getFormattedDate(): string;
+    getFormattedDateWithMonthName(): string;
+    static formatDateCode(dateCode: string): string;
+    isWithinOffset(offsetInDays: number): boolean;
+    static getFinancialYearRange(dateCodeModel: DateCodeModel): {
+        startDate: DateCodeModel;
+        endDate: DateCodeModel;
+    };
+    getRange(dateCodeModel: DateCodeModel): DateCodeModel[];
+    static diffInDays(startModel: DateCodeModel, endModel: DateCodeModel, excludeDays?: Weekday[], excludeDateCodes?: DateCodeModel[]): number;
+    static getByPredicates(models: DateCodeModel[], includePredicates: ((dateModel: DateCodeModel) => boolean)[], excludePredicates: ((dateModel: DateCodeModel) => boolean)[]): DateCodeModel[];
+    static getWeekdaysPredicate(weekdays: Weekday[]): (dateModel: DateCodeModel) => boolean;
+    static getDateCodesPredicate(dateCodes: DateCodeModel[]): (dateModel: DateCodeModel) => boolean;
+    diffInDays(endModel: DateCodeModel, excludeDays?: Weekday[], excludeDateCodes?: DateCodeModel[]): number;
+    static calculateNumberOfDays(startDateCode: string, endDateCode: string): number;
+    isDayPresent(days: Weekday[]): boolean;
+    isSame(dateCodeModel: DateCodeModel): boolean;
+    getWeekday(): Weekday;
+    getDateInIST(): Date;
+    static getDaysInCurrentMonth(): number;
+    getDaysInMonth(dateCode?: string): number;
+    isPresent(dateCodes: DateCodeModel[]): boolean;
+}