@rivtn/noseur 1.0.0

package/dist/esm/utils/InputHelper.js

@@ -0,0 +1,70 @@
+import { DOMHelper } from "./DOMUtils";
+export class InputFilter {
+    static INT = /[\d\-]/;
+    static HEX = /[0-9a-f]/i;
+    static ALPHA = /[a-z_]/i;
+    static NUMBER = /[\d\-\.]/;
+    static MONEY = /[\d\.\s,]/;
+    static ALPHANUM = /[a-z0-9_]/i;
+    static POSITIVE_INT = /[\d]/;
+    static POSITIVE_NUMBER = /[\d\.]/;
+    static EMAIL = /[a-z0-9_\.\-@]/i;
+}
+export var InputSpecialKey;
+(function (InputSpecialKey) {
+    InputSpecialKey[InputSpecialKey["ESC"] = 27] = "ESC";
+    InputSpecialKey[InputSpecialKey["TAB"] = 9] = "TAB";
+    InputSpecialKey[InputSpecialKey["RETURN"] = 13] = "RETURN";
+    InputSpecialKey[InputSpecialKey["BACKSPACE"] = 8] = "BACKSPACE";
+    InputSpecialKey[InputSpecialKey["DELETE"] = 46] = "DELETE";
+})(InputSpecialKey || (InputSpecialKey = {}));
+export const InputHelper = {
+    isNavKeyPress(event) {
+        let key = event.keyCode;
+        return (key >= 33 && key <= 40) || key === InputSpecialKey.RETURN || key === InputSpecialKey.TAB || key === InputSpecialKey.ESC;
+    },
+    isSpecialKey(event) {
+        let key = event.keyCode;
+        return key === 9 || key === 13 || key === 27 || key === 16 || key === 17 || (key >= 18 && key <= 20) ||
+            (DOMHelper.getBrowser().opera && !event.shiftKey && (key === 8 || (key >= 33 && key <= 35) || (key >= 36 && key <= 39) || (key >= 44 && key <= 45)));
+    },
+    getKey(event) {
+        return event.keyCode ?? event.charCode;
+    },
+    getCharCode(event) {
+        return event.charCode ?? event.keyCode ?? event.which;
+    },
+    validateEventValue(regex, event, value) {
+        const chars = value.split("");
+        for (const char of chars) {
+            if (!regex.test(char)) {
+                event.preventDefault();
+                return false;
+            }
+        }
+        return true;
+    },
+    validateEventKeyInput(regex, event) {
+        const browser = DOMHelper.getBrowser();
+        if (event.altKey || event.ctrlKey) {
+            return;
+        }
+        const key = this.getKey(event);
+        if (browser.mozilla && (this.isNavKeyPress(event) || (key === InputSpecialKey.DELETE && event.charCode === 0) || key === InputSpecialKey.BACKSPACE)) {
+            return;
+        }
+        const c = this.getCharCode(event);
+        const cc = String.fromCharCode(c);
+        if (browser.mozilla && (this.isSpecialKey(event) || !cc)) {
+            return;
+        }
+        const inputValid = regex.test(cc);
+        if (!inputValid) {
+            event.preventDefault();
+        }
+        return inputValid;
+    },
+    validate(value, filter) {
+        return !value || !filter || filter.test(value);
+    }
+};

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

@@ -0,0 +1,24 @@
+import React from "react";
+import { Scheme } from "../constants/Scheme";
+import { Alignment } from "../constants/Alignment";
+import { NoseurIconElement, NoseurLabel, NoseurObject } from "../constants/Types";
+export declare const MicroBuilder: {
+    ICON_COUNTER: number;
+    LABEL_COUNTER: number;
+    buildIcon(icon: NoseurIconElement, props?: {
+        scheme?: Scheme;
+        className?: string;
+        id?: string;
+        style?: React.CSSProperties;
+        relativeAlignment?: Alignment;
+        fillIcon?: boolean;
+        applyFaScheme?: boolean;
+    }, events?: NoseurObject<any>): React.JSX.Element | null;
+    buildLabel(label: NoseurLabel, props?: {
+        scheme: Scheme;
+        type?: string;
+        htmlFor?: string;
+        className?: string;
+        relativeAlignment?: Alignment;
+    }, events?: NoseurObject<any>): React.JSX.Element | null;
+};

package/dist/esm/utils/MicroBuilder.js

