ia-common 1.0.1-beta.2 → 1.0.1-beta.200

package/build/red-black-tree/red-black-tree.d.ts

@@ -0,0 +1,11 @@
+export declare class RedBlackTree<T, V> {
+    js_col: RedBlackTree<T, V>;
+    constructor(compare: any);
+    insert<T, V>(key: T, value: V): T;
+    remove(key: string): V;
+    getMin(): V;
+    isEmpty(): boolean;
+    getValues(): V[];
+    static getMinTree<T, V>(): RedBlackTree<T, V>;
+    static getMaxTree<T, V>(): RedBlackTree<T, V>;
+}

package/build/red-black-tree/red-black-tree.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedBlackTree = void 0;
+var _utils_1 = require("../@utils");
+var js_cols = require("./js-cols");
+var RedBlackTree = /** @class */ (function () {
+    function RedBlackTree(compare) {
+        this.js_col = new js_cols.RedBlackMap(compare);
+    }
+    RedBlackTree.prototype.insert = function (key, value) {
+        this.js_col.insert(key, value);
+        return key;
+    };
+    RedBlackTree.prototype.remove = function (key) {
+        return this.js_col.remove(key);
+    };
+    RedBlackTree.prototype.getMin = function () {
+        return this.js_col.getMin();
+    };
+    RedBlackTree.prototype.isEmpty = function () {
+        return this.js_col.isEmpty();
+    };
+    RedBlackTree.prototype.getValues = function () {
+        return this.js_col.getValues();
+    };
+    RedBlackTree.getMinTree = function () {
+        var compare = function (a, b) {
+            var _a = a.split("#"), aInteger = _a[0], aDecimal = _a[1];
+            var _b = b.split("#"), bInteger = _b[0], bDecimal = _b[1];
+            var aFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(aInteger)), "#").concat(Number(aDecimal));
+            var bFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(bInteger)), "#").concat(Number(bDecimal));
+            if (aFormatted < bFormatted)
+                return -1;
+            if (aFormatted > bFormatted)
+                return 1;
+            return 0;
+        };
+        return new RedBlackTree(compare);
+    };
+    RedBlackTree.getMaxTree = function () {
+        var compare = function (a, b) {
+            var _a = a.split("#"), aInteger = _a[0], aDecimal = _a[1];
+            var _b = b.split("#"), bInteger = _b[0], bDecimal = _b[1];
+            var aFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(aInteger)), "#").concat(Number(aDecimal));
+            var bFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(bInteger)), "#").concat(Number(bDecimal));
+            if (aFormatted < bFormatted)
+                return 1;
+            if (aFormatted > bFormatted)
+                return -1;
+            return 0;
+        };
+        return new RedBlackTree(compare);
+    };
+    return RedBlackTree;
+}());
+exports.RedBlackTree = RedBlackTree;

package/build/utils/date-util.d.ts

@@ -0,0 +1,21 @@
+import { INgbDateStruct } from "../@type";
+export declare class DateUtil {
+    static isValidDate(dateCode: string): boolean;
+    getDateCode(date: Date): string;
+    getTodayCode(): string;
+    convertStringToDate(dateString: string, format?: string): Date;
+    addNDaysToDate(date: Date, n: number): Date;
+    addNDaysToDateCode(dateCode: string, n: number): string;
+    convertMonthsToNumber: (months: INgbDateStruct) => string;
+    convertNumberToNgbDateStruct: (numericDate: string) => INgbDateStruct | null;
+    formatDateCode(dateCode: string, formatter?: string): string;
+    addYearsToDateCode(dateCode: string, noOfYear: number): string;
+    getDateTimeCode(date: Date): string;
+    formatCreatedOrUpdateOn(data: string): string;
+    convertToNgbDate(input: string): {
+        year: number;
+        month: number;
+        day: number;
+    };
+}
+export declare const dateUtil: DateUtil;

