@rivtn/noseur 1.0.0

package/dist/esm/utils/DateHelper.d.ts

@@ -0,0 +1,115 @@
+import { NoseurObject } from "../constants/Types";
+export interface Time {
+    ms: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    timezone: string;
+    meridian: "AM" | "PM";
+    timezoneOffset: number;
+}
+export declare enum Weekday {
+    SUNDAY = "SUNDAY",
+    MONDAY = "MONDAY",
+    TUESDAY = "TUESDAY",
+    WEDNESDAY = "WEDNESDAY",
+    THURSDAY = "THURSDAY",
+    FRIDAY = "FRIDAY",
+    SATURDAY = "SATURDAY"
+}
+export declare enum Month {
+    JANUARY = 0,
+    FEBRUARY = 1,
+    MARCH = 2,
+    APRIL = 3,
+    MAY = 4,
+    JUNE = 5,
+    JULY = 6,
+    AUGUST = 7,
+    SEPTEMBER = 8,
+    OCTOBER = 9,
+    NOVEMBER = 10,
+    DECEMBER = 11
+}
+export interface FormatedDate {
+    date: Date;
+    day: number;
+    year: number;
+    month: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    weekDay: string;
+    longYear: string;
+    monthName: string;
+    formatted: string;
+    disabled: boolean;
+    meridian: "AM" | "PM";
+    hourFormat: "12" | "24";
+    isNotInMonth: boolean;
+}
+export declare const DateHelper: {
+    WEEKDAYS_MAP: {
+        [key: string]: number;
+    };
+    now(): Date;
+    clone(_date: Date): Date;
+    addYears(_date: Date, value: number): Date;
+    addMonths(_date: Date, value: number): Date;
+    addDays(_date: Date, value: number): Date;
+    addHours(_date: Date, value: number): Date;
+    addMinutes(_date: Date, value: number): Date;
+    addSeconds(_date: Date, value: number): Date;
+    addTime(_date: Date, hours: number, minutes: number, seconds: number, ms?: number): Date;
+    withEndOfDayTime(_date: Date): Date;
+    withTime(_date: Date, _timeDate?: Date): Date;
+    withoutTime(_date: Date): Date;
+    daysInMonth(yearOrDate: number | Date, month?: number): number;
+    isInArrayOfDates(array: Date[], value: Date, withoutTime?: boolean): boolean;
+    areInArrayOfDates(array: (Date | undefined)[], values: Date[], withoutTime?: boolean): boolean;
+    anyInArrayOfDates(array: Date[], values: Date[], withoutTime?: boolean): boolean;
+    getTime(date: Date): Time;
+    formatDateToObject(originalDate: Date, formatMap: NoseurObject<Intl.DateTimeFormatOptions>, locale?: string, hourFormat?: "12" | "24", comparisonDate?: Date): FormatedDate;
+    isToday(date: Date): boolean;
+    isPast(date: Date): boolean;
+    isFuture(date: Date): boolean;
+    isNow(date: Date): boolean;
+    dateEquals(dates: Date[]): boolean;
+    dateIsInRange(_fromDate: Date, _toDate: Date, date: Date): boolean;
+    translateWeekday(weekday: string, locale?: string, option?: Intl.DateTimeFormatOptions): string;
+    getAllDaysInMonth(year: number, month: number, count?: number, reverse?: boolean): Date[];
+    getMilliSecondsBetweenDates(date1: Date, date2: Date): number;
+    getSecondsBetweenDates(date1: Date, date2: Date): number;
+    getMinutesBetweenDates(date1: Date, date2: Date): number;
+    getHoursBetweenDates(date1: Date, date2: Date): number;
+    getDaysBetweenDates(date1: Date, date2: Date): number;
+    getWeeksBetweenDates(date1: Date, date2: Date): number;
+    getMonthsBetweenDates(date1: Date, date2: Date): number;
+    getYearsBetweenDates(date1: Date, date2: Date): number;
+    getStartOfDay(date?: Date): Date;
+    getEndOfDay(date?: Date): Date;
+    getFirstDayInMonth(date?: Date): Date;
+    getLastDayInMonth(date?: Date): Date;
+    getStartOfMonth(date?: Date): Date;
+    getEndOfMonth(date?: Date): Date;
+    getFirstDayInYear(date?: Date): Date;
+    getLastDayInYear(date?: Date): Date;
+    getStartOfYear(date?: Date): Date;
+    getEndOfYear(date?: Date): Date;
+    getTomorrow(date?: Date): Date;
+    formatDuration(startDate: Date, endDate: Date, config?: {
+        showMaxIntervalOnly?: boolean;
+        separator?: string;
+        language?: {
+            days: string;
+            hrs: string;
+            mins: string;
+            sec: string;
+        };
+    }): string;
+    getNextWeekDay(weekDay: Weekday, date?: Date): Date;
+    getLastWeekdayOfMonth(weekDay: Weekday, date?: Date): Date;
+    getNextTwoWeekDayFrom(fromDate: Date, weekDay: Weekday, date?: Date): Date;
+    getNextQuarterStart(date?: Date): Date;
+    getNextQuarterEnd(date?: Date): Date;
+};

