@soyfri/template 1.0.0

package/dist/assets/ts/components/_StickyComponent.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStickyOptions = exports.StickyComponent = void 0;
+var index_1 = require("../_utils/index");
+var defaultStickyOptions = {
+    offset: 200,
+    reverse: false,
+    animation: true,
+    animationSpeed: '0.3s',
+    animationClass: 'animation-slide-in-down',
+};
+exports.defaultStickyOptions = defaultStickyOptions;
+var StickyComponent = /** @class */ (function () {
+    function StickyComponent(_element, options) {
+        var _this = this;
+        this.instanceName = '';
+        this.scroll = function () {
+            var offset = _this.getOption('offset');
+            var reverse = _this.getOption('reverse');
+            // Exit if false
+            if (offset === false) {
+                return;
+            }
+            var offsetNum = 0;
+            if (typeof offset === 'string') {
+                offsetNum = parseInt(offset);
+            }
+            var st = (0, index_1.getScrollTop)();
+            // Reverse scroll mode
+            if (reverse === true) {
+                // Release on reverse scroll mode
+                if (st > offsetNum && _this.lastScrollTop < st) {
+                    if (document.body.hasAttribute(_this.attributeName) === false) {
+                        _this.enable();
+                        document.body.setAttribute(_this.attributeName, 'on');
+                        document.body.setAttribute(_this.attributeName2, 'on');
+                    }
+                    if (_this.eventTriggerState === true) {
+                        index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.on');
+                        index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.change');
+                        _this.eventTriggerState = false;
+                    }
+                }
+                else {
+                    // Back scroll mode
+                    if (document.body.hasAttribute(_this.attributeName)) {
+                        _this.disable();
+                        document.body.removeAttribute(_this.attributeName);
+                        document.body.removeAttribute(_this.attributeName2);
+                    }
+                    if (_this.eventTriggerState === false) {
+                        index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.off');
+                        index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.change');
+                        _this.eventTriggerState = true;
+                    }
+                }
+                _this.lastScrollTop = st;
+                return;
+            }
+            // Classic scroll mode
+            if (st > offsetNum) {
+                if (document.body.hasAttribute(_this.attributeName) === false) {
+                    _this.enable();
+                    document.body.setAttribute(_this.attributeName, 'on');
+                    document.body.setAttribute(_this.attributeName2, 'on');
+                }
+                if (_this.eventTriggerState === true) {
+                    index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.on');
+                    index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.change');
+                    _this.eventTriggerState = false;
+                }
+            }
+            else {
+                // back scroll mode
+                if (document.body.hasAttribute(_this.attributeName) === true) {
+                    _this.disable();
+                    document.body.removeAttribute(_this.attributeName);
+                    document.body.removeAttribute(_this.attributeName2);
+                }
+                if (_this.eventTriggerState === false) {
+                    index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.off');
+                    index_1.EventHandlerUtil.trigger(_this.element, 'kt.sticky.change');
+                    _this.eventTriggerState = true;
+                }
+            }
+        };
+        this.getOption = function (name) {
+            var dataStickyAttr = 'data-kt-sticky-' + name;
+            if (_this.element.hasAttribute(dataStickyAttr) === true) {
+                var attrValueInStr = _this.element.getAttribute(dataStickyAttr);
+                var attrValue = (0, index_1.getAttributeValueByBreakpoint)(attrValueInStr || '');
+                if (attrValue !== null && String(attrValue) === 'true') {
+                    return true;
+                }
+                else if (attrValue !== null && String(attrValue) === 'false') {
+                    return false;
+                }
+                return attrValue;
+            }
+            else {
+                var optionName = (0, index_1.stringSnakeToCamel)(name);
+                var option = (0, index_1.getObjectPropertyValueByKey)(_this.options, optionName);
+                if (option) {
+                    return (0, index_1.getAttributeValueByBreakpoint)(option);
+                }
+            }
+        };
+        this.disable = function () {
+            index_1.ElementStyleUtil.remove(_this.element, 'top');
+            index_1.ElementStyleUtil.remove(_this.element, 'width');
+            index_1.ElementStyleUtil.remove(_this.element, 'left');
+            index_1.ElementStyleUtil.remove(_this.element, 'right');
+            index_1.ElementStyleUtil.remove(_this.element, 'z-index');
+            index_1.ElementStyleUtil.remove(_this.element, 'position');
+        };
+        this.enable = function (update) {
+            if (update === void 0) { update = false; }
+            var top = _this.getOption('top');
+            var left = _this.getOption('left');
+            // const right = this.getOption("right");
+            var width = _this.getOption('width');
+            var zindex = _this.getOption('zindex');
+            if (update !== true && _this.getOption('animation') === true) {
+                index_1.ElementStyleUtil.set(_this.element, 'animationDuration', _this.getOption('animationSpeed'));
+                index_1.ElementAnimateUtil.animateClass(_this.element, 'animation ' + _this.getOption('animationClass'));
+            }
+            if (zindex !== null) {
+                index_1.ElementStyleUtil.set(_this.element, 'z-index', zindex);
+                index_1.ElementStyleUtil.set(_this.element, 'position', 'fixed');
+            }
+            if (top !== null) {
+                index_1.ElementStyleUtil.set(_this.element, 'top', top);
+            }
+            if (width !== null && width !== undefined) {
+                var widthTarget = (0, index_1.getObjectPropertyValueByKey)(width, 'target');
+                if (widthTarget) {
+                    var targetElement = document.querySelector(widthTarget);
+                    if (targetElement) {
+                        width = (0, index_1.getCSS)(targetElement, 'width');
+                    }
+                }
+                index_1.ElementStyleUtil.set(_this.element, 'width', width);
+            }
+            if (left !== null) {
+                if (String(left).toLowerCase() === 'auto') {
+                    var offsetLeft = (0, index_1.getElementOffset)(_this.element).left;
+                    if (offsetLeft > 0) {
+                        index_1.ElementStyleUtil.set(_this.element, 'left', String(offsetLeft) + 'px');
+                    }
+                }
+            }
+        };
+        this.update = function () {
+            if (document.body.hasAttribute(_this.attributeName) === true) {
+                _this.disable();
+                document.body.removeAttribute(_this.attributeName);
+                document.body.removeAttribute(_this.attributeName2);
+                _this.enable(true);
+                document.body.setAttribute(_this.attributeName, 'on');
+                document.body.setAttribute(_this.attributeName2, 'on');
+            }
+        };
+        // Event API
+        this.on = function (name, callBack) {
+            return index_1.EventHandlerUtil.on(_this.element, name, callBack);
+        };
+        this.one = function (name, callback) {
+            return index_1.EventHandlerUtil.one(_this.element, name, callback);
+        };
+        this.off = function (name, handlerId) {
+            return index_1.EventHandlerUtil.off(_this.element, name, handlerId);
+        };
+        this.trigger = function (name) {
+            return index_1.EventHandlerUtil.trigger(_this.element, name);
+        };
+        this.element = _element;
+        this.options = Object.assign(defaultStickyOptions, options);
+        this.instanceUid = (0, index_1.getUniqueIdWithPrefix)('sticky');
+        this.instanceName = this.element.getAttribute('data-kt-sticky-name');
+        this.attributeName = 'data-kt-sticky-' + this.instanceName;
+        this.attributeName2 = 'data-kt-' + this.instanceName;
+        this.eventTriggerState = true;
+        this.lastScrollTop = 0;
+        // Event Handlers
+        window.addEventListener('scroll', this.scroll);
+        // Initial Launch
+        this.scroll();
+        index_1.DataUtil.set(this.element, 'sticky', this);
+    }
+    // Static methods
+    StickyComponent.hasInstace = function (element) {
+        return index_1.DataUtil.has(element, 'sticky');
+    };
+    StickyComponent.getInstance = function (element) {
+        if (element !== null && StickyComponent.hasInstace(element)) {
+            var data = index_1.DataUtil.get(element, 'sticky');
+            if (data) {
+                return data;
+            }
+        }
+    };
+    // Create Instances
+    StickyComponent.createInstances = function (selector) {
+        index_1.DataUtil.getAllInstancesByKey("sticky").forEach(function (stickyInst) {
+            window.removeEventListener("scroll", stickyInst.scroll);
+        });
+        var elements = document.body.querySelectorAll(selector);
+        elements.forEach(function (element) {
+            var item = element;
+            var sticky = StickyComponent.getInstance(item);
+            if (!sticky) {
+                sticky = new StickyComponent(item, defaultStickyOptions);
+            }
+        });
+    };
+    StickyComponent.bootstrap = function (attr) {
+        if (attr === void 0) { attr = '[data-kt-sticky="true"]'; }
+        StickyComponent.createInstances(attr);
+    };
+    StickyComponent.reInitialization = function (attr) {
+        if (attr === void 0) { attr = '[data-kt-sticky="true"]'; }
+        StickyComponent.createInstances(attr);
+    };
+    StickyComponent.createInsance = function (selector, options) {
+        if (options === void 0) { options = defaultStickyOptions; }
+        var element = document.body.querySelector(selector);
+        if (!element) {
+            return;
+        }
+        var item = element;
+        var sticky = StickyComponent.getInstance(item);
+        if (!sticky) {
+            sticky = new StickyComponent(item, options);
+        }
+        return sticky;
+    };
+    return StickyComponent;
+}());
+exports.StickyComponent = StickyComponent;

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