@@ -0,0 +1,61 @@
+import React from "react";
+import { Classname } from "./Classname";
+import { TypeChecker } from "./TypeChecker";
+import { ObjectHelper } from "./ObjectHelper";
+import { Alignment } from "../constants/Alignment";
+export const MicroBuilder = {
+    ICON_COUNTER: 0,
+    LABEL_COUNTER: 0,
+    buildIcon(icon, props, events) {
+        if (!icon) {
+            return null;
+        }
+        const isFontAwesomeIcon = TypeChecker.isTypeOfAny(icon, ["string"]);
+        const className = Classname.build(isFontAwesomeIcon ? icon : icon.props.className, {
+            "noseur-wd-auto": props?.fillIcon,
+            "noseur-mg-r-15": props?.relativeAlignment == Alignment.LEFT,
+            "noseur-mg-l-15": props?.relativeAlignment == Alignment.RIGHT,
+        }, (isFontAwesomeIcon && props?.scheme && props.applyFaScheme ? `${props.scheme}-tx` : null), "noseur-icon", props?.className);
+        const key = `icon-${++MicroBuilder.ICON_COUNTER}`;
+        if (!isFontAwesomeIcon) {
+            const iconProps = { ...icon.props };
+            ObjectHelper.addAll(iconProps, events);
+            iconProps.key = iconProps.key ?? key;
+            iconProps.id = iconProps.id ?? props?.id;
+            iconProps.key = props?.scheme ?? iconProps.scheme;
+            iconProps.style = { ...(iconProps.style), ...(props?.style) };
+            iconProps.className = Classname.build(className, iconProps.className);
+            return React.cloneElement(icon, iconProps);
+        }
+        return React.createElement("i", { key: key, className: className, id: props?.id, style: props?.style, ...events });
+    },
+    buildLabel(label, props, events) {
+        if (!label) {
+            return null;
+        }
+        const isRawString = TypeChecker.isTypeOfAny(label, ["string"]);
+        const className = Classname.build(!isRawString && props?.scheme ? `${props.scheme}-tx` : null, {
+            "noseur-mg-b-05rem": props?.relativeAlignment == Alignment.TOP,
+            "noseur-mg-r-05rem": props?.relativeAlignment == Alignment.LEFT,
+            "noseur-mg-l-05rem": props?.relativeAlignment == Alignment.RIGHT,
+            "noseur-mg-t-05rem": props?.relativeAlignment == Alignment.BOTTOM,
+        }, "noseur-label", props?.className, label.props?.className);
+        const key = `icon-${MicroBuilder.LABEL_COUNTER++}`;
+        if (!isRawString) {
+            const labelProps = { ...(label.props || {}) };
+            ObjectHelper.addAll(labelProps, events);
+            labelProps.className = className;
+            labelProps.key = labelProps.key || key;
+            labelProps.scheme = props?.scheme || labelProps.scheme;
+            return React.cloneElement(label, labelProps);
+        }
+        const rProps = {
+            key,
+            ...events,
+            className,
+        };
+        if (props?.htmlFor)
+            rProps.htmlFor = props?.htmlFor;
+        return (props?.type == "label" ? React.createElement("label", { ...rProps }, label) : React.createElement("span", { ...rProps }, label));
+    }
+};

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

@@ -0,0 +1,51 @@
+import React from "react";
+import { NoseurObject } from "../constants/Types";
+import { ComponentBaseProps } from "../core/ComponentBaseProps";
+export declare const ObjectHelper: {
+    isString(data: any): data is string;
+    findDiffKeys(primaryObj: NoseurObject<any>, checkerObj: NoseurObject<any>, exclusions?: string[]): NoseurObject<any>;
+    clone<T>(obj: any[] | NoseurObject<any> | T): T;
+    cloneArray(obj: any[]): any[];
+    cloneObject(obj: NoseurObject<any>): NoseurObject<any>;
+    addAll(target: NoseurObject<any>, source?: NoseurObject<any>): NoseurObject<any>;
+    conditionalClone(obj: NoseurObject<any>, conditionCallback: (key: string) => boolean): NoseurObject<any>;
+    extractEventProps(obj: NoseurObject<any>, excludes?: string[]): NoseurObject<any>;
+    resolveStringTemplate(unprocessed: string, valueMap: NoseurObject<any>): string;
+    toTitleCase(value: string): string;
+    resolveManageRef<T1, T2>(component: React.Component<ComponentBaseProps<T1, T2>, any>, funsies: T2): void;
+    resolveRef<T>(ref: React.ForwardedRef<T>, value?: T, always?: boolean): void;
+    expandStringTemplate(unprocessed: string, valueMap: NoseurObject<any>, options?: {
+        chop?: string;
+        prefix?: string;
+        suffix?: string;
+        seperator?: string;
+        relativeExpansion?: boolean;
+    }): string;
+    objectGetWithStringTemplate(valueMap: NoseurObject<any>, template: string, options?: {
+        prefix?: string;
+        suffix?: string;
+        optional?: string;
+        seperator?: string;
+    }): any;
+    joinValues(...values: any[]): any;
+    merge<T>(...obj: any[][] | NoseurObject<any>[] | T[]): any;
+    round(num: number): number;
+    object(obj: any): any;
+    getExtension(value: string, options?: {
+        delimiter?: string;
+        lastOnly?: boolean;
+        excludeDelimiter?: boolean;
+    }): string;
+    escapeCharacters(message: string): string;
+    resolveEnclosedValues(content: string, paramsMap: {
+        search: {
+            open: string;
+            close: string;
+        };
+        replace: {
+            open: string;
+            close: string;
+        };
+    }[]): string;
+    flattenChildren(propsChildren: any): any;
+};