package/dist/esm/utils/DateHelper.js

@@ -0,0 +1,338 @@
+import { BoolHelper } from "./BoolHelper";
+export var Weekday;
+(function (Weekday) {
+    Weekday["SUNDAY"] = "SUNDAY";
+    Weekday["MONDAY"] = "MONDAY";
+    Weekday["TUESDAY"] = "TUESDAY";
+    Weekday["WEDNESDAY"] = "WEDNESDAY";
+    Weekday["THURSDAY"] = "THURSDAY";
+    Weekday["FRIDAY"] = "FRIDAY";
+    Weekday["SATURDAY"] = "SATURDAY";
+})(Weekday || (Weekday = {}));
+export var Month;
+(function (Month) {
+    Month[Month["JANUARY"] = 0] = "JANUARY";
+    Month[Month["FEBRUARY"] = 1] = "FEBRUARY";
+    Month[Month["MARCH"] = 2] = "MARCH";
+    Month[Month["APRIL"] = 3] = "APRIL";
+    Month[Month["MAY"] = 4] = "MAY";
+    Month[Month["JUNE"] = 5] = "JUNE";
+    Month[Month["JULY"] = 6] = "JULY";
+    Month[Month["AUGUST"] = 7] = "AUGUST";
+    Month[Month["SEPTEMBER"] = 8] = "SEPTEMBER";
+    Month[Month["OCTOBER"] = 9] = "OCTOBER";
+    Month[Month["NOVEMBER"] = 10] = "NOVEMBER";
+    Month[Month["DECEMBER"] = 11] = "DECEMBER";
+})(Month || (Month = {}));
+export const DateHelper = {
+    WEEKDAYS_MAP: Object.values(Weekday).reduce((acc, weekday, index) => {
+        acc[weekday] = index;
+        return acc;
+    }, {}),
+    now() {
+        return new Date();
+    },
+    clone(_date) {
+        return new Date(_date.getTime());
+    },
+    addYears(_date, value) {
+        const date = new Date(_date.getTime());
+        date.setFullYear(date.getFullYear() + value);
+        return date;
+    },
+    addMonths(_date, value) {
+        const date = new Date(_date.getTime());
+        date.setMonth(date.getMonth() + value);
+        return date;
+    },
+    addDays(_date, value) {
+        const date = new Date(_date.getTime());
+        date.setDate(date.getDate() + value);
+        return date;
+    },
+    addHours(_date, value) {
+        const date = new Date(_date.getTime());
+        date.setHours(date.getHours() + value);
+        return date;
+    },
+    addMinutes(_date, value) {
+        const date = new Date(_date.getTime());
+        date.setMinutes(date.getMinutes() + value);
+        return date;
+    },
+    addSeconds(_date, value) {
+        const date = new Date(_date.getTime());
+        date.setSeconds(date.getSeconds() + value);
+        return date;
+    },
+    addTime(_date, hours, minutes, seconds, ms = 0) {
+        const date = new Date(_date.getTime());
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours, minutes, seconds, ms);
+    },
+    withEndOfDayTime(_date) {
+        const date = new Date(_date.getTime());
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 58, 59);
+    },
+    withTime(_date, _timeDate) {
+        const date = new Date(_date.getTime());
+        const timeDate = _timeDate ?? new Date();
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate(), timeDate.getHours(), timeDate.getMinutes(), timeDate.getSeconds(), timeDate.getMilliseconds());
+    },
+    withoutTime(_date) {
+        const date = new Date(_date.getTime());
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    },
+    daysInMonth(yearOrDate, month = 0) {
+        if (typeof yearOrDate === "number") {
+            return new Date(yearOrDate, month + 1, 0).getDate();
+        }
+        return new Date(yearOrDate.getFullYear(), yearOrDate.getMonth() + 1, 0).getDate();
+    },
+    isInArrayOfDates(array, value, withoutTime = true) {
+        let rightOperand = withoutTime ? DateHelper.withoutTime(value) : value;
+        return !!array.find(item => {
+            let leftOperand = withoutTime ? DateHelper.withoutTime(item) : item;
+            return leftOperand.getTime() == rightOperand.getTime();
+        });
+    },
+    areInArrayOfDates(array, values, withoutTime = true) {
+        let presentCount = 0;
+        let rightOperands = withoutTime ? values.map(value => DateHelper.withoutTime(value)) : values;
+        array.forEach(item => {
+            if (!item)
+                return;
+            let leftOperand = withoutTime ? DateHelper.withoutTime(item) : item;
+            for (const rightOperand of rightOperands) {
+                if (leftOperand.getTime() === rightOperand.getTime())
+                    presentCount++;
+            }
+        });
+        return presentCount >= values.length;
+    },
+    anyInArrayOfDates(array, values, withoutTime = true) {
+        let rightOperands = withoutTime ? values.map(value => DateHelper.withoutTime(value)) : values;
+        return !!array.find(item => {
+            let leftOperand = withoutTime ? DateHelper.withoutTime(item) : item;
+            return DateHelper.isInArrayOfDates(rightOperands, leftOperand);
+        });
+    },
+    getTime(date) {
+        return {
+            hours: date.getHours(),
+            ms: date.getMilliseconds(),
+            minutes: date.getMinutes(),
+            seconds: date.getSeconds(),
+            timezoneOffset: date.getTimezoneOffset(),
+            meridian: date.getHours() >= 12 ? "PM" : "AM",
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        };
+    },
+    formatDateToObject(originalDate, formatMap, locale = "default", hourFormat = "24", comparisonDate = new Date()) {
+        const formattedDate = {};
+        const date = new Date(originalDate.valueOf());
+        let hours = date.getHours();
+        const meridian = hours >= 12 ? 'PM' : 'AM';
+        if (hourFormat === "12" && hours >= 12) {
+            hours = hours % 12;
+            hours = hours ? hours : 12;
+        }
+        formattedDate["date"] = date;
+        formattedDate["meridian"] = meridian;
+        formattedDate["day"] = date.getDate();
+        formattedDate["hourFormat"] = hourFormat;
+        formattedDate["month"] = date.getMonth();
+        formattedDate["year"] = date.getFullYear();
+        formattedDate["hours"] = ('' + hours).padStart(2, '0');
+        formattedDate["minutes"] = ('' + date.getMinutes()).padStart(2, '0');
+        formattedDate["seconds"] = ('' + date.getSeconds()).padStart(2, '0');
+        formattedDate["isNotInMonth"] = !(date.getMonth() === comparisonDate.getMonth() && date.getFullYear() === comparisonDate.getFullYear());
+        Object.keys(formatMap).forEach(key => {
+            formattedDate[key] = date.toLocaleString(locale, formatMap[key]);
+        });
+        formattedDate;
+        return formattedDate;
+    },
+    isToday(date) {
+        let todaysDate = new Date();
+        return todaysDate.getDate() === date.getDate() && todaysDate.getMonth() === date.getMonth() && todaysDate.getFullYear() === date.getFullYear();
+    },
+    isPast(date) {
+        return (new Date()).getTime() > date.getTime();
+    },
+    isFuture(date) {
+        return !DateHelper.isPast(date);
+    },
+    isNow(date) {
+        return new Date().getTime() === date.getTime();
+    },
+    dateEquals(dates) {
+        return !dates.length || BoolHelper.allEquals((o) => o.getTime() === dates[0].getTime(), ...dates);
+    },
+    dateIsInRange(_fromDate, _toDate, date) {
+        let fromDate = new Date(_fromDate.getTime()), toDate = new Date(_toDate.getTime());
+        if (_fromDate > _toDate) {
+            toDate = new Date(_fromDate.getTime());
+            fromDate = new Date(_toDate.getTime());
+        }
+        return date > fromDate && date < toDate;
+    },
+    translateWeekday(weekday, locale = "en", option = { weekday: 'short' }) {
+        const weekdayIndex = Object.keys(Weekday).indexOf(weekday);
+        if (weekdayIndex < 0)
+            throw new Error(`Unknown weekday "${weekday}"`);
+        return new Date(2001, 0, weekdayIndex).toLocaleDateString(locale, option);
+    },
+    getAllDaysInMonth(year, month, count, reverse) {
+        const daysInMonth = DateHelper.daysInMonth(year, month);
+        const negator = reverse ? -daysInMonth : 1;
+        const days = Array.from({ length: count ? count : daysInMonth }, (_, i) => new Date(year, month, Math.abs(i + negator)));
+        return reverse ? days.reverse() : days;
+    },
+    getMilliSecondsBetweenDates(date1, date2) {
+        return Math.abs(date2.getTime() - date1.getTime());
+    },
+    getSecondsBetweenDates(date1, date2) {
+        return DateHelper.getMilliSecondsBetweenDates(date1, date2);
+    },
+    getMinutesBetweenDates(date1, date2) {
+        return Math.round(DateHelper.getMilliSecondsBetweenDates(date1, date2) / (1000 * 60));
+    },
+    getHoursBetweenDates(date1, date2) {
+        return Math.round(DateHelper.getMilliSecondsBetweenDates(date1, date2) / (1000 * 60 * 60));
+    },
+    getDaysBetweenDates(date1, date2) {
+        return Math.round(DateHelper.getMilliSecondsBetweenDates(date1, date2) / (1000 * 60 * 60 * 24));
+    },
+    getWeeksBetweenDates(date1, date2) {
+        return Math.round(DateHelper.getMilliSecondsBetweenDates(date1, date2) / (1000 * 60 * 60 * 24 * 7));
+    },
+    getMonthsBetweenDates(date1, date2) {
+        const diffYears = date2.getFullYear() - date1.getFullYear();
+        return Math.abs((diffYears * 12) + (date2.getMonth() - date1.getMonth()));
+    },
+    getYearsBetweenDates(date1, date2) {
+        return date2.getFullYear() - date1.getFullYear();
+    },
+    getStartOfDay(date = new Date()) {
+        const newDate = DateHelper.clone(date);
+        newDate.setUTCHours(0, 0, 0, 0);
+        return newDate;
+    },
+    getEndOfDay(date = new Date()) {
+        const newDate = DateHelper.clone(date);
+        newDate.setUTCHours(23, 59, 59, 999);
+        return newDate;
+    },
+    getFirstDayInMonth(date = new Date()) {
+        return new Date(date.getFullYear(), date.getMonth(), 1);
+    },
+    getLastDayInMonth(date = new Date()) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 0);
+    },
+    getStartOfMonth(date = new Date()) {
+        return DateHelper.getFirstDayInMonth(date);
+    },
+    getEndOfMonth(date = new Date()) {
+        return DateHelper.getLastDayInMonth(date);
+    },
+    getFirstDayInYear(date = new Date()) {
+        return new Date(date.getFullYear(), 0, 1);
+    },
+    getLastDayInYear(date = new Date()) {
+        return new Date(date.getFullYear(), 11, 31);
+    },
+    getStartOfYear(date = new Date()) {
+        return DateHelper.getFirstDayInYear(date);
+    },
+    getEndOfYear(date = new Date()) {
+        return DateHelper.getLastDayInYear(date);
+    },
+    getTomorrow(date = new Date()) {
+        const tomorrowMidnight = DateHelper.clone(date);
+        tomorrowMidnight.setDate(tomorrowMidnight.getDate() + 1);
+        tomorrowMidnight.setHours(0, 0, 0, 0);
+        return tomorrowMidnight;
+    },
+    formatDuration(startDate, endDate, config = {}) {
+        if (!config.language)
+            config.language = {
+                sec: "sec",
+                hrs: "hrs",
+                mins: "mins",
+                days: "days",
+            };
+        let diffInSeconds = Math.abs(Math.floor((endDate.getTime() - startDate.getTime()) / 1000));
+        if (diffInSeconds === 0)
+            return "0sec";
+        const days = Math.floor(diffInSeconds / 86400);
+        diffInSeconds %= 86400;
+        const hours = Math.floor(diffInSeconds / 3600);
+        diffInSeconds %= 3600;
+        const minutes = Math.floor(diffInSeconds / 60);
+        const seconds = diffInSeconds % 60;
+        const parts = [];
+        if (days > 0)
+            parts.push(`${days}${config.language.days}`);
+        if ((parts.length === 0 || !config.showMaxIntervalOnly) && hours > 0)
+            parts.push(`${hours}${config.language.hrs}`);
+        if ((parts.length === 0 || !config.showMaxIntervalOnly) && minutes > 0)
+            parts.push(`${minutes}${config.language.mins}`);
+        if ((parts.length === 0 || !config.showMaxIntervalOnly) && seconds > 0)
+            parts.push(`${seconds}${config.language.sec}`);
+        return parts.join(config.separator ?? " ");
+    },
+    getNextWeekDay(weekDay, date = new Date()) {
+        const targetDayIndex = DateHelper.WEEKDAYS_MAP[weekDay];
+        const resultDate = DateHelper.clone(date);
+        const currentDayIndex = resultDate.getDay();
+        let dayDiff = targetDayIndex - currentDayIndex;
+        if (dayDiff <= 0) {
+            dayDiff += 7;
+        }
+        resultDate.setDate(resultDate.getDate() + dayDiff);
+        return resultDate;
+    },
+    getLastWeekdayOfMonth(weekDay, date = new Date()) {
+        const targetDayIndex = DateHelper.WEEKDAYS_MAP[weekDay];
+        const resultDate = DateHelper.clone(date);
+        const currentDayIndex = resultDate.getDay();
+        let dayDiff = targetDayIndex - currentDayIndex;
+        if (dayDiff <= 0) {
+            dayDiff += 7;
+        }
+        resultDate.setDate(resultDate.getDate() + dayDiff);
+        return resultDate;
+    },
+    getNextTwoWeekDayFrom(fromDate, weekDay, date = new Date()) {
+        const targetDayIndex = DateHelper.WEEKDAYS_MAP[weekDay];
+        let anchorDate = DateHelper.clone(fromDate);
+        let startDayIndex = anchorDate.getDay();
+        let daysToFirstTarget = (targetDayIndex - startDayIndex + 7) % 7;
+        anchorDate.setDate(anchorDate.getDate() + daysToFirstTarget);
+        const msPerDay = 24 * 60 * 60 * 1000;
+        const daysSinceAnchor = (date - anchorDate) / msPerDay;
+        let intervalsPassed = 0;
+        if (daysSinceAnchor > 0) {
+            intervalsPassed = Math.ceil(daysSinceAnchor / 14);
+        }
+        const resultDate = new Date(anchorDate);
+        resultDate.setDate(anchorDate.getDate() + (intervalsPassed * 14));
+        return resultDate;
+    },
+    getNextQuarterStart(date = new Date()) {
+        const result = DateHelper.clone(date);
+        const currentMonth = result.getMonth();
+        const nextQuarterMonth = (Math.floor(currentMonth / 3) + 1) * 3;
+        result.setMonth(nextQuarterMonth, 1);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    },
+    getNextQuarterEnd(date = new Date()) {
+        const result = DateHelper.clone(date);
+        const currentMonth = result.getMonth();
+        const nextQuarterStartMonth = (Math.floor(currentMonth / 3) + 1) * 3;
+        result.setMonth(nextQuarterStartMonth + 3, 0);
+        result.setHours(23, 59, 59, 999);
+        return result;
+    },
+};

