sea-platform-helpers-lib 1.5.37

package/dist/utils/currency/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/currency/index.ts"],"names":[],"mappings":"AAUA,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAE5B;AAED,wBAAgB,gBAAgB,iEAE/B"}

package/dist/utils/currency/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrencies = getCurrencies;
+exports.getExchangeRates = getExchangeRates;
+const currencyx_js_1 = require("@mixxtor/currencyx-js");
+const currency_1 = require("../../constants/currency");
+const currency = (0, currencyx_js_1.createCurrency)({
+    default: "google",
+    exchanges: {
+        google: currencyx_js_1.exchanges.google({ base: currency_1.DEFAULT_CURRENCY_CODE }),
+    },
+});
+function getCurrencies() {
+    return currency.getList();
+}
+function getExchangeRates() {
+    return currency.getExchangeRates();
+}

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

@@ -0,0 +1,4 @@
+export declare const findItem: <T, K extends keyof T>(node: T, predicate: (node: T) => boolean, childrenKey: K) => T | undefined;
+export declare const flattenTree: <T, K extends keyof T>(node: T, childrenKey: K) => T[];
+export declare const getAllLeafNodes: <T, K extends keyof T>(node: T, childrenKey: K) => T[];
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/dfs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/dfs/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAC3C,MAAM,CAAC,EACP,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,aAAa,CAAC,KACb,CAAC,GAAG,SAwBN,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAC9C,MAAM,CAAC,EACP,aAAa,CAAC,KACb,CAAC,EAeH,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAClD,MAAM,CAAC,EACP,aAAa,CAAC,KACb,CAAC,EAeH,CAAC"}

package/dist/utils/dfs/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllLeafNodes = exports.flattenTree = exports.findItem = void 0;
+const findItem = (node, predicate, childrenKey) => {
+    // If the current node matches the predicate, return it
+    if (predicate(node)) {
+        return node;
+    }
+    // Retrieve children from the given key, ensuring it's not null or undefined
+    const children = node[childrenKey];
+    // If no children or children is null/undefined, return null
+    if (!children) {
+        return undefined;
+    }
+    // Otherwise, search through the children recursively
+    for (let child of children) {
+        const result = (0, exports.findItem)(child, predicate, childrenKey);
+        if (result) {
+            return result;
+        }
+    }
+    // Return undefined if the element is not found
+    return undefined;
+};
+exports.findItem = findItem;
+const flattenTree = (node, childrenKey) => {
+    // Start with the current node
+    const result = [node];
+    // Retrieve children from the given key, ensuring it's not null or undefined
+    const children = node[childrenKey];
+    // If children exist, recursively process them and add to the result
+    if (children) {
+        for (let child of children) {
+            result.push(...(0, exports.flattenTree)(child, childrenKey)); // Flatten the results
+        }
+    }
+    return result;
+};
+exports.flattenTree = flattenTree;
+const getAllLeafNodes = (node, childrenKey) => {
+    const children = node[childrenKey];
+    // If the node has no children or the children array is empty, it's a leaf
+    if (!children || children.length === 0) {
+        return [node];
+    }
+    // Otherwise, recursively get leaf nodes from all children
+    const leafNodes = [];
+    for (let child of children) {
+        leafNodes.push(...(0, exports.getAllLeafNodes)(child, childrenKey));
+    }
+    return leafNodes;
+};
+exports.getAllLeafNodes = getAllLeafNodes;

