admin back-office environment (skeleton); admin categories

1 files changed, 492 insertions, 0 deletions

diff --git a/public/assets/js/_dependency-control/require/require.slim.js b/public/assets/js/_dependency-control/require/require.slim.js
new file mode 100644
index 0000000..f42cea6
--- /dev/null
+++ b/public/assets/js/_dependency-control/require/require.slim.js
@@ -0,0 +1,492 @@
+(function (requireFiles) {
+    var require, _helpers = {
+        isFunction: function (obj) {
+            return typeof (obj) == 'function';
+        },
+        isArray: isArraylike
+    };
+    if (typeof (window.require) != 'undefined') {
+        return;
+    }
+
+    function isArraylike(obj) {
+        return Array.isArray(obj);
+    }
+
+    function ModulesConfiguration(versions, modules) {
+        this.modules = modules || {};
+        this.modulePaths = {};
+
+        for (var i = 0; i < versions.length; i++) {
+            var v = versions[i];
+            for (var k in v) {
+                var moduleName = k;
+                var url = v[k];
+                if (typeof (url) == 'object') {
+                    this.modulePaths[moduleName] = url.Url;
+                    continue;
+                }
+                this.modulePaths[moduleName] = url;
+            }
+        }
+        this.updateState = function (state, moduleDependencies, callback) {
+            var config = this, i = 0;
+            if (!Array.isArray(moduleDependencies)) {
+                moduleDependencies = [moduleDependencies];
+            }
+            state.moduleDependencies = moduleDependencies;
+            state.dependencies = moduleDependencies.filter(function (x) {
+                return x && x.indexOf('exports') === -1 && x.indexOf('require') === -1;
+            }).map(function (x) {
+                return config.getOrCreateState(x);
+            });
+            state.loaded = true;
+            state.readyCallback = function () {
+                state.ready = true;
+                if (callback && typeof callback === 'function') {
+                    state.object = invokeCallback(callback, state.moduleDependencies, state.name);
+                    document.dispatchEvent(new CustomEvent("require.moduleLoaded", { detail: state }));
+                }
+            };
+            
+            state.readyCheck && state.readyCheck();
+            if (state.dependencies.length) {
+                for (; i < state.dependencies.length; i++) {
+                    state.dependencies[i].callbacks.push(function () {
+                        state.readyCheck && state.readyCheck();
+                    });
+                }
+                require(
+                    state.dependencies.map(function (x) { return x.name }),
+                    function () {
+                        state.readyCheck && state.readyCheck();
+                    }
+                );
+            }
+        }
+
+        this.getOrCreateState = function (moduleName, ignoreWarnings) {
+            var state = window.define.amd.getProp(moduleName);
+            if (!state) {
+                window.define.amd[moduleName] = state = this.createState(moduleName, ignoreWarnings);
+            }
+
+            return state;
+        }
+        this.createState = function (moduleName, ignoreWarnings) {
+            var url = this.modulePaths.getProp(this.modules[moduleName] || moduleName);
+            if (!url && !ignoreWarnings) {
+                console.warn(
+                    "%c Module '%s' path is not present. Define it using the global '__requireFiles' variable", 
+                    [ 'background: orange', 'color: black', 'display: block', 'text-align: center', 'font-size: 14px', 'font-weight: 600'].join(';'), 
+                    moduleName
+                );
+            }
+            return {
+                url: this.modulePaths.getProp(this.modules[moduleName] || moduleName),
+                name: moduleName,
+                loaded: false,
+                callbacks: [],
+                ready: false,
+                dependencies: [],
+                doCallBacks: function () {
+                    for (var i = 0; i < this.callbacks.length; i++) {
+                        this.callbacks[i].apply(this, []);
+                    }
+                    this.callbacks = [];
+                },
+                removeReadyDependencies: function () {
+                    this.dependencies = this.dependencies.filter(function (x) { return !x.ready; });
+                },
+                readyCheck: function () {
+                    this.removeReadyDependencies();
+                    if (!this.dependencies.length && this.loaded) {
+                        if (!this.ready) {
+                            if (this.readyCallback) {
+                                this.readyCallback.apply(this, []);
+                            } else {
+                                this.ready = true;
+                            }
+                            this.doCallBacks();
+                        }
+                    }
+                },
+                hasUrl: function () {
+                    if (!this.url) {
+                        return false;
+                    }
+                    return true;
+                },
+                callPending: function () {
+                    this.pending = true;
+                },
+                callDone: function () {
+                    if (!this.loaded) {
+                        completeDefine(this.name);
+                        if (!this.loaded) {
+                            console.warn('should be loaded');
+                        }
+                    }
+                }
+            };
+        }
+    }
+    
+    var debug = false;
+    var config = new ModulesConfiguration(
+        requireFiles || []
+    );
+
+    Object.defineProperty(Object.prototype, "getProp", {
+        value: function (prop) {
+            if (!prop || (typeof (prop) !== typeof ('') && !(prop instanceof String))) {
+                console.warn('invalid property access', prop, this);
+                return null;
+            }
+            var key, self = this;
+            for (key in self) {
+                if (key.toLowerCase() === prop.toLowerCase()) {
+                    return self[key];
+                }
+            }
+        },
+        //this keeps jquery happy
+        enumerable: false
+    });
+
+    
+    
+    function invokeCallback(callback, moduleNames, exportsName) {
+        var callbackArguments = [],
+            resultFactory = function (r) { return r; },
+            e, i = 0, state, result;
+        for (; i < moduleNames.length; i++) {
+            switch (moduleNames[i]) {
+                case 'exports':
+                    if (!window.exports) {
+                        window.exports = {};
+                    }
+                    e = window.exports[exportsName];
+                    if (!e) {
+                        e = window.exports[exportsName] = {};
+                    }
+                    resultFactory = function () { return e; };
+                    callbackArguments.push(e);
+                    break;
+                case 'require':
+                    callbackArguments.push(require);
+                    break;
+                default:
+                    state = config.getOrCreateState(moduleNames[i]);
+                    callbackArguments.push(state.object);
+            }
+        }
+        result = callback.apply(window, callbackArguments);
+        return resultFactory(result);
+    }
+
+    function TaskWatcher(callback, moduleNames) {
+        var self = this;
+        //moduleNames = config.bundle(moduleNames);
+        this.pendingModules = getPendingStates(moduleNames);
+        this.check = function () {
+            if (this.finished) {
+                return true;
+            }
+            if (!this.pendingModules.filter(function (x) { return !x.ready; }).length) {
+                this.done();
+                return true;
+            }
+            return false;
+        };
+        this.done = function () {
+            var s = moduleNames.map(function (x) { return config.getOrCreateState(x); }), 
+                i = 0, 
+                state;
+            this.finished = true;
+            for (; i < s.length; i++) {
+                state = s[i];
+                state.readyCheck && state.readyCheck();
+            }
+            callback();
+            if (debug) {
+                console.debug('done', moduleNames);   
+            }
+        }
+        
+        function getPendingStates(moduleNames) {
+            var pendingStates = [], script, state, i = 0;
+            for (; i < moduleNames.length; i++) {
+                script = moduleNames[i];
+                state = config.getOrCreateState(script);
+                if (!state.ready) {
+                    state.callbacks.push(function () {
+                        self.check();
+                    });
+                    pendingStates.push(state);
+                }
+            }
+            return pendingStates;
+        }
+    }
+
+
+    function getScriptCached (url, callback) {
+        var d = document, t = 'script',
+            o = d.createElement(t),
+            s = d.getElementsByTagName(t)[0];
+        o.src = url;
+        o.defer = true;
+        if (callback) {
+            o.addEventListener('load', function (e) {
+                if (debug) {
+                    console.debug('loaded script', url, e);   
+                }
+                callback(null, e);
+            }, false);
+        } else {
+            console.warn('loading script without callback', url);
+        }
+
+        s.parentNode.insertBefore(o, s);
+    }
+    
+    window.require = require = function require (moduleNames, callback) {
+        var i = 0, watcher, pendingStates;
+        if (typeof (moduleNames) === typeof ('') || moduleNames instanceof String) {
+            moduleNames = [moduleNames];
+        }
+        callback = (function (cb, moduleNames) {
+            return function () {
+                invokeCallback(cb, moduleNames);
+            }
+        })(callback, moduleNames);
+        watcher = new TaskWatcher(callback, moduleNames);
+        if (watcher.check()) {
+            return;
+        }
+
+        pendingStates = watcher.pendingModules.filter(function (x) { return x.hasUrl() && !x.pending });
+        if (!pendingStates.length) {
+            return;
+        }
+
+        for (; i < pendingStates.length; i++) {
+            fetchIfNeeded(pendingStates[i]);
+        }
+        
+        function fetchIfNeeded(state){
+            if (state.loaded && !state.ready) {
+                state.callbacks.push(function () {
+                    watcher.check();
+                });
+            } else {
+                state.callPending();
+                getScriptCached(state.url, function () {
+                    state.callDone();
+                });
+            }
+        }
+
+    };
+
+    require.getScriptCached = getScriptCached;
+
+    require.getStyleSheet = function getStyleSheet(path, fn, scope) {
+        var head = document.getElementsByTagName('head')[0], // reference to document.head for appending/ removing link nodes
+            link = document.createElement('link');           // create the link node
+        link.setAttribute('href', path);
+        link.setAttribute('rel', 'stylesheet');
+        link.setAttribute('type', 'text/css');
+
+        var sheet, cssRules;
+        // get the correct properties to check for depending on the browser
+        if ('sheet' in link) {
+            sheet = 'sheet'; cssRules = 'cssRules';
+        } else {
+            sheet = 'styleSheet'; cssRules = 'rules';
+        }
+
+        var interval_id = setInterval(function () {                     // start checking whether the style sheet has successfully loaded
+                try {
+                    if (link[sheet] && link[sheet][cssRules].length) { // SUCCESS! our style sheet has loaded
+                        clearInterval(interval_id);                      // clear the counters
+                        clearTimeout(timeout_id);
+                        fn.call(scope || window, true, link);           // fire the callback with success == true
+                    }
+                } catch (e) { } finally { }
+            }, 10),                                                   // how often to check if the stylesheet is loaded
+            timeout_id = setTimeout(function () {       // start counting down till fail
+                clearInterval(interval_id);             // clear the counters
+                clearTimeout(timeout_id);
+                head.removeChild(link);                // since the style sheet didn't load, remove the link node from the DOM
+                fn.call(scope || window, false, link); // fire the callback with success == false
+            }, 15000);                                 // how long to wait before failing
+
+        head.appendChild(link);  // insert the link node into the DOM and start loading the style sheet
+
+        return link; // return the link node;
+    }
+    
+    require.resource = function (scripts, callback) {
+        if (!_helpers.isArray(scripts)) {
+            scripts = [scripts];
+        }
+        function flattenArray(arr) {
+            if (!_helpers.isArray(arr)) {
+                return arr;
+            }
+
+            return arr.map(function (n) {
+                return flattenArray(n)
+            });
+        }
+        scripts = flattenArray(scripts).reverse();
+        if (typeof (scripts) == 'undefined') {
+            console.error('require.resource called without scripts', arguments);
+            return;
+        }
+        function next() {
+            if (!scripts.length) {
+                callback && callback();
+                return;
+            }
+
+            if (!_helpers.loadedScripts) {
+                _helpers.loadedScripts = [];
+            }
+            if (!_helpers.loadingScriptCallbacks) {
+                _helpers.loadingScriptCallbacks = {};
+            }
+
+            var script = scripts.pop();
+            var css = script.indexOf('.css') !== -1;
+
+            var originalScript = script;
+            if (script.indexOf('~/') === 0) {
+                script = script.replace('~/', $siteRoot());
+            }
+
+            if (_helpers.loadingScriptCallbacks[script]) {
+                _helpers.loadingScriptCallbacks[script].push(function () {
+                    next();
+                });
+                return;
+            }
+
+            if (!css) {
+                if (document.querySelector('script[src="' + script + '"]') || _helpers.loadedScripts.indexOf(script) !== -1) {
+                    next();
+                    return;
+                }
+            } else {
+                if (document.querySelector('link[href="' + script + '"]') || _helpers.loadedScripts.indexOf(script) !== -1) {
+                    next();
+                    return;
+                }
+            }
+
+            _helpers.loadingScriptCallbacks[script] = [function () {
+                next();
+            }];
+
+            function done() {
+                _helpers.loadedScripts.push(script);
+                document.dispatchEvent(new CustomEvent("require.scriptLoaded", { detail: originalScript }));
+                for (var i = 0; i < _helpers.loadingScriptCallbacks[script].length; i++) {
+                    _helpers.loadingScriptCallbacks[script][i]();
+                }
+                delete _helpers.loadingScriptCallbacks[script];
+            }
+
+            if (css) {
+                require.getStyleSheet(script, function () {
+                    done();
+                });
+            }
+            else {
+                require.getScriptCached(script, function () {
+                    done();
+                });
+            }
+        }
+        next();
+    };
+
+    function getModuleName(url) {
+        var u = url;
+        u = u.substring(u.lastIndexOf('/') + 1);
+        u = u.substring(0, u.lastIndexOf('.'));
+        return u;
+    }
+
+    function completeDefine(moduleName) {
+        if (typeof (_helpers._pendingDefinition) === 'undefined') {
+            define(moduleName, [], function () { });
+            return;
+        }
+        var moduleDependencies = _helpers._pendingDefinition.moduleDependencies;
+        var callback = _helpers._pendingDefinition.callback;
+        delete _helpers._pendingDefinition;
+        var state = config.getOrCreateState(moduleName, true);
+        config.updateState(state, moduleDependencies, callback);
+    }
+
+    window.define = function (moduleName, moduleDependencies, callback) {
+        if (typeof (moduleName) === "string") {
+            if (_helpers.isFunction(moduleDependencies)) {
+                callback = moduleDependencies;
+                moduleDependencies = [];
+            }
+        } else if (_helpers.isArray(moduleName)) {
+            callback = moduleDependencies;
+            moduleDependencies = moduleName;
+            moduleName = null;
+        } else if (_helpers.isFunction(moduleName)) {
+            callback = moduleName;
+            moduleDependencies = [];
+            moduleName = null;
+        }
+        if (debug)
+            console.log('define', moduleName, moduleDependencies);
+
+        _helpers._pendingDefinition = {
+            moduleDependencies: moduleDependencies,
+            callback: callback
+        };
+        // if (moduleName == null && document.currentScript){
+        //     try {
+        //         moduleName = getModuleName(document.currentScript.src);
+        //         if (moduleName.indexOf(".min") === moduleName.length - 4){
+        //             moduleName = moduleName.substring(0, moduleName.length - 4);
+        //         }
+        //     } catch (e) {
+        //         console && console.warn("Could not resolve current script");
+        //     }
+        //
+        // }
+        if (moduleName != null) {
+            completeDefine(moduleName);
+        }
+
+
+    }
+    window.define.amd = window.define && window.define.amd ? window.define.amd : {};
+
+    window.define.pendingModules = function () {
+        var states = [];
+        for (var k in window.define.amd) {
+            states.push(window.define.amd[k]);
+        }
+
+        return {
+            blocked: states.filter(function (x) {
+                return (x.pending && !x.ready) || 
+                    (x.dependencies || []).filter(function (d) { return !d.ready; }).length;
+            }),
+            missing: states.filter(function (x) {
+                return !x.loaded;
+            })
+        };
+    }
+})(window.__requireFiles);
\ No newline at end of file