package/dist/esm/utils/Debugger.d.ts

@@ -0,0 +1,12 @@
+export declare class Debugger {
+    private static _NAMESPACE;
+    private static _SECURE_FIELD_PLACEHOLDER;
+    private static _ENABLED_DEBUGGING;
+    private static _SECURE_FIELDS;
+    static setNamespace: (namespace: string) => string;
+    static registerSecureFields: (fields: string[]) => void;
+    static log: (...args: any) => false | void;
+    static warn: (...args: any) => false | void;
+    static error: (...args: any) => false | void;
+    private static sanitize;
+}

package/dist/esm/utils/Debugger.js

@@ -0,0 +1,30 @@
+import { TypeChecker } from "./TypeChecker";
+import { ObjectHelper } from "./ObjectHelper";
+export class Debugger {
+    static _NAMESPACE = "NOSEUR.DEBUGGER";
+    static _SECURE_FIELD_PLACEHOLDER = "<REDACTED>";
+    static _ENABLED_DEBUGGING = (sessionStorage.getItem("NOSEUR.DEBUGGER.ENABLE") ?? localStorage.getItem("NOSEUR.DEBUGGER.ENABLE")) === "true";
+    static _SECURE_FIELDS = [
+        "access_token",
+        "session_token",
+    ];
+    static setNamespace = (namespace) => Debugger._NAMESPACE = namespace;
+    static registerSecureFields = (fields) => fields.forEach((field) => Debugger._SECURE_FIELDS.push(field));
+    static log = (...args) => Debugger._ENABLED_DEBUGGING && console.log(Debugger._NAMESPACE, ...Debugger.sanitize(...args));
+    static warn = (...args) => Debugger._ENABLED_DEBUGGING && console.warn(Debugger._NAMESPACE, ...Debugger.sanitize(...args));
+    static error = (...args) => Debugger._ENABLED_DEBUGGING && console.error(Debugger._NAMESPACE, ...Debugger.sanitize(...args));
+    static sanitize = (...args) => {
+        for (let index = 0; index < args.length; index++) {
+            if (!TypeChecker.isArray(args[index]) && TypeChecker.isObject(args[index])) {
+                args[index] = ObjectHelper.cloneObject(args[index]);
+                Object.keys(args[index]).forEach((key) => {
+                    if (Debugger._SECURE_FIELDS.includes(key)) {
+                        args[index][key] = Debugger._SECURE_FIELD_PLACEHOLDER;
+                        return;
+                    }
+                });
+            }
+        }
+        return args;
+    };
+}

