@encodeagent/platform-helper-util 1.2508.1241505

package/dist/core.js

@@ -0,0 +1,1165 @@
+"use strict";
+/**
+ * @fileoverview Core utility functions including global object handling, environment detection, validation, string manipulation, and caching utilities
+ * @copyright PrimeObjects Software Inc. (C) 2024 All Rights Reserved
+ * @author EncodeAgent Team.
+ * @copyright © 2024 PrimeObjects Software Inc. All rights reserved.
+ * @license Proprietary - Subject to PrimeObjects License Agreements
+ * @contact encode.agent@primeobjects.com
+ * @website https://www.encodeagent.com/
+ *
+ * This software contains proprietary and confidential information of
+ * PrimeObjects Software Inc. Any reproduction or distribution of this
+ * software, in whole or in part, without written permission of
+ * PrimeObjects Software Inc. is strictly prohibited.
+ *
+ * Unauthorized copying of this file, via any medium, is strictly prohibited.
+ * This file is proprietary and confidential.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCacheByGroupId = exports.resetCacheByGroupId = exports.removeCache = exports.setCache = exports.getCache = exports.findLanguage = exports.findGender = exports.findCountry = exports.deepFlatten = exports.formatJSONString = exports.readableFileSize = exports.formatText = exports.numberWithCommas = exports.formatNumberBMK = exports.shortenNumber = exports.groupItems = exports.removeNoValueProperty = exports.isObjectString = exports.isObject = exports.shortenString = exports.formatString = exports.getUTCMaxISOString = exports.getUTCISOString = exports.getMaxTimestamp = exports.getTimestamp = exports.isPassword = exports.isEmail = exports.checkToTrue = exports.ttl = exports.serialNumber = exports.getDateTimeString = exports.timeDiff = exports.getSubObject = exports.base64ToJson = exports.jsonToBase64 = exports.isEmptyString = exports.isPhoneNumber = exports.isGuid = exports.isNonEmptyString = exports.stringToColor = exports.doNothing = exports.getPropName = exports.setLibTrack = exports.libTrackIsOn = exports.setAppTrack = exports.appTrackIsOn = exports.getGlobalEnv = exports.getGlobalObject = exports.getProcess = exports.getWindow = void 0;
+exports.toTitle = exports.getObjsDifference = exports.wait = exports.isGoodJSON = exports.parseString = exports.generateBatchArray = exports.calculateSurcharge = exports.convertToOneParagraph = exports.trimNewLine = exports.getLastDayOfTheWeek = exports.getFirstDayOfTheWeek = exports.isFloatString = exports.isIntegerString = exports.isBooleanString = exports.isNumberString = exports.convertEnumToArray = exports.isEmptyGuid = exports.sameGuid = exports.cleanGuid = exports.removeCacheByGroupId = exports.getCacheByGroupId = void 0;
+const lodash_1 = require("lodash");
+// import { isValidNumber } from "libphonenumber-js";
+const constants_1 = require("./constants");
+/**
+ * Gets the global window object if available, otherwise returns empty object
+ * @returns {IWindow | Record<string, never>} Window object or empty object
+ * @example
+ * const win = getWindow();
+ * if ('document' in win) {
+ *   // Browser environment
+ * }
+ */
+const getWindow = () => {
+    return typeof window !== "undefined" ? window : {};
+};
+exports.getWindow = getWindow;
+/**
+ * Gets the Node.js process object if available, otherwise returns empty object
+ * @returns {IProcess | Record<string, never>} Process object or empty object
+ * @example
+ * const proc = getProcess();
+ * if ('env' in proc) {
+ *   // Node.js environment
+ * }
+ */
+const getProcess = () => {
+    return typeof process !== "undefined" ? process : {};
+};
+exports.getProcess = getProcess;
+/**
+ * Gets the appropriate global object for the current environment
+ * @returns {GlobalObject} Global object (window in browser, process in Node.js)
+ * @example
+ * const global = getGlobalObject();
+ * console.log('env' in global ? 'Node.js' : 'Browser');
+ */
+const getGlobalObject = () => {
+    if (typeof window !== "undefined")
+        return window;
+    if (typeof process !== "undefined")
+        return process;
+    return {};
+};
+exports.getGlobalObject = getGlobalObject;
+/**
+ * Gets environment variables from the global object
+ * @returns {NodeJS.ProcessEnv | undefined} Environment variables object or undefined
+ * @example
+ * const env = getGlobalEnv();
+ * const port = env?.PORT || '3000';
+ */
+const getGlobalEnv = () => {
+    const global = (0, exports.getGlobalObject)();
+    return 'env' in global ? global.env : undefined;
+};
+exports.getGlobalEnv = getGlobalEnv;
+/**
+ * Checks if application tracking is enabled
+ * @returns {boolean} True if app tracking is enabled
+ * @example
+ * if (appTrackIsOn()) {
+ *   console.log('Tracking enabled');
+ * }
+ */
+const appTrackIsOn = () => {
+    const global = (0, exports.getGlobalObject)();
+    // Check direct property
+    if ('APP_TRACK' in global) {
+        const value = String(global.APP_TRACK).toLowerCase();
+        if (value === 'true')
+            return true;
+    }
+    // Check environment variables
+    const env = (0, exports.getGlobalEnv)();
+    if (env?.APP_TRACK?.toLowerCase() === 'true')
+        return true;
+    return false;
+};
+exports.appTrackIsOn = appTrackIsOn;
+/**
+ * Sets the application tracking flag
+ * @param {boolean} value - Whether to enable app tracking
+ * @example
+ * setAppTrack(true); // Enable tracking
+ */
+const setAppTrack = (value) => {
+    const global = (0, exports.getGlobalObject)();
+    global.APP_TRACK = value;
+};
+exports.setAppTrack = setAppTrack;
+/**
+ * Checks if library tracking is enabled
+ * @returns {boolean} True if library tracking is enabled
+ * @example
+ * if (libTrackIsOn()) {
+ *   console.log('Library tracking enabled');
+ * }
+ */
+const libTrackIsOn = () => {
+    const global = (0, exports.getGlobalObject)();
+    // Check direct property
+    if ('LIB_TRACK' in global) {
+        const value = String(global.LIB_TRACK).toLowerCase();
+        if (value === 'true')
+            return true;
+    }
+    // Check environment variables
+    const env = (0, exports.getGlobalEnv)();
+    if (env?.LIB_TRACK?.toLowerCase() === 'true')
+        return true;
+    return false;
+};
+exports.libTrackIsOn = libTrackIsOn;
+/**
+ * Sets the library tracking flag
+ * @param {boolean} value - Whether to enable library tracking
+ * @example
+ * setLibTrack(false); // Disable library tracking
+ */
+const setLibTrack = (value) => {
+    const global = (0, exports.getGlobalObject)();
+    global.LIB_TRACK = value;
+};
+exports.setLibTrack = setLibTrack;
+/**
+ * Converts a string to a valid property name in camelCase
+ * @param {string} s - Input string to convert
+ * @returns {string} Camel case property name
+ * @throws {Error} When input string is empty or invalid
+ * @example
+ * getPropName('user name') // returns 'userName'
+ * getPropName('API-KEY') // returns 'apiKey'
+ */
+const getPropName = (s) => {
+    if (!s || typeof s !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+    const cleaned = s.replace(/[^a-zA-Z0-9]/g, " ").replace(/[ ]{2,}/gi, " ").trim();
+    if (!cleaned) {
+        throw new Error('Input string must contain at least one alphanumeric character');
+    }
+    return (0, exports.formatText)(cleaned, "camel");
+};
+exports.getPropName = getPropName;
+/**
+ * Utility function to handle TypeScript unused variable warnings
+ * @param {T} o - Any value to return unchanged
+ * @returns {T} The input value unchanged
+ * @template T
+ * @example
+ * const unused = doNothing(someVariable); // Prevents TS unused variable warning
+ */
+const doNothing = (o) => {
+    return o;
+};
+exports.doNothing = doNothing;
+/**
+ * Converts a string to a consistent HSL color
+ * @param {string} str - Input string to convert to color
+ * @param {number} [s=50] - Saturation value (0-100)
+ * @param {number} [l=50] - Lightness value (0-100)
+ * @returns {string | null} HSL color string or null if invalid input
+ * @example
+ * stringToColor('user123', 70, 60) // returns 'hsl(245, 70%, 60%)'
+ * stringToColor('admin', 80) // returns 'hsl(123, 80%, 50%)'
+ */
+const stringToColor = (str, s = 50, l = 50) => {
+    if (!str || typeof str !== 'string') {
+        return null;
+    }
+    // Validate saturation and lightness values
+    const saturation = Math.max(0, Math.min(100, s));
+    const lightness = Math.max(0, Math.min(100, l));
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = str.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    const hue = Math.abs(hash) % 360;
+    return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
+};
+exports.stringToColor = stringToColor;
+/**
+ * Checks if a value is a non-empty string
+ * @param {unknown} s - Value to check
+ * @param {boolean} [trim=false] - Whether to trim whitespace before checking
+ * @returns {boolean} True if value is a non-empty string
+ * @example
+ * isNonEmptyString('hello') // returns true
+ * isNonEmptyString('  ', true) // returns false
+ * isNonEmptyString('  ', false) // returns true
+ */
+const isNonEmptyString = (s, trim = false) => {
+    if (!(0, lodash_1.isString)(s)) {
+        return false;
+    }
+    return trim ? s.trim().length > 0 : s.length > 0;
+};
+exports.isNonEmptyString = isNonEmptyString;
+/**
+ * Validates if a string is a valid GUID/UUID format
+ * @param {unknown} s - Value to validate
+ * @param {boolean} [allowNilEmpty=false] - Whether to allow null/empty values
+ * @returns {boolean} True if valid GUID format
+ * @example
+ * isGuid('550e8400-e29b-41d4-a716-446655440000') // returns true
+ * isGuid('{550e8400-e29b-41d4-a716-446655440000}') // returns true
+ * isGuid('invalid-guid') // returns false
+ */
+const isGuid = (s, allowNilEmpty = false) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    if (!(0, exports.isNonEmptyString)(s))
+        return false;
+    const pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const cleaned = s.replace(/[{}]/g, "").toLowerCase();
+    return pattern.test(cleaned);
+};
+exports.isGuid = isGuid;
+// export const isPhoneNumberAdvanced = (s: any): boolean => {
+//     if (!isNonEmptyString(s)) return false;
+//     return isValidNumber(s.trim().replace(/ /g, ""));
+// };
+//[E.164][1] format +16175551212
+/**
+ * Validates if a string is a valid phone number format
+ * @param {string} value - Phone number string to validate
+ * @param {boolean} [allowNilEmpty=false] - Whether to allow null/empty values
+ * @returns {boolean} True if valid phone number format
+ * @example
+ * isPhoneNumber('(555) 123-4567') // returns true
+ * isPhoneNumber('+1 555 123 4567') // returns true
+ * isPhoneNumber('invalid') // returns false
+ */
+const isPhoneNumber = (value, allowNilEmpty = false) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(value))
+        return true;
+    if (!(0, exports.isNonEmptyString)(value))
+        return false;
+    let cleanValue = value;
+    // Remove country code prefix if present
+    if (cleanValue.startsWith("+")) {
+        const parts = cleanValue.split(" ");
+        parts.shift(); // Remove country code
+        cleanValue = parts.join(" ");
+    }
+    // Extract only digits
+    const digits = cleanValue.match(/\d/g);
+    if (!digits)
+        return false;
+    const numericOnly = digits.join("");
+    // Validate US phone number format (10 digits)
+    const pattern = /^[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/;
+    return pattern.test(numericOnly);
+};
+exports.isPhoneNumber = isPhoneNumber;
+/**
+ * Checks if a value is an empty string
+ * @param {unknown} s - Value to check
+ * @param {boolean} [trim=false] - Whether to trim whitespace before checking
+ * @returns {boolean} True if value is an empty string
+ * @example
+ * isEmptyString('') // returns true
+ * isEmptyString('   ', true) // returns true
+ * isEmptyString('hello') // returns false
+ */
+const isEmptyString = (s, trim = false) => {
+    if ((0, lodash_1.isNil)(s) || !(0, lodash_1.isString)(s)) {
+        return false;
+    }
+    return trim ? s.trim().length === 0 : s.length === 0;
+};
+exports.isEmptyString = isEmptyString;
+/**
+ * Converts a JSON object to Base64 encoded string
+ * @param {Record<string, any>} object - Object to encode
+ * @returns {string} Base64 encoded string
+ * @throws {Error} When object cannot be serialized or Buffer is not available
+ * @example
+ * jsonToBase64({ name: 'John', age: 30 }) // returns 'eyJuYW1lIjoiSm9obiIsImFnZSI6MzB9'
+ */
+const jsonToBase64 = (object) => {
+    if (!object || typeof object !== 'object') {
+        throw new Error('Input must be a valid object');
+    }
+    try {
+        const json = JSON.stringify(object);
+        // Check if Buffer is available (Node.js environment)
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(json).toString('base64');
+        }
+        // Fallback for browser environment
+        if (typeof btoa !== 'undefined') {
+            return btoa(json);
+        }
+        throw new Error('Base64 encoding not available in this environment');
+    }
+    catch (error) {
+        throw new Error(`Failed to encode object to Base64: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+exports.jsonToBase64 = jsonToBase64;
+/**
+ * Converts a Base64 encoded string back to JSON object
+ * @param {string} base64 - Base64 encoded string
+ * @returns {any} Parsed JSON object
+ * @throws {Error} When base64 string is invalid or cannot be parsed
+ * @example
+ * base64ToJson('eyJuYW1lIjoiSm9obiIsImFnZSI6MzB9') // returns { name: 'John', age: 30 }
+ */
+const base64ToJson = (base64) => {
+    if (!(0, exports.isNonEmptyString)(base64)) {
+        throw new Error('Input must be a non-empty Base64 string');
+    }
+    try {
+        let json;
+        // Check if Buffer is available (Node.js environment)
+        if (typeof Buffer !== 'undefined') {
+            json = Buffer.from(base64, 'base64').toString();
+        }
+        else if (typeof atob !== 'undefined') {
+            // Fallback for browser environment
+            json = atob(base64);
+        }
+        else {
+            throw new Error('Base64 decoding not available in this environment');
+        }
+        return JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`Failed to decode Base64 to JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+exports.base64ToJson = base64ToJson;
+/**
+ * Extracts specified properties from an object into a new object
+ * @param {Record<string, any> | null | undefined} obj - Source object
+ * @param {string} props - Comma-separated property names to extract
+ * @returns {Record<string, any> | undefined} New object with extracted properties
+ * @throws {Error} When props string is invalid
+ * @example
+ * getSubObject({ a: 1, b: 2, c: 3 }, 'a, b') // returns { a: 1, b: 2 }
+ * @deprecated Consider using object destructuring or lodash.pick instead
+ */
+const getSubObject = (obj, props) => {
+    if ((0, lodash_1.isNil)(obj))
+        return undefined;
+    if (!(0, exports.isNonEmptyString)(props)) {
+        throw new Error('Props must be a non-empty string');
+    }
+    try {
+        // Safer alternative to eval - manually parse and extract properties
+        const propNames = props.split(',').map(p => p.trim()).filter(p => p.length > 0);
+        const result = {};
+        for (const propName of propNames) {
+            if (propName in obj) {
+                result[propName] = obj[propName];
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        throw new Error(`Failed to extract properties: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+exports.getSubObject = getSubObject;
+/**
+ * Calculates the time difference between two dates
+ * @param {Date} d1 - First date (later date for positive result)
+ * @param {Date} d2 - Second date (earlier date for positive result)
+ * @param {string} type - Unit of time difference (second, minute, hour)
+ * @returns {number} Time difference in specified units
+ * @throws {Error} When dates are invalid
+ * @example
+ * timeDiff(new Date('2023-01-02'), new Date('2023-01-01'), 'hour') // returns 24
+ * timeDiff(new Date('2023-01-01 12:30'), new Date('2023-01-01 12:00'), 'minute') // returns 30
+ */
+const timeDiff = (d1, d2, type) => {
+    if (!(d1 instanceof Date) || !(d2 instanceof Date)) {
+        throw new Error('Both parameters must be valid Date objects');
+    }
+    if ((0, lodash_1.isNaN)(d1.getTime()) || (0, lodash_1.isNaN)(d2.getTime())) {
+        throw new Error('Both dates must be valid');
+    }
+    const diffT = d1.getTime() - d2.getTime();
+    if (type === "second" || type === "sec" || type === "s") {
+        return Math.floor(diffT / 1000);
+    }
+    if (type === "minute" || type === "min" || type === "m") {
+        return Math.floor(diffT / 1000 / 60);
+    }
+    if (type === "hour" || type === "hr" || type === "h") {
+        return Math.floor(diffT / 1000 / 60 / 60);
+    }
+    // Default: return milliseconds
+    return diffT;
+};
+exports.timeDiff = timeDiff;
+/**
+ * Formats a date into a string with customizable delimiter and parts
+ * @param {Date} [dt] - Date to format (defaults to current date)
+ * @param {string} [delimiter="-"] - Character to use as delimiter
+ * @param {string} [part="full"] - Which part of the date to return
+ * @returns {string} Formatted date string
+ * @example
+ * getDateTimeString() // returns "2023-01-01-12-30-45-123"
+ * getDateTimeString(new Date(), "_", "date") // returns "2023_01_01"
+ */
+const getDateTimeString = (dt, delimiter = "-", part = "full") => {
+    const date = dt || new Date();
+    if (!(date instanceof Date) || (0, lodash_1.isNaN)(date.getTime())) {
+        throw new Error('Invalid date provided');
+    }
+    let formatted = date
+        .toISOString()
+        .replace("T", "-")
+        .replace(/:/g, "-")
+        .replace("Z", "")
+        .replace(/\./g, "-");
+    const parts = formatted.split("-");
+    switch (part) {
+        case "date":
+            formatted = `${parts[0]}-${parts[1]}-${parts[2]}`;
+            break;
+        case "time":
+            formatted = `${parts[3]}-${parts[4]}-${parts[5]}`;
+            break;
+        case "ms":
+            formatted = parts[6] || "000";
+            break;
+        default:
+            // Keep full format
+            break;
+    }
+    return delimiter === "-" ? formatted : formatted.replace(/-/g, delimiter);
+};
+exports.getDateTimeString = getDateTimeString;
+/**
+ * Generates a unique serial number based on current timestamp
+ * @returns {string} Generated serial number
+ * @example
+ * serialNumber() // returns "20230101123045123456"
+ */
+const serialNumber = () => {
+    const now = new Date();
+    const utcTime = new Date(now.getTime() + now.getTimezoneOffset() * 60000);
+    let timeString = utcTime.toISOString()
+        .replace(/-/g, "")
+        .replace(/:/g, "")
+        .replace("Z", "")
+        .replace("T", "")
+        .replace(/\./g, "");
+    const chars = timeString.substring(1).split("");
+    let result = "";
+    let index = 0;
+    while (index < chars.length) {
+        const current = parseInt(chars[index]);
+        const next = index < chars.length - 1 ? parseInt(chars[index + 1]) : 0;
+        const combined = current * 10 + next;
+        if (combined <= 9) {
+            result += current.toString();
+            index += 1;
+        }
+        else if (combined >= 10 && combined < 36) {
+            result += String.fromCharCode("a".charCodeAt(0) + combined - 10);
+            index += 2;
+        }
+        else {
+            result += current.toString();
+            index += 1;
+        }
+    }
+    return result;
+};
+exports.serialNumber = serialNumber;
+/**
+ * Calculates a TTL (Time To Live) timestamp in seconds
+ * @param {number} [mins=60] - Minutes to add to current time
+ * @returns {number} Unix timestamp in seconds
+ * @example
+ * ttl(30) // returns current timestamp + 30 minutes in seconds
+ * ttl() // returns current timestamp + 60 minutes in seconds
+ */
+const ttl = (mins = 60) => {
+    if (!(0, lodash_1.isNumber)(mins) || mins < 0) {
+        mins = 60;
+    }
+    const nowInSeconds = Math.floor(Date.now() / 1000);
+    return nowInSeconds + mins * 60;
+};
+exports.ttl = ttl;
+const checkToTrue = (js, props) => {
+    if (!(0, lodash_1.isObject)(props))
+        props = {};
+    try {
+        const func = (0, lodash_1.isFunction)(props.jsEvalFunction)
+            ? props.jsEvalFunction(js)
+            : null;
+        if (!(0, lodash_1.isFunction)(func)) {
+            if (func)
+                return true;
+        }
+        else {
+            if (func(props))
+                return true;
+        }
+    }
+    catch (ex) {
+        console.error("Error when evaluating checkToTrue", { ex, js });
+    }
+    return false;
+};
+exports.checkToTrue = checkToTrue;
+const isEmail = (s, allowNilEmpty) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    let email = s ?? "";
+    if (email.indexOf(" ") >= 0)
+        return false;
+    if ((0, exports.isNonEmptyString)(email))
+        email = email.trim().replace(/[+]/g, "");
+    const pattern = new RegExp(/^(("[\w-\s]+")|([\w-]+(?:\.[\w-]+)*)|("[\w-\s]+")([\w-]+(?:\.[\w-]+)*))(@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$)|(@\[?((25[0-5]\.|2[0-4][0-9]\.|1[0-9]{2}\.|[0-9]{1,2}\.))((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\.){2}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\]?$)/i);
+    return pattern.test(email);
+};
+exports.isEmail = isEmail;
+const isPassword = (s, settings) => {
+    if (!(0, lodash_1.isObject)(settings))
+        settings = {};
+    const needLowerCaseLetter = settings.needLowerCaseLetter ??
+        constants_1.DEFAULT_PASSWORD_RULE.needLowerCaseLetter;
+    const needUpperCaseLetter = settings.needUpperCaseLetter ??
+        constants_1.DEFAULT_PASSWORD_RULE.needUpperCaseLetter;
+    const needDigit = settings.needDigit ?? constants_1.DEFAULT_PASSWORD_RULE.needDigit;
+    const needSpecialChar = settings.needSpecialChar ?? constants_1.DEFAULT_PASSWORD_RULE.needSpecialChar;
+    const allowNilEmpty = settings.allowNilEmpty;
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    let v = s ?? "";
+    const minLen = settings.minLen && settings.minLen > 5 ? settings.minLen : 8;
+    if ((0, exports.isNonEmptyString)(v))
+        v = v.trim().replace(/ /g, "");
+    if (v.length < minLen)
+        return false;
+    let result = true;
+    if (needDigit) {
+        result = new RegExp(/^(?=.*[\d])[\w!\-@#$%.^&*]+$/).test(v);
+        if (!result)
+            console.log("Password does not contain digit.");
+    }
+    if (result && needUpperCaseLetter) {
+        result = new RegExp(/^(?=.*[A-Z])[\w!\-@#$%.^&*]+$/).test(v);
+        if (!result)
+            console.log("Password does not contain uppercase letter.");
+    }
+    if (result && needLowerCaseLetter) {
+        result = new RegExp(/^(?=.*[a-z])[\w!\-@#$%.^&*]+$/).test(v);
+        if (!result)
+            console.log("Password does not contain lowercase letter.");
+    }
+    if (result && needSpecialChar) {
+        result = new RegExp(/^(?=.*[!\-@#$%?:;~=`"',_<>(){}\.\/\]\[\\\|\+^&*])[\w?=.*[!\-@#$%?:;~=`"',_<>(){}\.\/\]\[\\\|\+^&*]+$/).test(v);
+        if (!result)
+            console.log("Password does not contain special character.");
+    }
+    return result;
+};
+exports.isPassword = isPassword;
+const getTimestamp = (dt) => {
+    return dt ? new Date(dt).getTime() : new Date().getTime();
+};
+exports.getTimestamp = getTimestamp;
+const getMaxTimestamp = () => {
+    return new Date("9999-12-31T23:59:59.999Z").getTime();
+};
+exports.getMaxTimestamp = getMaxTimestamp;
+const getUTCISOString = (dt, minutesDiff) => {
+    if (!dt)
+        dt = new Date();
+    if (minutesDiff === undefined)
+        minutesDiff = 0;
+    if ((0, lodash_1.isNumber)(minutesDiff))
+        dt.setMinutes(dt.getMinutes() + minutesDiff);
+    return dt.toISOString();
+};
+exports.getUTCISOString = getUTCISOString;
+const getUTCMaxISOString = () => {
+    return (0, exports.getUTCISOString)(new Date("9999-12-31T23:59:59.999Z"), 0);
+};
+exports.getUTCMaxISOString = getUTCMaxISOString;
+const formatString = (...args) => {
+    if (args.length == 0)
+        return null;
+    let s = args[0];
+    for (let i = 1; i < args.length; i++) {
+        s = s.replace(/\{0\}/g, args[i]);
+    }
+    return s;
+};
+exports.formatString = formatString;
+const shortenString = (s, l) => {
+    return s.length <= l ? s : `${s.substring(0, l)} ...`;
+};
+exports.shortenString = shortenString;
+//the isObject from lodash will cause error from typescript
+//this one will not
+const isObject = (v) => {
+    return (0, lodash_1.isObject)(v) ? true : false;
+};
+exports.isObject = isObject;
+const isObjectString = (s) => {
+    try {
+        JSON.parse(s);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isObjectString = isObjectString;
+const removeNoValueProperty = (data, removeEmptyString) => {
+    if ((0, lodash_1.isArray)(data)) {
+        return (0, lodash_1.without)((0, lodash_1.map)(data, (r) => {
+            return r === undefined ||
+                r === null ||
+                (r === "" && removeEmptyString)
+                ? null
+                : (0, lodash_1.isObject)(r)
+                    ? (0, exports.removeNoValueProperty)(r, removeEmptyString)
+                    : r;
+        }), null);
+    }
+    for (const p in data) {
+        const v = data[p];
+        if (v === undefined || v === null || (v === "" && removeEmptyString)) {
+            delete data[p];
+        }
+        else {
+            if ((0, lodash_1.isArray)(v)) {
+                data[p] = (0, lodash_1.without)((0, lodash_1.map)(v, (r) => {
+                    return r === undefined ||
+                        r === null ||
+                        (r === "" && removeEmptyString)
+                        ? null
+                        : (0, lodash_1.isObject)(r)
+                            ? (0, exports.removeNoValueProperty)(r, removeEmptyString)
+                            : r;
+                }), null);
+            }
+            else {
+                if ((0, lodash_1.isObject)(v)) {
+                    data[p] = (0, exports.removeNoValueProperty)(v, removeEmptyString);
+                }
+            }
+        }
+    }
+    return data;
+};
+exports.removeNoValueProperty = removeNoValueProperty;
+const groupItems = (data, groups, propNameForItemGroup, propNameForItemSort) => {
+    if (!((0, lodash_1.isArray)(data) && data.length > 0))
+        return [];
+    propNameForItemGroup = propNameForItemGroup
+        ? propNameForItemGroup
+        : "group";
+    propNameForItemSort = propNameForItemSort
+        ? propNameForItemSort
+        : "fullName";
+    const result = (0, lodash_1.map)(groups, (group) => {
+        return {
+            ...group,
+            data: (0, lodash_1.sortBy)((0, lodash_1.without)((0, lodash_1.map)(data, (item) => {
+                return propNameForItemGroup &&
+                    item[propNameForItemGroup] == group.id
+                    ? item
+                    : null;
+            }), null), (item) => {
+                return propNameForItemSort && item[propNameForItemSort];
+            })
+        };
+    });
+    return result;
+};
+exports.groupItems = groupItems;
+const shortenNumber = (num, fractionDigits) => {
+    if (!(0, lodash_1.isNumber)(fractionDigits) ||
+        ((0, lodash_1.isNumber)(fractionDigits) && fractionDigits < 0))
+        fractionDigits = 1;
+    const lookup = [
+        { value: 1, symbol: "" },
+        { value: 1e3, symbol: "K" },
+        { value: 1e6, symbol: "M" },
+        { value: 1e9, symbol: "G" },
+        { value: 1e12, symbol: "T" },
+        { value: 1e15, symbol: "P" },
+        { value: 1e18, symbol: "E" }
+    ];
+    //const rx = /\.0+$|(\.[0-9]*[1-9])0+$/;
+    const item = lookup
+        .slice()
+        .reverse()
+        .find(function (item) {
+        return num >= item.value;
+    });
+    return item
+        ? item && (num / item.value).toFixed(fractionDigits) + item.symbol
+        : "0";
+};
+exports.shortenNumber = shortenNumber;
+const formatNumberBMK = (v) => {
+    if (!(0, lodash_1.isNumber)(v) || !v)
+        return "";
+    if (v > 1000000000)
+        return `${(0, exports.numberWithCommas)(Math.round(v / 100000000) / 10)}B`;
+    if (v > 1000000)
+        return `${(0, exports.numberWithCommas)(Math.round(v / 100000) / 10)}M`;
+    if (v > 1000)
+        return `${(0, exports.numberWithCommas)(Math.round(v / 100) / 10)}K`;
+    return `${v}`;
+};
+exports.formatNumberBMK = formatNumberBMK;
+const numberWithCommas = (x) => {
+    if (!(0, lodash_1.isNumber)(x) && !((0, lodash_1.isString)(x) && x.length > 0))
+        return null;
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+exports.numberWithCommas = numberWithCommas;
+const formatText = (text, format) => {
+    switch (format) {
+        case "lower":
+            return text.toLowerCase();
+        case "upper":
+            return text.toUpperCase();
+        case "capital":
+        case "capital-first":
+            return (0, lodash_1.capitalize)(text);
+        case "capital-all":
+            return (0, lodash_1.map)(text.split(" "), lodash_1.capitalize).join(" ");
+        case "initials":
+            return (0, lodash_1.map)(text.split(" "), (t) => t.length > 0 ? t.charAt(0) : "").join(" ");
+        case "camel":
+            return (0, lodash_1.camelCase)(text);
+        default:
+            return text;
+    }
+};
+exports.formatText = formatText;
+const readableFileSize = (fileSizeInBytes) => {
+    if (!(0, lodash_1.isNumber)(fileSizeInBytes))
+        return "";
+    let i = -1;
+    const byteUnits = [" KB", " MB", " GB", " TB", "PB", "EB", "ZB", "YB"];
+    do {
+        fileSizeInBytes = fileSizeInBytes / 1024;
+        i++;
+    } while (fileSizeInBytes > 1024);
+    return Math.max(fileSizeInBytes, 0.1).toFixed(1) + byteUnits[i];
+};
+exports.readableFileSize = readableFileSize;
+const formatJSONString = (c) => {
+    const jsonValue = (0, exports.isNonEmptyString)(c) ? JSON.parse(c) : c;
+    try {
+        return JSON.stringify(jsonValue, null, 4);
+    }
+    catch (ex) {
+        //console.log({ v, ex })
+    }
+    return JSON.stringify(jsonValue);
+};
+exports.formatJSONString = formatJSONString;
+const deepFlatten = (array) => {
+    let result = [];
+    array.forEach(function (elem) {
+        if (Array.isArray(elem)) {
+            result = result.concat((0, exports.deepFlatten)(elem));
+        }
+        else {
+            result.push(elem);
+        }
+    });
+    return result;
+};
+exports.deepFlatten = deepFlatten;
+const findCountry = (codeOrName, resultFormat) => {
+    const country = (0, lodash_1.find)(constants_1.COUNTRIES, (c) => {
+        return (c.name.toLocaleLowerCase() == codeOrName.toLowerCase() ||
+            c.code.toLocaleLowerCase() == codeOrName.toLowerCase() ||
+            c.code3.toLocaleLowerCase() == codeOrName.toLowerCase());
+    });
+    if (!country)
+        return undefined;
+    switch (resultFormat) {
+        case "PicklistOption": {
+            return {
+                text: country?.name,
+                value: country?.code
+            };
+        }
+        default: {
+            return country;
+        }
+    }
+};
+exports.findCountry = findCountry;
+const findGender = (textOrValue) => {
+    return (0, lodash_1.find)(constants_1.GENDERS, (c) => {
+        return (c.text.toLowerCase() == textOrValue.toLowerCase() ||
+            c.value.toLowerCase() == textOrValue.toLowerCase());
+    });
+};
+exports.findGender = findGender;
+const findLanguage = (codeOrName, resultFormat) => {
+    const language = (0, lodash_1.find)(constants_1.LANGUAGES, (c) => {
+        let found = c.name.toLowerCase() == codeOrName.trim().toLowerCase() ||
+            c.code.toLowerCase() == codeOrName.trim().toLowerCase();
+        if (!found) {
+            const names = c.name.split(",");
+            found =
+                names.length > 1 &&
+                    !(0, lodash_1.isNil)((0, lodash_1.find)(names, (name) => {
+                        return (name.trim().toLowerCase() ==
+                            codeOrName.trim().toLowerCase());
+                    }));
+        }
+        return found;
+    });
+    if (!language)
+        return undefined;
+    switch (resultFormat) {
+        case "PicklistOption": {
+            return {
+                text: language?.name,
+                value: language?.code
+            };
+        }
+        default: {
+            return language;
+        }
+    }
+};
+exports.findLanguage = findLanguage;
+const getCache = (key, defaultValue) => {
+    if (!(0, exports.isNonEmptyString)(key))
+        return undefined;
+    const g = (0, exports.getGlobalObject)();
+    if (!(0, exports.isObject)(g.localCache))
+        g.localCache = {};
+    const cacheData = g.localCache[key];
+    if ((0, lodash_1.isNil)(cacheData))
+        return defaultValue;
+    const { data, ttl } = cacheData;
+    if ((0, lodash_1.isInteger)(ttl) && Date.now() > data.ttl * 1000) {
+        (0, exports.removeCache)(key);
+        return !(0, lodash_1.isNil)(defaultValue) ? defaultValue : undefined;
+    }
+    return !(0, lodash_1.isNil)(data)
+        ? data
+        : !(0, lodash_1.isNil)(defaultValue)
+            ? defaultValue
+            : undefined;
+};
+exports.getCache = getCache;
+const setCache = (key, data, expireMinutes) => {
+    const g = (0, exports.getGlobalObject)();
+    if (!(0, exports.isNonEmptyString)(key))
+        return;
+    if (!(0, exports.isObject)(g.localCache))
+        g.localCache = {};
+    if ((0, lodash_1.isNil)(data))
+        return (0, exports.removeCache)(key);
+    if (!(0, lodash_1.isNil)(expireMinutes) &&
+        (0, lodash_1.isInteger)(expireMinutes) &&
+        expireMinutes > 0) {
+        g.localCache[key] = {
+            data,
+            ttl: (0, exports.ttl)(expireMinutes)
+        };
+    }
+    else {
+        g.localCache[key] = { data };
+    }
+};
+exports.setCache = setCache;
+const removeCache = (key) => {
+    const g = (0, exports.getGlobalObject)();
+    if (!(0, exports.isObject)(g.localCache))
+        g.localCache = {};
+    delete g.localCache[key];
+};
+exports.removeCache = removeCache;
+const resetCacheByGroupId = (groupId) => {
+    (0, exports.removeCache)(groupId);
+};
+exports.resetCacheByGroupId = resetCacheByGroupId;
+const setCacheByGroupId = (groupId, key, value) => {
+    const groupCache = (0, exports.getCache)(groupId) ?? {};
+    groupCache[key] = value;
+    (0, exports.setCache)(groupId, groupCache);
+};
+exports.setCacheByGroupId = setCacheByGroupId;
+const getCacheByGroupId = (groupId, key) => {
+    const groupCache = (0, exports.getCache)(groupId) ?? {};
+    return groupCache[key];
+};
+exports.getCacheByGroupId = getCacheByGroupId;
+const removeCacheByGroupId = (groupId, key) => {
+    const groupCache = (0, exports.getCache)(groupId) ?? {};
+    delete groupCache[key];
+    (0, exports.setCache)(groupId, groupCache);
+};
+exports.removeCacheByGroupId = removeCacheByGroupId;
+const cleanGuid = (v) => {
+    return !v
+        ? ""
+        : (v + "")
+            .replace("{", "")
+            .replace("}", "")
+            .replace(/_/g, "-")
+            .trim()
+            .toLowerCase();
+};
+exports.cleanGuid = cleanGuid;
+const sameGuid = (a, b) => {
+    return (0, exports.cleanGuid)(a) === (0, exports.cleanGuid)(b);
+};
+exports.sameGuid = sameGuid;
+const isEmptyGuid = (v) => {
+    return (0, exports.sameGuid)(v, constants_1.GUID_EMPTY);
+};
+exports.isEmptyGuid = isEmptyGuid;
+const convertEnumToArray = (thisEnum) => {
+    let result = [];
+    let i = Object.keys(thisEnum).length / 2;
+    for (let key in thisEnum) {
+        i--;
+        if (i < 0)
+            result.push({ key, value: thisEnum[key] });
+    }
+    return result;
+};
+exports.convertEnumToArray = convertEnumToArray;
+const isNumberString = (s, allowNilEmpty) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    const v = s ?? "";
+    return (!(0, lodash_1.isNaN)(v) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+        !(0, lodash_1.isNaN)(parseFloat(v)) // ...and ensure strings of whitespace fail
+    );
+};
+exports.isNumberString = isNumberString;
+const isBooleanString = (s, allowNilEmpty) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    const v = s ?? "";
+    return v.toLowerCase() == "true" || v.toLowerCase() == "false";
+};
+exports.isBooleanString = isBooleanString;
+const isIntegerString = (s, allowNilEmpty) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    if (!(0, exports.isNumberString)(s, allowNilEmpty))
+        return false;
+    const v = s ?? "";
+    return !(0, lodash_1.isNaN)(parseInt(v)) && /^-?\d+?$/.test(v);
+};
+exports.isIntegerString = isIntegerString;
+const isFloatString = (s, allowNilEmpty) => {
+    if (allowNilEmpty && !(0, exports.isNonEmptyString)(s))
+        return true;
+    if (!(0, exports.isNumberString)(s, allowNilEmpty))
+        return false;
+    const v = s ?? "";
+    return !(0, lodash_1.isNaN)(parseFloat(v)) && /^-?\d+(?:[.]\d*?)?$/.test(v);
+};
+exports.isFloatString = isFloatString;
+const getFirstDayOfTheWeek = (ts, setToFirstSecond) => {
+    const dt = new Date(ts);
+    dt.setDate(dt.getDate() - dt.getDay());
+    if (setToFirstSecond) {
+        dt.setHours(0, 0, 0, 0);
+    }
+    return dt.getTime();
+};
+exports.getFirstDayOfTheWeek = getFirstDayOfTheWeek;
+const getLastDayOfTheWeek = (ts, setToLastSecond) => {
+    const dt = new Date(ts);
+    dt.setDate(dt.getDate() + 6 - dt.getDay());
+    if (setToLastSecond) {
+        dt.setHours(23, 59, 59, 59);
+    }
+    return dt.getTime();
+};
+exports.getLastDayOfTheWeek = getLastDayOfTheWeek;
+const trimNewLine = (content) => {
+    const chars = content.split("");
+    while (chars[0] == "\n") {
+        chars.shift();
+    }
+    while (chars[chars.length - 1] == "\n") {
+        chars.pop();
+    }
+    return chars.join("");
+};
+exports.trimNewLine = trimNewLine;
+const convertToOneParagraph = (content) => {
+    return (0, exports.trimNewLine)(content)
+        .replace(new RegExp(`(\n){2,}`, "g"), "\n")
+        .replace(/\n/g, " ")
+        .replace(new RegExp(`( ){2,}`, "g"), " ")
+        .trim();
+};
+exports.convertToOneParagraph = convertToOneParagraph;
+/**
+ * Calculates surcharge amount based on configuration
+ * @param {number} value - Base value to calculate surcharge on
+ * @param {ISurcharge} surcharge - Surcharge configuration
+ * @returns {number} Calculated surcharge amount
+ * @throws {Error} When value is negative or surcharge config is invalid
+ * @example
+ * calculateSurcharge(100, { type: 'percentage', value: 10 }) // returns 10
+ * calculateSurcharge(100, { type: 'number', value: 5 }) // returns 5
+ */
+const calculateSurcharge = (value, surcharge) => {
+    if (typeof value !== 'number' || value < 0) {
+        throw new Error('Value must be a non-negative number');
+    }
+    if (!surcharge || typeof surcharge.value !== 'number' || surcharge.value < 0) {
+        throw new Error('Invalid surcharge configuration');
+    }
+    if (!['percentage', 'number'].includes(surcharge.type)) {
+        throw new Error('Surcharge type must be "percentage" or "number"');
+    }
+    return surcharge.type === "percentage"
+        ? value * surcharge.value * 0.01
+        : surcharge.value;
+};
+exports.calculateSurcharge = calculateSurcharge;
+const generateBatchArray = (list, size, func) => {
+    const result = [];
+    const items = (0, lodash_1.map)(list, (c) => {
+        return func ? func(c) : c;
+    });
+    for (let i = 0; i < items.length; i += size) {
+        const batch = items.slice(i, i + size);
+        result.push(batch);
+    }
+    return result;
+};
+exports.generateBatchArray = generateBatchArray;
+const parseString = (input) => {
+    // Check if the input is a boolean
+    if (input.toLowerCase() === "true") {
+        return true;
+    }
+    else if (input.toLowerCase() === "false") {
+        return false;
+    }
+    // Check if the input is a number
+    const numberValue = Number(input);
+    if (!(0, lodash_1.isNaN)(numberValue)) {
+        return numberValue;
+    }
+    // If it's neither a boolean nor a number, return the string itself
+    return input;
+};
+exports.parseString = parseString;
+const isGoodJSON = (json) => {
+    return !(0, lodash_1.isNil)(json) && !(0, lodash_1.isError)((0, lodash_1.attempt)(JSON.parse, json));
+};
+exports.isGoodJSON = isGoodJSON;
+const wait = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+exports.wait = wait;
+const getObjsDifference = (obj1, obj2, path = "") => {
+    let diffs = [];
+    const allKeys = new Set([
+        ...Object.keys(obj1),
+        ...Object.keys(obj2)
+    ]);
+    for (let key of allKeys) {
+        const fullPath = path ? `${path}.${key}` : key;
+        const val1 = obj1[key];
+        const val2 = obj2[key];
+        if (!(key in obj1)) {
+            diffs.push({ type: "added", key: fullPath, value: val2 });
+        }
+        else if (!(key in obj2)) {
+            diffs.push({ type: "removed", key: fullPath, value: val1 });
+        }
+        else if (typeof val1 === "object" &&
+            typeof val2 === "object" &&
+            val1 &&
+            val2) {
+            diffs.push(...(0, exports.getObjsDifference)(val1, val2, fullPath));
+        }
+        else if (val1 !== val2) {
+            diffs.push({
+                type: "changed",
+                key: fullPath,
+                from: val1,
+                to: val2
+            });
+        }
+    }
+    return diffs;
+};
+exports.getObjsDifference = getObjsDifference;
+const toTitle = (str) => {
+    const minorWords = new Set([
+        "a",
+        "an",
+        "and",
+        "as",
+        "at",
+        "but",
+        "by",
+        "for",
+        "in",
+        "nor",
+        "of",
+        "on",
+        "or",
+        "so",
+        "the",
+        "to",
+        "up",
+        "yet"
+    ]);
+    // Split string into words
+    const wordList = (0, lodash_1.words)((0, lodash_1.toLower)(str), /[A-Za-z0-9]+/g);
+    // Capitalize words, except minor words (unless first or last)
+    const result = wordList.map((word, index) => {
+        if (index === 0 ||
+            index === lodash_1.words.length - 1 ||
+            !minorWords.has(word)) {
+            return (0, lodash_1.capitalize)(word);
+        }
+        else {
+            return word.toLowerCase();
+        }
+    });
+    return result.join(" ");
+};
+exports.toTitle = toTitle;
+//# sourceMappingURL=core.js.map