File Manager

Editing File: /home/maglabs/it/lib/web/jquery/bootstrap/tab.js

/**
 * --------------------------------------------------------------------------
 * Bootstrap (v5.1.3): tab.js and base-component.js
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
 * --------------------------------------------------------------------------
 */

define([
    "./util/index",
    "./dom/event-handler",
    "./dom/selector-engine"
], function(Util, EventHandler, SelectorEngine) {
    'use strict';

const defineJQueryPlugin = Util.defineJQueryPlugin;
    const executeAfterTransition = Util.executeAfterTransition;
    const getElement = Util.getElement;
    const getElementFromSelector = Util.getElementFromSelector;
    const isDisabled = Util.isDisabled;
    const reflow = Util.reflow;

/**
     * ------------------------------------------------------------------------
     * Constants
     * ------------------------------------------------------------------------
     */

const VERSION = '5.1.3';
    const NAME = 'tab';
    const DATA_KEY = 'bs.tab';
    const EVENT_KEY = `.${DATA_KEY}`;
    const DATA_API_KEY = '.data-api';

const CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
    const CLASS_NAME_ACTIVE = 'active';
    const CLASS_NAME_FADE = 'fade';
    const CLASS_NAME_SHOW = 'show';

const SELECTOR_DROPDOWN = '.dropdown';
    const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
    const SELECTOR_ACTIVE = '.active';
    const SELECTOR_ACTIVE_UL = ':scope > li > .active';
    const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
    const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
    const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';

/**
     * ------------------------------------------------------------------------
     * Class Definition
     * ------------------------------------------------------------------------
     */

function Tab(element) {
        element = getElement(element);

if (!element) {
            return;
        }

this._element = element;
        Data.set(this._element, DATA_KEY, this);
    }

// Getters

Tab.VERSION = VERSION;

Tab.NAME = NAME;

Tab.DATA_KEY = 'bs.' + Tab.NAME;

Tab.EVENT_KEY = '.' + Tab.DATA_KEY;

// Public

Tab.prototype.dispose = function() {
        Data.remove(this._element, this.constructor.DATA_KEY);
        EventHandler.off(this._element, this.constructor.EVENT_KEY);

Object.getOwnPropertyNames(this).forEach(propertyName => {
            this[propertyName] = null;
        })
    }

Tab.prototype._queueCallback = function(callback, element, isAnimated = true) {
        executeAfterTransition(callback, element, isAnimated);
    }

Tab.prototype.show = function() {
        if ((this._element.parentNode &&
            this._element.parentNode.nodeType === Node.ELEMENT_NODE &&
            this._element.classList.contains(CLASS_NAME_ACTIVE))) {
            return;
        }

let previous;
        const target = getElementFromSelector(this._element);
        const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP);

if (listElement) {
            const itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE;
            previous = SelectorEngine.find(itemSelector, listElement);
            previous = previous[previous.length - 1];
        }

const hideEvent = previous ?
            EventHandler.trigger(previous, EVENT_HIDE, {
                relatedTarget: this._element
            }) :
            null;

const showEvent = EventHandler.trigger(this._element, EVENT_SHOW, {
            relatedTarget: previous
        });

if (showEvent.defaultPrevented || (hideEvent !== null && hideEvent.defaultPrevented)) {
            return;
        }

this._activate(this._element, listElement);

if (target) {
            this._activate(target, target.parentNode, complete);
        } else {
            complete();
        }
    }

// Private

Tab.prototype._activate = function(element, container, callback) {
        const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ?
            SelectorEngine.find(SELECTOR_ACTIVE_UL, container) :
            SelectorEngine.children(container, SELECTOR_ACTIVE);

const active = activeElements[0];
        const isTransitioning = callback && (active && active.classList.contains(CLASS_NAME_FADE));

const complete = () => this._transitionComplete(element, active, callback);

if (active && isTransitioning) {
            active.classList.remove(CLASS_NAME_SHOW);
            this._queueCallback(complete, element, true);
        } else {
            complete();
        }
    }

Tab.prototype._transitionComplete = function(element, active, callback) {
        if (active) {
            active.classList.remove(CLASS_NAME_ACTIVE);

const dropdownChild = SelectorEngine.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode);

if (dropdownChild) {
                dropdownChild.classList.remove(CLASS_NAME_ACTIVE);
            }

if (active.getAttribute('role') === 'tab') {
                active.setAttribute('aria-selected', false);
            }
        }

element.classList.add(CLASS_NAME_ACTIVE);
        if (element.getAttribute('role') === 'tab') {
            element.setAttribute('aria-selected', true);
        }

reflow(element);

if (element.classList.contains(CLASS_NAME_FADE)) {
            element.classList.add(CLASS_NAME_SHOW);
        }

let parent = element.parentNode;
        if (parent && parent.nodeName === 'LI') {
            parent = parent.parentNode;
        }

if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
            const dropdownElement = element.closest(SELECTOR_DROPDOWN);

if (dropdownElement) {
                SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement)
                    .forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE));
            }

element.setAttribute('aria-expanded', true);
        }

if (callback) {
            callback();
        }
    }

// Static

Tab.getInstance = function(element) {
        return Data.get(getElement(element), this.DATA_KEY);
    }

Tab.getOrCreateInstance = function(element, config = {}) {
        return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
    }

Tab.jQueryInterface = function(config) {
        return this.each(function () {
            const data = Tab.getOrCreateInstance(this);

if (typeof config === 'string') {
                if (typeof data[config] === 'undefined') {
                    throw new TypeError(`No method named "${config}"`);
                }

data[config]();
            }
        })
    }

/**
     * ------------------------------------------------------------------------
     * Data Api implementation
     * ------------------------------------------------------------------------
     */

EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
        if (['A', 'AREA'].includes(this.tagName)) {
            event.preventDefault();
        }

if (isDisabled(this)) {
            return;
        }

const data = Tab.getOrCreateInstance(this);
        data.show();
    })

/**
     * ------------------------------------------------------------------------
     * jQuery
     * ------------------------------------------------------------------------
     * add .Tab to jQuery only if jQuery is present
     */

defineJQueryPlugin(Tab);

return Tab;
});

Back to Directory File Manager