package/dist/esm/utils/FileHelper.d.ts

@@ -0,0 +1,8 @@
+import { FileInputPreviewType } from "../form/FileInput";
+export declare const FileHelper: {
+    fileListToFileArray(fileList: FileList | null): File[];
+    humanFileSize(bytes: number, si?: boolean, dp?: number): string;
+    fileToText: (file: File) => Promise<string>;
+    fileToBase64: (file: File) => Promise<unknown>;
+    detectPreviewTypeFromUrl: (url: string) => FileInputPreviewType.PDF | FileInputPreviewType.AUTO | FileInputPreviewType.HTML | FileInputPreviewType.IMAGE | FileInputPreviewType.VIDEO | FileInputPreviewType.AUDIO;
+};

package/dist/esm/utils/FileHelper.js

@@ -0,0 +1,65 @@
+import { FileInputPreviewType } from "../form/FileInput";
+import { BoolHelper } from "./BoolHelper";
+export const FileHelper = {
+    fileListToFileArray(fileList) {
+        const files = [];
+        if (!fileList)
+            return files;
+        for (let index = 0; index < fileList.length; index++) {
+            files.push(fileList.item(index));
+        }
+        return files;
+    },
+    // https://stackoverflow.com/questions/10420352/converting-file-size-in-bytes-to-human-readable-string/10420404
+    humanFileSize(bytes, si = false, dp = 1) {
+        const thresh = si ? 1000 : 1024;
+        if (Math.abs(bytes) < thresh) {
+            return bytes + ' B';
+        }
+        const units = si
+            ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+            : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+        let u = -1;
+        const r = 10 ** dp;
+        do {
+            bytes /= thresh;
+            ++u;
+        } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+        return bytes.toFixed(dp) + ' ' + units[u];
+    },
+    fileToText: async (file) => {
+        return await file.text();
+    },
+    fileToBase64: (file) => {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onloadend = () => {
+                const base64data = reader.result;
+                if (!base64data) {
+                    reject(new Error("Failed to convert File to Base64"));
+                    return;
+                }
+                resolve(base64data.substring(base64data.indexOf(',') + 1));
+            };
+        });
+    },
+    detectPreviewTypeFromUrl: (url) => {
+        if (BoolHelper.anyEquals((e) => url.includes(e.toLowerCase()), ".pdf")) {
+            return FileInputPreviewType.PDF;
+        }
+        else if (BoolHelper.anyEquals((e) => url.includes(e.toLowerCase()), ".mp3", ".wav")) {
+            return FileInputPreviewType.AUDIO;
+        }
+        else if (BoolHelper.anyEquals((e) => url.includes(e.toLowerCase()), ".html", ".text")) {
+            return FileInputPreviewType.HTML;
+        }
+        else if (BoolHelper.anyEquals((e) => url.includes(e.toLowerCase()), ".mp4", ".mpeg", ".mov")) {
+            return FileInputPreviewType.VIDEO;
+        }
+        else if (BoolHelper.anyEquals((e) => url.includes(e.toLowerCase()), ".png", ".jpg", ".gif", ".jpeg", ".webp")) {
+            return FileInputPreviewType.IMAGE;
+        }
+        return FileInputPreviewType.AUTO;
+    },
+};