package/dist/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * as PhoneNumber from "./phone-number";
+export * as String from "./string";
+export * as Moment from "./moment";
+export * as DFS from "./dfs";
+export * as Array from "./array";
+export * as Number from "./numbers";
+export * as Tree from "./tree";
+export * as Language from "./language";
+export * as Notification from "./notification";
+export * as Currency from "./currency";
+export * as QrCode from "./qrcode";
+export * as Permission from "./permission";
+export * as JWT from "./jwt";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,50 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JWT = exports.Permission = exports.QrCode = exports.Currency = exports.Notification = exports.Language = exports.Tree = exports.Number = exports.Array = exports.DFS = exports.Moment = exports.String = exports.PhoneNumber = void 0;
+// export * as Bcrypt from "./bcrypt";
+exports.PhoneNumber = __importStar(require("./phone-number"));
+exports.String = __importStar(require("./string"));
+exports.Moment = __importStar(require("./moment"));
+exports.DFS = __importStar(require("./dfs"));
+exports.Array = __importStar(require("./array"));
+exports.Number = __importStar(require("./numbers"));
+exports.Tree = __importStar(require("./tree"));
+exports.Language = __importStar(require("./language"));
+exports.Notification = __importStar(require("./notification"));
+exports.Currency = __importStar(require("./currency"));
+exports.QrCode = __importStar(require("./qrcode"));
+exports.Permission = __importStar(require("./permission"));
+exports.JWT = __importStar(require("./jwt"));

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

@@ -0,0 +1,3 @@
+import { Environments } from "../../constants/server";
+export declare const generateJWTKey: (env: Environments | string) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/jwt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/jwt/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,eAAO,MAAM,cAAc,GAAI,KAAK,YAAY,GAAG,MAAM,WAExD,CAAC"}

package/dist/utils/jwt/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJWTKey = void 0;
+const jwt_1 = require("../../constants/jwt");
+const generateJWTKey = (env) => {
+    return `${env}-${jwt_1.JWTCookieKey}`;
+};
+exports.generateJWTKey = generateJWTKey;

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

@@ -0,0 +1,6 @@
+import * as langs from "langs";
+export declare const getLanguageCodes: () => string[];
+export declare const getLanguages: () => langs.Language[];
+export declare const getLanguageNameFromCode: (code: string) => string;
+export declare function isRtl(langCode: string): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/language/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/language/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,eAAO,MAAM,gBAAgB,gBAAyB,CAAC;AAEvD,eAAO,MAAM,YAAY,wBAAoB,CAAC;AAE9C,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,WACgB,CAAC;AAIrE,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE/C"}

package/dist/utils/language/index.js

@@ -0,0 +1,48 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLanguageNameFromCode = exports.getLanguages = exports.getLanguageCodes = void 0;
+exports.isRtl = isRtl;
+const langs = __importStar(require("langs"));
+const getLanguageCodes = () => langs.codes("1");
+exports.getLanguageCodes = getLanguageCodes;
+const getLanguages = () => langs.all();
+exports.getLanguages = getLanguages;
+const getLanguageNameFromCode = (code) => { var _a; return ((_a = langs.all().find((l) => l[1] === code)) === null || _a === void 0 ? void 0 : _a.name) || "Unknown Language"; };
+exports.getLanguageNameFromCode = getLanguageNameFromCode;
+const RTL_LANGS = ["ar", "fa", "he", "ur", "ps", "dv", "ku", "sd", "yi"];
+function isRtl(langCode) {
+    return RTL_LANGS.includes(langCode.toLowerCase());
+}

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

