HTTP/1.1 200 Connection established

HTTP/1.1 200 OK
Date: Tue, 16 Apr 2024 20:37:51 GMT
Server: Apache/2.4.6 (CentOS) mpm-itk/2.4.7-04 OpenSSL/1.0.2k-fips PHP/7.4.33
X-Powered-By: PHP/7.4.33
Etag: "4fc5eeff399f986c72eecc29f615eaed"
Cache-Control: public, max-age=2592000
Connection: close
Transfer-Encoding: chunked
Content-Type: application/javascript; charset=

(function (global, factory) {
    if (typeof define === "function" && define.amd) {
        define(['exports'], factory);
    } else if (typeof exports !== "undefined") {
        factory(exports);
    } else {
        var mod = {
            exports: {}
        };
        factory(mod.exports);
        global.eventEmitter = mod.exports;
    }
})(this, function (exports) {
    'use strict';

    Object.defineProperty(exports, "__esModule", {
        value: true
    });

    function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
        }
    }

    var _createClass = function () {
        function defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }

        return function (Constructor, protoProps, staticProps) {
            if (protoProps) defineProperties(Constructor.prototype, protoProps);
            if (staticProps) defineProperties(Constructor, staticProps);
            return Constructor;
        };
    }();

    var EventEmitter = function () {
        function EventEmitter() {
            _classCallCheck(this, EventEmitter);

            this._queue = [];
        }

        _createClass(EventEmitter, [{
            key: 'emit',
            value: function emit() {
                for (var _len = arguments.length, argv = Array(_len), _key = 0; _key < _len; _key++) {
                    argv[_key] = arguments[_key];
                }

                this._queue.forEach(function (handler) {

                    handler.apply(undefined, argv);
                });
            }
        }, {
            key: 'push',
            value: function push(handler) {

                this._queue.push(handler);
                return this;
            }
        }, {
            key: 'clear',
            value: function clear() {

                this._queue = [];
            }
        }]);

        return EventEmitter;
    }();

    exports.default = EventEmitter;
});

(function (global, factory) {
    if (typeof define === "function" && define.amd) {
        define(['exports', 'event-emitter.js'], factory);
    } else if (typeof exports !== "undefined") {
        factory(exports, require('event-emitter.js'));
    } else {
        var mod = {
            exports: {}
        };
        factory(mod.exports, global.eventEmitter);
        global.tab = mod.exports;
    }
})(this, function (exports, _eventEmitter) {
    'use strict';

    Object.defineProperty(exports, "__esModule", {
        value: true
    });

    var _eventEmitter2 = _interopRequireDefault(_eventEmitter);

    function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : {
            default: obj
        };
    }

    function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
        }
    }

    var _createClass = function () {
        function defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }

        return function (Constructor, protoProps, staticProps) {
            if (protoProps) defineProperties(Constructor.prototype, protoProps);
            if (staticProps) defineProperties(Constructor, staticProps);
            return Constructor;
        };
    }();

    var Tab = function () {
        function Tab(node) {
            _classCallCheck(this, Tab);

            this._node = node;
            this._status = null;
            this._frame = null;
            this._behavior = 'default';
            this._events = {
                'statusChange': new _eventEmitter2.default()
            };

            this._extractFrame();
            this._extractStatus();
            this._extractBehavior();
        }

        _createClass(Tab, [{
            key: '_extractFrame',
            value: function _extractFrame() {

                var node = this._node;
                var frame = node.dataset['tabFrame'];
                if (!frame) return;

                frame = document.querySelector(frame);
                if (!frame) return;

                this.combineWithFrame(frame);
            }
        }, {
            key: '_extractStatus',
            value: function _extractStatus() {

                var node = this._node;
                var status = node.dataset['tabSelected'];

                if (status) this.show();else this.hide();
            }
        }, {
            key: '_extractBehavior',
            value: function _extractBehavior() {

                var node = this._node;
                this._behavior = node.dataset['tabBehavior'];
            }
        }, {
            key: 'getBehavior',
            value: function getBehavior() {

                return this._behavior;
            }
        }, {
            key: 'setBehavior',
            value: function setBehavior(behavior) {

                this._behavior = behavior;
                return this;
            }
        }, {
            key: 'combineWithFrame',
            value: function combineWithFrame(node) {

                this._frame = node;
            }
        }, {
            key: 'show',
            value: function show() {

                var node = this._node;
                var frame = this._frame;
                var event = this._events['statusChange'];

                node.classList.add('active');
                node.classList.remove('inactive');

                frame.classList.add('active');
                frame.classList.remove('inactive');

                this._status = 'active';
                event.emit(this._status, this);
            }
        }, {
            key: 'hide',
            value: function hide() {

                var node = this._node;
                var frame = this._frame;
                var event = this._events['statusChange'];

                node.classList.add('inactive');
                node.classList.remove('active');

                frame.classList.add('inactive');
                frame.classList.remove('active');

                this._status = 'inactive';
                event.emit(this._status, this);
            }
        }, {
            key: 'toggle',
            value: function toggle() {

                if (this._status === 'inactive') this.show();else this.hide();
            }
        }, {
            key: 'getNode',
            value: function getNode() {

                return this._node;
            }
        }, {
            key: 'isActive',
            value: function isActive() {

                return this._status === 'active';
            }
        }, {
            key: 'on',
            value: function on(eventName, handler) {

                var events = this._events;

                if (events[eventName]) {

                    var emitter = events[eventName];
                    emitter.push(handler);
                }
            }
        }]);

        return Tab;
    }();

    window.Tab = Tab;

    exports.default = Tab;
});