@@ -0,0 +1,36 @@
+export declare class SwapperStore {
+    static store: Map<string, SwapperComponent>;
+    static set(instanceId: string, drawerComponentObj: SwapperComponent): void;
+    static get(instanceId: string): SwapperComponent | undefined;
+    static remove(instanceId: string): void;
+    static has(instanceId: string): boolean;
+    static getAllInstances(): Map<string, SwapperComponent>;
+}
+export interface ISwapperOptions {
+    mode: string;
+}
+export interface ISwapperQueries {
+    componentName: string;
+    instanseQuery: string;
+    attrQuery: string;
+}
+declare const defaultSwapperOptions: ISwapperOptions;
+declare const defaultSwapperQueires: ISwapperQueries;
+declare class SwapperComponent {
+    element: HTMLElement;
+    options: ISwapperOptions;
+    queries: ISwapperQueries;
+    constructor(_element: HTMLElement, _options: ISwapperOptions, _queries: ISwapperQueries);
+    private getOption;
+    update: () => void;
+    on: (name: string, handler: Function) => void;
+    one: (name: string, handler: Function) => void;
+    off: (name: string, handlerId: string) => void;
+    trigger: (name: string, event: Event) => boolean;
+    static getInstance: (el: HTMLElement, componentName?: string) => SwapperComponent | null;
+    static createInstances: (selector?: string, options?: ISwapperOptions, queries?: ISwapperQueries) => void;
+    static createInsance: (selector?: string, options?: ISwapperOptions, queries?: ISwapperQueries) => SwapperComponent | undefined;
+    static bootstrap: (selector?: string) => void;
+    static reinitialization: (selector?: string) => void;
+}
+export { SwapperComponent, defaultSwapperOptions, defaultSwapperQueires };