@@ -0,0 +1,30 @@
+import moment from "moment";
+import * as momentTZ from "moment-timezone";
+export { momentTZ, moment };
+export type Unit = "years" | "months" | "days" | "hours" | "minutes" | "seconds";
+export declare const loadMomentLocale: (lang: string) => Promise<void>;
+export declare const normalize: (d?: Date | string | null) => Date | undefined;
+export declare const normalizeTime: (timeString?: string) => Date | undefined;
+export declare const formatDate: (data: Date | string, format?: string, localTimeZone?: boolean) => string;
+export declare const toUtcClockFromUserTime: (timeHHmmss: string, userTZ?: string) => string;
+export declare const toUserTimeFromUtcClock: (timeHHmmss: string, userTZ?: string) => string;
+export declare const toUserTimeFromUtcClockAs12Hour: (timeHHmmss: string, userTZ?: string) => string;
+export declare const formatDateAsLabel: (date: string | Date) => string;
+export declare const getCurrentYear: () => string;
+export declare const getDaysCountBetweenTwoDays: (date1: string, date2: string) => number;
+export declare const getDaysCountTillNow: (pastDate: string) => number;
+export declare const getAge: (birthdate: string) => number;
+export declare const getStartOfDay: (date?: Date | string) => Date;
+export declare const getEndOfDay: (date?: Date | string) => Date;
+export declare const getNextPeriod: (date: string | Date, period: "day" | "week" | "month") => Date;
+export declare const getPreviousPeriod: (date: string | Date, period: "day" | "week" | "month") => Date;
+export default moment;
+export declare const isDateInQuarterAndYear: (date: Date, quarter: number, year: number) => boolean;
+export declare const getEndOfQuarter: (year: number, quarter: number) => Date;
+export declare const changeTimezone: (date: Date | string, timezone: string) => moment.Moment;
+export declare function isDateBefore(date1: Date | string | null | undefined, date2: Date | string | null | undefined, includeSame?: boolean): boolean;
+export declare function isDateAfter(date1: Date | string | null | undefined, date2: Date | string | null | undefined, includeSame?: boolean): boolean;
+export declare const generateDateRange: (startDate: string | Date, endDate: string | Date, unit: Unit) => string[];
+export declare const toBackendDateKey: (d: Date | string | moment.Moment) => string;
+export declare const generateYearsBetween: (start: Date | string, end: Date | string) => number[];
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/moment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/moment/index.ts"],"names":[],"mappings":"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"}

package/dist/utils/moment/index.js

