meemup-library 1.0.39 → 1.0.41

package/dist/controllers/ApiController.d.ts

@@ -0,0 +1,19 @@
+import { AxiosError, AxiosInstance, AxiosResponse } from "axios";
+import IAccount from "../interfaces/IAccount";
+import IAnswer from "../interfaces/IAnswer";
+export default class ApiController {
+    account: IAccount;
+    constructor(account: IAccount);
+    defaultHeader(authorization?: boolean): Promise<{
+        Authorization?: string | undefined;
+        companyId: string;
+    }>;
+    createInstance(header?: object, authorization?: boolean, timeout?: number): Promise<AxiosInstance>;
+    fetchSuccess(response: AxiosResponse, init?: any): IAnswer;
+    fetchError(error: AxiosError, initMessage?: null): IAnswer;
+    postWithAuth(url: string, body?: any, header?: any): Promise<IAnswer>;
+    putWithAuth(url: string, body: any, header?: any): Promise<IAnswer>;
+    getWithAuth(url: string, header?: any): Promise<IAnswer>;
+    get(url: string, header?: any): Promise<IAnswer>;
+    deleteWithAuth(url: string, header?: any): Promise<IAnswer>;
+}

package/dist/controllers/ApiController.js

@@ -0,0 +1,92 @@
+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());
+    });
+};
+import axios from "axios";
+export default class ApiController {
+    constructor(account) {
+        this.account = account;
+    }
+    defaultHeader(authorization = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign({ companyId: this.account.companyId + "" }, authorization ? { Authorization: "Bearer " + this.account.token } : {});
+        });
+    }
+    createInstance(header = {}, authorization = true, timeout = 15000) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let data = yield this.defaultHeader(authorization);
+            return axios.create({
+                withCredentials: true,
+                timeout: timeout,
+                headers: Object.assign(Object.assign({}, data), header)
+            });
+        });
+    }
+    fetchSuccess(response, init = {}) {
+        if (response.status === 200) {
+            if (response.data.success === true) {
+                return response.data;
+            }
+            if (response.data.message === "company not found") {
+                //TODO need fix
+                return response.data;
+            }
+        }
+        else if (response.status === 401) {
+            //TODO need fix
+            return response.data;
+            // window.location.replace(rootPath.signIn);
+        }
+        return Object.assign(Object.assign({}, response.data), { data: init });
+    }
+    fetchError(error, initMessage = null) {
+        // console.log("error : ", error);
+        const message = error.message === "Network Error" ? "Please check your internet connection!" : error.message;
+        return {
+            success: false,
+            data: null,
+            exception: initMessage ? initMessage : message,
+            message: initMessage ? initMessage : message
+        };
+    }
+    postWithAuth(url, body = {}, header = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log("POST");
+            const ax = yield this.createInstance(header, true);
+            return ax.post(url, body).then(this.fetchSuccess).catch(this.fetchError);
+        });
+    }
+    putWithAuth(url, body, header = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log("PUT");
+            const ax = yield this.createInstance(header, true, 8000);
+            return ax.put(url, body).then(this.fetchSuccess).catch(this.fetchError);
+        });
+    }
+    getWithAuth(url, header = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log("GET");
+            const ax = yield this.createInstance(header, true);
+            return ax.get(url).then(this.fetchSuccess).catch(this.fetchError);
+        });
+    }
+    get(url, header = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log("GET");
+            const ax = yield this.createInstance(header, false);
+            return ax.get(url).then(this.fetchSuccess).catch(this.fetchError);
+        });
+    }
+    deleteWithAuth(url, header = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log("DELETE");
+            const ax = yield this.createInstance(header, true);
+            return ax.delete(url).then(this.fetchSuccess).catch(this.fetchError);
+        });
+    }
+}

package/dist/controllers/CustomerFacingDisplayPacketController.d.ts