package/dist/assets/ts/components/_SwapperComponent.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSwapperQueires = exports.defaultSwapperOptions = exports.SwapperComponent = exports.SwapperStore = void 0;
+var index_1 = require("../_utils/index");
+var SwapperStore = /** @class */ (function () {
+    function SwapperStore() {
+    }
+    SwapperStore.set = function (instanceId, drawerComponentObj) {
+        if (SwapperStore.has(instanceId)) {
+            return;
+        }
+        SwapperStore.store.set(instanceId, drawerComponentObj);
+    };
+    SwapperStore.get = function (instanceId) {
+        if (!SwapperStore.has(instanceId)) {
+            return;
+        }
+        return SwapperStore.store.get(instanceId);
+    };
+    SwapperStore.remove = function (instanceId) {
+        if (!SwapperStore.has(instanceId)) {
+            return;
+        }
+        SwapperStore.store.delete(instanceId);
+    };
+    SwapperStore.has = function (instanceId) {
+        return SwapperStore.store.has(instanceId);
+    };
+    SwapperStore.getAllInstances = function () {
+        return SwapperStore.store;
+    };
+    SwapperStore.store = new Map();
+    return SwapperStore;
+}());
+exports.SwapperStore = SwapperStore;
+var defaultSwapperOptions = {
+    mode: 'append',
+};
+exports.defaultSwapperOptions = defaultSwapperOptions;
+var defaultSwapperQueires = {
+    componentName: 'swapper',
+    instanseQuery: '[data-kt-swapper="true"]',
+    attrQuery: 'data-kt-swapper-',
+};
+exports.defaultSwapperQueires = defaultSwapperQueires;
+var SwapperComponent = /** @class */ (function () {
+    function SwapperComponent(_element, _options, _queries) {
+        var _this = this;
+        ///////////////////////
+        // ** Public API  ** //
+        ///////////////////////
+        this.update = function () {
+            var _a;
+            var parentSelector = (_a = _this.getOption('parent')) === null || _a === void 0 ? void 0 : _a.toString();
+            var mode = _this.getOption('mode');
+            var parentElement = parentSelector ? document.querySelector(parentSelector) : null;
+            if (parentElement && _this.element.parentNode !== parentElement) {
+                var alreadyPended = document.getElementById('kt_header_menu') !== null;
+                if (!alreadyPended) {
+                    if (mode === 'prepend') {
+                        parentElement.prepend(_this.element);
+                    }
+                    else if (mode === 'append') {
+                        parentElement.append(_this.element);
+                    }
+                }
+            }
+        };
+        // Event API
+        this.on = function (name, handler) {
+            return index_1.EventHandlerUtil.on(_this.element, name, handler);
+        };
+        this.one = function (name, handler) {
+            return index_1.EventHandlerUtil.one(_this.element, name, handler);
+        };
+        this.off = function (name, handlerId) {
+            return index_1.EventHandlerUtil.off(_this.element, name, handlerId);
+        };
+        this.trigger = function (name, event) {
+            return index_1.EventHandlerUtil.trigger(_this.element, name, event);
+        };
+        this.element = _element;
+        this.options = Object.assign(defaultSwapperOptions, _options);
+        this.queries = _queries;
+        // Initial update
+        this.update();
+        SwapperStore.set(this.element.id, this);
+    }
+    SwapperComponent.prototype.getOption = function (name) {
+        var attr = this.element.getAttribute("".concat(this.queries.attrQuery).concat(name));
+        if (attr) {
+            var value = (0, index_1.getAttributeValueByBreakpoint)(attr);
+            if (attr != null && String(value) === 'true') {
+                return true;
+            }
+            else if (value !== null && String(value) === 'false') {
+                return false;
+            }
+            return value;
+        }
+        else {
+            var optionName = (0, index_1.stringSnakeToCamel)(name);
+            var option = (0, index_1.getObjectPropertyValueByKey)(this.options, optionName);
+            if (option) {
+                return (0, index_1.getAttributeValueByBreakpoint)(option);
+            }
+            else {
+                return null;
+            }
+        }
+    };
+    // Static methods
+    SwapperComponent.getInstance = function (el, componentName) {
+        if (componentName === void 0) { componentName = defaultSwapperQueires.componentName; }
+        var place = SwapperStore.get(el.id);
+        if (place) {
+            return place;
+        }
+        return null;
+    };
+    SwapperComponent.createInstances = function (selector, options, queries) {
+        if (selector === void 0) { selector = defaultSwapperQueires.instanseQuery; }
+        if (options === void 0) { options = defaultSwapperOptions; }
+        if (queries === void 0) { queries = defaultSwapperQueires; }
+        var elements = document.body.querySelectorAll(selector);
+        elements.forEach(function (el) {
+            var item = el;
+            var place = SwapperComponent.getInstance(item);
+            if (!place) {
+                place = new SwapperComponent(item, options, queries);
+            }
+        });
+    };
+    SwapperComponent.createInsance = function (selector, options, queries) {
+        if (selector === void 0) { selector = defaultSwapperQueires.instanseQuery; }
+        if (options === void 0) { options = defaultSwapperOptions; }
+        if (queries === void 0) { queries = defaultSwapperQueires; }
+        var element = document.body.querySelector(selector);
+        if (!element) {
+            return;
+        }
+        var item = element;
+        var place = SwapperComponent.getInstance(item);
+        if (!place) {
+            place = new SwapperComponent(item, options, queries);
+        }
+        return place;
+    };
+    SwapperComponent.bootstrap = function (selector) {
+        if (selector === void 0) { selector = defaultSwapperQueires.instanseQuery; }
+        SwapperComponent.createInstances(selector);
+    };
+    SwapperComponent.reinitialization = function (selector) {
+        if (selector === void 0) { selector = defaultSwapperQueires.instanseQuery; }
+        SwapperComponent.createInstances(selector);
+    };
+    return SwapperComponent;
+}());
+exports.SwapperComponent = SwapperComponent;
+// Window resize handler
+window.addEventListener('resize', function () {
+    var timer;
+    (0, index_1.throttle)(timer, function () {
+        // Locate and update Offcanvas instances on window resize
+        var elements = document.querySelectorAll(defaultSwapperQueires.instanseQuery);
+        elements.forEach(function (el) {
+            var place = SwapperComponent.getInstance(el);
+            if (place) {
+                place.update();
+            }
+        });
+    }, 200);
+});

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