@@ -0,0 +1,224 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateYearsBetween = exports.toBackendDateKey = exports.generateDateRange = exports.changeTimezone = exports.getEndOfQuarter = exports.isDateInQuarterAndYear = exports.getPreviousPeriod = exports.getNextPeriod = exports.getEndOfDay = exports.getStartOfDay = exports.getAge = exports.getDaysCountTillNow = exports.getDaysCountBetweenTwoDays = exports.getCurrentYear = exports.formatDateAsLabel = exports.toUserTimeFromUtcClockAs12Hour = exports.toUserTimeFromUtcClock = exports.toUtcClockFromUserTime = exports.formatDate = exports.normalizeTime = exports.normalize = exports.loadMomentLocale = exports.moment = exports.momentTZ = void 0;
+exports.isDateBefore = isDateBefore;
+exports.isDateAfter = isDateAfter;
+const moment_1 = __importDefault(require("moment"));
+exports.moment = moment_1.default;
+const momentTZ = __importStar(require("moment-timezone"));
+exports.momentTZ = momentTZ;
+const loadMomentLocale = (lang) => __awaiter(void 0, void 0, void 0, function* () {
+    if (lang == "ar") {
+        yield require("moment/locale/ar");
+        moment_1.default.locale("en");
+        // moment.locale("ar");
+    }
+    else {
+        moment_1.default.locale("en");
+    }
+});
+exports.loadMomentLocale = loadMomentLocale;
+const normalize = (d) => {
+    if (!d)
+        return undefined;
+    const date = new Date(d);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+};
+exports.normalize = normalize;
+const normalizeTime = (timeString) => {
+    return timeString ? new Date(`1970-01-01T${timeString}Z`) : undefined;
+};
+exports.normalizeTime = normalizeTime;
+const formatDate = (data, format = "YYYY-MM-DD", localTimeZone = false) => {
+    let momentDate = (0, moment_1.default)(data);
+    if (localTimeZone) {
+        const userTZ = moment_1.default.tz.guess();
+        momentDate = moment_1.default.utc(data).tz(userTZ);
+        // momentDate = moment.tz(momentDate.toString(), userTZ);
+    }
+    return momentDate.format(format).toString();
+};
+exports.formatDate = formatDate;
+const toUtcClockFromUserTime = (timeHHmmss, userTZ = moment_1.default.tz.guess()) => momentTZ.tz(`1970-01-01 ${timeHHmmss}`, userTZ).utc().format("HH:mm:ss");
+exports.toUtcClockFromUserTime = toUtcClockFromUserTime;
+const toUserTimeFromUtcClock = (timeHHmmss, userTZ = moment_1.default.tz.guess()) => momentTZ.utc(`1970-01-01 ${timeHHmmss}`).tz(userTZ).format("HH:mm:ss");
+exports.toUserTimeFromUtcClock = toUserTimeFromUtcClock;
+const toUserTimeFromUtcClockAs12Hour = (timeHHmmss, userTZ = moment_1.default.tz.guess()) => momentTZ.utc(`1970-01-01 ${timeHHmmss}`).tz(userTZ).format("hh:mm A");
+exports.toUserTimeFromUtcClockAs12Hour = toUserTimeFromUtcClockAs12Hour;
+const formatDateAsLabel = (date) => {
+    const now = (0, moment_1.default)();
+    const inputDate = (0, moment_1.default)(date);
+    const diffInMinutes = now.diff(inputDate, "minutes");
+    const diffInHours = now.diff(inputDate, "hours");
+    if (diffInMinutes < 1) {
+        return "just now";
+    }
+    else if (diffInMinutes < 60) {
+        return `${diffInMinutes} min ago`;
+    }
+    else if (diffInHours < 24) {
+        return `${diffInHours} hour${diffInHours > 1 ? "s" : ""} ago`;
+    }
+    else {
+        return inputDate.tz(moment_1.default.tz.guess()).format("DD MMM YYYY hh:mm a");
+    }
+};
+exports.formatDateAsLabel = formatDateAsLabel;
+const getCurrentYear = () => (0, moment_1.default)().format("YYYY").toString();
+exports.getCurrentYear = getCurrentYear;
+const getDaysCountBetweenTwoDays = (date1, date2) => (0, moment_1.default)(date2).diff((0, moment_1.default)(date1), "days");
+exports.getDaysCountBetweenTwoDays = getDaysCountBetweenTwoDays;
+const getDaysCountTillNow = (pastDate) => (0, exports.getDaysCountBetweenTwoDays)(moment_1.default.utc().format("YYYY-MM-DD"), pastDate);
+exports.getDaysCountTillNow = getDaysCountTillNow;
+const getAge = (birthdate) => (0, moment_1.default)().diff((0, moment_1.default)(birthdate), "years");
+exports.getAge = getAge;
+const getStartOfDay = (date) => {
+    return (0, moment_1.default)(date).startOf("day").toDate();
+};
+exports.getStartOfDay = getStartOfDay;
+const getEndOfDay = (date) => {
+    return (0, moment_1.default)(date).endOf("day").toDate();
+};
+exports.getEndOfDay = getEndOfDay;
+const getNextPeriod = (date, period) => (0, moment_1.default)(date).add(1, period).toDate();
+exports.getNextPeriod = getNextPeriod;
+const getPreviousPeriod = (date, period) => (0, moment_1.default)(date).subtract(1, period).toDate();
+exports.getPreviousPeriod = getPreviousPeriod;
+exports.default = moment_1.default;
+const isDateInQuarterAndYear = (date, quarter, year) => {
+    if (!date)
+        return false;
+    const d = new Date(date);
+    const q = Math.floor(d.getMonth() / 3) + 1;
+    return d.getFullYear() === year && q === quarter;
+};
+exports.isDateInQuarterAndYear = isDateInQuarterAndYear;
+const getEndOfQuarter = (year, quarter) => {
+    const endMonth = quarter * 3 - 1; // Q1: Feb, Q2: May, Q3: Aug, Q4: Nov
+    const date = new Date(year, endMonth + 1, 0); // Last day of that month
+    date.setHours(23, 59, 59, 999); // End of day
+    return date;
+};
+exports.getEndOfQuarter = getEndOfQuarter;
+const changeTimezone = (date, timezone) => momentTZ.utc(date).tz(timezone);
+exports.changeTimezone = changeTimezone;
+function isDateBefore(date1, date2, includeSame = true) {
+    if (!date1 || !date2)
+        return true; // or return true if you want nulls treated as before
+    const m1 = (0, moment_1.default)(date1);
+    const m2 = (0, moment_1.default)(date2);
+    if (!m1.isValid() || !m2.isValid())
+        return false;
+    return includeSame ? m1.isSameOrBefore(m2) : m1.isBefore(m2);
+}
+function isDateAfter(date1, date2, includeSame = true) {
+    if (!date1 || !date2)
+        return true;
+    const m1 = (0, moment_1.default)(date1);
+    const m2 = (0, moment_1.default)(date2);
+    if (!m1.isValid() || !m2.isValid())
+        return false;
+    return includeSame ? m1.isSameOrAfter(m2) : m1.isAfter(m2);
+}
+const generateDateRange = (startDate, endDate, unit) => {
+    const start = (0, moment_1.default)(startDate);
+    const end = (0, moment_1.default)(endDate);
+    const result = [];
+    let format = "";
+    switch (unit) {
+        case "years": {
+            format = "YYYY";
+            break;
+        }
+        case "months": {
+            format = "YYYY-MM";
+            break;
+        }
+        case "days": {
+            format = "YYYY-MM-DD";
+            break;
+        }
+        case "hours": {
+            format = "YYYY-MM-DD HH";
+            break;
+        }
+        case "minutes": {
+            format = "YYYY-MM-DD HH:mm";
+            break;
+        }
+        case "seconds": {
+            format = "YYYY-MM-DD HH:mm:ss";
+            break;
+        }
+        default:
+            break;
+    }
+    let current = start.clone();
+    while (current.isSameOrBefore(end, unit)) {
+        result.push(current.format(format));
+        current.add(1, unit);
+    }
+    return result;
+};
+exports.generateDateRange = generateDateRange;
+const toBackendDateKey = (d) => {
+    return (0, moment_1.default)(d).startOf("day").format("YYYY-MM-DD");
+};
+exports.toBackendDateKey = toBackendDateKey;
+const generateYearsBetween = (start, end) => {
+    const startMoment = (0, moment_1.default)(start);
+    const endMoment = (0, moment_1.default)(end);
+    const startYear = Math.min(startMoment.year(), endMoment.year());
+    const endYear = Math.max(startMoment.year(), endMoment.year());
+    const years = [];
+    for (let year = startYear; year <= endYear; year++) {
+        years.push(year);
+    }
+    return years;
+};
+exports.generateYearsBetween = generateYearsBetween;

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

