Subversion Repositories SmartDukaan

/**
 * Debug Toolbar Javascript.
 *
 * Creates the DEBUGKIT namespace and provides methods for extending
 * and enhancing the Html toolbar. Includes library agnostic Event, Element,
 * Cookie and Request wrappers.
 *
 *
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://cakephp.org CakePHP(tm) Project
 * @since         DebugKit 0.1
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

/* jshint jquery: true */

var DEBUGKIT = function () {
        var undef;
        return {
                module: function (newmodule) {
                        if (this[newmodule] === undef) {
                                this[newmodule] = {};
                                return this[newmodule];
                        }
                        return this[newmodule];
                }
        };
}();

(function () {
        function versionGTE(a, b) {
                var len = Math.min(a.length, b.length);
                for (var i = 0; i < len; i++) {
                        a[i] = parseInt(a[i], 10);
                        b[i] = parseInt(b[i], 10);
                        if (a[i] > b[i]) {
                                return true;
                        }
                        if (a[i] < b[i]) {
                                return false;
                        }
                }
                return true;
        }

        function versionWithin(version, min, max) {
                version = version.split('.');
                min = min.split('.');
                max = max.split('.');
                return versionGTE(version, min) && versionGTE(max, version);
        }

        // Look for existing jQuery that matches the requirements.
        if (window.jQuery && versionWithin(jQuery.fn.jquery, "1.8", "2.1")) {
                DEBUGKIT.$ = window.jQuery;
        } else {
                // sync load the file. Using document.write() does not block
                // in recent versions of chrome.
                var req = new XMLHttpRequest();
                req.onload = function () {
                        eval(this.responseText);
                        // Restore both $ and jQuery to the original values.
                        DEBUGKIT.$ = jQuery.noConflict(true);
                };
                req.open('get', window.DEBUGKIT_JQUERY_URL, false);
                req.send();
        }
})();

DEBUGKIT.loader = function () {
        return {
                // List of methods to run on startup.
                _startup: [],

                // Register a new method to be run on dom ready.
                register: function (method) {
                        this._startup.push(method);
                },

                init: function () {
                        for (var i = 0, callback; callback = this._startup[i]; i++) {
                                callback.init();
                        }
                }
        };
}();

DEBUGKIT.module('sqlLog');
DEBUGKIT.sqlLog = function () {
        var $ = DEBUGKIT.$;

        return {
                init : function () {
                        var sqlPanel = $('#sql_log-tab');
                        var buttons = sqlPanel.find('input');

                        // Button handling code for explain links.
                        // Performs XHR request to get explain query.
                        var handleButton = function (event) {
                                event.preventDefault();
                                var form = $(this.form),
                                        data = form.serialize(),
                                        dbName = form.find('input[name*=ds]').val() || 'default';

                                var fetch = $.ajax({
                                        url: this.form.action,
                                        data: data,
                                        type: 'POST',
                                        success : function (response) {
                                                $('#sql-log-explain-' + dbName).html(response);
                                        },
                                        error : function () {
                                                alert('Could not fetch EXPLAIN for query.');
                                        }
                                });
                        };

                        buttons.filter('.sql-explain-link').on('click', handleButton);
                }
        };
}();
DEBUGKIT.loader.register(DEBUGKIT.sqlLog);

