From c94fb32c7a3c28b18a27460aa2447eeec1fac1de Mon Sep 17 00:00:00 2001 From: Pascal Szewczyk Date: Mon, 18 Jul 2016 23:23:54 +0200 Subject: uikit added --- js/core/core.js | 786 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 786 insertions(+) create mode 100755 js/core/core.js (limited to 'js/core/core.js') diff --git a/js/core/core.js b/js/core/core.js new file mode 100755 index 0000000..85540af --- /dev/null +++ b/js/core/core.js @@ -0,0 +1,786 @@ +/*! UIkit 2.26.4 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */ +(function(core) { + + if (typeof define == "function" && define.amd) { // AMD + + define("uikit", function(){ + + var uikit = window.UIkit || core(window, window.jQuery, window.document); + + uikit.load = function(res, req, onload, config) { + + var resources = res.split(','), load = [], i, base = (config.config && config.config.uikit && config.config.uikit.base ? config.config.uikit.base : "").replace(/\/+$/g, ""); + + if (!base) { + throw new Error( "Please define base path to UIkit in the requirejs config." ); + } + + for (i = 0; i < resources.length; i += 1) { + var resource = resources[i].replace(/\./g, '/'); + load.push(base+'/components/'+resource); + } + + req(load, function() { + onload(uikit); + }); + }; + + return uikit; + }); + } + + if (!window.jQuery) { + throw new Error( "UIkit requires jQuery" ); + } + + if (window && window.jQuery) { + core(window, window.jQuery, window.document); + } + + +})(function(global, $, doc) { + + "use strict"; + + var UI = {}, _UI = global.UIkit ? Object.create(global.UIkit) : undefined; + + UI.version = '2.26.4'; + + UI.noConflict = function() { + // restore UIkit version + if (_UI) { + global.UIkit = _UI; + $.UIkit = _UI; + $.fn.uk = _UI.fn; + } + + return UI; + }; + + UI.prefix = function(str) { + return str; + }; + + // cache jQuery + UI.$ = $; + + UI.$doc = UI.$(document); + UI.$win = UI.$(window); + UI.$html = UI.$('html'); + + UI.support = {}; + UI.support.transition = (function() { + + var transitionEnd = (function() { + + var element = doc.body || doc.documentElement, + transEndEventNames = { + WebkitTransition : 'webkitTransitionEnd', + MozTransition : 'transitionend', + OTransition : 'oTransitionEnd otransitionend', + transition : 'transitionend' + }, name; + + for (name in transEndEventNames) { + if (element.style[name] !== undefined) return transEndEventNames[name]; + } + }()); + + return transitionEnd && { end: transitionEnd }; + })(); + + UI.support.animation = (function() { + + var animationEnd = (function() { + + var element = doc.body || doc.documentElement, + animEndEventNames = { + WebkitAnimation : 'webkitAnimationEnd', + MozAnimation : 'animationend', + OAnimation : 'oAnimationEnd oanimationend', + animation : 'animationend' + }, name; + + for (name in animEndEventNames) { + if (element.style[name] !== undefined) return animEndEventNames[name]; + } + }()); + + return animationEnd && { end: animationEnd }; + })(); + + // requestAnimationFrame polyfill + //https://github.com/darius/requestAnimationFrame + (function() { + + Date.now = Date.now || function() { return new Date().getTime(); }; + + var vendors = ['webkit', 'moz']; + for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) { + var vp = vendors[i]; + window.requestAnimationFrame = window[vp+'RequestAnimationFrame']; + window.cancelAnimationFrame = (window[vp+'CancelAnimationFrame'] + || window[vp+'CancelRequestAnimationFrame']); + } + if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent) // iOS6 is buggy + || !window.requestAnimationFrame || !window.cancelAnimationFrame) { + var lastTime = 0; + window.requestAnimationFrame = function(callback) { + var now = Date.now(); + var nextTime = Math.max(lastTime + 16, now); + return setTimeout(function() { callback(lastTime = nextTime); }, + nextTime - now); + }; + window.cancelAnimationFrame = clearTimeout; + } + }()); + + UI.support.touch = ( + ('ontouchstart' in document) || + (global.DocumentTouch && document instanceof global.DocumentTouch) || + (global.navigator.msPointerEnabled && global.navigator.msMaxTouchPoints > 0) || //IE 10 + (global.navigator.pointerEnabled && global.navigator.maxTouchPoints > 0) || //IE >=11 + false + ); + + UI.support.mutationobserver = (global.MutationObserver || global.WebKitMutationObserver || null); + + UI.Utils = {}; + + UI.Utils.isFullscreen = function() { + return document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement || document.fullscreenElement || false; + }; + + UI.Utils.str2json = function(str, notevil) { + try { + if (notevil) { + return JSON.parse(str + // wrap keys without quote with valid double quote + .replace(/([\$\w]+)\s*:/g, function(_, $1){return '"'+$1+'":';}) + // replacing single quote wrapped ones to double quote + .replace(/'([^']+)'/g, function(_, $1){return '"'+$1+'"';}) + ); + } else { + return (new Function("", "var json = " + str + "; return JSON.parse(JSON.stringify(json));"))(); + } + } catch(e) { return false; } + }; + + UI.Utils.debounce = function(func, wait, immediate) { + var timeout; + return function() { + var context = this, args = arguments; + var later = function() { + timeout = null; + if (!immediate) func.apply(context, args); + }; + var callNow = immediate && !timeout; + clearTimeout(timeout); + timeout = setTimeout(later, wait); + if (callNow) func.apply(context, args); + }; + }; + + UI.Utils.throttle = function (func, limit) { + var wait = false; + return function () { + if (!wait) { + func.call(); + wait = true; + setTimeout(function () { + wait = false; + }, limit); + } + } + }; + + UI.Utils.removeCssRules = function(selectorRegEx) { + var idx, idxs, stylesheet, _i, _j, _k, _len, _len1, _len2, _ref; + + if(!selectorRegEx) return; + + setTimeout(function(){ + try { + _ref = document.styleSheets; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + stylesheet = _ref[_i]; + idxs = []; + stylesheet.cssRules = stylesheet.cssRules; + for (idx = _j = 0, _len1 = stylesheet.cssRules.length; _j < _len1; idx = ++_j) { + if (stylesheet.cssRules[idx].type === CSSRule.STYLE_RULE && selectorRegEx.test(stylesheet.cssRules[idx].selectorText)) { + idxs.unshift(idx); + } + } + for (_k = 0, _len2 = idxs.length; _k < _len2; _k++) { + stylesheet.deleteRule(idxs[_k]); + } + } + } catch (_error) {} + }, 0); + }; + + UI.Utils.isInView = function(element, options) { + + var $element = $(element); + + if (!$element.is(':visible')) { + return false; + } + + var window_left = UI.$win.scrollLeft(), window_top = UI.$win.scrollTop(), offset = $element.offset(), left = offset.left, top = offset.top; + + options = $.extend({topoffset:0, leftoffset:0}, options); + + if (top + $element.height() >= window_top && top - options.topoffset <= window_top + UI.$win.height() && + left + $element.width() >= window_left && left - options.leftoffset <= window_left + UI.$win.width()) { + return true; + } else { + return false; + } + }; + + UI.Utils.checkDisplay = function(context, initanimation) { + + var elements = UI.$('[data-uk-margin], [data-uk-grid-match], [data-uk-grid-margin], [data-uk-check-display]', context || document), animated; + + if (context && !elements.length) { + elements = $(context); + } + + elements.trigger('display.uk.check'); + + // fix firefox / IE animations + if (initanimation) { + + if (typeof(initanimation)!='string') { + initanimation = '[class*="uk-animation-"]'; + } + + elements.find(initanimation).each(function(){ + + var ele = UI.$(this), + cls = ele.attr('class'), + anim = cls.match(/uk-animation-(.+)/); + + ele.removeClass(anim[0]).width(); + + ele.addClass(anim[0]); + }); + } + + return elements; + }; + + UI.Utils.options = function(string) { + + if ($.type(string)!='string') return string; + + if (string.indexOf(':') != -1 && string.trim().substr(-1) != '}') { + string = '{'+string+'}'; + } + + var start = (string ? string.indexOf("{") : -1), options = {}; + + if (start != -1) { + try { + options = UI.Utils.str2json(string.substr(start)); + } catch (e) {} + } + + return options; + }; + + UI.Utils.animate = function(element, cls) { + + var d = $.Deferred(); + + element = UI.$(element); + + element.css('display', 'none').addClass(cls).one(UI.support.animation.end, function() { + element.removeClass(cls); + d.resolve(); + }); + + element.css('display', ''); + + return d.promise(); + }; + + UI.Utils.uid = function(prefix) { + return (prefix || 'id') + (new Date().getTime())+"RAND"+(Math.ceil(Math.random() * 100000)); + }; + + UI.Utils.template = function(str, data) { + + var tokens = str.replace(/\n/g, '\\n').replace(/\{\{\{\s*(.+?)\s*\}\}\}/g, "{{!$1}}").split(/(\{\{\s*(.+?)\s*\}\})/g), + i=0, toc, cmd, prop, val, fn, output = [], openblocks = 0; + + while(i < tokens.length) { + + toc = tokens[i]; + + if(toc.match(/\{\{\s*(.+?)\s*\}\}/)) { + i = i + 1; + toc = tokens[i]; + cmd = toc[0]; + prop = toc.substring(toc.match(/^(\^|\#|\!|\~|\:)/) ? 1:0); + + switch(cmd) { + case '~': + output.push("for(var $i=0;$i<"+prop+".length;$i++) { var $item = "+prop+"[$i];"); + openblocks++; + break; + case ':': + output.push("for(var $key in "+prop+") { var $val = "+prop+"[$key];"); + openblocks++; + break; + case '#': + output.push("if("+prop+") {"); + openblocks++; + break; + case '^': + output.push("if(!"+prop+") {"); + openblocks++; + break; + case '/': + output.push("}"); + openblocks--; + break; + case '!': + output.push("__ret.push("+prop+");"); + break; + default: + output.push("__ret.push(escape("+prop+"));"); + break; + } + } else { + output.push("__ret.push('"+toc.replace(/\'/g, "\\'")+"');"); + } + i = i + 1; + } + + fn = new Function('$data', [ + 'var __ret = [];', + 'try {', + 'with($data){', (!openblocks ? output.join('') : '__ret = ["Not all blocks are closed correctly."]'), '};', + '}catch(e){__ret = [e.message];}', + 'return __ret.join("").replace(/\\n\\n/g, "\\n");', + "function escape(html) { return String(html).replace(/&/g, '&').replace(/\"/g, '"').replace(//g, '>');}" + ].join("\n")); + + return data ? fn(data) : fn; + }; + + UI.Utils.events = {}; + UI.Utils.events.click = UI.support.touch ? 'tap' : 'click'; + + global.UIkit = UI; + + // deprecated + + UI.fn = function(command, options) { + + var args = arguments, cmd = command.match(/^([a-z\-]+)(?:\.([a-z]+))?/i), component = cmd[1], method = cmd[2]; + + if (!UI[component]) { + $.error("UIkit component [" + component + "] does not exist."); + return this; + } + + return this.each(function() { + var $this = $(this), data = $this.data(component); + if (!data) $this.data(component, (data = UI[component](this, method ? undefined : options))); + if (method) data[method].apply(data, Array.prototype.slice.call(args, 1)); + }); + }; + + $.UIkit = UI; + $.fn.uk = UI.fn; + + UI.langdirection = UI.$html.attr("dir") == "rtl" ? "right" : "left"; + + UI.components = {}; + + UI.component = function(name, def) { + + var fn = function(element, options) { + + var $this = this; + + this.UIkit = UI; + this.element = element ? UI.$(element) : null; + this.options = $.extend(true, {}, this.defaults, options); + this.plugins = {}; + + if (this.element) { + this.element.data(name, this); + } + + this.init(); + + (this.options.plugins.length ? this.options.plugins : Object.keys(fn.plugins)).forEach(function(plugin) { + + if (fn.plugins[plugin].init) { + fn.plugins[plugin].init($this); + $this.plugins[plugin] = true; + } + + }); + + this.trigger('init.uk.component', [name, this]); + + return this; + }; + + fn.plugins = {}; + + $.extend(true, fn.prototype, { + + defaults : {plugins: []}, + + boot: function(){}, + init: function(){}, + + on: function(a1,a2,a3){ + return UI.$(this.element || this).on(a1,a2,a3); + }, + + one: function(a1,a2,a3){ + return UI.$(this.element || this).one(a1,a2,a3); + }, + + off: function(evt){ + return UI.$(this.element || this).off(evt); + }, + + trigger: function(evt, params) { + return UI.$(this.element || this).trigger(evt, params); + }, + + find: function(selector) { + return UI.$(this.element ? this.element: []).find(selector); + }, + + proxy: function(obj, methods) { + + var $this = this; + + methods.split(' ').forEach(function(method) { + if (!$this[method]) $this[method] = function() { return obj[method].apply(obj, arguments); }; + }); + }, + + mixin: function(obj, methods) { + + var $this = this; + + methods.split(' ').forEach(function(method) { + if (!$this[method]) $this[method] = obj[method].bind($this); + }); + }, + + option: function() { + + if (arguments.length == 1) { + return this.options[arguments[0]] || undefined; + } else if (arguments.length == 2) { + this.options[arguments[0]] = arguments[1]; + } + } + + }, def); + + this.components[name] = fn; + + this[name] = function() { + + var element, options; + + if (arguments.length) { + + switch(arguments.length) { + case 1: + + if (typeof arguments[0] === "string" || arguments[0].nodeType || arguments[0] instanceof jQuery) { + element = $(arguments[0]); + } else { + options = arguments[0]; + } + + break; + case 2: + + element = $(arguments[0]); + options = arguments[1]; + break; + } + } + + if (element && element.data(name)) { + return element.data(name); + } + + return (new UI.components[name](element, options)); + }; + + if (UI.domready) { + UI.component.boot(name); + } + + return fn; + }; + + UI.plugin = function(component, name, def) { + this.components[component].plugins[name] = def; + }; + + UI.component.boot = function(name) { + + if (UI.components[name].prototype && UI.components[name].prototype.boot && !UI.components[name].booted) { + UI.components[name].prototype.boot.apply(UI, []); + UI.components[name].booted = true; + } + }; + + UI.component.bootComponents = function() { + + for (var component in UI.components) { + UI.component.boot(component); + } + }; + + + // DOM mutation save ready helper function + + UI.domObservers = []; + UI.domready = false; + + UI.ready = function(fn) { + + UI.domObservers.push(fn); + + if (UI.domready) { + fn(document); + } + }; + + UI.on = function(a1,a2,a3){ + + if (a1 && a1.indexOf('ready.uk.dom') > -1 && UI.domready) { + a2.apply(UI.$doc); + } + + return UI.$doc.on(a1,a2,a3); + }; + + UI.one = function(a1,a2,a3){ + + if (a1 && a1.indexOf('ready.uk.dom') > -1 && UI.domready) { + a2.apply(UI.$doc); + return UI.$doc; + } + + return UI.$doc.one(a1,a2,a3); + }; + + UI.trigger = function(evt, params) { + return UI.$doc.trigger(evt, params); + }; + + UI.domObserve = function(selector, fn) { + + if(!UI.support.mutationobserver) return; + + fn = fn || function() {}; + + UI.$(selector).each(function() { + + var element = this, + $element = UI.$(element); + + if ($element.data('observer')) { + return; + } + + try { + + var observer = new UI.support.mutationobserver(UI.Utils.debounce(function(mutations) { + fn.apply(element, []); + $element.trigger('changed.uk.dom'); + }, 50), {childList: true, subtree: true}); + + // pass in the target node, as well as the observer options + observer.observe(element, { childList: true, subtree: true }); + + $element.data('observer', observer); + + } catch(e) {} + }); + }; + + UI.init = function(root) { + + root = root || document; + + UI.domObservers.forEach(function(fn){ + fn(root); + }); + }; + + UI.on('domready.uk.dom', function(){ + + UI.init(); + + if (UI.domready) UI.Utils.checkDisplay(); + }); + + document.addEventListener('DOMContentLoaded', function(){ + + var domReady = function() { + + UI.$body = UI.$('body'); + + UI.trigger('beforeready.uk.dom'); + + UI.component.bootComponents(); + + // custom scroll observer + var rafToken = requestAnimationFrame((function(){ + + var memory = {dir: {x:0, y:0}, x: window.pageXOffset, y:window.pageYOffset}; + + var fn = function(){ + // reading this (window.page[X|Y]Offset) causes a full page recalc of the layout in Chrome, + // so we only want to do this once + var wpxo = window.pageXOffset; + var wpyo = window.pageYOffset; + + // Did the scroll position change since the last time we were here? + if (memory.x != wpxo || memory.y != wpyo) { + + // Set the direction of the scroll and store the new position + if (wpxo != memory.x) {memory.dir.x = wpxo > memory.x ? 1:-1; } else { memory.dir.x = 0; } + if (wpyo != memory.y) {memory.dir.y = wpyo > memory.y ? 1:-1; } else { memory.dir.y = 0; } + + memory.x = wpxo; + memory.y = wpyo; + + // Trigger the scroll event, this could probably be sent using memory.clone() but this is + // more explicit and easier to see exactly what is being sent in the event. + UI.$doc.trigger('scrolling.uk.document', [{ + "dir": {"x": memory.dir.x, "y": memory.dir.y}, "x": wpxo, "y": wpyo + }]); + } + + cancelAnimationFrame(rafToken); + rafToken = requestAnimationFrame(fn); + }; + + if (UI.support.touch) { + UI.$html.on('touchmove touchend MSPointerMove MSPointerUp pointermove pointerup', fn); + } + + if (memory.x || memory.y) fn(); + + return fn; + + })()); + + // run component init functions on dom + UI.trigger('domready.uk.dom'); + + if (UI.support.touch) { + + // remove css hover rules for touch devices + // UI.Utils.removeCssRules(/\.uk-(?!navbar).*:hover/); + + // viewport unit fix for uk-height-viewport - should be fixed in iOS 8 + if (navigator.userAgent.match(/(iPad|iPhone|iPod)/g)) { + + UI.$win.on('load orientationchange resize', UI.Utils.debounce((function(){ + + var fn = function() { + $('.uk-height-viewport').css('height', window.innerHeight); + return fn; + }; + + return fn(); + + })(), 100)); + } + } + + UI.trigger('afterready.uk.dom'); + + // mark that domready is left behind + UI.domready = true; + + // auto init js components + if (UI.support.mutationobserver) { + + var initFn = UI.Utils.debounce(function(){ + requestAnimationFrame(function(){ UI.init(document.body);}); + }, 10); + + (new UI.support.mutationobserver(function(mutations) { + + var init = false; + + mutations.every(function(mutation){ + + if (mutation.type != 'childList') return true; + + for (var i = 0, node; i < mutation.addedNodes.length; ++i) { + + node = mutation.addedNodes[i]; + + if (node.outerHTML && node.outerHTML.indexOf('data-uk-') !== -1) { + return (init = true) && false; + } + } + return true; + }); + + if (init) initFn(); + + })).observe(document.body, {childList: true, subtree: true}); + } + }; + + if (document.readyState == 'complete' || document.readyState == 'interactive') { + setTimeout(domReady); + } + + return domReady; + + }()); + + // add touch identifier class + UI.$html.addClass(UI.support.touch ? "uk-touch" : "uk-notouch"); + + // add uk-hover class on tap to support overlays on touch devices + if (UI.support.touch) { + + var hoverset = false, + exclude, + hovercls = 'uk-hover', + selector = '.uk-overlay, .uk-overlay-hover, .uk-overlay-toggle, .uk-animation-hover, .uk-has-hover'; + + UI.$html.on('mouseenter touchstart MSPointerDown pointerdown', selector, function() { + + if (hoverset) $('.'+hovercls).removeClass(hovercls); + + hoverset = $(this).addClass(hovercls); + + }).on('mouseleave touchend MSPointerUp pointerup', function(e) { + + exclude = $(e.target).parents(selector); + + if (hoverset) { + hoverset.not(exclude).removeClass(hovercls); + } + }); + } + + return UI; +}); -- cgit v1.2.3