@@ -0,0 +1,8 @@
+import { DTO } from "../..";
+type NotificationData = {
+    title: string;
+    description: string;
+};
+export declare const generateNotificationData: (notification: DTO.Notification.INotification) => NotificationData;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/notification/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/notification/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,GAAG,EAAE,MAAM,OAAO,CAAC;AAEvC,KAAK,gBAAgB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,eAAO,MAAM,wBAAwB,GACnC,cAAc,GAAG,CAAC,YAAY,CAAC,aAAa,KAC3C,gBAsCF,CAAC"}

package/dist/utils/notification/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNotificationData = void 0;
+const __1 = require("../..");
+const generateNotificationData = (notification) => {
+    var _a, _b, _c, _d, _e;
+    const data = {
+        title: "Unknown Notification",
+        description: "Unknown Notification...",
+    };
+    switch (notification.type) {
+        case __1.CONSTANTS.AccountAlertSetting.AlertActions.TaskAssignedToYou: {
+            const task = ((_a = notification.objects) !== null && _a !== void 0 ? _a : {}).task;
+            data.title = "New task assigned to you";
+            data.description = `${task === null || task === void 0 ? void 0 : task.title} assigned to you,check it!`;
+            break;
+        }
+        case __1.CONSTANTS.AccountAlertSetting.AlertActions.TaskUnassignedFromYou: {
+            const task = ((_b = notification.objects) !== null && _b !== void 0 ? _b : {}).task;
+            data.title = "Task unassigned from you";
+            data.description = ` Task ${task === null || task === void 0 ? void 0 : task.title} unassigned from you, check it!`;
+            break;
+        }
+        case __1.CONSTANTS.AccountAlertSetting.AlertActions.NewCommentAdded: {
+            const addedBy = ((_c = notification.objects) !== null && _c !== void 0 ? _c : {})
+                .addedBy;
+            const objectName = ((_d = notification.objects) !== null && _d !== void 0 ? _d : {}).objectName;
+            const model = ((_e = notification.objects) !== null && _e !== void 0 ? _e : {}).model;
+            data.title = `New comment`;
+            data.description = `A new comment by ${addedBy === null || addedBy === void 0 ? void 0 : addedBy.name}on ${objectName} ${model}`;
+            break;
+        }
+        default:
+            break;
+    }
+    return data;
+};
+exports.generateNotificationData = generateNotificationData;

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