package/dist/esm/utils/ObjectHelper.js

@@ -0,0 +1,334 @@
+import React from "react";
+import { TypeChecker } from "./TypeChecker";
+export const ObjectHelper = {
+    isString(data) {
+        return typeof data === 'string';
+    },
+    findDiffKeys(primaryObj, checkerObj, exclusions = []) {
+        if (!primaryObj || !checkerObj) {
+            return {};
+        }
+        return Object.keys(primaryObj).filter(key => !checkerObj.hasOwnProperty(key)).reduce((result, current) => {
+            if (!exclusions.includes(current))
+                result[current] = primaryObj[current];
+            return result;
+        }, {});
+    },
+    clone(obj) {
+        return (TypeChecker.isDict(obj) ? ObjectHelper.cloneObject(obj) : ObjectHelper.cloneArray(obj));
+    },
+    cloneArray(obj) {
+        var clone = [];
+        if (!obj) {
+            return clone;
+        }
+        for (const value of obj) {
+            clone.push(TypeChecker.isArray(value) ? ObjectHelper.clone(value) : value);
+        }
+        return clone;
+    },
+    cloneObject(obj) {
+        var clone = {};
+        if (!obj) {
+            return clone;
+        }
+        Object.keys(obj).map((key) => {
+            let value = obj[key];
+            clone[key] = TypeChecker.isArray(value) ? ObjectHelper.clone(value) : value;
+        });
+        return clone;
+    },
+    addAll(target, source) {
+        if (source)
+            Object.keys(source).map((key) => target[key] = source[key]);
+        return target;
+    },
+    conditionalClone(obj, conditionCallback) {
+        var clone = {};
+        if (!obj) {
+            return clone;
+        }
+        Object.keys(obj).map((key) => {
+            if (conditionCallback(key) === true) {
+                clone[key] = obj[key];
+            }
+        });
+        return clone;
+    },
+    extractEventProps(obj, excludes = []) {
+        return this.conditionalClone(obj, (key) => excludes.indexOf(key) === -1
+            && key.startsWith("on")
+            && key[2] != undefined
+            && key[2] == key[2].toUpperCase());
+    },
+    resolveStringTemplate(unprocessed, valueMap) {
+        let value = "";
+        let templateValue = "";
+        let openedTemplate = false;
+        for (let index = 0; index < unprocessed.length; index++) {
+            const ch = unprocessed[index];
+            if (ch == '{') {
+                openedTemplate = true;
+                continue;
+            }
+            if (ch == '}') {
+                value += valueMap[templateValue] || "";
+                openedTemplate = false;
+                templateValue = "";
+                continue;
+            }
+            ;
+            if (openedTemplate) {
+                templateValue += ch;
+            }
+            else {
+                value += ch;
+            }
+        }
+        return value;
+    },
+    toTitleCase(value) {
+        return (value && (value[0].toUpperCase() + value.substring(1).toLowerCase()));
+    },
+    resolveManageRef(component, funsies) {
+        const manageRef = component.props.manageRef;
+        if (!manageRef)
+            return;
+        if (manageRef instanceof Function) {
+            manageRef(funsies);
+        }
+        else {
+            manageRef.current = funsies;
+        }
+    },
+    resolveRef(ref, value, always = false) {
+        if (!ref || (!value && !always) || !ref)
+            return;
+        if (ref instanceof Function) {
+            ref(value ?? null);
+        }
+        else {
+            ref.current = value ?? null;
+        }
+    },
+    expandStringTemplate(unprocessed, valueMap, options = {}) {
+        let value = "";
+        var chopped = "";
+        let templateValue = "";
+        let openedTemplate = false;
+        let subValueMap = valueMap;
+        const chop = options.chop ?? '';
+        const prefix = options.prefix ?? '{';
+        const suffix = options.suffix ?? '}';
+        const seperator = options.seperator || '.';
+        for (let index = 0; index < unprocessed.length; index++) {
+            const ch = unprocessed[index];
+            if (ch === (options.chop) && unprocessed[index + 1] === prefix) {
+                continue;
+            }
+            if (ch === prefix) {
+                openedTemplate = true;
+                if (index > 0 && unprocessed[index - 1] === options.chop) {
+                    chopped = chop;
+                }
+                continue;
+            }
+            if (openedTemplate && ch === seperator) {
+                if (!(templateValue in subValueMap)) {
+                    value += `${chopped}${prefix}${templateValue}${seperator}`;
+                    openedTemplate = false;
+                    templateValue = "";
+                    chopped = "";
+                    continue;
+                }
+                subValueMap = subValueMap[templateValue];
+                templateValue = "";
+                chopped = "";
+                continue;
+            }
+            if (openedTemplate && ch === suffix) {
+                const actualTemplateValue = templateValue;
+                const defaultValSepIndex = templateValue.indexOf(":");
+                if (defaultValSepIndex > -1) {
+                    templateValue = actualTemplateValue.substring(0, defaultValSepIndex);
+                }
+                value += subValueMap[templateValue]
+                    ?? (options.relativeExpansion ? `${chopped}${prefix}${actualTemplateValue}${suffix}` : "");
+                subValueMap = valueMap;
+                openedTemplate = false;
+                templateValue = "";
+                chopped = "";
+                continue;
+            }
+            ;
+            if (openedTemplate) {
+                templateValue += ch;
+            }
+            else {
+                value += ch;
+            }
+        }
+        if (openedTemplate) {
+            value += `${chopped}${prefix}${templateValue}`;
+        }
+        else {
+            value += templateValue;
+        }
+        return value;
+    },
+    objectGetWithStringTemplate(valueMap, template, options = {}) {
+        let expandedString = "";
+        let templateValue = "";
+        let openedTemplate = false;
+        let subValueMap = valueMap;
+        let parsingAltValue = false;
+        const prefix = options.prefix ?? '{';
+        const suffix = options.suffix ?? '}';
+        const optional = options.optional ?? '?';
+        const seperator = options.seperator ?? '.';
+        const templateLength = template.length;
+        if (template.indexOf(prefix) < 0)
+            return subValueMap[template] ?? "";
+        for (let index = 0; index < templateLength; index++) {
+            const ch = template[index];
+            if (!parsingAltValue && ch == prefix) {
+                openedTemplate = true;
+                continue;
+            }
+            if (openedTemplate && ch == seperator) {
+                let altValue = templateValue.endsWith(optional) ? {} : undefined;
+                const splitted = templateValue.split(optional);
+                templateValue = splitted[0];
+                try {
+                    altValue = JSON.parse(splitted[1]);
+                }
+                catch (_) { }
+                subValueMap = subValueMap[templateValue] ?? altValue;
+                templateValue = "";
+                continue;
+            }
+            if (ch == suffix) {
+                if (parsingAltValue && templateValue[templateValue.length - 1] !== optional) {
+                    parsingAltValue = false;
+                    templateValue += suffix;
+                    continue;
+                }
+                openedTemplate = false;
+                parsingAltValue = false;
+                let altValue = templateValue.endsWith(optional) ? "" : undefined;
+                const splitted = templateValue.split(optional);
+                templateValue = splitted[0];
+                if (splitted.length > 1)
+                    altValue = splitted[1];
+                expandedString += subValueMap[templateValue] ?? altValue;
+                subValueMap = valueMap;
+                templateValue = "";
+                continue;
+            }
+            ;
+            if (openedTemplate) {
+                templateValue += ch;
+                if (ch === optional && ((index + 1) < templateLength) && template[index + 1] === prefix)
+                    parsingAltValue = true;
+            }
+            else {
+                expandedString += ch;
+            }
+        }
+        return expandedString;
+    },
+    joinValues(...values) {
+        if (!values.length)
+            return;
+        if (TypeChecker.isObject(values[0])) {
+            return values.reduce((acc, value) => {
+                if (value)
+                    Object.keys(value).forEach((key) => acc[key] = value[key]);
+                return acc;
+            }, {});
+        }
+        if (TypeChecker.isArray(values[0])) {
+            return values.reduce((acc, value) => {
+                if (!value)
+                    return acc;
+                return acc.concat(value);
+            }, []);
+        }
+        if (TypeChecker.isString(values[0]) || TypeChecker.isNumber(values[0])) {
+            return values.reduce((acc, value) => {
+                if (!value)
+                    return acc;
+                return acc + value;
+            }, "");
+        }
+        return values;
+    },
+    merge(...obj) {
+        if (!obj.length)
+            return {};
+        const isObject = TypeChecker.isDict(obj[0]);
+        let result = ObjectHelper.clone(obj[0]);
+        for (let index = 1; index < obj.length; index++) {
+            const entry = ObjectHelper.clone(obj[index]);
+            if (isObject) {
+                Object.keys(entry).map((key) => {
+                    result[key] = entry[key];
+                });
+                continue;
+            }
+            result.concat(entry);
+        }
+        return result;
+    },
+    round(num) {
+        return Math.round((num + Number.EPSILON) * 100) / 100;
+    },
+    object(obj) {
+        if (!TypeChecker.isObject(obj))
+            return {};
+        return obj;
+    },
+    getExtension(value, options) {
+        const delimiter = options?.delimiter ?? ".";
+        if (options?.lastOnly)
+            return value.substring(value.lastIndexOf(delimiter) + (options.excludeDelimiter ? 1 : 0));
+        return value.substring(0, value.indexOf(delimiter));
+    },
+    escapeCharacters(message) {
+        let messagePart = message.split("");
+        for (let index = 0; index < messagePart.length; index++) {
+            let char = messagePart[index];
+            if ("~!@#$%^&*()_+-={}[]<>?".includes(char)) {
+                char = "\\" + char;
+            }
+            messagePart[index] = char;
+        }
+        return messagePart.join("");
+    },
+    resolveEnclosedValues(content, paramsMap) {
+        let resolvedContent = content;
+        for (const params of paramsMap) {
+            let { open: searchOpen, close: searchClose } = params.search;
+            let { open: replaceOpen, close: replaceClose } = params.replace;
+            let escapedSearchOpen = ObjectHelper.escapeCharacters(searchOpen);
+            let escapedSearchClose = ObjectHelper.escapeCharacters(searchClose);
+            resolvedContent = resolvedContent.replace(new RegExp(escapedSearchOpen + `*([\\w&,.+×÷=/-<>\\[\\]():\\s+])+` + escapedSearchClose, "g"), (m, _) => {
+                const value = (m.replaceAll(searchOpen, "")?.replaceAll(searchClose, "") ?? "");
+                return `${replaceOpen}${value}${replaceClose}`;
+            });
+        }
+        return resolvedContent;
+    },
+    flattenChildren(propsChildren) {
+        const _children = propsChildren.length ? propsChildren : [propsChildren];
+        let children = [];
+        for (const child of _children) {
+            if (child.type === React.Fragment && child.props.children) {
+                children.push(...ObjectHelper.flattenChildren(child.props.children));
+                continue;
+            }
+            children.push(child);
+        }
+        return children;
+    },
+};

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

