@soyfri/template 1.0.0

package/README.md

@@ -0,0 +1,39 @@
+# Metronic Template NPM Package
+
+This NPM package provides essential utilities for integrating the Metronic theme into React projects. It includes helper functions, utility variables, and classes that facilitate the development of consistent and responsive user interfaces.
+
+## Features
+
+- **Theme Layout Helpers**: Functions to streamline the implementation of Metronic's layout components.
+- **Utility Variables**: Predefined variables for consistent theming and styling across your application.
+- **CSS Utility Classes**: A collection of classes to apply common styles effortlessly.
+
+## Installation
+
+To install the package, run:
+
+```bash
+npm install metronic-template
+```
+
+## Usage
+
+Import the necessary utilities into your React project:
+
+```javascript
+import { layoutHelper } from 'metronic-template';
+// Use layoutHelper in your component
+```
+
+## Dependencies
+
+This package serves as a core dependency for multiple React projects, ensuring a unified integration of the Metronic theme.
+
+## Repository
+
+For more information, documentation, and contributions, visit the GitHub repository: [Metronic Template](https://github.com/soyfrii/Metronic-template)
+
+## License
+
+This project is licensed under the MIT License.
+

package/dist/assets/ts/_utils/DomHelpers.d.ts

@@ -0,0 +1,29 @@
+import { OffsetModel } from './models/OffsetModel';
+import { ViewPortModel } from './models/ViewPortModel';
+declare function getCSS(el: HTMLElement, styleProp: string): string;
+declare function getCSSVariableValue(variableName: string): string;
+declare function getElementActualCss(el: HTMLElement, prop: any, cache: boolean): number | undefined;
+declare function getElementActualHeight(el: HTMLElement): number | undefined;
+declare function getElementActualWidth(el: HTMLElement, cache?: boolean): number | undefined;
+declare function getElementIndex(element: HTMLElement): number;
+declare function getElementMatches(element: HTMLElement, selector: string): boolean;
+declare function getElementOffset(el: HTMLElement): OffsetModel;
+declare function getElementParents(element: Element, selector: string): Element[];
+declare function getHighestZindex(el: HTMLElement): number | null;
+declare function getScrollTop(): number;
+declare function getViewPort(): ViewPortModel;
+declare function insertAfterElement(el: HTMLElement, referenceNode: HTMLElement): HTMLElement | undefined;
+declare function isElementHasClasses(element: HTMLElement, classesStr: string): boolean;
+declare function isVisibleElement(element: HTMLElement): boolean;
+declare function throttle(timer: number | undefined, func: Function, delay?: number): void;
+declare function getElementChildren(element: HTMLElement, selector: string): Array<HTMLElement> | null;
+declare function getElementChild(element: HTMLElement, selector: string): HTMLElement | null;
+declare function isMobileDevice(): boolean;
+declare function slide(el: HTMLElement, dir: string, speed: number, callback: any): void;
+declare function slideUp(el: HTMLElement, speed: number, callback: any): void;
+declare function slideDown(el: HTMLElement, speed: number, callback: any): void;
+declare function getBreakpoint(breakpoint: string): string | number;
+declare function getAttributeValueByBreakpoint(incomingAttr: string): string | JSON;
+declare function colorLighten(color: string, amount: number): string;
+declare function colorDarken(color: string, amount: number): string;
+export { getBreakpoint, getCSS, getCSSVariableValue, getElementActualCss, getElementActualHeight, getElementActualWidth, getElementIndex, getElementMatches, getElementOffset, getElementParents, getHighestZindex, getScrollTop, getViewPort, insertAfterElement, isElementHasClasses, isVisibleElement, throttle, getElementChildren, getElementChild, isMobileDevice, slide, slideUp, slideDown, getAttributeValueByBreakpoint, colorLighten, colorDarken, };

package/dist/assets/ts/_utils/DomHelpers.js

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorDarken = exports.colorLighten = exports.getAttributeValueByBreakpoint = exports.slideDown = exports.slideUp = exports.slide = exports.isMobileDevice = exports.getElementChild = exports.getElementChildren = exports.throttle = exports.isVisibleElement = exports.isElementHasClasses = exports.insertAfterElement = exports.getViewPort = exports.getScrollTop = exports.getHighestZindex = exports.getElementParents = exports.getElementOffset = exports.getElementMatches = exports.getElementIndex = exports.getElementActualWidth = exports.getElementActualHeight = exports.getElementActualCss = exports.getCSSVariableValue = exports.getCSS = exports.getBreakpoint = void 0;
+var _ElementStyleUtil_1 = require("./_ElementStyleUtil");
+var _DataUtil_1 = require("./_DataUtil");
+var ElementAnimateUtil_1 = require("./ElementAnimateUtil");
+var _TypesHelpers_1 = require("./_TypesHelpers");
+function getCSS(el, styleProp) {
+    var defaultView = (el.ownerDocument || document).defaultView;
+    if (!defaultView) {
+        return '';
+    }
+    // sanitize property name to css notation
+    // (hyphen separated words eg. font-Size)
+    styleProp = styleProp.replace(/([A-Z])/g, '-$1').toLowerCase();
+    return defaultView.getComputedStyle(el, null).getPropertyValue(styleProp);
+}
+exports.getCSS = getCSS;
+function getCSSVariableValue(variableName) {
+    var hex = getComputedStyle(document.documentElement).getPropertyValue(variableName);
+    if (hex && hex.length > 0) {
+        hex = hex.trim();
+    }
+    return hex;
+}
+exports.getCSSVariableValue = getCSSVariableValue;
+function getElementActualCss(el, prop, cache) {
+    var css = '';
+    if (!el.getAttribute('kt-hidden-' + prop) || cache === false) {
+        var value 
+        // the element is hidden so:
+        // making the el block so we can meassure its height but still be hidden
+        = void 0;
+        // the element is hidden so:
+        // making the el block so we can meassure its height but still be hidden
+        css = el.style.cssText;
+        el.style.cssText = 'position: absolute; visibility: hidden; display: block;';
+        if (prop === 'width') {
+            value = el.offsetWidth;
+        }
+        else if (prop === 'height') {
+            value = el.offsetHeight;
+        }
+        el.style.cssText = css;
+        // store it in cache
+        if (value !== undefined) {
+            el.setAttribute('kt-hidden-' + prop, value.toString());
+            return parseFloat(value.toString());
+        }
+        return 0;
+    }
+    else {
+        // store it in cache
+        var attributeValue = el.getAttribute('kt-hidden-' + prop);
+        if (attributeValue || attributeValue === '0') {
+            return parseFloat(attributeValue);
+        }
+    }
+}
+exports.getElementActualCss = getElementActualCss;
+function getElementActualHeight(el) {
+    return getElementActualCss(el, 'height', false);
+}
+exports.getElementActualHeight = getElementActualHeight;
+function getElementActualWidth(el, cache) {
+    return getElementActualCss(el, 'width', false);
+}
+exports.getElementActualWidth = getElementActualWidth;
+function getElementIndex(element) {
+    if (element.parentNode) {
+        var c = element.parentNode.children;
+        for (var i = 0; i < c.length; i++) {
+            if (c[i] === element)
+                return i;
+        }
+    }
+    return -1;
+}
+exports.getElementIndex = getElementIndex;
+// https://developer.mozilla.org/en-US/docs/Web/API/Element/matches
+function getElementMatches(element, selector) {
+    var p = Element.prototype;
+    var f = p.matches || p.webkitMatchesSelector;
+    if (element && element.tagName) {
+        return f.call(element, selector);
+    }
+    else {
+        return false;
+    }
+}
+exports.getElementMatches = getElementMatches;
+function getElementOffset(el) {
+    // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+    // Support: IE <=11 only
+    // Running getBoundingClientRect on a
+    // disconnected node in IE throws an error
+    if (!el.getClientRects().length) {
+        return { top: 0, left: 0 };
+    }
+    // Get document-relative position by adding viewport scroll to viewport-relative gBCR
+    var rect = el.getBoundingClientRect();
+    var win = el.ownerDocument.defaultView;
+    if (win) {
+        return {
+            top: rect.top + win.pageYOffset,
+            left: rect.left + win.pageXOffset,
+        };
+    }
+    return rect;
+}
+exports.getElementOffset = getElementOffset;
+function getElementParents(element, selector) {
+    // Element.matches() polyfill
+    if (!Element.prototype.matches) {
+        Element.prototype.matches = function (s) {
+            var matches = (document || this.ownerDocument).querySelectorAll(s);
+            var i = matches.length;
+            while (--i >= 0 && matches.item(i) !== this) { }
+            return i > -1;
+        };
+    }
+    // Set up a parent array
+    var parents = [];
+    var el = element;
+    // Push each parent element to the array
+    for (; el && el !== document.body; el = el.parentElement) {
+        if (selector) {
+            if (el.matches(selector)) {
+                parents.push(el);
+            }
+            continue;
+        }
+        parents.push(el);
+    }
+    // Return our parent array
+    return parents;
+}
+exports.getElementParents = getElementParents;
+function getHighestZindex(el) {
+    var bufferNode = el;
+    var buffer = el;
+    while (bufferNode && bufferNode !== document) {
+        // Ignore z-index if position is set to a value where z-index is ignored by the browser
+        // This makes behavior of this function consistent across browsers
+        // WebKit always returns auto if the element is positioned
+        var position = buffer.style.getPropertyValue('position');
+        if (position === 'absolute' || position === 'relative' || position === 'fixed') {
+            // IE returns 0 when zIndex is not specified
+            // other browsers return a string
+            // we ignore the case of nested elements with an explicit value of 0
+            // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
+            var value = parseInt(buffer.style.getPropertyValue('z-index'));
+            if (!isNaN(value) && value !== 0) {
+                return value;
+            }
+        }
+        bufferNode = bufferNode.parentNode;
+        buffer = bufferNode;
+    }
+    return null;
+}
+exports.getHighestZindex = getHighestZindex;
+function getScrollTop() {
+    return (document.scrollingElement || document.documentElement).scrollTop;
+}
+exports.getScrollTop = getScrollTop;
+// https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth
+function getViewPort() {
+    return {
+        width: window.innerWidth,
+        height: window.innerHeight,
+    };
+}
+exports.getViewPort = getViewPort;
+function insertAfterElement(el, referenceNode) {
+    var _a;
+    return (_a = referenceNode.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(el, referenceNode.nextSibling);
+}
+exports.insertAfterElement = insertAfterElement;
+function isElementHasClasses(element, classesStr) {
+    var classes = classesStr.split(' ');
+    for (var i = 0; i < classes.length; i++) {
+        if (!element.classList.contains(classes[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isElementHasClasses = isElementHasClasses;
+function isVisibleElement(element) {
+    return !(element.offsetWidth === 0 && element.offsetHeight === 0);
+}
+exports.isVisibleElement = isVisibleElement;
+// Throttle function: Input as function which needs to be throttled and delay is the time interval in milliseconds
+function throttle(timer, func, delay) {
+    // If setTimeout is already scheduled, no need to do anything
+    if (timer) {
+        return;
+    }
+    // Schedule a setTimeout after delay seconds
+    timer = window.setTimeout(function () {
+        func();
+        // Once setTimeout function execution is finished, timerId = undefined so that in <br>
+        // the next scroll event function execution can be scheduled by the setTimeout
+        timer = undefined;
+    }, delay);
+}
+exports.throttle = throttle;
+function getElementChildren(element, selector) {
+    if (!element || !element.childNodes) {
+        return null;
+    }
+    var result = [];
+    for (var i = 0; i < element.childNodes.length; i++) {
+        var child = element.childNodes[i];
+        // child.nodeType == 1 => Element, Text, Comment, ProcessingInstruction, CDATASection, EntityReference
+        if (child.nodeType === 1 && getElementMatches(child, selector)) {
+            result.push(child);
+        }
+    }
+    return result;
+}
+exports.getElementChildren = getElementChildren;
+function getElementChild(element, selector) {
+    var children = getElementChildren(element, selector);
+    return children ? children[0] : null;
+}
+exports.getElementChild = getElementChild;
+function isMobileDevice() {
+    var test = getViewPort().width < +getBreakpoint('lg') ? true : false;
+    if (test === false) {
+        // For use within normal web clients
+        test = navigator.userAgent.match(/iPad/i) != null;
+    }
+    return test;
+}
+exports.isMobileDevice = isMobileDevice;
+function slide(el, dir, speed, callback) {
+    if (!el ||
+        (dir === 'up' && isVisibleElement(el) === false) ||
+        (dir === 'down' && isVisibleElement(el) === true)) {
+        return;
+    }
+    speed = speed ? speed : 600;
+    var calcHeight = getElementActualHeight(el);
+    var calcPaddingTop = 0;
+    var calcPaddingBottom = 0;
+    if (_ElementStyleUtil_1.ElementStyleUtil.get(el, 'padding-top') && _DataUtil_1.DataUtil.get(el, 'slide-padding-top') !== true) {
+        _DataUtil_1.DataUtil.set(el, 'slide-padding-top', _ElementStyleUtil_1.ElementStyleUtil.get(el, 'padding-top'));
+    }
+    if (_ElementStyleUtil_1.ElementStyleUtil.get(el, 'padding-bottom') &&
+        _DataUtil_1.DataUtil.has(el, 'slide-padding-bottom') !== true) {
+        _DataUtil_1.DataUtil.set(el, 'slide-padding-bottom', _ElementStyleUtil_1.ElementStyleUtil.get(el, 'padding-bottom'));
+    }
+    if (_DataUtil_1.DataUtil.has(el, 'slide-padding-top')) {
+        var data = _DataUtil_1.DataUtil.get(el, 'slide-padding-top');
+        calcPaddingTop = parseInt(data);
+    }
+    if (_DataUtil_1.DataUtil.has(el, 'slide-padding-bottom')) {
+        var data = _DataUtil_1.DataUtil.get(el, 'slide-padding-bottom');
+        calcPaddingBottom = parseInt(data);
+    }
+    if (dir === 'up') {
+        // up
+        el.style.cssText = 'display: block; overflow: hidden;';
+        if (calcPaddingTop) {
+            ElementAnimateUtil_1.ElementAnimateUtil.animate(0, calcPaddingTop, speed, function (value) {
+                el.style.paddingTop = calcPaddingTop - value + 'px';
+            });
+        }
+        if (calcPaddingBottom) {
+            ElementAnimateUtil_1.ElementAnimateUtil.animate(0, calcPaddingBottom, speed, function (value) {
+                el.style.paddingBottom = calcPaddingBottom - value + 'px';
+            });
+        }
+        ElementAnimateUtil_1.ElementAnimateUtil.animate(0, calcHeight || 0, speed, function (value) {
+            el.style.height = (calcHeight || 0) - value + 'px';
+        }, function () {
+            el.style.height = '';
+            el.style.display = 'none';
+            if (typeof callback === 'function') {
+                callback();
+            }
+        });
+    }
+    else if (dir === 'down') {
+        // down
+        el.style.cssText = 'display: block; overflow: hidden;';
+        if (calcPaddingTop) {
+            ElementAnimateUtil_1.ElementAnimateUtil.animate(0, calcPaddingTop, speed, function (value) {
+                //
+                el.style.paddingTop = value + 'px';
+            }, function () {
+                el.style.paddingTop = '';
+            });
+        }
+        if (calcPaddingBottom) {
+            ElementAnimateUtil_1.ElementAnimateUtil.animate(0, calcPaddingBottom, speed, function (value) {
+                el.style.paddingBottom = value + 'px';
+            }, function () {
+                el.style.paddingBottom = '';
+            });
+        }
+        ElementAnimateUtil_1.ElementAnimateUtil.animate(0, calcHeight || 0, speed, function (value) {
+            el.style.height = value + 'px';
+        }, function () {
+            el.style.height = '';
+            el.style.display = '';
+            el.style.overflow = '';
+            if (typeof callback === 'function') {
+                callback();
+            }
+        });
+    }
+}
+exports.slide = slide;
+function slideUp(el, speed, callback) {
+    slide(el, 'up', speed, callback);
+}
+exports.slideUp = slideUp;
+function slideDown(el, speed, callback) {
+    slide(el, 'down', speed, callback);
+}
+exports.slideDown = slideDown;
+function getBreakpoint(breakpoint) {
+    var value = getCSSVariableValue('--bs-' + breakpoint);
+    if (value) {
+        value = parseInt(value.trim());
+    }
+    return value;
+}
+exports.getBreakpoint = getBreakpoint;
+function getAttributeValueByBreakpoint(incomingAttr) {
+    var value = (0, _TypesHelpers_1.toJSON)(incomingAttr);
+    if (typeof value !== 'object') {
+        return incomingAttr;
+    }
+    var width = getViewPort().width;
+    var resultKey;
+    var resultBreakpoint = -1;
+    var breakpoint;
+    for (var key in value) {
+        if (key === 'default') {
+            breakpoint = 0;
+        }
+        else {
+            breakpoint = getBreakpoint(key) ? +getBreakpoint(key) : parseInt(key);
+        }
+        if (breakpoint <= width && breakpoint > resultBreakpoint) {
+            resultKey = key;
+            resultBreakpoint = breakpoint;
+        }
+    }
+    return resultKey ? (0, _TypesHelpers_1.getObjectPropertyValueByKey)(value, resultKey) : value;
+}
+exports.getAttributeValueByBreakpoint = getAttributeValueByBreakpoint;
+function colorLighten(color, amount) {
+    var addLight = function (_color, _amount) {
+        var cc = parseInt(_color, 16) + _amount;
+        var cNum = cc > 255 ? 255 : cc;
+        var c = cNum.toString(16).length > 1 ? cNum.toString(16) : "0".concat(cNum.toString(16));
+        return c;
+    };
+    color = color.indexOf('#') >= 0 ? color.substring(1, color.length) : color;
+    amount = parseInt(((255 * amount) / 100).toString());
+    return (color = "#".concat(addLight(color.substring(0, 2), amount)).concat(addLight(color.substring(2, 4), amount)).concat(addLight(color.substring(4, 6), amount)));
+}
+exports.colorLighten = colorLighten;
+function colorDarken(color, amount) {
+    var subtractLight = function (_color, _amount) {
+        var cc = parseInt(color, 16) - amount;
+        var cNum = cc < 0 ? 0 : cc;
+        var c = cNum.toString(16).length > 1 ? cNum.toString(16) : "0".concat(cNum.toString(16));
+        return c;
+    };
+    color = color.indexOf('#') >= 0 ? color.substring(1, color.length) : color;
+    amount = parseInt(((255 * amount) / 100).toString());
+    return (color = "#".concat(subtractLight(color.substring(0, 2), amount)).concat(subtractLight(color.substring(2, 4), amount)).concat(subtractLight(color.substring(4, 6), amount)));
+}
+exports.colorDarken = colorDarken;

package/dist/assets/ts/_utils/ElementAnimateUtil.d.ts

@@ -0,0 +1,10 @@
+export declare class ElementAnimateUtil {
+    static animate(from: number, to: number, duration: number, update: Function, complete?: Function): void;
+    static animateClass(element: HTMLElement, animationName: string, callBack?: Function): void;
+    static transitionEnd(element: HTMLElement, callBack: Function): void;
+    static animationEnd(element: HTMLElement, callBack: Function): void;
+    static animationDelay(element: HTMLElement, value: string): void;
+    static animationDuration(element: HTMLElement, value: string): void;
+    static scrollTo(element: HTMLElement | null, offset: number, duration?: number): void;
+    static scrollTop(offset: number, duration: number): void;
+}

package/dist/assets/ts/_utils/ElementAnimateUtil.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementAnimateUtil = void 0;
+var _DOMEventHandlerUtil_1 = require("./_DOMEventHandlerUtil");
+var _ElementStyleUtil_1 = require("./_ElementStyleUtil");
+var DomHelpers_1 = require("./DomHelpers");
+var ElementAnimateUtil = /** @class */ (function () {
+    function ElementAnimateUtil() {
+    }
+    ElementAnimateUtil.animate = function (from, to, duration, update, complete) {
+        /**
+         * TinyAnimate.easings
+         *  Adapted from jQuery Easing
+         */
+        var easings = {
+            linear: function (t, b, c, d) {
+                return (c * t) / d + b;
+            },
+        };
+        // Create mock done() function if necessary
+        if (!complete) {
+            complete = function () { };
+        }
+        // Animation loop
+        // let canceled = false;
+        var change = to - from;
+        function loop(timestamp) {
+            var time = (timestamp || +new Date()) - start;
+            if (time >= 0) {
+                update(easings.linear(time, from, change, duration));
+            }
+            if (time >= 0 && time >= duration) {
+                update(to);
+                if (complete) {
+                    complete();
+                }
+            }
+            else {
+                window.requestAnimationFrame(loop);
+            }
+        }
+        update(from);
+        // Start animation loop
+        var start = window.performance && window.performance.now ? window.performance.now() : +new Date();
+        window.requestAnimationFrame(loop);
+    };
+    ElementAnimateUtil.animateClass = function (element, animationName, callBack) {
+        var animateClasses = animationName.split(' ');
+        animateClasses.forEach(function (cssClass) { return element.classList.add(cssClass); });
+        _DOMEventHandlerUtil_1.DOMEventHandlerUtil.one(element, 'animationend', function () {
+            animateClasses.forEach(function (cssClass) { return element.classList.remove(cssClass); });
+        });
+        if (callBack) {
+            _DOMEventHandlerUtil_1.DOMEventHandlerUtil.one(element, 'animationend', callBack);
+        }
+    };
+    ElementAnimateUtil.transitionEnd = function (element, callBack) {
+        _DOMEventHandlerUtil_1.DOMEventHandlerUtil.one(element, 'transitionend', callBack);
+    };
+    ElementAnimateUtil.animationEnd = function (element, callBack) {
+        _DOMEventHandlerUtil_1.DOMEventHandlerUtil.one(element, 'animationend', callBack);
+    };
+    ElementAnimateUtil.animationDelay = function (element, value) {
+        _ElementStyleUtil_1.ElementStyleUtil.set(element, 'animation-delay', value);
+    };
+    ElementAnimateUtil.animationDuration = function (element, value) {
+        _ElementStyleUtil_1.ElementStyleUtil.set(element, 'animation-duration', value);
+    };
+    ElementAnimateUtil.scrollTo = function (element, offset, duration) {
+        if (duration === void 0) { duration = 500; }
+        var targetPos = element ? (0, DomHelpers_1.getElementOffset)(element).top : 0;
+        var scrollPos = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+        if (offset) {
+            scrollPos += offset;
+            targetPos = targetPos - offset;
+        }
+        var from = scrollPos;
+        var to = targetPos;
+        ElementAnimateUtil.animate(from, to, duration, function (value) {
+            document.documentElement.scrollTop = value;
+            // document.body.parentNode.scrollTop = value;
+            document.body.scrollTop = value;
+        }); //, easing, done
+    };
+    ElementAnimateUtil.scrollTop = function (offset, duration) {
+        ElementAnimateUtil.scrollTo(null, offset, duration);
+    };
+    return ElementAnimateUtil;
+}());
+exports.ElementAnimateUtil = ElementAnimateUtil;

package/dist/assets/ts/_utils/EventHandlerUtil.d.ts

@@ -0,0 +1,24 @@
+export interface EventMeta {
+    name: string;
+    callback: Function;
+    one: boolean;
+    fired: boolean;
+}
+export declare class EventHandlerUtil {
+    static store: {
+        [name: string]: {
+            [handlerId: string]: EventMeta;
+        };
+    };
+    private static setEventMetasByName;
+    private static getEventMetaByName;
+    private static setEventMetaByNameAndHandlerId;
+    private static getEventMetaByHandlerId;
+    private static setFiredByNameAndHandlerId;
+    private static addEvent;
+    private static removeEvent;
+    static trigger(element: HTMLElement, name: string, target?: any, e?: Event): boolean;
+    static on: (element: HTMLElement, name: string, callBack: Function) => void;
+    static one(element: HTMLElement, name: string, callBack: Function): void;
+    static off(element: HTMLElement, name: string, handerId: string): void;
+}

package/dist/assets/ts/_utils/EventHandlerUtil.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandlerUtil = void 0;
+var _DataUtil_1 = require("./_DataUtil");
+var _TypesHelpers_1 = require("./_TypesHelpers");
+var EventHandlerUtil = /** @class */ (function () {
+    function EventHandlerUtil() {
+    }
+    EventHandlerUtil.setEventMetasByName = function (name, handlers) {
+        EventHandlerUtil.store[name] = handlers;
+    };
+    EventHandlerUtil.getEventMetaByName = function (name) {
+        return EventHandlerUtil.store[name];
+    };
+    EventHandlerUtil.setEventMetaByNameAndHandlerId = function (name, handlerId, meta) {
+        if (EventHandlerUtil.store[name]) {
+            EventHandlerUtil.store[name][handlerId] = meta;
+            return;
+        }
+        EventHandlerUtil.store[name] = {};
+        EventHandlerUtil.store[name][handlerId] = meta;
+    };
+    EventHandlerUtil.getEventMetaByHandlerId = function (name, handlerId) {
+        var handlersIds = EventHandlerUtil.store[name];
+        if (!handlersIds) {
+            return;
+        }
+        return handlersIds[handlerId];
+    };
+    EventHandlerUtil.setFiredByNameAndHandlerId = function (name, handerId, fired) {
+        var meta = EventHandlerUtil.getEventMetaByHandlerId(name, handerId);
+        if (!meta) {
+            return;
+        }
+        meta.fired = fired;
+        EventHandlerUtil.setEventMetaByNameAndHandlerId(name, handerId, meta);
+    };
+    EventHandlerUtil.addEvent = function (element, name, callback, one) {
+        if (one === void 0) { one = false; }
+        var handlerId = (0, _TypesHelpers_1.getUniqueIdWithPrefix)('event');
+        var data = _DataUtil_1.DataUtil.get(element, name);
+        var handlersIds = data ? data : [];
+        handlersIds.push(handlerId);
+        _DataUtil_1.DataUtil.set(element, name, handlersIds);
+        var meta = {
+            name: name,
+            callback: callback,
+            one: one,
+            fired: false,
+        };
+        EventHandlerUtil.setEventMetaByNameAndHandlerId(name, handlerId, meta);
+        return handlerId;
+    };
+    EventHandlerUtil.removeEvent = function (element, name, handerId) {
+        _DataUtil_1.DataUtil.removeOne(element, name, handerId);
+        var handlersIds = EventHandlerUtil.store[name];
+        if (handlersIds) {
+            return;
+        }
+        delete EventHandlerUtil.store[name][handerId];
+    };
+    EventHandlerUtil.trigger = function (element, name, target, e) {
+        var returnValue = true;
+        if (!_DataUtil_1.DataUtil.has(element, name)) {
+            return returnValue;
+        }
+        var eventValue;
+        var handlerId;
+        var data = _DataUtil_1.DataUtil.get(element, name);
+        var handlersIds = data ? data : [];
+        for (var i = 0; i < handlersIds.length; i++) {
+            handlerId = handlersIds[i];
+            if (EventHandlerUtil.store[name] && EventHandlerUtil.store[name][handlerId]) {
+                var handler = EventHandlerUtil.store[name][handlerId];
+                if (handler.name === name) {
+                    if (handler.one) {
+                        if (handler.fired) {
+                            EventHandlerUtil.store[name][handlerId].fired = true;
+                            eventValue = handler.callback.call(this, target);
+                        }
+                    }
+                    else {
+                        eventValue = handler.callback.call(this, target);
+                    }
+                    if (eventValue === false) {
+                        returnValue = false;
+                    }
+                }
+            }
+        }
+        return returnValue;
+    };
+    EventHandlerUtil.one = function (element, name, callBack) {
+        EventHandlerUtil.addEvent(element, name, callBack, true);
+    };
+    EventHandlerUtil.off = function (element, name, handerId) {
+        EventHandlerUtil.removeEvent(element, name, handerId);
+    };
+    EventHandlerUtil.store = {};
+    EventHandlerUtil.on = function (element, name, callBack) {
+        EventHandlerUtil.addEvent(element, name, callBack, false);
+    };
+    return EventHandlerUtil;
+}());
+exports.EventHandlerUtil = EventHandlerUtil;