package/dist/esm/utils/FunctionStackManager.d.ts

@@ -0,0 +1,13 @@
+import { NoseurObject } from "../constants/Types";
+export declare class FunctionStackManager {
+    push: Function;
+    popSmoke: Function;
+    stack: NoseurObject<Function[]>;
+    constructor();
+    register(key: string, ...funsies: Function[]): void;
+    unRegister(key: string, ...funsies: Function[]): void;
+    pop(key: string): Function | undefined;
+    popAll(key: string): Function[];
+    invokeAll(key: string, ...params: any[]): void;
+    invokeAllAndClear(key: string, ...params: any[]): void;
+}

package/dist/esm/utils/FunctionStackManager.js

@@ -0,0 +1,59 @@
+export class FunctionStackManager {
+    push;
+    popSmoke;
+    stack = {};
+    constructor() {
+        this.push = this.register.bind(this);
+        this.popSmoke = this.invokeAllAndClear.bind(this);
+    }
+    register(key, ...funsies) {
+        if (!this.stack || !key || !funsies)
+            return;
+        if (!(key in this.stack))
+            this.stack[key] = [];
+        this.stack[key].push(...funsies);
+    }
+    unRegister(key, ...funsies) {
+        if (!this.stack || !key || !funsies)
+            return;
+        if (!(key in this.stack))
+            this.stack[key] = [];
+        for (const funsy of funsies) {
+            const index = this.stack[key].indexOf(funsy);
+            if (index > -1)
+                this.stack[key].splice(index, 1);
+        }
+        ;
+    }
+    pop(key) {
+        if (!this.stack || !key)
+            return;
+        if (!(key in this.stack) || !this.stack[key].length)
+            return;
+        return this.stack[key][this.stack[key].length - 1];
+    }
+    popAll(key) {
+        if (!this.stack || !key)
+            return [];
+        if (!(key in this.stack) || !this.stack[key].length)
+            return [];
+        const funsies = this.stack[key];
+        delete this.stack[key];
+        return funsies;
+    }
+    invokeAll(key, ...params) {
+        if (!this.stack || !key)
+            return;
+        if (!(key in this.stack))
+            return;
+        this.stack[key].forEach(funsy => funsy(...params));
+    }
+    invokeAllAndClear(key, ...params) {
+        if (!this.stack || !key)
+            return;
+        if (!(key in this.stack))
+            return;
+        this.stack[key].forEach(funsy => funsy(...params));
+        delete this.stack[key];
+    }
+}