@@ -0,0 +1,10 @@
+export declare const StringHelper: {
+    segmentSplit(value: string, sep?: string): string[];
+    toSaneSentenceFormat(value: string, ignore?: boolean): string;
+    toPresentableMoneyValue(amount: number, options?: {
+        divisor?: number;
+        decimal?: number;
+        separator?: string;
+    }): string;
+    randomString(length?: number, characters?: string): string;
+};

package/dist/esm/utils/StringHelper.js

@@ -0,0 +1,54 @@
+export const StringHelper = {
+    segmentSplit(value, sep = "/") {
+        return value.split(sep).filter(s => s !== "");
+    },
+    toSaneSentenceFormat(value, ignore) {
+        if (ignore || !value)
+            return value;
+        return value.split("_").map(e => e[0].toUpperCase() + e.substring(1).toLowerCase()).join(" ");
+    },
+    toPresentableMoneyValue(amount, options = {
+        decimal: 2,
+        separator: ",",
+        divisor: 1000000,
+    }) {
+        let amountStr;
+        let isNegative = false;
+        if (options?.divisor)
+            amount /= options?.divisor;
+        if (amount < 0) {
+            isNegative = true;
+            amount = Math.abs(amount);
+        }
+        amountStr = String(amount);
+        if (options?.decimal)
+            amountStr = amount.toFixed(options?.decimal);
+        if (options?.separator) {
+            let reversedComma = [];
+            const amountMainParts = (amountStr.substring(0, amountStr.indexOf("."))).split("");
+            for (let index = amountMainParts.length - 1; index >= 0; index -= 3) {
+                reversedComma.push(amountMainParts[index]);
+                if (index === 0)
+                    continue;
+                reversedComma.push(amountMainParts[index - 1]);
+                if ((index - 2) < 0)
+                    continue;
+                reversedComma.push(amountMainParts[index - 2]);
+                if ((index - 2) !== 0)
+                    reversedComma.push(",");
+            }
+            amountStr = reversedComma.reverse().join("") + amountStr.substring(amountStr.indexOf("."));
+        }
+        return (isNegative ? "-" : "") + amountStr;
+    },
+    randomString(length = 10, characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
+        let result = '';
+        const charactersLength = characters.length;
+        let counter = 0;
+        while (counter < length) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+            counter += 1;
+        }
+        return result;
+    },
+};

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

