@bnsights/bbsf-admin-portal 1.1.2 → 1.1.3

package/{esm2020 → esm2022}/lib/_metronic/core/components/_CookieComponent.mjs

@@ -1,53 +1,53 @@
-/* eslint-disable no-useless-escape */
-// DOCS: https://javascript.info/cookie
-export class CookieComponent {
-    /**
-     * Returns the cookie with the given name, or undefined if not found
-     *
-     * @param  {string} name - cookie name
-     * @returns string | null
-     */
-    static get(name) {
-        let matches = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + '=([^;]*)'));
-        return matches ? decodeURIComponent(matches[1]) : undefined;
-    }
-    /**
-     * Please note that a cookie value is encoded,
-     * so getCookie uses a built-in decodeURIComponent function to decode it.
-     *
-     * @param  {string} name - cookie name
-     * @param  {string | number | boolean} value - cookie value
-     * @param  {any} cookieOptions - cookie options
-     * @returns void
-     */
-    static set(name, value, cookieOptions) {
-        const options = {
-            path: '/',
-            // add other defaults here if necessary
-            ...cookieOptions,
-        };
-        if (options.expires instanceof Date) {
-            options.expires = options.expires.toUTCString();
-        }
-        let updatedCookie = encodeURIComponent(name) + '=' + encodeURIComponent(value);
-        for (let optionKey in options) {
-            updatedCookie += '; ' + optionKey;
-            let optionValue = options[optionKey];
-            if (optionValue !== true) {
-                updatedCookie += '=' + optionValue;
-            }
-        }
-        document.cookie = updatedCookie;
-    }
-    /**
-     * To delete a cookie, we can call it with a negative expiration date
-     *
-     * @param  {string} name
-     */
-    static delete(name) {
-        CookieComponent.set(name, '', {
-            'max-age': -1,
-        });
-    }
-}
+/* eslint-disable no-useless-escape */
+// DOCS: https://javascript.info/cookie
+export class CookieComponent {
+    /**
+     * Returns the cookie with the given name, or undefined if not found
+     *
+     * @param  {string} name - cookie name
+     * @returns string | null
+     */
+    static get(name) {
+        let matches = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + '=([^;]*)'));
+        return matches ? decodeURIComponent(matches[1]) : undefined;
+    }
+    /**
+     * Please note that a cookie value is encoded,
+     * so getCookie uses a built-in decodeURIComponent function to decode it.
+     *
+     * @param  {string} name - cookie name
+     * @param  {string | number | boolean} value - cookie value
+     * @param  {any} cookieOptions - cookie options
+     * @returns void
+     */
+    static set(name, value, cookieOptions) {
+        const options = {
+            path: '/',
+            // add other defaults here if necessary
+            ...cookieOptions,
+        };
+        if (options.expires instanceof Date) {
+            options.expires = options.expires.toUTCString();
+        }
+        let updatedCookie = encodeURIComponent(name) + '=' + encodeURIComponent(value);
+        for (let optionKey in options) {
+            updatedCookie += '; ' + optionKey;
+            let optionValue = options[optionKey];
+            if (optionValue !== true) {
+                updatedCookie += '=' + optionValue;
+            }
+        }
+        document.cookie = updatedCookie;
+    }
+    /**
+     * To delete a cookie, we can call it with a negative expiration date
+     *
+     * @param  {string} name
+     */
+    static delete(name) {
+        CookieComponent.set(name, '', {
+            'max-age': -1,
+        });
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/_metronic/core/components/_DrawerComponent.mjs

@@ -0,0 +1,288 @@
+import { getAttributeValueByBreakpoint, getCSS, throttle } from "../_utils/DomHelpers";
+import { EventHandlerUtil } from "../_utils/EventHandlerUtil";
+import { DataUtil } from "../_utils/_DataUtil";
+import { DOMEventHandlerUtil } from "../_utils/_DOMEventHandlerUtil";
+import { ElementStyleUtil } from "../_utils/_ElementStyleUtil";
+import { getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel } from "../_utils/_TypesHelpers";
+const defaultDrawerOptions = {
+    overlay: true,
+    baseClass: 'drawer',
+    overlayClass: 'drawer-overlay',
+    direction: 'end',
+};
+class DrawerComponent {
+    constructor(_element, options) {
+        this.overlayElement = null;
+        this.toggleElement = null;
+        this.name = '';
+        this.shown = false;
+        this.lastWidth = 0;
+        this.closeElement = null;
+        this._handlers = () => {
+            const togglers = this._getOption('toggle');
+            const closers = this._getOption('close');
+            if (togglers !== null && togglers.length > 0) {
+                DOMEventHandlerUtil.on(document.body, togglers, 'click', (e) => {
+                    e.preventDefault();
+                    this.toggleElement = document.getElementById(togglers);
+                    this._toggle();
+                });
+            }
+            if (closers !== null && closers.length > 0) {
+                DOMEventHandlerUtil.on(document.body, closers, 'click', (e) => {
+                    e.preventDefault();
+                    this.closeElement = document.getElementById(closers);
+                    this._hide();
+                });
+            }
+        };
+        this._update = () => {
+            const width = String(this._getOption('width'));
+            const direction = String(this._getOption('direction'));
+            // Reset state
+            const hasBaseClass = this.element.classList.contains(`${this.options.baseClass}-on`);
+            const bodyCanvasAttr = String(document.body.getAttribute(`data-kt-drawer-${this.name}-`));
+            if (hasBaseClass === true && bodyCanvasAttr === 'on') {
+                this.shown = true;
+            }
+            else {
+                this.shown = false;
+            }
+            // Activate/deactivate
+            if (this._getOption('activate') === true) {
+                this.element.classList.add(this.options.baseClass);
+                this.element.classList.add(`${this.options.baseClass}-${direction}`);
+                ElementStyleUtil.set(this.element, 'width', width, true);
+                this.lastWidth = parseInt(width);
+            }
+            else {
+                ElementStyleUtil.set(this.element, 'width', '');
+                this.element.classList.remove(this.options.baseClass);
+                this.element.classList.remove(`${this.options.baseClass}-${direction}`);
+                this._hide();
+            }
+        };
+        this._getOption = (name) => {
+            const attr = this.element.getAttribute(`data-kt-drawer-${name}`);
+            if (attr) {
+                let value = getAttributeValueByBreakpoint(attr);
+                if (value !== null && String(value) === 'true') {
+                    return true;
+                }
+                else {
+                    if (value !== null && String(value) === 'false') {
+                        return false;
+                    }
+                }
+                return value;
+            }
+            else {
+                const optionName = stringSnakeToCamel(name);
+                const option = getObjectPropertyValueByKey(this.options, optionName);
+                if (option) {
+                    return getAttributeValueByBreakpoint(option);
+                }
+                else {
+                    return null;
+                }
+            }
+        };
+        this._toggle = () => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.drawer.toggle') === false) {
+                return;
+            }
+            if (this.shown) {
+                this._hide();
+            }
+            else {
+                this._show();
+            }
+            EventHandlerUtil.trigger(this.element, 'kt.drawer.toggled');
+        };
+        this._hide = () => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.drawer.hide') === false) {
+                return;
+            }
+            this.shown = false;
+            this._deleteOverlay();
+            document.body.removeAttribute(`data-kt-drawer-${this.name}`);
+            document.body.removeAttribute(`data-kt-drawer`);
+            this.element.classList.remove(`${this.options.baseClass}-on`);
+            if (this.toggleElement != null) {
+                this.toggleElement.classList.remove('active');
+            }
+            EventHandlerUtil.trigger(this.element, 'kt.drawer.after.hidden');
+        };
+        this._show = () => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.drawer.show') === false) {
+                return;
+            }
+            this.shown = true;
+            this._createOverlay();
+            document.body.setAttribute(`data-kt-drawer-${this.name}`, 'on');
+            document.body.setAttribute('data-kt-drawer', 'on');
+            this.element.classList.add(`${this.options.baseClass}-on`);
+            if (this.toggleElement !== null) {
+                this.toggleElement.classList.add('active');
+            }
+            EventHandlerUtil.trigger(this.element, 'kt.drawer.shown');
+        };
+        this._createOverlay = () => {
+            if (this._getOption('overlay') === true) {
+                this.overlayElement = document.createElement('DIV');
+                const elementZIndex = getCSS(this.element, 'z-index');
+                if (elementZIndex) {
+                    const overlayZindex = parseInt(elementZIndex) - 1;
+                    ElementStyleUtil.set(this.overlayElement, 'z-index', overlayZindex); // update
+                }
+                document.body.append(this.overlayElement);
+                const overlayClassOption = this._getOption('overlay-class');
+                if (overlayClassOption) {
+                    this.overlayElement.classList.add(overlayClassOption.toString());
+                }
+                this.overlayElement.addEventListener('click', (e) => {
+                    e.preventDefault();
+                    this._hide();
+                });
+            }
+        };
+        this._deleteOverlay = () => {
+            if (this.overlayElement !== null && this.overlayElement.parentNode) {
+                this.overlayElement.parentNode.removeChild(this.overlayElement);
+            }
+        };
+        this._getDirection = () => {
+            return String(this._getOption('direction')) === 'left' ? 'left' : 'right';
+        };
+        this._getWidth = () => {
+            let width = this._getOption('width');
+            if (width && width === 'auto') {
+                width = getCSS(this.element, 'width');
+            }
+            return width;
+        };
+        ///////////////////////
+        // ** Public API  ** //
+        ///////////////////////
+        this.toggle = () => {
+            this._toggle();
+        };
+        this.show = () => {
+            this._show();
+        };
+        this.hide = () => {
+            this._hide();
+        };
+        this.isShown = () => {
+            return this.shown;
+        };
+        this.update = () => {
+            this._update();
+        };
+        this.goElement = () => {
+            return this.element;
+        };
+        // Event API
+        this.on = (name, handler) => {
+            return EventHandlerUtil.on(this.element, name, handler);
+        };
+        this.one = (name, handler) => {
+            return EventHandlerUtil.one(this.element, name, handler);
+        };
+        this.off = (name) => {
+            return EventHandlerUtil.off(this.element, name);
+        };
+        this.trigger = (name, event) => {
+            return EventHandlerUtil.trigger(this.element, name, event);
+        };
+        this.element = _element;
+        this.options = Object.assign(defaultDrawerOptions, options);
+        this.instanceUid = getUniqueIdWithPrefix('drawer');
+        this.overlayElement = null;
+        this.name = this.element.getAttribute('data-kt-drawer-name') || '';
+        this.shown = false;
+        this.toggleElement = null;
+        // Event Handlers
+        this._handlers();
+        // Update Instance
+        this._update();
+        // Bind Instance
+        DataUtil.set(this.element, 'drawer', this);
+    }
+    // Static methods
+    static { this.hasInstace = (element) => {
+        return DataUtil.has(element, 'drawer');
+    }; }
+    static { this.getInstance = (element) => {
+        return DataUtil.get(element, 'drawer');
+    }; }
+    static { this.hideAll = () => {
+        const oldInstances = DataUtil.getAllInstancesByKey('drawer');
+        oldInstances.forEach((dr) => {
+            dr.hide();
+        });
+    }; }
+    static { this.updateAll = () => {
+        const oldInstances = DataUtil.getAllInstancesByKey('drawer');
+        oldInstances.forEach((dr) => {
+            dr.update();
+        });
+    }; }
+    // Create Instances
+    static createInstances(selector) {
+        const elements = document.body.querySelectorAll(selector);
+        elements.forEach((element) => {
+            const item = element;
+            let drawer = DrawerComponent.getInstance(item);
+            if (!drawer) {
+                drawer = new DrawerComponent(item, defaultDrawerOptions);
+            }
+            drawer.hide();
+        });
+    }
+    // Dismiss instances
+    static { this.handleDismiss = () => {
+        // External drawer toggle handler
+        DOMEventHandlerUtil.on(document.body, '[data-kt-drawer-dismiss="true"]', 'click', () => {
+            /* @ts-ignore */
+            const element = this.closest('[data-kt-drawer="true"]');
+            if (element) {
+                const drawer = DrawerComponent.getInstance(element);
+                if (drawer && drawer.isShown()) {
+                    drawer.hide();
+                }
+            }
+        });
+    }; }
+    // Global Initialization
+    static initGlobalHandlers() {
+        // Window Resize Handling
+        window.addEventListener('resize', function () {
+            let timer;
+            throttle(timer, () => {
+                // Locate and update Drawer instances on window resize
+                const elements = document.body.querySelectorAll('[data-kt-drawer="true"]');
+                elements.forEach((el) => {
+                    const item = el;
+                    const instance = DrawerComponent.getInstance(item);
+                    if (instance) {
+                        instance.update();
+                    }
+                });
+            }, 200);
+        });
+    }
+    static { this.bootstrap = () => {
+        DrawerComponent.createInstances('[data-kt-drawer="true"]');
+        DrawerComponent.initGlobalHandlers();
+        DrawerComponent.handleDismiss();
+    }; }
+    static { this.reinitialization = () => {
+        DrawerComponent.createInstances('[data-kt-drawer="true"]');
+        DrawerComponent.hideAll();
+        DrawerComponent.updateAll();
+        DrawerComponent.handleDismiss();
+    }; }
+}
+export { DrawerComponent, defaultDrawerOptions };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_DrawerComponent.js","sourceRoot":"","sources":["../../../../../../../projects/bbsf-admin-portal/src/lib/_metronic/core/components/_DrawerComponent.ts"],"names":[],"mappings":"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","sourcesContent":["import { getAttributeValueByBreakpoint, getCSS, throttle } from \"../_utils/DomHelpers\"\r\nimport { EventHandlerUtil } from \"../_utils/EventHandlerUtil\"\r\nimport { DataUtil } from \"../_utils/_DataUtil\"\r\nimport { DOMEventHandlerUtil } from \"../_utils/_DOMEventHandlerUtil\"\r\nimport { ElementStyleUtil } from \"../_utils/_ElementStyleUtil\"\r\nimport { getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel } from \"../_utils/_TypesHelpers\"\r\n\r\n\r\nexport interface DrawerOptions {\r\n  overlay: boolean\r\n  baseClass: string\r\n  overlayClass: string\r\n  direction: string\r\n}\r\n\r\nconst defaultDrawerOptions: DrawerOptions = {\r\n  overlay: true,\r\n  baseClass: 'drawer',\r\n  overlayClass: 'drawer-overlay',\r\n  direction: 'end',\r\n}\r\n\r\nclass DrawerComponent {\r\n  element: HTMLElement\r\n  overlayElement: HTMLElement | null = null\r\n  toggleElement: HTMLElement | null = null\r\n  options: DrawerOptions\r\n  instanceUid: string\r\n  name: string = ''\r\n  shown: boolean = false\r\n  lastWidth: number = 0\r\n  closeElement: HTMLElement | null = null\r\n\r\n  constructor(_element: HTMLElement, options: DrawerOptions) {\r\n    this.element = _element\r\n    this.options = Object.assign(defaultDrawerOptions, options)\r\n    this.instanceUid = getUniqueIdWithPrefix('drawer')\r\n    this.overlayElement = null\r\n    this.name = this.element.getAttribute('data-kt-drawer-name') || ''\r\n    this.shown = false\r\n    this.toggleElement = null\r\n    // Event Handlers\r\n    this._handlers()\r\n    // Update Instance\r\n    this._update()\r\n    // Bind Instance\r\n    DataUtil.set(this.element, 'drawer', this)\r\n  }\r\n\r\n  private _handlers = () => {\r\n    const togglers = this._getOption('toggle') as string\r\n    const closers = this._getOption('close') as string\r\n\r\n    if (togglers !== null && togglers.length > 0) {\r\n      DOMEventHandlerUtil.on(document.body, togglers, 'click', (e: Event) => {\r\n        e.preventDefault()\r\n        this.toggleElement = document.getElementById(togglers)\r\n        this._toggle()\r\n      })\r\n    }\r\n\r\n    if (closers !== null && closers.length > 0) {\r\n      DOMEventHandlerUtil.on(document.body, closers, 'click', (e: Event) => {\r\n        e.preventDefault()\r\n        this.closeElement = document.getElementById(closers)\r\n\r\n        this._hide()\r\n      })\r\n    }\r\n  }\r\n\r\n  private _update = () => {\r\n    const width = String(this._getOption('width'))\r\n    const direction = String(this._getOption('direction'))\r\n\r\n    // Reset state\r\n    const hasBaseClass = this.element.classList.contains(`${this.options.baseClass}-on`)\r\n    const bodyCanvasAttr = String(document.body.getAttribute(`data-kt-drawer-${this.name}-`))\r\n\r\n    if (hasBaseClass === true && bodyCanvasAttr === 'on') {\r\n      this.shown = true\r\n    } else {\r\n      this.shown = false\r\n    }\r\n\r\n    // Activate/deactivate\r\n    if (this._getOption('activate') === true) {\r\n      this.element.classList.add(this.options.baseClass)\r\n      this.element.classList.add(`${this.options.baseClass}-${direction}`)\r\n      ElementStyleUtil.set(this.element, 'width', width, true)\r\n\r\n      this.lastWidth = parseInt(width)\r\n    } else {\r\n      ElementStyleUtil.set(this.element, 'width', '')\r\n      this.element.classList.remove(this.options.baseClass)\r\n      this.element.classList.remove(`${this.options.baseClass}-${direction}`)\r\n      this._hide()\r\n    }\r\n  }\r\n\r\n  private _getOption = (name: string) => {\r\n    const attr = this.element.getAttribute(`data-kt-drawer-${name}`)\r\n    if (attr) {\r\n      let value = getAttributeValueByBreakpoint(attr)\r\n      if (value !== null && String(value) === 'true') {\r\n        return true\r\n      } else {\r\n        if (value !== null && String(value) === 'false') {\r\n          return false\r\n        }\r\n      }\r\n\r\n      return value\r\n    } else {\r\n      const optionName = stringSnakeToCamel(name)\r\n      const option = getObjectPropertyValueByKey(this.options, optionName)\r\n      if (option) {\r\n        return getAttributeValueByBreakpoint(option)\r\n      } else {\r\n        return null\r\n      }\r\n    }\r\n  }\r\n\r\n  private _toggle = () => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.drawer.toggle') === false) {\r\n      return\r\n    }\r\n\r\n    if (this.shown) {\r\n      this._hide()\r\n    } else {\r\n      this._show()\r\n    }\r\n\r\n    EventHandlerUtil.trigger(this.element, 'kt.drawer.toggled')\r\n  }\r\n\r\n  private _hide = () => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.drawer.hide') === false) {\r\n      return\r\n    }\r\n\r\n    this.shown = false\r\n    this._deleteOverlay()\r\n    document.body.removeAttribute(`data-kt-drawer-${this.name}`)\r\n    document.body.removeAttribute(`data-kt-drawer`)\r\n    this.element.classList.remove(`${this.options.baseClass}-on`)\r\n    if (this.toggleElement != null) {\r\n      this.toggleElement.classList.remove('active')\r\n    }\r\n\r\n    EventHandlerUtil.trigger(this.element, 'kt.drawer.after.hidden')\r\n  }\r\n\r\n  private _show = () => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.drawer.show') === false) {\r\n      return\r\n    }\r\n\r\n    this.shown = true\r\n    this._createOverlay()\r\n    document.body.setAttribute(`data-kt-drawer-${this.name}`, 'on')\r\n    document.body.setAttribute('data-kt-drawer', 'on')\r\n    this.element.classList.add(`${this.options.baseClass}-on`)\r\n    if (this.toggleElement !== null) {\r\n      this.toggleElement.classList.add('active')\r\n    }\r\n\r\n    EventHandlerUtil.trigger(this.element, 'kt.drawer.shown')\r\n  }\r\n\r\n  private _createOverlay = () => {\r\n    if (this._getOption('overlay') === true) {\r\n      this.overlayElement = document.createElement('DIV')\r\n      const elementZIndex = getCSS(this.element, 'z-index')\r\n      if (elementZIndex) {\r\n        const overlayZindex = parseInt(elementZIndex) - 1\r\n        ElementStyleUtil.set(this.overlayElement, 'z-index', overlayZindex) // update\r\n      }\r\n      document.body.append(this.overlayElement)\r\n      const overlayClassOption = this._getOption('overlay-class')\r\n      if (overlayClassOption) {\r\n        this.overlayElement.classList.add(overlayClassOption.toString())\r\n      }\r\n      this.overlayElement.addEventListener('click', (e) => {\r\n        e.preventDefault()\r\n        this._hide()\r\n      })\r\n    }\r\n  }\r\n\r\n  private _deleteOverlay = () => {\r\n    if (this.overlayElement !== null && this.overlayElement.parentNode) {\r\n      this.overlayElement.parentNode.removeChild(this.overlayElement)\r\n    }\r\n  }\r\n\r\n  private _getDirection = () => {\r\n    return String(this._getOption('direction')) === 'left' ? 'left' : 'right'\r\n  }\r\n\r\n  private _getWidth = () => {\r\n    let width = this._getOption('width')\r\n    if (width && width === 'auto') {\r\n      width = getCSS(this.element, 'width')\r\n    }\r\n\r\n    return width\r\n  }\r\n\r\n  ///////////////////////\r\n  // ** Public API  ** //\r\n  ///////////////////////\r\n  public toggle = () => {\r\n    this._toggle()\r\n  }\r\n\r\n  public show = () => {\r\n    this._show()\r\n  }\r\n\r\n  public hide = () => {\r\n    this._hide()\r\n  }\r\n\r\n  public isShown = () => {\r\n    return this.shown\r\n  }\r\n\r\n  public update = () => {\r\n    this._update()\r\n  }\r\n\r\n  public goElement = () => {\r\n    return this.element\r\n  }\r\n\r\n  // Event API\r\n  public on = (name: string, handler: Function) => {\r\n    return EventHandlerUtil.on(this.element, name, handler)\r\n  }\r\n\r\n  public one = (name: string, handler: Function) => {\r\n    return EventHandlerUtil.one(this.element, name, handler)\r\n  }\r\n\r\n  public off = (name: string) => {\r\n    return EventHandlerUtil.off(this.element, name)\r\n  }\r\n\r\n  public trigger = (name: string, event: Event) => {\r\n    return EventHandlerUtil.trigger(this.element, name, event)\r\n  }\r\n\r\n  // Static methods\r\n  public static hasInstace = (element: HTMLElement): boolean => {\r\n    return DataUtil.has(element, 'drawer')\r\n  }\r\n\r\n  public static getInstance = (element: HTMLElement) => {\r\n    return DataUtil.get(element, 'drawer')\r\n  }\r\n\r\n  public static hideAll = () => {\r\n    const oldInstances = DataUtil.getAllInstancesByKey('drawer')\r\n    oldInstances.forEach((dr) => {\r\n      dr.hide()\r\n    })\r\n  }\r\n\r\n  public static updateAll = () => {\r\n    const oldInstances = DataUtil.getAllInstancesByKey('drawer')\r\n    oldInstances.forEach((dr) => {\r\n      dr.update()\r\n    })\r\n  }\r\n\r\n  // Create Instances\r\n  public static createInstances(selector: string): void {\r\n    const elements = document.body.querySelectorAll(selector)\r\n    elements.forEach((element) => {\r\n      const item = element as HTMLElement\r\n      let drawer = DrawerComponent.getInstance(item)\r\n      if (!drawer) {\r\n        drawer = new DrawerComponent(item, defaultDrawerOptions)\r\n      }\r\n      drawer.hide()\r\n    })\r\n  }\r\n\r\n  // Dismiss instances\r\n  public static handleDismiss = () => {\r\n    // External drawer toggle handler\r\n    DOMEventHandlerUtil.on(document.body, '[data-kt-drawer-dismiss=\"true\"]', 'click', () => {\r\n      /* @ts-ignore */\r\n      const element = this.closest('[data-kt-drawer=\"true\"]')\r\n      if (element) {\r\n        const drawer = DrawerComponent.getInstance(element)\r\n        if (drawer && drawer.isShown()) {\r\n          drawer.hide()\r\n        }\r\n      }\r\n    })\r\n  }\r\n\r\n  // Global Initialization\r\n  public static initGlobalHandlers(): void {\r\n    // Window Resize Handling\r\n    window.addEventListener('resize', function () {\r\n      let timer: number | undefined\r\n      throttle(\r\n        timer,\r\n        () => {\r\n          // Locate and update Drawer instances on window resize\r\n          const elements = document.body.querySelectorAll('[data-kt-drawer=\"true\"]')\r\n          elements.forEach((el) => {\r\n            const item = el as HTMLElement\r\n            const instance = DrawerComponent.getInstance(item)\r\n            if (instance) {\r\n              instance.update()\r\n            }\r\n          })\r\n        },\r\n        200\r\n      )\r\n    })\r\n  }\r\n\r\n  public static bootstrap = () => {\r\n    DrawerComponent.createInstances('[data-kt-drawer=\"true\"]')\r\n    DrawerComponent.initGlobalHandlers()\r\n    DrawerComponent.handleDismiss()\r\n  }\r\n\r\n  public static reinitialization = () => {\r\n    DrawerComponent.createInstances('[data-kt-drawer=\"true\"]')\r\n    DrawerComponent.hideAll()\r\n    DrawerComponent.updateAll()\r\n    DrawerComponent.handleDismiss()\r\n  }\r\n}\r\n\r\nexport {DrawerComponent, defaultDrawerOptions}\r\n"]}