//
// NOTE DEBUGKIT.Util.Element is Deprecated.
//
// Util module and Element utility class.
DEBUGKIT.module('Util');
DEBUGKIT.Util.Element = {

        // Test if an element is a name node.
        nodeName: function (element, name) {
                return element.nodeName && element.nodeName.toLowerCase() === name.toLowerCase();
        },

        // Return a boolean if the element has the classname
        hasClass: function (element, className) {
                if (!element.className) {
                        return false;
                }
                return element.className.indexOf(className) > -1;
        },

        addClass: function (element, className) {
                if (!element.className) {
                        element.className = className;
                        return;
                }
                element.className = element.className.replace(/^(.*)$/, '$1 ' + className);
        },

        removeClass: function (element, className) {
                if (DEBUGKIT.Util.isArray(element)) {
                        DEBUGKIT.Util.Collection.apply(element, function (element) {
                                DEBUGKIT.Util.Element.removeClass(element, className);
                        });
                }
                if (!element.className) {
                        return false;
                }
                element.className = element.className.replace(new RegExp(' ?(' + className + ') ?'), '');
        },

        swapClass: function (element, removeClass, addClass) {
                if (!element.className) {
                        return false;
                }
                element.className = element.className.replace(removeClass, addClass);
        },

        show: function (element) {
                element.style.display = 'block';
        },

        hide: function (element) {
                element.style.display = 'none';
        },

        // Go between hide() and show() depending on element.style.display
        toggle: function (element) {
                if (element.style.display === 'none') {
                        this.show(element);
                        return;
                }
                this.hide(element);
        },

        _walk: function (element, walk) {
                var sibling = element[walk];
                while (true) {
                        if (sibling.nodeType == 1) {
                                break;
                        }
                        sibling = sibling[walk];
                }
                return sibling;
        },

        getNext: function (element) {
                return this._walk(element, 'nextSibling');
        },

        getPrevious: function (element) {
                return this._walk(element, 'previousSibling');
        },

        // Get or set an element's height, omit value to get, add value (integer) to set.
        height: function (element, value) {
                // Get value
                if (value === undefined) {
                        return parseInt(this.getStyle(element, 'height'), 10);
                }
                element.style.height = value + 'px';
        },

        // Gets the style in css format for property
        getStyle: function (element, property) {
                if (element.currentStyle) {
                        property = property.replace(/-[a-z]/g, function (match) {
                                return match.charAt(1).toUpperCase();
                        });
                        return element.currentStyle[property];
                }
                if (window.getComputedStyle) {
                        return document.defaultView.getComputedStyle(element, null).getPropertyValue(property);
                }
        }
};

//
// NOTE DEBUGKIT.Util.Collection is Deprecated.
//
DEBUGKIT.Util.Collection = {
        /**
         * Apply the passed function to each item in the collection.
         * The current element in the collection will be `this` in the callback
         * The callback is also passed the element and the index as arguments.
         * Optionally you can supply a binding parameter to change `this` in the callback.
         */
        apply: function (collection, callback, binding) {
                var name, thisVar, i = 0, len = collection.length;

                if (len === undefined) {
                        for (name in collection) {
                                thisVar = (binding === undefined) ? collection[name] : binding;
                                callback.apply(thisVar, [collection[name], name]);
                        }
                } else {
                        for (; i < len; i++) {
                                thisVar = (binding === undefined) ? collection[i] : binding;
                                callback.apply(thisVar, [collection[i], i]);
                        }
                }
        }
};