(function (global, factory) {
    if (typeof define === "function" && define.amd) {
        define(["exports", "tab.js"], factory);
    } else if (typeof exports !== "undefined") {
        factory(exports, require("tab.js"));
    } else {
        var mod = {
            exports: {}
        };
        factory(mod.exports, global.tab);
        global.tabs = mod.exports;
    }
})(this, function (exports, _tab) {
    'use strict';

    Object.defineProperty(exports, "__esModule", {
        value: true
    });

    var _tab2 = _interopRequireDefault(_tab);

    function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : {
            default: obj
        };
    }

    function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
        }
    }

    var _createClass = function () {
        function defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }

        return function (Constructor, protoProps, staticProps) {
            if (protoProps) defineProperties(Constructor.prototype, protoProps);
            if (staticProps) defineProperties(Constructor, staticProps);
            return Constructor;
        };
    }();

    var Tabs = function () {
        function Tabs() {
            var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

            _classCallCheck(this, Tabs);

            this._tabsPool = [];

            if (selector !== null) this.add(selector);
        }

        _createClass(Tabs, [{
            key: "add",
            value: function add() {
                var _this = this;

                var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ".tab";


                var nodeList = document.querySelectorAll(selector);
                var nodes = [].slice.call(nodeList);

                nodes.forEach(function (node) {

                    var tab = new _tab2.default(node);
                    _this.addTab(tab);
                });
            }
        }, {
            key: "addTab",
            value: function addTab(tab) {
                var _this2 = this;

                this._tabsPool.push(tab);
                var node = tab.getNode();

                node.addEventListener('click', function () {

                    var behavior = tab.getBehavior();

                    switch (behavior) {

                        case 'toggle':
                            _this2.hideAll(tab);
                            tab.toggle();
                            break;

                        default:
                            _this2.hideAll();
                            tab.show();
                            break;

                    }
                });
            }
        }, {
            key: "hideAll",
            value: function hideAll(except) {

                var tabs = this._tabsPool;

                tabs.forEach(function (tab) {

                    if (except === tab) return;

                    tab.hide();
                });
            }
        }]);

        return Tabs;
    }();

    window.Tabs = Tabs;

    exports.default = Tabs;
});


//# sourceMappingURL=maps/tabs.min.js.map