@hitsoft/e-donusum 1.0.5

package/_metronic/kt/_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/_metronic/kt/_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/_metronic/kt/_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/_metronic/kt/_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/_metronic/kt/_utils/_TypesHelpers.ts

@@ -0,0 +1,54 @@
+function getObjectPropertyValueByKey(obj: any, key: string): any | undefined {
+  const map = new Map(Object.entries(obj))
+  if (obj.hasOwnProperty(key) && map) {
+    return map.get(key)
+  }
+}
+
+/**
+ * Generates unique ID for give prefix.
+ * @param {string} prefix Prefix for generated ID
+ * @returns {boolean}
+ */
+function getUniqueIdWithPrefix(prefix: string | undefined): string {
+  const result = Math.floor(Math.random() * new Date().getTime()).toString()
+  if (!prefix) {
+    return result
+  }
+
+  return `${prefix}${result}`
+}
+
+/* eslint-disable no-useless-escape */
+function stringSnakeToCamel(str: string): string {
+  return str.replace(/(\-\w)/g, function (m) {
+    return m[1].toUpperCase()
+  })
+}
+
+function toJSON(value: string | JSON): JSON | undefined {
+  if (typeof value !== 'string') {
+    return value
+  }
+
+  if (!value) {
+    return undefined
+  }
+
+  // ("'" => "\"");
+  const result = value
+    .toString()
+    .split('')
+    .map((el) => (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 {
+    return undefined
+  }
+}
+
+export {getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel, toJSON}

package/_metronic/kt/_utils/index.ts

@@ -0,0 +1,12 @@
+// Types
+export * from './models/OffsetModel'
+export * from './models/ViewPortModel'
+// Helpers
+export * from './DomHelpers'
+export * from './_TypesHelpers'
+// Basic
+export * from './_DataUtil'
+export * from './_DOMEventHandlerUtil'
+export * from './_ElementStyleUtil'
+export * from './ElementAnimateUtil'
+export * from './EventHandlerUtil'

package/_metronic/kt/_utils/models/OffsetModel.ts

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

package/_metronic/kt/_utils/models/ViewPortModel.ts

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