//
// NOTE DEBUGKIT.Util.Event is Deprecated.
//
// Event binding
DEBUGKIT.Util.Event = function () {
        var _listeners = {},
                _eventId = 0;

        var preventDefault = function () {
                this.returnValue = false;
        };

        var stopPropagation = function () {
                this.cancelBubble = true;
        };

        // Fixes IE's broken event object, adds in common methods + properties.
        var fixEvent = function (event) {
                if (!event.preventDefault) {
                        event.preventDefault = preventDefault;
                }
                if (!event.stopPropagation) {
                        event.stopPropagation = stopPropagation;
                }
                if (!event.target) {
                        event.target = event.srcElement || document;
                }
                if (event.pageX === null && event.clientX !== null) {
                        var doc = document.body;
                        event.pageX = event.clientX + (doc.scrollLeft || 0) - (doc.clientLeft || 0);
                        event.pageY = event.clientY + (doc.scrollTop || 0) - (doc.clientTop || 0);
                }
                return event;
        };

        return {
                // Bind an event listener of type to element, handler is your method.
                addEvent: function (element, type, handler, capture) {
                        capture = (capture === undefined) ? false : capture;

                        var callback = function (event) {
                                event = fixEvent(event || window.event);
                                handler.apply(element, [event]);
                        };

                        if (element.addEventListener) {
                                element.addEventListener(type, callback, capture);
                        } else if (element.attachEvent) {
                                type = 'on' + type;
                                element.attachEvent(type, callback);
                        } else {
                                type = 'on' + type;
                                element[type] = callback;
                        }
                        _listeners[++_eventId] = {element: element, type: type, handler: callback};
                },

                // Destroy an event listener. requires the exact same function as was used for attaching
                // the event.
                removeEvent: function (element, type, handler) {
                        if (element.removeEventListener) {
                                element.removeEventListener(type, handler, false);
                        } else if (element.detachEvent) {
                                type = 'on' + type;
                                element.detachEvent(type, handler);
                        } else {
                                type = 'on' + type;
                                element[type] = null;
                        }
                },

                // Bind an event to the DOMContentLoaded or other similar event.
                domready: function (callback) {
                        if (document.addEventListener) {
                                return document.addEventListener('DOMContentLoaded', callback, false);
                        }

                        if (document.all && !window.opera) {
                                // Define a "blank" external JavaScript tag
                                document.write(
                                        '<script type="text/javascript" id="__domreadywatcher" defer="defer" src="javascript:void(0)"><\/script>'
                                );
                                var contentloadtag = document.getElementById('__domreadywatcher');
                                contentloadtag.onreadystatechange = function () {
                                        if (this.readyState === 'complete') {
                                                callback();
                                        }
                                };
                                contentloadtag = null;
                                return;
                        }

                        if (/Webkit/i.test(navigator.userAgent)) {
                                var _timer = setInterval(function () {
                                        if (/loaded|complete/.test(document.readyState)) {
                                                clearInterval(_timer);
                                                callback();
                                        }
                                }, 10);
                        }
                },

                // Unload all the events attached by DebugKit. Fix any memory leaks.
                unload: function () {
                        var listener;
                        for (var i in _listeners) {
                                listener = _listeners[i];
                                try {
                                        this.removeEvent(listener.element, listener.type, listener.handler);
                                } catch (e) {}
                                delete _listeners[i];
                        }
                        delete _listeners;
                }
        };
}();

// Cookie utility
DEBUGKIT.Util.Cookie = function () {
        var cookieLife = 60;

// Public methods
        return {
                /**
                 * Write to cookie.
                 *
                 * @param [string] name Name of cookie to write.
                 * @param [mixed] value Value to write to cookie.
                 */
                write: function (name, value) {
                        var date = new Date();
                        date.setTime(date.getTime() + (cookieLife * 24 * 60 * 60 * 1000));
                        var expires = '; expires=' + date.toGMTString();
                        document.cookie = name + '=' + value + expires + '; path=/';
                        return true;
                },

                /**
                 * Read from the cookie.
                 *
                 * @param [string] name Name of cookie to read.
                 */
                read: function (name) {
                        name = name + '=';
                        var cookieJar = document.cookie.split(';');
                        var cookieJarLength = cookieJar.length;
                        for (var i = 0; i < cookieJarLength; i++) {
                                var chips = cookieJar[i];
                                // Trim leading spaces
                                while (chips.charAt(0) === ' ') {
                                        chips = chips.substring(1, chips.length);
                                }
                                if (chips.indexOf(name) === 0) {
                                        return chips.substring(name.length, chips.length);
                                }
                        }
                        return false;
                },

                /**
                 * Delete a cookie by name.
                 *
                 * @param [string] name of cookie to delete.
                 */
                del: function (name) {
                        var date = new Date();
                        date.setFullYear(2000, 0, 1);
                        var expires = ' ; expires=' + date.toGMTString();
                        document.cookie = name + '=' + expires + '; path=/';
                }
        };
}();

//
// NOTE DEBUGKIT.Util.merge is Deprecated.
//

/**
 * Object merge takes any number of arguments and glues them together.
 *
 * @param [Object] one first object
 * @return object
 */
DEBUGKIT.Util.merge = function () {
        var out = {};
        var argumentsLength = arguments.length;
        for (var i = 0; i < argumentsLength; i++) {
                var current = arguments[i];
                for (var prop in current) {
                        if (current[prop] !== undefined) {
                                out[prop] = current[prop];
                        }
                }
        }
        return out;
};

//
// NOTE DEBUGKIT.Util.isArray is Deprecated.
//

/**
 * Check if the given object is an array.
 */
DEBUGKIT.Util.isArray = function (test) {
        return Object.prototype.toString.call(test) === '[object Array]';
};

