@hitsoft/e-donusum 1.0.10 → 1.0.12

package/_metronic/kt/_utils/EventHandlerUtil.ts

@@ -1,144 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

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

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

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