@@ -0,0 +1,9 @@
+import ILocalSetting from "../interfaces/ILocalSetting";
+import ISetting from "../interfaces/ISetting";
+import ICustomerFacingDisplayPacket from "../interfaces/cfds/ICustomerFacingDisplayPacket";
+import IOrder from "../interfaces/order/IOrder";
+declare const _default: {
+    code(order: IOrder, setting: ISetting, localSetting: ILocalSetting): ICustomerFacingDisplayPacket;
+    decode(data: string): ICustomerFacingDisplayPacket;
+};
+export default _default;

package/dist/controllers/CustomerFacingDisplayPacketController.js

@@ -0,0 +1,47 @@
+import { initCustomerFacingDisplayPacket } from "../interfaces/cfds/ICustomerFacingDisplayPacket";
+export default new class CustomerFacingDisplayPacketController {
+    code(order, setting, localSetting) {
+        let packet = Object.assign(Object.assign({}, initCustomerFacingDisplayPacket), { r: localSetting.udpClientName, c: setting.currencySymbol, d: [] });
+        order.products.forEach(product => {
+            let extPro = [];
+            product.extras.forEach(ext => {
+                extPro.push({
+                    q: ext.quantity,
+                    s: ext.pizzaSide,
+                    t: ext.text,
+                    p: ext.totalAmount
+                });
+            });
+            let pro = {
+                q: product.quantity,
+                t: product.title,
+                p: product.totalAmount,
+                e: extPro
+            };
+            packet.d.push(pro);
+        });
+        packet.dd = order.displayDiscount;
+        packet.re = order.remark;
+        packet.ot = order.orderType;
+        packet.dc = order.deliveryCost;
+        packet.ds = order.displaySubTotal;
+        packet.tt = setting.taxTitle;
+        packet.dt = order.displayTax;
+        packet.pt = order.paymentType;
+        packet.ps = order.paymentState;
+        packet.rcp = order.roundCashPayments;
+        packet.rca = order.displayRoundCashAmount;
+        packet.fees = order.displayFees;
+        packet.ta = order.displayTotalAmount;
+        return packet;
+    }
+    decode(data) {
+        let packet = Object.assign({}, initCustomerFacingDisplayPacket);
+        try {
+            return JSON.parse(data);
+        }
+        catch (e) {
+        }
+        return packet;
+    }
+}();

package/dist/controllers/DashboardController.d.ts

@@ -0,0 +1,20 @@
+import IOnlineOrderItem from "../interfaces/IOnlineOrderItem";
+import EnumDashboardSort from "../enums/EnumDashboardSort";
+import EnumShowOrderMode from "../enums/EnumShowOrderMode";
+import IOrder from "../interfaces/order/IOrder";
+declare const _default: {
+    showOrderModeText(mode: EnumShowOrderMode): string;
+    getSortTypeText(sort: EnumDashboardSort): string;
+    todayPosMoney(orders: IOrder[]): number;
+    todayOnlineMoney(orders: IOnlineOrderItem[]): number;
+    todayMoney(localOrders: IOrder[], onlineOrders: IOnlineOrderItem[], mode: EnumShowOrderMode): number;
+    todayOrderCount(localOrders: IOrder[], onlineOrders: IOnlineOrderItem[], mode: EnumShowOrderMode): number;
+    customer(order: IOnlineOrderItem): string;
+    customerForDashboardComponent(order: IOnlineOrderItem): string;
+    sortOrders(orders: IOnlineOrderItem[], mode: EnumDashboardSort): IOnlineOrderItem[];
+    distinctAllOrders(localOrders: IOrder[], onlineOrders: IOnlineOrderItem[]): IOnlineOrderItem[];
+    createOrderList(localOrders: IOrder[], onlineOrders: IOnlineOrderItem[], mode: EnumShowOrderMode, sort: EnumDashboardSort): IOnlineOrderItem[];
+    orderModelToOnlineOrderItem(order: IOrder): IOnlineOrderItem;
+    getViaIcon(data: IOnlineOrderItem): "store" | "web" | undefined;
+};
+export default _default;