//
// NOTE DEBUGKIT.Util.Request is Deprecated.
//
// Simple wrapper for XmlHttpRequest objects.
DEBUGKIT.Util.Request = function (options) {
        var _defaults = {
                onComplete : function () {},
                onRequest : function () {},
                onFail : function () {},
                method : 'GET',
                async : true,
                headers : {
                        'X-Requested-With': 'XMLHttpRequest',
                        'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
                }
        };

        var self = this;
        this.options = DEBUGKIT.Util.merge(_defaults, options);
        this.options.method = this.options.method.toUpperCase();

        var ajax = this.createObj();
        this.transport = ajax;

        // Event assignment
        this.onComplete = this.options.onComplete;
        this.onRequest = this.options.onRequest;
        this.onFail = this.options.onFail;

        this.send = function (url, data) {
                if (this.options.method === 'GET' && data) {
                        url = url + ((url.charAt(url.length - 1) === '?') ? '&' : '?') + data; //check for ? at the end of the string
                        data = null;
                }
                // Open connection
                this.transport.open(this.options.method, url, this.options.async);

                // Set statechange and pass the active XHR object to it. From here it handles all status changes.
                this.transport.onreadystatechange = function () {
                        self.onReadyStateChange.apply(self, arguments);
                };
                for (var key in this.options.headers) {
                        this.transport.setRequestHeader(key, this.options.headers[key]);
                }
                if (typeof data === 'object') {
                        data = this.serialize(data);
                }
                if (data) {
                        this.transport.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                }
                this.onRequest();
                this.transport.send(data);
        };
};

DEBUGKIT.Util.Request.prototype.onReadyStateChange = function () {
        if (this.transport.readyState !== 4) {
                return;
        }
        if (this.transport.status === 200 || this.transport.status > 300 && this.transport.status < 400) {
                this.response = {
                        xml: this.transport.responseXML,
                        text: this.transport.responseText
                };

                if (typeof this.onComplete === 'function') {
                        this.onComplete.apply(this, [this, this.response]);
                } else {
                        return this.response;
                }
        } else if (this.transport.status > 400) {
                if (typeof this.onFail === 'function') {
                        this.onFail.apply(this, []);
                } else {
                        console.error('Request failed');
                }
        }
};

/**
 * Creates cross-broswer XHR object used for requests.
 * Tries using the standard XmlHttpRequest, then IE's wacky ActiveX Objects.
 */
DEBUGKIT.Util.Request.prototype.createObj = function () {
        var request = null;
        try {
                request = new XMLHttpRequest();
        } catch (MS) {
                try {
                        request = new ActiveXObject('Msxml2.XMLHTTP');
                } catch (old_MS) {
                        try {
                                request = new ActiveXObject('Microsoft.XMLHTTP');
                        } catch (failure) {
                                request = null;
                        }
                }
        }
        return request;
};

/**
 * Serializes an object literal into a querystring.
 */
DEBUGKIT.Util.Request.prototype.serialize = function (data) {
        var out = '';
        for (var name in data) {
                if (data.hasOwnProperty(name)) {
                        out += name + '=' + data[name] + '&';
                }
        }
        return out.substring(0, out.length - 1);
};