package/dist/esm/utils/InputHelper.d.ts

@@ -0,0 +1,37 @@
+export declare class InputFilter {
+    static INT: RegExp;
+    static HEX: RegExp;
+    static ALPHA: RegExp;
+    static NUMBER: RegExp;
+    static MONEY: RegExp;
+    static ALPHANUM: RegExp;
+    static POSITIVE_INT: RegExp;
+    static POSITIVE_NUMBER: RegExp;
+    static EMAIL: RegExp;
+}
+export declare enum InputSpecialKey {
+    ESC = 27,
+    TAB = 9,
+    RETURN = 13,
+    BACKSPACE = 8,
+    DELETE = 46
+}
+type InputEventAlias = {
+    which?: any;
+    altKey?: any;
+    ctrlKey?: any;
+    keyCode?: any;
+    shiftKey?: any;
+    charCode?: any;
+    preventDefault?: any;
+};
+export declare const InputHelper: {
+    isNavKeyPress(event: InputEventAlias): boolean;
+    isSpecialKey(event: InputEventAlias): any;
+    getKey(event: any): any;
+    getCharCode(event: InputEventAlias): any;
+    validateEventValue(regex: RegExp, event: React.SyntheticEvent, value: string): boolean;
+    validateEventKeyInput(regex: RegExp, event: InputEventAlias): boolean | undefined;
+    validate(value: string, filter: RegExp): boolean;
+};
+export {};