@soyfri/template 1.0.0

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

@@ -0,0 +1,6 @@
+export declare class DOMEventHandlerUtil {
+    static store: Map<any, any>;
+    static on(element: HTMLElement, selector: string, eventName: string, callBack: any): string;
+    static off(element: HTMLElement, eventName: string, eventId: string): void;
+    static one(element: HTMLElement, eventName: string, callBack: Function): void;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMEventHandlerUtil = void 0;
+var _TypesHelpers_1 = require("./_TypesHelpers");
+var DOMEventHandlerUtil = /** @class */ (function () {
+    function DOMEventHandlerUtil() {
+    }
+    DOMEventHandlerUtil.on = function (element, selector, eventName, callBack) {
+        var eventId = (0, _TypesHelpers_1.getUniqueIdWithPrefix)('DOMEvent');
+        DOMEventHandlerUtil.store.set(eventId, function (e) {
+            var targets = element.querySelectorAll(selector);
+            var target = e.target;
+            while (target && target !== element) {
+                for (var i = 0; i < targets.length; i++) {
+                    if (target === targets[i]) {
+                        callBack.call(target, e);
+                    }
+                }
+                if (target.parentElement) {
+                    target = target.parentElement;
+                }
+                else {
+                    target = null;
+                }
+            }
+        });
+        element.addEventListener(eventName, DOMEventHandlerUtil.store.get(eventId));
+        return eventId;
+    };
+    DOMEventHandlerUtil.off = function (element, eventName, eventId) {
+        var funcFromStore = DOMEventHandlerUtil.store.get(eventId);
+        if (!funcFromStore) {
+            return;
+        }
+        element.removeEventListener(eventName, funcFromStore);
+        DOMEventHandlerUtil.store.delete(eventId);
+    };
+    DOMEventHandlerUtil.one = function (element, eventName, callBack) {
+        element.addEventListener(eventName, function calee(e) {
+            // remove event
+            if (e.target && e.target.removeEventListener) {
+                e.target.removeEventListener(e.type, calee);
+            }
+            if (element && e && e.currentTarget) {
+                // if (element && element.removeEventListener && e && e.currentTarget) {
+                e.currentTarget.removeEventListener(e.type, calee);
+            }
+            // call hander
+            return callBack(e);
+        });
+    };
+    DOMEventHandlerUtil.store = new Map();
+    return DOMEventHandlerUtil;
+}());
+exports.DOMEventHandlerUtil = DOMEventHandlerUtil;

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

@@ -0,0 +1,9 @@
+export declare class DataUtil {
+    static store: Map<HTMLElement, Map<string, unknown>>;
+    static set(instance: HTMLElement | undefined, key: string, data: unknown): void;
+    static get(instance: HTMLElement, key: string): unknown | undefined;
+    static remove(instance: HTMLElement, key: string): void;
+    static removeOne(instance: HTMLElement, key: string, eventId: string): void;
+    static has(instance: HTMLElement, key: string): boolean;
+    static getAllInstancesByKey(key: string): any[];
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataUtil = void 0;
+var DataUtil = /** @class */ (function () {
+    function DataUtil() {
+    }
+    DataUtil.set = function (instance, key, data) {
+        if (!instance) {
+            return;
+        }
+        var instanceData = DataUtil.store.get(instance);
+        if (!instanceData) {
+            var newMap = new Map().set(key, data);
+            DataUtil.store.set(instance, newMap);
+            return;
+        }
+        instanceData.set(key, data);
+    };
+    DataUtil.get = function (instance, key) {
+        var instanceData = DataUtil.store.get(instance);
+        if (!instanceData) {
+            return;
+        }
+        return instanceData.get(key);
+    };
+    DataUtil.remove = function (instance, key) {
+        var instanceData = DataUtil.store.get(instance);
+        if (!instanceData) {
+            return;
+        }
+        instanceData.delete(key);
+    };
+    DataUtil.removeOne = function (instance, key, eventId) {
+        var instanceData = DataUtil.store.get(instance);
+        if (!instanceData) {
+            return;
+        }
+        var eventsIds = instanceData.get(key);
+        if (!eventsIds) {
+            return;
+        }
+        var updateEventsIds = eventsIds.filter(function (f) { return f !== eventId; });
+        DataUtil.set(instance, key, updateEventsIds);
+    };
+    DataUtil.has = function (instance, key) {
+        var instanceData = DataUtil.store.get(instance);
+        if (instanceData) {
+            return instanceData.has(key);
+        }
+        return false;
+    };
+    DataUtil.getAllInstancesByKey = function (key) {
+        var result = [];
+        DataUtil.store.forEach(function (val) {
+            val.forEach(function (v, k) {
+                if (k === key) {
+                    result.push(v);
+                }
+            });
+        });
+        return result;
+    };
+    DataUtil.store = new Map();
+    return DataUtil;
+}());
+exports.DataUtil = DataUtil;

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

@@ -0,0 +1,5 @@
+export declare class ElementStyleUtil {
+    static set(element: HTMLElement, property: string, value?: any, important?: boolean): void;
+    static get(element: HTMLElement, attributeName: string): string;
+    static remove(element: HTMLElement, attibuteName: string): void;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementStyleUtil = void 0;
+var ElementStyleUtil = /** @class */ (function () {
+    function ElementStyleUtil() {
+    }
+    ElementStyleUtil.set = function (element, property, value, important) {
+        if (important) {
+            element.style.setProperty(property, value, 'important');
+        }
+        else {
+            element.style.setProperty(property, value);
+        }
+    };
+    ElementStyleUtil.get = function (element, attributeName) {
+        return element.style.getPropertyValue(attributeName);
+    };
+    ElementStyleUtil.remove = function (element, attibuteName) {
+        element.style.removeProperty(attibuteName);
+    };
+    return ElementStyleUtil;
+}());
+exports.ElementStyleUtil = ElementStyleUtil;

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

@@ -0,0 +1,10 @@
+declare function getObjectPropertyValueByKey(obj: any, key: string): any | undefined;
+/**
+ * Generates unique ID for give prefix.
+ * @param {string} prefix Prefix for generated ID
+ * @returns {boolean}
+ */
+declare function getUniqueIdWithPrefix(prefix: string | undefined): string;
+declare function stringSnakeToCamel(str: string): string;
+declare function toJSON(value: string | JSON): JSON | undefined;
+export { getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel, toJSON };

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJSON = exports.stringSnakeToCamel = exports.getUniqueIdWithPrefix = exports.getObjectPropertyValueByKey = void 0;
+function getObjectPropertyValueByKey(obj, key) {
+    var map = new Map(Object.keys(obj).map(function (key) { return [key, obj[key]]; }));
+    if (obj.hasOwnProperty(key) && map) {
+        return map.get(key);
+    }
+}
+exports.getObjectPropertyValueByKey = getObjectPropertyValueByKey;
+/**
+ * Generates unique ID for give prefix.
+ * @param {string} prefix Prefix for generated ID
+ * @returns {boolean}
+ */
+function getUniqueIdWithPrefix(prefix) {
+    var result = Math.floor(Math.random() * new Date().getTime()).toString();
+    if (!prefix) {
+        return result;
+    }
+    return "".concat(prefix).concat(result);
+}
+exports.getUniqueIdWithPrefix = getUniqueIdWithPrefix;
+/* eslint-disable no-useless-escape */
+function stringSnakeToCamel(str) {
+    return str.replace(/(\-\w)/g, function (m) {
+        return m[1].toUpperCase();
+    });
+}
+exports.stringSnakeToCamel = stringSnakeToCamel;
+function toJSON(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    if (!value) {
+        return undefined;
+    }
+    // ("'" => "\"");
+    var result = value
+        .toString()
+        .split('')
+        .map(function (el) { return (el !== "'" ? el : '"'); })
+        .join('');
+    var jsonStr = result.replace(/(\w+:)|(\w+ :)/g, function (matched) {
+        return '"' + matched.substring(0, matched.length - 1) + '":';
+    });
+    try {
+        return JSON.parse(jsonStr);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+exports.toJSON = toJSON;

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

@@ -0,0 +1,9 @@
+export * from './models/OffsetModel';
+export * from './models/ViewPortModel';
+export * from './DomHelpers';
+export * from './_TypesHelpers';
+export * from './_DataUtil';
+export * from './_DOMEventHandlerUtil';
+export * from './_ElementStyleUtil';
+export * from './ElementAnimateUtil';
+export * from './EventHandlerUtil';

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

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Types
+__exportStar(require("./models/OffsetModel"), exports);
+__exportStar(require("./models/ViewPortModel"), exports);
+// Helpers
+__exportStar(require("./DomHelpers"), exports);
+__exportStar(require("./_TypesHelpers"), exports);
+// Basic
+__exportStar(require("./_DataUtil"), exports);
+__exportStar(require("./_DOMEventHandlerUtil"), exports);
+__exportStar(require("./_ElementStyleUtil"), exports);
+__exportStar(require("./ElementAnimateUtil"), exports);
+__exportStar(require("./EventHandlerUtil"), exports);

package/dist/assets/ts/_utils/models/OffsetModel.d.ts

@@ -0,0 +1,4 @@
+export interface OffsetModel {
+    top: number;
+    left: number;
+}

package/dist/assets/ts/_utils/models/OffsetModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/assets/ts/_utils/models/ViewPortModel.d.ts

@@ -0,0 +1,4 @@
+export interface ViewPortModel {
+    width: number;
+    height: number;
+}

package/dist/assets/ts/_utils/models/ViewPortModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/assets/ts/components/MenuComponent.d.ts

@@ -0,0 +1,88 @@
+export interface MenuOptions {
+    dropdown: {
+        hoverTimeout: number;
+        zindex: number;
+    };
+    accordion: {
+        slideSpeed: number;
+        expand: boolean;
+    };
+}
+declare const defaultMenuOptions: MenuOptions;
+declare class MenuComponent {
+    element: HTMLElement;
+    options: MenuOptions;
+    instanceUid: string;
+    triggerElement: HTMLElement | null;
+    constructor(_element: HTMLElement, options: MenuOptions);
+    private _setTriggerElement;
+    private _isTriggerElement;
+    private _getItemOption;
+    private _getItemElement;
+    private _getItemParentElement;
+    private _getItemParentElements;
+    private _getDropdownPopperConfig;
+    private _getItemChildElement;
+    private _getItemChildElements;
+    private _getItemSubElement;
+    private _getCss;
+    private _getItemSubType;
+    private _isItemSubShown;
+    private _isItemDropdownPermanent;
+    private _isItemParentShown;
+    private _isItemSubElement;
+    private _hasItemSub;
+    private _getItemLinkElement;
+    private _getItemToggleElement;
+    private _showDropdown;
+    private initDropdownPopper;
+    private _hideDropdown;
+    private destroyDropdownPopper;
+    private _showAccordion;
+    private _hideAccordion;
+    private _hideAccordions;
+    private _reset;
+    private _destroy;
+    private _update;
+    private _hide;
+    private _show;
+    private _toggle;
+    private _mouseout;
+    private _mouseover;
+    private _dismiss;
+    private _link;
+    private _click;
+    click: (element: HTMLElement, e: Event) => void;
+    link: (element: HTMLElement, e: Event) => void;
+    dismiss: (element: HTMLElement, e: Event) => void;
+    mouseover: (element: HTMLElement, e: Event) => void;
+    mouseout: (element: HTMLElement, e: Event) => void;
+    getItemTriggerType: (item: HTMLElement) => string | boolean | JSON | null;
+    getItemSubType: (element: HTMLElement) => "dropdown" | "accordion";
+    show: (item: HTMLElement) => void;
+    hide: (item: HTMLElement) => void;
+    reset: (item: HTMLElement) => void;
+    update: () => void;
+    getElement: () => HTMLElement;
+    getItemLinkElement: (item: HTMLElement) => HTMLElement | null;
+    getItemToggleElement: (item: HTMLElement) => HTMLElement | null;
+    getItemSubElement: (item: HTMLElement) => HTMLElement | null;
+    getItemParentElements: (item: HTMLElement) => HTMLElement[];
+    isItemSubShown: (item: HTMLElement) => boolean;
+    isItemParentShown: (item: HTMLElement) => boolean;
+    getTriggerElement: () => HTMLElement | null;
+    isItemDropdownPermanent: (item: HTMLElement) => boolean;
+    hideAccordions: (item: HTMLElement) => void;
+    on: (name: string, handler: any) => void;
+    one: (name: string, handler: any) => void;
+    off: (name: string, handlerId: string) => void;
+    static getInstance: (element: HTMLElement) => MenuComponent | null;
+    static hideDropdowns: (skip: HTMLElement | undefined) => void;
+    static updateDropdowns: () => void;
+    static createInstances: (selector: string) => void;
+    static initGlobalHandlers: () => void;
+    static bootstrap: () => void;
+    static reinitialization: () => void;
+    static createInsance: (selector: string, options?: MenuOptions) => MenuComponent | undefined;
+}
+export { MenuComponent, defaultMenuOptions };