// Basic toolbar module.
DEBUGKIT.toolbar = function () {
        // Shortcuts
        var Cookie = DEBUGKIT.Util.Cookie,
                $ = DEBUGKIT.$,
                toolbarHidden = false;

        return {
                elements: {},
                panels: {},

                init: function () {
                        var i, element, lists, index, _this = this;

                        this.elements.toolbar = $('#debug-kit-toolbar');

                        if (this.elements.toolbar.length === 0) {
                                throw new Error('Toolbar not found, make sure you loaded it.');
                        }

                        this.elements.panel = $('#panel-tabs');
                        this.elements.panel.find('.panel-tab').each(function (i, panel) {
                                _this.addPanel(panel);
                        });

                        lists = this.elements.toolbar.find('.depth-0');

                        this.makeNeatArray(lists);
                        this.deactivatePanel(true);
                },

                // Add a panel to the toolbar
                addPanel: function (tab) {
                        var button, content, _this = this;
                        var panel = {
                                id : false,
                                element : tab,
                                button : undefined,
                                content : undefined,
                                active : false
                        };
                        tab = $(tab);
                        button = tab.children('a');

                        panel.id = button.attr('href').replace(/^#/, '');
                        panel.button = button;
                        panel.content = tab.find('.panel-content');

                        if (!panel.id || panel.content.length === 0) {
                                return false;
                        }
                        this.makePanelDraggable(panel);
                        this.makePanelMinMax(panel);

                        button.on('click', function (event) {
                                event.preventDefault();
                                _this.togglePanel(panel.id);
                        });

                        this.panels[panel.id] = panel;
                        return panel.id;
                },

                // Find the handle element and make the panel drag resizable.
                makePanelDraggable: function (panel) {

                        // Create a variable in the enclosing scope, for scope tricks.
                        var currentElement = null;

                        // Use the elements startHeight stored Event.pageY and current Event.pageY to
                        // resize the panel.
                        var mouseMoveHandler = function (event) {
                                event.preventDefault();
                                if (!currentElement) {
                                        return;
                                }
                                var newHeight = currentElement.data('startHeight') + (event.pageY - currentElement.data('startY'));
                                currentElement.parent().height(newHeight);
                        };

                        // Handle the mouseup event, remove the other listeners so the panel
                        // doesn't continue to resize.
                        var mouseUpHandler = function (event) {
                                currentElement = null;
                                $(document).off('mousemove', mouseMoveHandler).off('mouseup', mouseUpHandler);
                        };

                        var mouseDownHandler = function (event) {
                                event.preventDefault();

                                currentElement = $(this);
                                currentElement.data('startY', event.pageY);
                                currentElement.data('startHeight', currentElement.parent().height());

                                // Attach to document so mouse doesn't have to stay precisely on the 'handle'.
                                $(document).on('mousemove', mouseMoveHandler)
                                        .on('mouseup', mouseUpHandler);
                        };

                        panel.content.find('.panel-resize-handle').on('mousedown', mouseDownHandler);
                },

                // Make the maximize button work on the panels.
                makePanelMinMax: function (panel) {
                        var _oldHeight;

                        var maximize = function () {
                                if (!_oldHeight) {
                                        _oldHeight = this.parentNode.offsetHeight;
                                }
                                var windowHeight = window.innerHeight;
                                var panelHeight = windowHeight - this.parentNode.offsetTop;
                                $(this.parentNode).height(panelHeight);
                                $(this).text('-');
                        };

                        var minimize = function () {
                                $(this.parentNode).height(_oldHeight);
                                $(this).text('+');
                                _oldHeight = null;
                        };

                        var state = 1;
                        var toggle = function (event) {
                                event.preventDefault();
                                if (state === 1) {
                                        maximize.call(this);
                                        state = 0;
                                } else {
                                        state = 1;
                                        minimize.call(this);
                                }
                        };

                        panel.content.find('.panel-toggle').on('click', toggle);
                },

                // Toggle a panel
                togglePanel: function (id) {
                        if (this.panels[id] && this.panels[id].active) {
                                this.deactivatePanel(true);
                        } else {
                                this.deactivatePanel(true);
                                this.activatePanel(id);
                        }
                },

                // Make a panel active.
                activatePanel: function (id, unique) {
                        if (this.panels[id] !== undefined && !this.panels[id].active) {
                                var panel = this.panels[id];
                                if (panel.content.length > 0) {
                                        panel.content.css('display', 'block');
                                }

                                var contentHeight = panel.content.find('.panel-content-data').height() + 70;
                                if (contentHeight <= (window.innerHeight / 2)) {
                                        panel.content.height(contentHeight);
                                }

                                panel.button.addClass('active');
                                panel.active = true;
                                return true;
                        }
                        return false;
                },

                // Deactivate a panel. use true to hide all panels.
                deactivatePanel: function (id) {
                        if (id === true) {
                                for (var i in this.panels) {
                                        this.deactivatePanel(i);
                                }
                                return true;
                        }
                        if (this.panels[id] !== undefined) {
                                var panel = this.panels[id];
                                if (panel.content !== undefined) {
                                        panel.content.hide();
                                }
                                panel.button.removeClass('active');
                                panel.active = false;
                                return true;
                        }
                        return false;
                },

                // Bind events for all the collapsible arrays.
                makeNeatArray: function (lists) {
                        lists.find('ul').hide()
                                .parent().addClass('expandable collapsed');

                        lists.on('click', 'li', function (event) {
                                event.stopPropagation();
                                $(this).children('ul').toggle().toggleClass('expanded collapsed');
                        });
                }
        };
}();
DEBUGKIT.loader.register(DEBUGKIT.toolbar);

DEBUGKIT.module('historyPanel');
DEBUGKIT.historyPanel = function () {
        var toolbar = DEBUGKIT.toolbar,
                $ = DEBUGKIT.$,
                historyLinks;

        // Private methods to handle JSON response and insertion of
        // new content.
        var switchHistory = function (response) {

                historyLinks.removeClass('loading');

                $.each(toolbar.panels, function (id, panel) {
                        if (panel.content === undefined || response[id] === undefined) {
                                return;
                        }

                        var regionDiv = panel.content.find('.panel-resize-region');
                        if (!regionDiv.length) {
                                return;
                        }

                        var regionDivs = regionDiv.children();

                        regionDivs.filter('div').hide();
                        regionDivs.filter('.panel-history').each(function (i, panelContent) {
                                var panelId = panelContent.id.replace('-history', '');
                                if (response[panelId]) {
                                        panelContent = $(panelContent);
                                        panelContent.html(response[panelId]);
                                        var lists = panelContent.find('.depth-0');
                                        toolbar.makeNeatArray(lists);
                                }
                                panelContent.show();
                        });
                });
        };

        // Private method to handle restoration to current request.
        var restoreCurrentState = function () {
                var id, i, panelContent, tag;

                historyLinks.removeClass('loading');

                $.each(toolbar.panels, function (panel, id) {
                        if (panel.content === undefined) {
                                return;
                        }
                        var regionDiv = panel.content.find('.panel-resize-region');
                        if (!regionDiv.length) {
                                return;
                        }
                        var regionDivs = regionDiv.children();
                        regionDivs.filter('div').show()
                                .end()
                                .filter('.panel-history').hide();
                });
        };

        function handleHistoryLink(event) {
                event.preventDefault();

                historyLinks.removeClass('active');
                $(this).addClass('active loading');

                if (this.id === 'history-restore-current') {
                        restoreCurrentState();
                        return false;
                }

                var xhr = $.ajax({
                        url: this.href,
                        type: 'GET',
                        dataType: 'json'
                });
                xhr.success(switchHistory).fail(function () {
                        alert('History retrieval failed');
                });
        }

        return {
                init : function () {
                        if (toolbar.panels.history === undefined) {
                                return;
                        }

                        historyLinks = toolbar.panels.history.content.find('.history-link');
                        historyLinks.on('click', handleHistoryLink);
                }
        };
}();
DEBUGKIT.loader.register(DEBUGKIT.historyPanel);

//Add events + behaviors for toolbar collapser.
DEBUGKIT.toolbarToggle = function () {
        var toolbar = DEBUGKIT.toolbar,
                $ = DEBUGKIT.$,
                Cookie = DEBUGKIT.Util.Cookie,
                toolbarHidden = false;

        return {
                init: function () {
                        var button = $('#hide-toolbar'),
                                self = this;

                        button.on('click', function (event) {
                                event.preventDefault();
                                self.toggleToolbar();
                        });

                        var toolbarState = Cookie.read('toolbarDisplay');
                        if (toolbarState !== 'show') {
                                toolbarHidden = false;
                                this.toggleToolbar();
                        }
                },

                toggleToolbar: function () {
                        var display = toolbarHidden ? 'show' : 'hide';
                        $.each(toolbar.panels, function (i, panel) {
                                $(panel.element)[display]();
                                Cookie.write('toolbarDisplay', display);
                        });
                        toolbarHidden = !toolbarHidden;

                        if (toolbarHidden) {
                                $('#debug-kit-toolbar').addClass('minimized');
                        } else {
                                $('#debug-kit-toolbar').removeClass('minimized');
                        }

                        return false;
                }
        };
}();
DEBUGKIT.loader.register(DEBUGKIT.toolbarToggle);

DEBUGKIT.$(document).ready(function () {
        DEBUGKIT.loader.init();
});