package/dist/controllers/DashboardController.js

@@ -0,0 +1,150 @@
+import EnumDashboardSort from "../enums/EnumDashboardSort";
+import EnumShowOrderMode from "../enums/EnumShowOrderMode";
+export default new class DashboardController {
+    showOrderModeText(mode) {
+        switch (mode) {
+            case EnumShowOrderMode.onlyPos:
+                return "Pos orders";
+            case EnumShowOrderMode.onlyWebShop:
+                return "Web Shop orders";
+            case EnumShowOrderMode.all:
+                return "Show all orders";
+            default:
+                return "";
+        }
+    }
+    getSortTypeText(sort) {
+        switch (sort) {
+            case EnumDashboardSort.amount:
+                return "Sort by amount";
+            case EnumDashboardSort.date:
+                return "Sort by date";
+            case EnumDashboardSort.discount:
+                return "Sort by discount";
+            case EnumDashboardSort.tip:
+                return "Sort by tip";
+            default:
+                return "";
+        }
+    }
+    todayPosMoney(orders) {
+        if (orders.length > 0) {
+            return orders.map(i => i.displayTotalAmount).reduce((a, b) => a + b);
+        }
+        return 0;
+    }
+    todayOnlineMoney(orders) {
+        if (orders.length > 0) {
+            return orders.map(i => i.amount).reduce((a, b) => a + b);
+        }
+        return 0;
+    }
+    todayMoney(localOrders, onlineOrders, mode) {
+        switch (mode) {
+            case EnumShowOrderMode.all:
+                return this.todayOnlineMoney(this.distinctAllOrders(localOrders, onlineOrders));
+            case EnumShowOrderMode.onlyPos:
+                return this.todayPosMoney(localOrders);
+            case EnumShowOrderMode.onlyWebShop:
+                return this.todayOnlineMoney(onlineOrders);
+            default:
+                return 0;
+        }
+    }
+    todayOrderCount(localOrders, onlineOrders, mode) {
+        switch (mode) {
+            case EnumShowOrderMode.all:
+                return this.distinctAllOrders(localOrders, onlineOrders).length;
+            case EnumShowOrderMode.onlyPos:
+                return localOrders.length;
+            case EnumShowOrderMode.onlyWebShop:
+                return onlineOrders.length;
+            default:
+                return 0;
+        }
+    }
+    customer(order) {
+        return order.customer.trim() === "" ? "GUEST" : order.customer;
+    }
+    customerForDashboardComponent(order) {
+        let text = order.customer.trim() === "" ? "GUEST" : order.customer;
+        if (text.length > 28)
+            text = text.substring(0, 25).trim() + "...";
+        return text;
+    }
+    sortOrders(orders, mode) {
+        switch (mode) {
+            case EnumDashboardSort.date:
+                return orders.sort((a, b) => a.registrationDate < b.registrationDate ? 1 : -1);
+            case EnumDashboardSort.amount:
+                return orders.sort((a, b) => a.amount < b.amount ? 1 : -1);
+            // case EnumDashboardSort.discount:
+            // return orders.sort((a: IOnlineOrderItem, b: IOnlineOrderItem) => a.displayDiscount >= b.displayDiscount ? 1 : -1);
+            // case EnumDashboardSort.tip:
+            //   return orders.sort((a: IOrder, b: IOrder) => a.displayTip >= b.displayTip ? 1 : -1);
+            default:
+                return orders;
+        }
+    }
+    distinctAllOrders(localOrders, onlineOrders) {
+        let locals = localOrders.map(i => this.orderModelToOnlineOrderItem(i));
+        let localsIdList = locals.map(i => i.id);
+        let onLocals = onlineOrders.filter(i => !localsIdList.includes(i.id));
+        return [...locals, ...onLocals];
+    }
+    createOrderList(localOrders, onlineOrders, mode, sort) {
+        switch (mode) {
+            case EnumShowOrderMode.all:
+                return this.sortOrders(this.distinctAllOrders(localOrders, onlineOrders), sort);
+            case EnumShowOrderMode.onlyPos:
+                return this.sortOrders(this.distinctAllOrders(localOrders, onlineOrders.filter(i => i.via === "POS")), sort);
+            case EnumShowOrderMode.onlyWebShop:
+                return this.sortOrders(onlineOrders.filter(i => i.via !== "POS"), sort);
+            default:
+                return [];
+        }
+    }
+    orderModelToOnlineOrderItem(order) {
+        return {
+            amount: order.displayTotalAmount,
+            id: order.id,
+            orderType: order.orderType,
+            asSoonAsPossible: order.asSoonAsPossible,
+            companyId: 0,
+            customer: `${order.firstName} ${order.lastName}`,
+            customerId: 0,
+            desiredDateTime: "",
+            distance: 0,
+            driverFullName: order.driverName + "",
+            driverId: order.driverId ? order.driverId : -1,
+            duration: 0,
+            orderNumber: order.number,
+            orderTypeString: "",
+            haveDeliveryInstructionsRemarks: order.remark !== "",
+            paymentState: 1,
+            paymentStateString: "Paid",
+            state: 1,
+            paymentType: order.paymentType,
+            paymentTypeString: "",
+            preparationTime: "",
+            stateString: "POS",
+            registrationDate: order.registrationDate.toString(),
+            via: "POS",
+            remarks: order.remark !== "",
+            tip: 0,
+            deliveryCost: 0,
+            channel: 1,
+            discount: 0
+        };
+    }
+    getViaIcon(data) {
+        switch (data.via) {
+            case "POS":
+                return "store";
+            case "Web shop":
+                return "web";
+            default:
+                return undefined;
+        }
+    }
+}();