package/build/utils/date-util.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateUtil = exports.DateUtil = void 0;
+var date_fns_1 = require("date-fns");
+var DateUtil = /** @class */ (function () {
+    function DateUtil() {
+        this.convertMonthsToNumber = function (months) {
+            var year = months.year.toString().slice(2, 4);
+            var month = months.month.toString().padStart(2, "0");
+            var day = months.day.toString().padStart(2, "0");
+            var dates = year.concat(month).concat(day);
+            return "".concat(dates);
+        };
+        this.convertNumberToNgbDateStruct = function (numericDate) {
+            if (typeof numericDate === "string" && numericDate.length === 6) {
+                var year = parseInt(numericDate.slice(0, 2), 10);
+                var month = parseInt(numericDate.slice(2, 4), 10);
+                var day = parseInt(numericDate.slice(4, 6), 10);
+                if (!isNaN(year) && !isNaN(month) && !isNaN(day)) {
+                    return { year: 2000 + year, month: month, day: day };
+                }
+            }
+            return null;
+        };
+    }
+    DateUtil.isValidDate = function (dateCode) {
+        if (dateCode.length !== 6)
+            return false;
+        // Date format: YYMMDD
+        function isDate(dateString) {
+            var separators = ["\\.", "\\-", "\\/"];
+            var stringBits = dateString.split(new RegExp(separators.join("|"), "g"));
+            var intBits = stringBits.map(function (bit) { return parseInt(bit); });
+            var parsedDate = new Date(intBits[0], intBits[1] - 1, intBits[2]);
+            return (parsedDate.getFullYear() === intBits[0] &&
+                parsedDate.getMonth() + 1 === intBits[1] &&
+                parsedDate.getDate() === intBits[2]);
+        }
+        return isDate("20".concat(dateCode.slice(0, 2), ".").concat(dateCode.slice(2, 4), ".").concat(dateCode.slice(4, 6)));
+    };
+    DateUtil.prototype.getDateCode = function (date) {
+        return (0, date_fns_1.format)(date, "yyMMdd");
+    };
+    DateUtil.prototype.getTodayCode = function () {
+        return (0, date_fns_1.format)(new Date(), "yyMMdd");
+    };
+    DateUtil.prototype.convertStringToDate = function (dateString, format) {
+        if (format === void 0) { format = "yyMMdd"; }
+        var parsedDate = (0, date_fns_1.parse)(dateString, format, new Date());
+        // IST has a fixed offset of UTC+5:30
+        var indianDate = new Date(parsedDate.getTime() + 330 * 60 * 1000);
+        return indianDate;
+    };
+    DateUtil.prototype.addNDaysToDate = function (date, n) {
+        return (0, date_fns_1.add)(date, { days: n });
+    };
+    DateUtil.prototype.addNDaysToDateCode = function (dateCode, n) {
+        return this.getDateCode(this.addNDaysToDate(this.convertStringToDate(dateCode, "yyMMdd"), n));
+    };
+    DateUtil.prototype.formatDateCode = function (dateCode, formatter) {
+        if (formatter === void 0) { formatter = "dd-MMM (EE)"; }
+        var date = (0, date_fns_1.parse)(dateCode, "yyMMdd", new Date());
+        var d = (0, date_fns_1.format)(date, formatter);
+        return d.slice(0, d.length - 2) + d.slice(d.length - 1);
+    };
+    DateUtil.prototype.addYearsToDateCode = function (dateCode, noOfYear) {
+        var date = this.convertStringToDate(dateCode);
+        var nextYear = new Date(date);
+        nextYear.setFullYear(date.getFullYear() + 1);
+        return this.getDateCode(nextYear);
+    };
+    DateUtil.prototype.getDateTimeCode = function (date) {
+        return (0, date_fns_1.format)(date, "yyMMddHHmm");
+    };
+    DateUtil.prototype.formatCreatedOrUpdateOn = function (data) {
+        var datePart = data.slice(8, 10);
+        var monthPart = data.slice(5, 7);
+        var yearPart = data.slice(2, 4);
+        return "".concat(yearPart).concat(monthPart).concat(datePart);
+    };
+    DateUtil.prototype.convertToNgbDate = function (input) {
+        var year = 2000 + parseInt(input.substring(0, 2), 10);
+        var month = parseInt(input.substring(2, 4), 10);
+        var day = parseInt(input.substring(4, 6), 10);
+        return { year: year, month: month, day: day };
+    };
+    return DateUtil;
+}());
+exports.DateUtil = DateUtil;
+exports.dateUtil = new DateUtil();

package/build/utils/string-to-date-conversion-methods.d.ts