@@ -0,0 +1,14 @@
+import { NoseurObject } from "../constants/Types";
+export type Subscription = (...data: any) => void;
+export type SecondaryDataSubscription = (secondaryData: NoseurObject<any>) => void;
+export declare const Subscriber: {
+    KEYS: {
+        SECONDARY_DATA: string;
+    };
+    __subscriptions: NoseurObject<Subscription[]>;
+    subscribe: (key: string, subscription: Subscription) => void;
+    unSubscribe: (key: string, subscription: Subscription) => void;
+    report(key: string, ...data: any): void;
+    subscriptions: (key?: string) => Subscription[] | NoseurObject<Subscription[]>;
+    clearSubscriptions: (key?: string) => {} | undefined;
+};

package/dist/esm/utils/Subscriber.js

@@ -0,0 +1,27 @@
+export const Subscriber = {
+    KEYS: {
+        SECONDARY_DATA: "SECONDARY_DATA",
+    },
+    __subscriptions: {},
+    subscribe: (key, subscription) => {
+        if (!(key in Subscriber.__subscriptions))
+            Subscriber.__subscriptions[key] = [];
+        if (Subscriber.__subscriptions[key].includes(subscription))
+            return;
+        Subscriber.__subscriptions[key].push(subscription);
+    },
+    unSubscribe: (key, subscription) => {
+        if (!(key in Subscriber.__subscriptions))
+            return;
+        const index = Subscriber.__subscriptions[key].indexOf(subscription);
+        if (index > -1)
+            Subscriber.__subscriptions[key].splice(index, 1);
+    },
+    report(key, ...data) {
+        if (!(key in Subscriber.__subscriptions))
+            return;
+        Subscriber.__subscriptions[key].forEach(subscription => subscription(...data));
+    },
+    subscriptions: (key) => key ? Subscriber.__subscriptions[key] : Subscriber.__subscriptions,
+    clearSubscriptions: (key) => key ? ((key in Subscriber.__subscriptions) ? delete Subscriber.__subscriptions[key] : undefined) : Subscriber.__subscriptions = {},
+};

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

@@ -0,0 +1,32 @@
+import { NoseurObject } from "../constants/Types";
+export interface TimerCallbacks {
+    onEnd?: () => void;
+    onStop?: () => void;
+    onStart?: () => void;
+    onPause?: () => void;
+    onResume?: () => void;
+    onRestart?: () => void;
+    action?: (...args: any[]) => void;
+    onAction?: (percentage: number) => void;
+}
+export interface TimerOption {
+    delay?: number;
+    timeout: number;
+    cbs?: TimerCallbacks;
+    isInterval?: boolean;
+}
+export declare class Timer {
+    timer?: number;
+    startTime?: number;
+    cbs?: TimerCallbacks;
+    isInterval?: boolean;
+    totalTicks: number;
+    elapseTicks: number;
+    options: NoseurObject<any>;
+    constructor(options: TimerOption, ...args: any[]);
+    start(__resumed__?: boolean): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    restart(timeout?: number): void;
+}