package/dist/controllers/DateTimeController.d.ts

@@ -0,0 +1,20 @@
+import ITextValue from "../interfaces/ITextValue";
+declare const _default: {
+    toDateString(date: Date): string;
+    strDateToStringShortDate(date: string): string;
+    showDesiredDate(date: string): string;
+    showDesiredTime(date: string): string;
+    showEstimateTime(time: string | null): string;
+    estimateToMinute(time: string | null): number;
+    minuteToEstimate(minute?: number): string;
+    dateBoxOptions(minimumDate?: string, maximumDate?: string): ITextValue[];
+    timeBoxOptions(): ITextValue[];
+    nearestTime(): string;
+    firstBiggerThanSecond(first: Date, second: Date): boolean;
+    mixDateAndTimeForTimeModal(date: string | null, time: string | null): Date;
+    dateToNumber(date: Date): string;
+    convertTimeStringToDateByT(data?: Date | string | null): Date | string | null;
+    formatAMPMDate(date: Date | string | null): string;
+    formatDateTime(dateTime: string, mode?: string): string;
+};
+export default _default;

package/dist/controllers/DateTimeController.js

@@ -0,0 +1,301 @@
+export default new class DateTimeController {
+    toDateString(date) {
+        let parts = new Intl.DateTimeFormat("en-GB", {
+            day: "2-digit",
+            month: "2-digit",
+            year: "numeric"
+        }).format(date).split("/");
+        return `${parts[2]}-${parts[1]}-${parts[0]}`;
+    }
+    strDateToStringShortDate(date) {
+        try {
+            return date.split("T")[0];
+        }
+        catch (e) {
+            return date;
+        }
+    }
+    showDesiredDate(date) {
+        try {
+            let dt = new Date(Date.parse(date));
+            let hours = dt.getHours();
+            let minutes = dt.getMinutes();
+            let ampm = hours >= 12 ? "PM" : "AM";
+            hours = hours % 12;
+            hours = hours ? hours : 12; // the hour '0' should be "12"
+            minutes = minutes < 10 ? "0" + minutes : minutes;
+            let time = (hours < 10 ? "0" + hours : hours) + ":" + minutes + " " + ampm;
+            let dtString = new Intl.DateTimeFormat("en-CA", {
+                weekday: "short",
+                month: "short",
+                day: "2-digit"
+            }).format(dt ? dt : Date.now());
+            return (`${dtString} ${time}`);
+        }
+        catch (e) {
+            return date;
+        }
+    }
+    showDesiredTime(date) {
+        try {
+            return date.split("T")[1].substring(0, 5);
+        }
+        catch (e) {
+            return date;
+        }
+    }
+    showEstimateTime(time) {
+        return time !== null ? time : "00:00";
+    }
+    estimateToMinute(time) {
+        if (time === null)
+            return 0;
+        let parts = time.split(":");
+        return (+parts[0] * 60) + (+parts[1]);
+    }
+    minuteToEstimate(minute = 0) {
+        let hour = parseInt((minute / 60) + "");
+        let min = parseInt(((minute % 60) + "").substring(0, 2));
+        return (hour < 10 ? "0" : "") + hour + ":" + (min < 10 ? "0" : "") + min;
+    }
+    dateBoxOptions(minimumDate = "2023-03-08T00:00:00", maximumDate = "2023-04-08T00:00:00") {
+        let arr = [];
+        let date = new Date(minimumDate);
+        const max = new Date(maximumDate).toDateString();
+        do {
+            arr.push({
+                text: date.toDateString(),
+                value: date.toLocaleDateString("en-CA", {
+                    year: "numeric",
+                    month: "2-digit",
+                    day: "2-digit"
+                })
+            });
+            // add a day
+            date.setDate(date.getDate() + 1);
+        } while (date.toDateString() !== max);
+        if (arr.length > 0) {
+            // arr[0].label = `Today   ${arr[0].label}`;
+            arr[0].text = "Today";
+        }
+        if (arr.length > 1) {
+            // arr[1].label = `Tomorrow   ${arr[1].label}`;
+            arr[1].text = "Tomorrow";
+        }
+        return arr;
+    }
+    timeBoxOptions() {
+        return [
+            { text: "12:00 AM", value: "00:00" },
+            { text: "12:15 AM", value: "00:15" },
+            { text: "12:30 AM", value: "00:30" },
+            { text: "12:45 AM", value: "00:45" },
+            { text: "01:00 AM", value: "01:00" },
+            { text: "01:15 AM", value: "01:15" },
+            { text: "01:30 AM", value: "01:30" },
+            { text: "01:45 AM", value: "01:45" },
+            { text: "02:00 AM", value: "02:00" },
+            { text: "02:15 AM", value: "02:15" },
+            { text: "02:30 AM", value: "02:30" },
+            { text: "02:45 AM", value: "02:45" },
+            { text: "03:00 AM", value: "03:00" },
+            { text: "03:15 AM", value: "03:15" },
+            { text: "03:30 AM", value: "03:30" },
+            { text: "03:45 AM", value: "03:45" },
+            { text: "04:00 AM", value: "04:00" },
+            { text: "04:15 AM", value: "04:15" },
+            { text: "04:30 AM", value: "04:30" },
+            { text: "04:45 AM", value: "04:45" },
+            { text: "05:00 AM", value: "05:00" },
+            { text: "05:15 AM", value: "05:15" },
+            { text: "05:30 AM", value: "05:30" },
+            { text: "05:45 AM", value: "05:45" },
+            { text: "06:00 AM", value: "06:00" },
+            { text: "06:15 AM", value: "06:15" },
+            { text: "06:30 AM", value: "06:30" },
+            { text: "06:45 AM", value: "06:45" },
+            { text: "07:00 AM", value: "07:00" },
+            { text: "07:15 AM", value: "07:15" },
+            { text: "07:30 AM", value: "07:30" },
+            { text: "07:45 AM", value: "07:45" },
+            { text: "08:00 AM", value: "08:00" },
+            { text: "08:15 AM", value: "08:15" },
+            { text: "08:30 AM", value: "08:30" },
+            { text: "08:45 AM", value: "08:45" },
+            { text: "09:00 AM", value: "09:00" },
+            { text: "09:15 AM", value: "09:15" },
+            { text: "09:30 AM", value: "09:30" },
+            { text: "09:45 AM", value: "09:45" },
+            { text: "10:00 AM", value: "10:00" },
+            { text: "10:15 AM", value: "10:15" },
+            { text: "10:30 AM", value: "10:30" },
+            { text: "10:45 AM", value: "10:45" },
+            { text: "11:00 AM", value: "11:00" },
+            { text: "11:15 AM", value: "11:15" },
+            { text: "11:30 AM", value: "11:30" },
+            { text: "11:45 AM", value: "11:45" },
+            { text: "12:00 PM", value: "12:00" },
+            { text: "12:15 PM", value: "12:15" },
+            { text: "12:30 PM", value: "12:30" },
+            { text: "12:45 PM", value: "12:45" },
+            { text: "01:00 PM", value: "13:00" },
+            { text: "01:15 PM", value: "13:15" },
+            { text: "01:30 PM", value: "13:30" },
+            { text: "01:45 PM", value: "13:45" },
+            { text: "02:00 PM", value: "14:00" },
+            { text: "02:15 PM", value: "14:15" },
+            { text: "02:30 PM", value: "14:30" },
+            { text: "02:45 PM", value: "14:45" },
+            { text: "03:00 PM", value: "15:00" },
+            { text: "03:15 PM", value: "15:15" },
+            { text: "03:30 PM", value: "15:30" },
+            { text: "03:45 PM", value: "15:45" },
+            { text: "04:00 PM", value: "16:00" },
+            { text: "04:15 PM", value: "16:15" },
+            { text: "04:30 PM", value: "16:30" },
+            { text: "04:45 PM", value: "16:45" },
+            { text: "05:00 PM", value: "17:00" },
+            { text: "05:15 PM", value: "17:15" },
+            { text: "05:30 PM", value: "17:30" },
+            { text: "05:45 PM", value: "17:45" },
+            { text: "06:00 PM", value: "18:00" },
+            { text: "06:15 PM", value: "18:15" },
+            { text: "06:30 PM", value: "18:30" },
+            { text: "06:45 PM", value: "18:45" },
+            { text: "07:00 PM", value: "19:00" },
+            { text: "07:15 PM", value: "19:15" },
+            { text: "07:30 PM", value: "19:30" },
+            { text: "07:45 PM", value: "19:45" },
+            { text: "08:00 PM", value: "20:00" },
+            { text: "08:15 PM", value: "20:15" },
+            { text: "08:30 PM", value: "20:30" },
+            { text: "08:45 PM", value: "20:45" },
+            { text: "09:00 PM", value: "21:00" },
+            { text: "09:15 PM", value: "21:15" },
+            { text: "09:30 PM", value: "21:30" },
+            { text: "09:45 PM", value: "21:45" },
+            { text: "10:00 PM", value: "22:00" },
+            { text: "10:15 PM", value: "22:15" },
+            { text: "10:30 PM", value: "22:30" },
+            { text: "10:45 PM", value: "22:45" },
+            { text: "11:00 PM", value: "23:00" },
+            { text: "11:15 PM", value: "23:15" },
+            { text: "11:30 PM", value: "23:30" },
+            { text: "11:45 PM", value: "23:45" }
+        ];
+    }
+    nearestTime() {
+        let dt = new Date();
+        let hours = dt.getHours();
+        let minutes = dt.getMinutes();
+        hours = hours < 10 ? "0" + hours : hours;
+        minutes = minutes < 10 ? "0" + minutes : minutes;
+        let time = `${hours}:${minutes}`;
+        let result = this.timeBoxOptions().find(i => i.value >= time);
+        if (!result)
+            return "00:00";
+        return result.value;
+    }
+    // isBetweenTowDate(start: Date, end: Date, date: Date) {
+    //   return date.getTime() >= start.getTime() && date.getTime() <= end.getTime();
+    // }
+    firstBiggerThanSecond(first, second) {
+        return first.getTime() >= second.getTime();
+    }
+    mixDateAndTimeForTimeModal(date, time) {
+        let dt = new Date();
+        if (date) {
+            dt.setFullYear(+date.split("-")[0]);
+            dt.setMonth(+date.split("-")[1] - 1);
+            dt.setDate(+date.split("-")[2]);
+        }
+        if (time) {
+            dt.setHours(+time.split(":")[0]);
+            dt.setMinutes(+time.split(":")[1]);
+            dt.setSeconds(0);
+            dt.setMilliseconds(0);
+        }
+        return dt;
+    }
+    dateToNumber(date) {
+        let year = date.getFullYear();
+        let month = date.getMonth();
+        if (month < 10)
+            month = "0" + month;
+        let day = date.getDate();
+        if (day < 10)
+            day = "0" + day;
+        let hours = date.getHours();
+        if (hours < 10)
+            hours = "0" + hours;
+        let minutes = date.getMinutes();
+        if (minutes < 10)
+            minutes = "0" + minutes;
+        let second = date.getSeconds();
+        if (second < 10)
+            second = "0" + second;
+        let milliSecond = date.getMilliseconds() + "";
+        while (milliSecond.length < 3)
+            milliSecond = "0" + milliSecond;
+        return `${year}${month}${day}${hours}${minutes}${second}${milliSecond}`;
+    }
+    convertTimeStringToDateByT(data = null) {
+        if (data instanceof Date) {
+            return data;
+        }
+        else if (typeof data === "string" && data.length > 0) {
+            try {
+                const time_ = data.split("T");
+                const parts = time_[1].split(":");
+                let dd = new Date();
+                dd.setHours(isNaN(Number(parts[0])) ? 0 : Number(parts[0]));
+                dd.setMinutes(isNaN(Number(parts[1])) ? 0 : Number(parts[1]));
+                dd.setSeconds(isNaN(Number(parts[2])) ? 0 : Number(parts[2]));
+                return dd;
+            }
+            catch (e) {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    formatAMPMDate(date) {
+        let datetime = this.convertTimeStringToDateByT(date);
+        if (datetime instanceof Date) {
+            let hours = datetime.getHours();
+            let minutes = datetime.getMinutes();
+            let ampm = hours >= 12 ? "PM" : "AM";
+            hours = hours % 12;
+            hours = hours ? hours : 12;
+            minutes = minutes < 10 ? "0" + minutes : minutes;
+            return (hours < 10 ? "0" + hours : hours) + ":" + minutes + " " + ampm;
+        }
+        else {
+            return "";
+        }
+    }
+    formatDateTime(dateTime, mode = "full") {
+        try {
+            let dt = Date.parse(dateTime);
+            let time_ = this.formatAMPMDate(dateTime);
+            if (mode !== "full") {
+                return time_;
+            }
+            return (new Intl.DateTimeFormat("en-GB", {
+                weekday: "short",
+                year: "2-digit",
+                month: "short",
+                day: "2-digit"
+                // hour: "2-digit",
+                // minute: "2-digit"
+            }).format(dt ? dt : Date.now()) +
+                " " +
+                time_);
+        }
+        catch (e) {
+            return dateTime;
+        }
+    }
+}();

package/dist/controllers/LogController.d.ts

@@ -0,0 +1,14 @@
+import IStorageControler from "../interfaces/IStorageControler";
+export default class LogController {
+    active: boolean;
+    label: string;
+    storage: IStorageControler;
+    constructor(pre_label: string, storageController: IStorageControler, state: boolean);
+    console(data: any): void;
+    description(title: string, description?: any): void;
+    error(title: string, description?: any): void;
+    info(title: string, description?: any): void;
+    log(title: string, description?: any): void;
+    private createLogDescription;
+    private _log;
+}