@@ -0,0 +1,36 @@
+export interface ToggleOptions {
+    saveState: boolean;
+    targetState?: string;
+    toggleState?: string;
+    targetToggleMode?: string;
+}
+declare const defaultToggleOptions: ToggleOptions;
+declare class ToggleComponent {
+    element: HTMLElement;
+    instanceUid: string;
+    options: ToggleOptions;
+    state: string;
+    mode: string;
+    target: HTMLElement | null;
+    attribute: string;
+    constructor(_element: HTMLElement, options: ToggleOptions);
+    private _handlers;
+    private _toggle;
+    private _enable;
+    private _disable;
+    private _isEnabled;
+    toggle: () => this;
+    enable: () => this | undefined;
+    disable: () => false | this;
+    isEnabled: () => boolean;
+    goElement: () => HTMLElement;
+    on: (name: string, handler: Function) => void;
+    one: (name: string, handler: Function) => void;
+    off: (name: string, handlerId: string) => void;
+    trigger: (name: string, event?: Event) => boolean;
+    static getInstance: (el: HTMLElement) => {} | null;
+    static createInstances: (selector: string) => void;
+    static reinitialization: () => void;
+    static bootstrap: () => void;
+}
+export { ToggleComponent, defaultToggleOptions };

package/dist/assets/ts/components/_ToggleComponent.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultToggleOptions = exports.ToggleComponent = void 0;
+var index_1 = require("../_utils/index");
+// Helpers
+var _CookieComponent_1 = require("./_CookieComponent");
+var defaultToggleOptions = {
+    saveState: false,
+};
+exports.defaultToggleOptions = defaultToggleOptions;
+var ToggleComponent = /** @class */ (function () {
+    function ToggleComponent(_element, options) {
+        var _this = this;
+        this.state = '';
+        this.mode = '';
+        this.target = null;
+        this.attribute = '';
+        this._handlers = function () {
+            _this.element.addEventListener('click', function (e) {
+                e.preventDefault();
+                if (_this.mode === '') {
+                    _this._toggle();
+                    return;
+                }
+                if (_this.mode === 'off' && !_this._isEnabled()) {
+                    _this._toggle();
+                }
+                else if (_this.mode === 'on' && _this._isEnabled()) {
+                    _this._toggle();
+                }
+            });
+        };
+        // Event handlers
+        this._toggle = function () {
+            // Trigger "after.toggle" event
+            index_1.EventHandlerUtil.trigger(_this.element, 'kt.toggle.change');
+            if (_this._isEnabled()) {
+                _this._disable();
+            }
+            else {
+                _this._enable();
+            }
+            // Trigger "before.toggle" event
+            index_1.EventHandlerUtil.trigger(_this.element, 'kt.toggle.changed');
+            return _this;
+        };
+        this._enable = function () {
+            var _a;
+            if (_this._isEnabled()) {
+                return;
+            }
+            index_1.EventHandlerUtil.trigger(_this.element, 'kt.toggle.enable');
+            (_a = _this.target) === null || _a === void 0 ? void 0 : _a.setAttribute(_this.attribute, 'on');
+            if (_this.state.length > 0) {
+                _this.element.classList.add(_this.state);
+            }
+            if (_this.options.saveState) {
+                _CookieComponent_1.CookieComponent.set(_this.attribute, 'on', {});
+            }
+            index_1.EventHandlerUtil.trigger(_this.element, 'kt.toggle.enabled');
+            return _this;
+        };
+        this._disable = function () {
+            var _a;
+            if (!_this._isEnabled()) {
+                return false;
+            }
+            index_1.EventHandlerUtil.trigger(_this.element, 'kt.toggle.disable');
+            (_a = _this.target) === null || _a === void 0 ? void 0 : _a.removeAttribute(_this.attribute);
+            if (_this.state.length > 0) {
+                _this.element.classList.remove(_this.state);
+            }
+            if (_this.options.saveState) {
+                _CookieComponent_1.CookieComponent.delete(_this.attribute);
+            }
+            index_1.EventHandlerUtil.trigger(_this.element, 'kt.toggle.disabled');
+            return _this;
+        };
+        this._isEnabled = function () {
+            if (!_this.target) {
+                return false;
+            }
+            return String(_this.target.getAttribute(_this.attribute)).toLowerCase() === 'on';
+        };
+        ///////////////////////
+        // ** Public API  ** //
+        ///////////////////////
+        // Plugin API
+        // Plugin API
+        this.toggle = function () {
+            return _this._toggle();
+        };
+        this.enable = function () {
+            return _this._enable();
+        };
+        this.disable = function () {
+            return _this._disable();
+        };
+        this.isEnabled = function () {
+            return _this._isEnabled();
+        };
+        this.goElement = function () {
+            return _this.element;
+        };
+        // Event API
+        this.on = function (name, handler) {
+            return index_1.EventHandlerUtil.on(_this.element, name, handler);
+        };
+        this.one = function (name, handler) {
+            return index_1.EventHandlerUtil.one(_this.element, name, handler);
+        };
+        this.off = function (name, handlerId) {
+            return index_1.EventHandlerUtil.off(_this.element, name, handlerId);
+        };
+        this.trigger = function (name, event) {
+            return index_1.EventHandlerUtil.trigger(_this.element, name, event);
+        };
+        this.options = Object.assign(defaultToggleOptions, options);
+        this.instanceUid = (0, index_1.getUniqueIdWithPrefix)('toggle');
+        this.element = _element;
+        var elementTargetAttr = this.element.getAttribute('data-kt-toggle-target');
+        if (elementTargetAttr) {
+            this.target = document.querySelector(elementTargetAttr);
+        }
+        var elementToggleAttr = this.element.getAttribute('data-kt-toggle-state');
+        this.state = elementToggleAttr || '';
+        var elementModeAttr = this.element.getAttribute('data-kt-toggle-mode');
+        this.mode = elementModeAttr || '';
+        this.attribute = 'data-kt-' + this.element.getAttribute('data-kt-toggle-name');
+        // Event Handlers
+        this._handlers();
+        // Update Instance
+        // Bind Instance
+        index_1.DataUtil.set(this.element, 'toggle', this);
+    }
+    // Static methods
+    ToggleComponent.getInstance = function (el) {
+        var toggleElement = index_1.DataUtil.get(el, 'toggle');
+        if (toggleElement) {
+            return toggleElement;
+        }
+        return null;
+    };
+    ToggleComponent.createInstances = function (selector) {
+        var elements = document.body.querySelectorAll(selector);
+        elements.forEach(function (el) {
+            var toggle = ToggleComponent.getInstance(el);
+            if (!toggle) {
+                toggle = new ToggleComponent(el, defaultToggleOptions);
+            }
+        });
+    };
+    ToggleComponent.reinitialization = function () {
+        ToggleComponent.createInstances('[data-kt-toggle]');
+    };
+    ToggleComponent.bootstrap = function () {
+        ToggleComponent.createInstances('[data-kt-toggle]');
+    };
+    return ToggleComponent;
+}());
+exports.ToggleComponent = ToggleComponent;

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

@@ -0,0 +1,13 @@
+export * from './_CookieComponent';
+export * from './_DrawerComponent';
+export * from './_FeedbackComponent';
+export * from './_ImageInputComponent';
+export * from './_ScrollComponent';
+export * from './_ScrollTopComponent';
+export * from './_StepperComponent';
+export * from './_StickyComponent';
+export * from './_ToggleComponent';
+export * from './_PasswordMeterComponent';
+export * from './_SwapperComponent';
+export * from './MenuComponent';
+export * from './SearchComponent';