@@ -0,0 +1,4 @@
+export declare const numeralUtils: typeof import("numeral");
+export declare const getRandomInt: (min: number, max: number) => number;
+export declare const calculateRange: (arr: number[]) => number;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/numbers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/numbers/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,0BAAkB,CAAC;AAE5C,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAIvD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,EAAE,WAa3C,CAAC"}

package/dist/utils/numbers/index.js

@@ -0,0 +1,59 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRange = exports.getRandomInt = exports.numeralUtils = void 0;
+const numeral = __importStar(require("numeral"));
+exports.numeralUtils = numeral.default;
+const getRandomInt = (min, max) => {
+    const lower = Math.ceil(min);
+    const upper = Math.floor(max);
+    return Math.floor(Math.random() * (upper - lower + 1)) + lower;
+};
+exports.getRandomInt = getRandomInt;
+const calculateRange = (arr) => {
+    if (arr.length === 0)
+        return 0;
+    let min = arr[0];
+    let max = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+        const num = arr[i];
+        if (num < min)
+            min = num;
+        else if (num > max)
+            max = num;
+    }
+    return max - min;
+};
+exports.calculateRange = calculateRange;

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

@@ -0,0 +1,3 @@
+import { PermissionKeys } from "../../constants/permission";
+export declare function hasPermission(accountPermissionKeys: PermissionKeys[] | undefined, requiredPermission: PermissionKeys[], strategy?: "all" | "some" | "one"): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/permission/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/permission/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,wBAAgB,aAAa,CAC3B,qBAAqB,EAAE,cAAc,EAAE,GAAG,SAAS,EACnD,kBAAkB,EAAE,cAAc,EAAE,EACpC,QAAQ,GAAE,KAAK,GAAG,MAAM,GAAG,KAAa,GACvC,OAAO,CAcT"}

package/dist/utils/permission/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPermission = hasPermission;
+function hasPermission(accountPermissionKeys, requiredPermission, strategy = "all") {
+    if (!accountPermissionKeys || accountPermissionKeys.length === 0)
+        return false;
+    if (requiredPermission.length === 0)
+        return strategy === "all";
+    const permissionSet = new Set(accountPermissionKeys);
+    switch (strategy) {
+        case "all":
+            return requiredPermission.every((key) => permissionSet.has(key));
+        case "some":
+        case "one":
+            return requiredPermission.some((key) => permissionSet.has(key));
+        default:
+            return false;
+    }
+}