@soyfri/template 1.0.1 → 1.0.4

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

@@ -1,48 +1,43 @@
-"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) {
+import { DataUtil } from './_DataUtil';
+import { getUniqueIdWithPrefix } from './_TypesHelpers';
+export class EventHandlerUtil {
+    static store = {};
+    static setEventMetasByName(name, handlers) {
         EventHandlerUtil.store[name] = handlers;
-    };
-    EventHandlerUtil.getEventMetaByName = function (name) {
+    }
+    static getEventMetaByName(name) {
         return EventHandlerUtil.store[name];
-    };
-    EventHandlerUtil.setEventMetaByNameAndHandlerId = function (name, handlerId, meta) {
+    }
+    static setEventMetaByNameAndHandlerId(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];
+    }
+    static getEventMetaByHandlerId(name, handlerId) {
+        const handlersIds = EventHandlerUtil.store[name];
         if (!handlersIds) {
             return;
         }
         return handlersIds[handlerId];
-    };
-    EventHandlerUtil.setFiredByNameAndHandlerId = function (name, handerId, fired) {
-        var meta = EventHandlerUtil.getEventMetaByHandlerId(name, handerId);
+    }
+    static setFiredByNameAndHandlerId(name, handerId, fired) {
+        const 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 : [];
+    }
+    static addEvent(element, name, callback, one = false) {
+        const handlerId = getUniqueIdWithPrefix('event');
+        const data = DataUtil.get(element, name);
+        const handlersIds = data ? data : [];
         handlersIds.push(handlerId);
-        _DataUtil_1.DataUtil.set(element, name, handlersIds);
-        var meta = {
+        DataUtil.set(element, name, handlersIds);
+        const meta = {
             name: name,
             callback: callback,
             one: one,
@@ -50,28 +45,28 @@ var EventHandlerUtil = /** @class */ (function () {
         };
         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];
+    }
+    static removeEvent(element, name, handerId) {
+        DataUtil.removeOne(element, name, handerId);
+        const 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)) {
+    }
+    static trigger(element, name, target, e) {
+        let returnValue = true;
+        if (!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++) {
+        let eventValue;
+        let handlerId;
+        const data = DataUtil.get(element, name);
+        const handlersIds = data ? data : [];
+        for (let i = 0; i < handlersIds.length; i++) {
             handlerId = handlersIds[i];
             if (EventHandlerUtil.store[name] && EventHandlerUtil.store[name][handlerId]) {
-                var handler = EventHandlerUtil.store[name][handlerId];
+                const handler = EventHandlerUtil.store[name][handlerId];
                 if (handler.name === name) {
                     if (handler.one) {
                         if (handler.fired) {
@@ -89,17 +84,14 @@ var EventHandlerUtil = /** @class */ (function () {
             }
         }
         return returnValue;
+    }
+    static on = function (element, name, callBack) {
+        EventHandlerUtil.addEvent(element, name, callBack, false);
     };
-    EventHandlerUtil.one = function (element, name, callBack) {
+    static one(element, name, callBack) {
         EventHandlerUtil.addEvent(element, name, callBack, true);
-    };
-    EventHandlerUtil.off = function (element, name, handerId) {
+    }
+    static off(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;
+    }
+}

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

@@ -0,0 +1,144 @@
+import {DataUtil} from './_DataUtil'
+import {getUniqueIdWithPrefix} from './_TypesHelpers'
+
+export interface EventMeta {
+  name: string
+  callback: Function
+  one: boolean
+  fired: boolean
+}
+
+export class EventHandlerUtil {
+  static store: {
+    [name: string]: {
+      [handlerId: string]: EventMeta
+    }
+  } = {}
+
+  private static setEventMetasByName(
+    name: string,
+    handlers: {
+      [handlerId: string]: EventMeta
+    }
+  ): void {
+    EventHandlerUtil.store[name] = handlers
+  }
+
+  private static getEventMetaByName(name: string):
+    | {
+        [handlerId: string]: EventMeta
+      }
+    | undefined {
+    return EventHandlerUtil.store[name]
+  }
+
+  private static setEventMetaByNameAndHandlerId(
+    name: string,
+    handlerId: string,
+    meta: EventMeta
+  ): void {
+    if (EventHandlerUtil.store[name]) {
+      EventHandlerUtil.store[name][handlerId] = meta
+      return
+    }
+    EventHandlerUtil.store[name] = {}
+    EventHandlerUtil.store[name][handlerId] = meta
+  }
+
+  private static getEventMetaByHandlerId(name: string, handlerId: string): EventMeta | undefined {
+    const handlersIds = EventHandlerUtil.store[name]
+    if (!handlersIds) {
+      return
+    }
+    return handlersIds[handlerId]
+  }
+
+  private static setFiredByNameAndHandlerId(name: string, handerId: string, fired: boolean): void {
+    const meta = EventHandlerUtil.getEventMetaByHandlerId(name, handerId)
+    if (!meta) {
+      return
+    }
+
+    meta.fired = fired
+    EventHandlerUtil.setEventMetaByNameAndHandlerId(name, handerId, meta)
+  }
+
+  private static addEvent(
+    element: HTMLElement,
+    name: string,
+    callback: Function,
+    one: boolean = false
+  ): string {
+    const handlerId = getUniqueIdWithPrefix('event')
+    const data = DataUtil.get(element, name)
+    const handlersIds = data ? (data as string[]) : []
+    handlersIds.push(handlerId)
+
+    DataUtil.set(element, name, handlersIds)
+
+    const meta: EventMeta = {
+      name: name,
+      callback: callback,
+      one: one,
+      fired: false,
+    }
+
+    EventHandlerUtil.setEventMetaByNameAndHandlerId(name, handlerId, meta)
+    return handlerId
+  }
+
+  private static removeEvent(element: HTMLElement, name: string, handerId: string) {
+    DataUtil.removeOne(element, name, handerId)
+    const handlersIds = EventHandlerUtil.store[name]
+    if (handlersIds) {
+      return
+    }
+
+    delete EventHandlerUtil.store[name][handerId]
+  }
+
+  public static trigger(element: HTMLElement, name: string, target?: any, e?: Event): boolean {
+    let returnValue = true
+    if (!DataUtil.has(element, name)) {
+      return returnValue
+    }
+
+    let eventValue
+    let handlerId
+    const data = DataUtil.get(element, name)
+    const handlersIds = data ? (data as string[]) : []
+    for (let i = 0; i < handlersIds.length; i++) {
+      handlerId = handlersIds[i]
+      if (EventHandlerUtil.store[name] && EventHandlerUtil.store[name][handlerId]) {
+        const 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
+  }
+
+  public static on = function (element: HTMLElement, name: string, callBack: Function): void {
+    EventHandlerUtil.addEvent(element, name, callBack, false)
+  }
+
+  public static one(element: HTMLElement, name: string, callBack: Function): void {
+    EventHandlerUtil.addEvent(element, name, callBack, true)
+  }
+
+  public static off(element: HTMLElement, name: string, handerId: string): void {
+    EventHandlerUtil.removeEvent(element, name, handerId)
+  }
+}

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

@@ -1,17 +1,13 @@
-"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;
+import { getUniqueIdWithPrefix } from './_TypesHelpers';
+export class DOMEventHandlerUtil {
+    static store = new Map();
+    static on(element, selector, eventName, callBack) {
+        const eventId = getUniqueIdWithPrefix('DOMEvent');
+        DOMEventHandlerUtil.store.set(eventId, (e) => {
+            const targets = element.querySelectorAll(selector);
+            let target = e.target;
             while (target && target !== element) {
-                for (var i = 0; i < targets.length; i++) {
+                for (let i = 0; i < targets.length; i++) {
                     if (target === targets[i]) {
                         callBack.call(target, e);
                     }
@@ -26,16 +22,16 @@ var DOMEventHandlerUtil = /** @class */ (function () {
         });
         element.addEventListener(eventName, DOMEventHandlerUtil.store.get(eventId));
         return eventId;
-    };
-    DOMEventHandlerUtil.off = function (element, eventName, eventId) {
-        var funcFromStore = DOMEventHandlerUtil.store.get(eventId);
+    }
+    static off(element, eventName, eventId) {
+        const funcFromStore = DOMEventHandlerUtil.store.get(eventId);
         if (!funcFromStore) {
             return;
         }
         element.removeEventListener(eventName, funcFromStore);
         DOMEventHandlerUtil.store.delete(eventId);
-    };
-    DOMEventHandlerUtil.one = function (element, eventName, callBack) {
+    }
+    static one(element, eventName, callBack) {
         element.addEventListener(eventName, function calee(e) {
             // remove event
             if (e.target && e.target.removeEventListener) {
@@ -48,8 +44,5 @@ var DOMEventHandlerUtil = /** @class */ (function () {
             // call hander
             return callBack(e);
         });
-    };
-    DOMEventHandlerUtil.store = new Map();
-    return DOMEventHandlerUtil;
-}());
-exports.DOMEventHandlerUtil = DOMEventHandlerUtil;
+    }
+}

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

@@ -0,0 +1,60 @@
+import {getUniqueIdWithPrefix} from './_TypesHelpers'
+
+export class DOMEventHandlerUtil {
+  public static store = new Map()
+
+  public static on(
+    element: HTMLElement,
+    selector: string,
+    eventName: string,
+    callBack: any
+  ): string {
+    const eventId = getUniqueIdWithPrefix('DOMEvent')
+    DOMEventHandlerUtil.store.set(eventId, (e: Event) => {
+      const targets = element.querySelectorAll(selector)
+      let target: HTMLElement | null = e.target as HTMLElement
+      while (target && target !== element) {
+        for (let 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
+  }
+
+  public static off(element: HTMLElement, eventName: string, eventId: string): void {
+    const funcFromStore = DOMEventHandlerUtil.store.get(eventId)
+    if (!funcFromStore) {
+      return
+    }
+
+    element.removeEventListener(eventName, funcFromStore)
+    DOMEventHandlerUtil.store.delete(eventId)
+  }
+
+  public static one(element: HTMLElement, eventName: string, callBack: Function): void {
+    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)
+    })
+  }
+}

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

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

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

@@ -0,0 +1,72 @@
+export class DataUtil {
+  static store: Map<HTMLElement, Map<string, unknown>> = new Map()
+
+  public static set(instance: HTMLElement | undefined, key: string, data: unknown): void {
+    if (!instance) {
+      return
+    }
+
+    const instanceData = DataUtil.store.get(instance)
+    if (!instanceData) {
+      const newMap = new Map().set(key, data)
+      DataUtil.store.set(instance, newMap)
+      return
+    }
+
+    instanceData.set(key, data)
+  }
+
+  public static get(instance: HTMLElement, key: string): unknown | undefined {
+    const instanceData = DataUtil.store.get(instance)
+    if (!instanceData) {
+      return
+    }
+
+    return instanceData.get(key)
+  }
+
+  public static remove(instance: HTMLElement, key: string): void {
+    const instanceData = DataUtil.store.get(instance)
+    if (!instanceData) {
+      return
+    }
+
+    instanceData.delete(key)
+  }
+
+  public static removeOne(instance: HTMLElement, key: string, eventId: string) {
+    const instanceData = DataUtil.store.get(instance)
+    if (!instanceData) {
+      return
+    }
+
+    const eventsIds = instanceData.get(key)
+    if (!eventsIds) {
+      return
+    }
+
+    const updateEventsIds = (eventsIds as string[]).filter((f) => f !== eventId)
+    DataUtil.set(instance, key, updateEventsIds)
+  }
+
+  public static has(instance: HTMLElement, key: string): boolean {
+    const instanceData = DataUtil.store.get(instance)
+    if (instanceData) {
+      return instanceData.has(key)
+    }
+
+    return false
+  }
+
+  public static getAllInstancesByKey(key: string) {
+    const result: any[] = []
+    DataUtil.store.forEach((val) => {
+      val.forEach((v, k) => {
+        if (k === key) {
+          result.push(v)
+        }
+      })
+    })
+    return result
+  }
+}

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

@@ -1,23 +1,16 @@
-"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) {
+export class ElementStyleUtil {
+    static set(element, property, value, important) {
         if (important) {
             element.style.setProperty(property, value, 'important');
         }
         else {
             element.style.setProperty(property, value);
         }
-    };
-    ElementStyleUtil.get = function (element, attributeName) {
+    }
+    static get(element, attributeName) {
         return element.style.getPropertyValue(attributeName);
-    };
-    ElementStyleUtil.remove = function (element, attibuteName) {
+    }
+    static remove(element, attibuteName) {
         element.style.removeProperty(attibuteName);
-    };
-    return ElementStyleUtil;
-}());
-exports.ElementStyleUtil = ElementStyleUtil;
+    }
+}

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

@@ -0,0 +1,17 @@
+export class ElementStyleUtil {
+  public static set(element: HTMLElement, property: string, value?: any, important?: boolean) {
+    if (important) {
+      element.style.setProperty(property, value, 'important')
+    } else {
+      element.style.setProperty(property, value)
+    }
+  }
+
+  public static get(element: HTMLElement, attributeName: string) {
+    return element.style.getPropertyValue(attributeName)
+  }
+
+  public static remove(element: HTMLElement, attibuteName: string) {
+    element.style.removeProperty(attibuteName)
+  }
+}

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

@@ -1,33 +1,27 @@
-"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]]; }));
+    const map = new Map(Object.keys(obj).map(key => [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();
+    const result = Math.floor(Math.random() * new Date().getTime()).toString();
     if (!prefix) {
         return result;
     }
-    return "".concat(prefix).concat(result);
+    return `${prefix}${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;
@@ -36,19 +30,19 @@ function toJSON(value) {
         return undefined;
     }
     // ("'" => "\"");
-    var result = value
+    const result = value
         .toString()
         .split('')
-        .map(function (el) { return (el !== "'" ? el : '"'); })
+        .map((el) => (el !== "'" ? el : '"'))
         .join('');
-    var jsonStr = result.replace(/(\w+:)|(\w+ :)/g, function (matched) {
+    const jsonStr = result.replace(/(\w+:)|(\w+ :)/g, function (matched) {
         return '"' + matched.substring(0, matched.length - 1) + '":';
     });
     try {
         return JSON.parse(jsonStr);
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
 }
-exports.toJSON = toJSON;
+export { getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel, toJSON };