@@ -0,0 +1,19 @@
+import { IModifyEntity, Modify } from "../@type";
+import { IKeyValue } from "../interface/key-value.interface";
+export declare function ConvertCommonEntries<T extends {
+    createdOn: Date;
+    updatedOn: Date;
+}>(inputObject: {
+    [key: string]: T;
+}): IKeyValue<IModifyEntity<T>>;
+export declare function ConvertToCommonEntities<T extends {
+    createdOn: Date;
+    updatedOn: Date;
+}>(inputObject: T[]): IModifyEntity<T>[];
+export declare function ConvertToCommonEntity<T extends {
+    createdOn: Date;
+    updatedOn: Date;
+}, R extends Modify<T, {
+    createdOn: string;
+    updatedOn: string;
+}>>(obj: T): R;

package/build/utils/string-to-date-conversion-methods.js

@@ -0,0 +1,48 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertToCommonEntity = exports.ConvertToCommonEntities = exports.ConvertCommonEntries = void 0;
+//key - value converter
+function ConvertCommonEntries(inputObject) {
+    return Object.entries(inputObject).reduce(function (acc, _a) {
+        var key = _a[0], value = _a[1];
+        acc[key] = ConvertToCommonEntity(value);
+        return acc;
+    }, {});
+}
+exports.ConvertCommonEntries = ConvertCommonEntries;
+function ConvertToCommonEntities(inputObject) {
+    return inputObject.reduce(function (acc, value) {
+        var modifiedEntity = ConvertToCommonEntity(value);
+        acc.push(modifiedEntity);
+        return acc;
+    }, []);
+}
+exports.ConvertToCommonEntities = ConvertToCommonEntities;
+function ConvertToCommonEntity(obj) {
+    var _a, _b;
+    var _ = obj.createdOn, __ = obj.updatedOn, objectToAssign = __rest(obj, ["createdOn", "updatedOn"]);
+    return __assign({ createdOn: (_a = obj.createdOn) === null || _a === void 0 ? void 0 : _a.toISOString(), updatedOn: (_b = obj.updatedOn) === null || _b === void 0 ? void 0 : _b.toISOString() }, objectToAssign);
+}
+exports.ConvertToCommonEntity = ConvertToCommonEntity;

package/build/utils/string-utils.d.ts

@@ -1,4 +1,10 @@
 export declare class StringUtil {
     generateRandomPassword(): string;
+    static convertToIdObjectResponse<T extends {
+        id: number;
+    }>(entities: T[]): {
+        [id: number]: T;
+    };
+    static PadStartToIntegerPart(number: number, length?: number): string;
 }
 export declare const stringUtil: StringUtil;

package/build/utils/string-utils.js

@@ -35,6 +35,24 @@ var StringUtil = /** @class */ (function () {
         }
         return passwordArray.join("");
     };
+    StringUtil.convertToIdObjectResponse = function (entities) {
+        var response = {};
+        entities.forEach(function (entity) {
+            if (!response[entity.id])
+                response[entity.id] = entity;
+        });
+        return response;
+    };
+    StringUtil.PadStartToIntegerPart = function (number, length) {
+        if (length === void 0) { length = 7; }
+        var numString = number.toString();
+        var _a = numString.split("."), integerPart = _a[0], decimalPart = _a[1];
+        var paddedIntegerPart = integerPart.padStart(length, "0");
+        var formattedNum = decimalPart
+            ? "".concat(paddedIntegerPart, ".").concat(decimalPart)
+            : paddedIntegerPart;
+        return formattedNum;
+    };
     return StringUtil;
 }());
 exports.StringUtil = StringUtil;

package/build/utils/validate-utils.d.ts

@@ -0,0 +1,4 @@
+import { CorporateActionsType } from "../@enum";
+export declare class ValidateUtils {
+    static validateCorporateActionType(corporateActionType: CorporateActionsType, expectedType: CorporateActionsType): void;
+}

package/build/utils/validate-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateUtils = void 0;
+var _model_1 = require("../@model");
+var ValidateUtils = /** @class */ (function () {
+    function ValidateUtils() {
+    }
+    ValidateUtils.validateCorporateActionType = function (corporateActionType, expectedType) {
+        if (corporateActionType !== expectedType) {
+            throw new _model_1.AppBadRequestException({
+                key: expectedType,
+                message: [
+                    "Corporate action entity with type does not belongs to ".concat(expectedType),
+                ],
+            });
+        }
+    };
+    return ValidateUtils;
+}());
+exports.ValidateUtils = ValidateUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ia-common",
-  "version": "1.0.1-beta.2",
+  "version": "1.0.1-beta.200",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -30,5 +30,8 @@
     "del-cli": "^5.1.0",
     "eslint": "^8.56.0",
     "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "date-fns": "^3.3.1"
   }
 }