uikit-sass-rails 1.3.0 → 1.4.0

data/vendor/assets/javascripts/uikit/{components → core}/cover.js

@@ -1,19 +1,5 @@
-/*! UIkit 2.11.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
-(function(addon) {
-
-    var component;
-
-    if (jQuery && jQuery.UIkit) {
-        component = addon(jQuery, jQuery.UIkit);
-    }
-
-    if (typeof define == "function" && define.amd) {
-        define("uikit-cover", ["uikit"], function(){
-            return component || addon(jQuery, jQuery.UIkit);
-        });
-    }
-
-})(function($, UI){
+/*! UIkit 2.20.3 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(UI){
 
     "use strict";
 
@@ -23,20 +9,35 @@
             automute : true
         },
 
+        boot: function() {
+
+            // auto init
+            UI.ready(function(context) {
+
+                UI.$("[data-uk-cover]", context).each(function(){
+
+                    var ele = UI.$(this);
+
+                    if(!ele.data("cover")) {
+                        var plugin = UI.cover(ele, UI.Utils.options(ele.attr("data-uk-cover")));
+                    }
+                });
+            });
+        },
+
         init: function() {
 
-            this.parent    = this.element.parent();
-            this.dimension = {w: this.element.width(), h: this.element.height()};
-            this.ratio     = this.dimension.w / this.dimension.h;
+            this.parent = this.element.parent();
 
             UI.$win.on('load resize orientationchange', UI.Utils.debounce(function(){
                 this.check();
             }.bind(this), 100));
 
-            this.check();
-
-            this.element.data("cover", this);
+            this.on("display.uk.check", function(e) {
+                if(this.element.is(":visible")) this.check();
+            }.bind(this));
 
+            this.check();
 
             if (this.element.is('iframe') && this.options.automute) {
 
@@ -52,6 +53,23 @@
 
         check: function() {
 
+            this.element.css({
+                'width'  : '',
+                'height' : ''
+            });
+
+            this.dimension = {w: this.element.width(), h: this.element.height()};
+
+            if (this.element.attr('width') && !isNaN(this.element.attr('width'))) {
+                this.dimension.w = this.element.attr('width');
+            }
+
+            if (this.element.attr('height') && !isNaN(this.element.attr('height'))) {
+                this.dimension.h = this.element.attr('height');
+            }
+
+            this.ratio     = this.dimension.w / this.dimension.h;
+
             var w = this.parent.width(), h = this.parent.height(), width, height;
 
             // if element height < parent height (gap underneath)
@@ -74,16 +92,4 @@
         }
     });
 
-    // auto init
-    UI.ready(function(context) {
-
-        $("[data-uk-cover]", context).each(function(){
-
-            var ele = $(this);
-
-            if(!ele.data("cover")) {
-                var plugin = UI.cover(ele, UI.Utils.options(ele.attr("data-uk-cover")));
-            }
-        });
-    });
-});
+})(UIkit);

data/vendor/assets/javascripts/uikit/core/dropdown.js

@@ -0,0 +1,296 @@
+/*! UIkit 2.20.3 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(UI) {
+
+    "use strict";
+
+    var active = false, hoverIdle;
+
+    UI.component('dropdown', {
+
+        defaults: {
+           'mode'       : 'hover',
+           'remaintime' : 800,
+           'justify'    : false,
+           'boundary'   : UI.$win,
+           'delay'      : 0,
+           'hoverDelayIdle'  : 250
+        },
+
+        remainIdle: false,
+
+        boot: function() {
+
+            var triggerevent = UI.support.touch ? "click" : "mouseenter";
+
+            // init code
+            UI.$html.on(triggerevent+".dropdown.uikit", "[data-uk-dropdown]", function(e) {
+
+                var ele = UI.$(this);
+
+                if (!ele.data("dropdown")) {
+
+                    var dropdown = UI.dropdown(ele, UI.Utils.options(ele.attr("data-uk-dropdown")));
+
+                    if (triggerevent=="click" || (triggerevent=="mouseenter" && dropdown.options.mode=="hover")) {
+                        dropdown.element.trigger(triggerevent);
+                    }
+
+                    if (dropdown.element.find('.uk-dropdown').length) {
+                        e.preventDefault();
+                    }
+                }
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.dropdown  = this.find('.uk-dropdown');
+
+            this.centered  = this.dropdown.hasClass('uk-dropdown-center');
+            this.justified = this.options.justify ? UI.$(this.options.justify) : false;
+
+            this.boundary  = UI.$(this.options.boundary);
+            this.flipped   = this.dropdown.hasClass('uk-dropdown-flip');
+
+            if (!this.boundary.length) {
+                this.boundary = UI.$win;
+            }
+
+            // Init ARIA
+            this.element.attr('aria-haspopup', 'true');
+            this.element.attr('aria-expanded', this.element.hasClass("uk-open"));
+
+            if (this.options.mode == "click" || UI.support.touch) {
+
+                this.on("click.uikit.dropdown", function(e) {
+
+                    var $target = UI.$(e.target);
+
+                    if (!$target.parents(".uk-dropdown").length) {
+
+                        if ($target.is("a[href='#']") || $target.parent().is("a[href='#']") || ($this.dropdown.length && !$this.dropdown.is(":visible")) ){
+                            e.preventDefault();
+                        }
+
+                        $target.blur();
+                    }
+
+                    if (!$this.element.hasClass('uk-open')) {
+
+                        $this.show();
+
+                    } else {
+
+                        if ($target.is("a:not(.js-uk-prevent)") || $target.is(".uk-dropdown-close") || !$this.dropdown.find(e.target).length) {
+                            $this.hide();
+                        }
+                    }
+                });
+
+            } else {
+
+                this.on("mouseenter", function(e) {
+
+                    if ($this.remainIdle) {
+                        clearTimeout($this.remainIdle);
+                    }
+
+                    if (hoverIdle) {
+                        clearTimeout(hoverIdle);
+                    }
+
+                    if (active && active == $this) {
+                        return;
+                    }
+
+                    // pseudo manuAim
+                    if (active && active != $this) {
+
+                        hoverIdle = setTimeout(function() {
+                            hoverIdle = setTimeout($this.show.bind($this), $this.options.delay);
+                        }, $this.options.hoverDelayIdle);
+
+                    } else {
+
+                        hoverIdle = setTimeout($this.show.bind($this), $this.options.delay);
+                    }
+
+                }).on("mouseleave", function() {
+
+                    if (hoverIdle) {
+                        clearTimeout(hoverIdle);
+                    }
+
+                    $this.remainIdle = setTimeout(function() {
+                        if (active && active == $this) $this.hide();
+                    }, $this.options.remaintime);
+
+                }).on("click", function(e){
+
+                    var $target = UI.$(e.target);
+
+                    if ($this.remainIdle) {
+                        clearTimeout($this.remainIdle);
+                    }
+
+                    if ($target.is("a[href='#']") || $target.parent().is("a[href='#']")){
+                        e.preventDefault();
+                    }
+
+                    $this.show();
+                });
+            }
+        },
+
+        show: function(){
+
+            UI.$html.off("click.outer.dropdown");
+
+            if (active && active != this) {
+                active.hide();
+            }
+
+            if (hoverIdle) {
+                clearTimeout(hoverIdle);
+            }
+
+            this.checkDimensions();
+            this.element.addClass('uk-open');
+
+            // Update ARIA
+            this.element.attr('aria-expanded', 'true');
+
+            this.trigger('show.uk.dropdown', [this]);
+
+            UI.Utils.checkDisplay(this.dropdown, true);
+            active = this;
+
+            this.registerOuterClick();
+        },
+
+        hide: function() {
+            this.element.removeClass('uk-open');
+
+            if (this.remainIdle) {
+                clearTimeout(this.remainIdle);
+            }
+
+            this.remainIdle = false;
+
+            // Update ARIA
+            this.element.attr('aria-expanded', 'false');
+
+            this.trigger('hide.uk.dropdown', [this]);
+
+            if (active == this) active = false;
+        },
+
+        registerOuterClick: function(){
+
+            var $this = this;
+
+            UI.$html.off("click.outer.dropdown");
+
+            setTimeout(function() {
+
+                UI.$html.on("click.outer.dropdown", function(e) {
+
+                    if (hoverIdle) {
+                        clearTimeout(hoverIdle);
+                    }
+
+                    var $target = UI.$(e.target);
+
+                    if (active == $this && ($target.is("a:not(.js-uk-prevent)") || $target.is(".uk-dropdown-close") || !$this.dropdown.find(e.target).length)) {
+                        $this.hide();
+                        UI.$html.off("click.outer.dropdown");
+                    }
+                });
+            }, 10);
+        },
+
+        checkDimensions: function() {
+
+            if (!this.dropdown.length) return;
+
+            if (this.justified && this.justified.length) {
+                this.dropdown.css("min-width", "");
+            }
+
+            var $this     = this,
+                dropdown  = this.dropdown.css("margin-" + UI.langdirection, ""),
+                offset    = dropdown.show().offset(),
+                width     = dropdown.outerWidth(),
+                boundarywidth  = this.boundary.width(),
+                boundaryoffset = this.boundary.offset() ? this.boundary.offset().left:0;
+
+            // centered dropdown
+            if (this.centered) {
+                dropdown.css("margin-" + UI.langdirection, (parseFloat(width) / 2 - dropdown.parent().width() / 2) * -1);
+                offset = dropdown.offset();
+
+                // reset dropdown
+                if ((width + offset.left) > boundarywidth || offset.left < 0) {
+                    dropdown.css("margin-" + UI.langdirection, "");
+                    offset = dropdown.offset();
+                }
+            }
+
+            // justify dropdown
+            if (this.justified && this.justified.length) {
+
+                var jwidth = this.justified.outerWidth();
+
+                dropdown.css("min-width", jwidth);
+
+                if (UI.langdirection == 'right') {
+
+                    var right1   = boundarywidth - (this.justified.offset().left + jwidth),
+                        right2   = boundarywidth - (dropdown.offset().left + dropdown.outerWidth());
+
+                    dropdown.css("margin-right", right1 - right2);
+
+                } else {
+                    dropdown.css("margin-left", this.justified.offset().left - offset.left);
+                }
+
+                offset = dropdown.offset();
+
+            }
+
+            if ((width + (offset.left-boundaryoffset)) > boundarywidth) {
+                dropdown.addClass('uk-dropdown-flip');
+                offset = dropdown.offset();
+            }
+
+            if ((offset.left-boundaryoffset) < 0) {
+
+                dropdown.addClass("uk-dropdown-stack");
+
+                if (dropdown.hasClass('uk-dropdown-flip')) {
+
+                    if (!this.flipped) {
+                        dropdown.removeClass('uk-dropdown-flip');
+                        offset = dropdown.offset();
+                        dropdown.addClass('uk-dropdown-flip');
+                    }
+
+                    setTimeout(function(){
+
+                        if ((dropdown.offset().left-boundaryoffset) < 0 || !$this.flipped && (dropdown.outerWidth() + (offset.left-boundaryoffset)) < boundarywidth) {
+                            dropdown.removeClass('uk-dropdown-flip');
+                        }
+                    }, 0);
+                }
+
+                this.trigger('stack.uk.dropdown', [this]);
+            }
+
+            dropdown.css("display", "");
+        }
+
+    });
+
+})(UIkit);

data/vendor/assets/javascripts/uikit/core/grid.js

@@ -0,0 +1,172 @@
+/*! UIkit 2.20.3 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(UI) {
+
+    "use strict";
+
+    var grids = [];
+
+    UI.component('gridMatchHeight', {
+
+        defaults: {
+            "target" : false,
+            "row"    : true
+        },
+
+        boot: function() {
+
+            // init code
+            UI.ready(function(context) {
+
+                UI.$("[data-uk-grid-match]", context).each(function() {
+                    var grid = UI.$(this), obj;
+
+                    if (!grid.data("gridMatchHeight")) {
+                        obj = UI.gridMatchHeight(grid, UI.Utils.options(grid.attr("data-uk-grid-match")));
+                    }
+                });
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.columns  = this.element.children();
+            this.elements = this.options.target ? this.find(this.options.target) : this.columns;
+
+            if (!this.columns.length) return;
+
+            UI.$win.on('load resize orientationchange', (function() {
+
+                var fn = function() {
+                    $this.match();
+                };
+
+                UI.$(function() { fn(); });
+
+                return UI.Utils.debounce(fn, 50);
+            })());
+
+            UI.$html.on("changed.uk.dom", function(e) {
+                $this.columns  = $this.element.children();
+                $this.elements = $this.options.target ? $this.find($this.options.target) : $this.columns;
+                $this.match();
+            });
+
+            this.on("display.uk.check", function(e) {
+                if(this.element.is(":visible")) this.match();
+            }.bind(this));
+
+            grids.push(this);
+        },
+
+        match: function() {
+
+            var firstvisible = this.columns.filter(":visible:first");
+
+            if (!firstvisible.length) return;
+
+            var stacked = Math.ceil(100 * parseFloat(firstvisible.css('width')) / parseFloat(firstvisible.parent().css('width'))) >= 100;
+
+            if (stacked) {
+                this.revert();
+            } else {
+                UI.Utils.matchHeights(this.elements, this.options);
+            }
+
+            return this;
+        },
+
+        revert: function() {
+            this.elements.css('min-height', '');
+            return this;
+        }
+    });
+
+    UI.component('gridMargin', {
+
+        defaults: {
+            "cls": "uk-grid-margin"
+        },
+
+        boot: function() {
+
+            // init code
+            UI.ready(function(context) {
+
+                UI.$("[data-uk-grid-margin]", context).each(function() {
+                    var grid = UI.$(this), obj;
+
+                    if (!grid.data("gridMargin")) {
+                        obj = UI.gridMargin(grid, UI.Utils.options(grid.attr("data-uk-grid-margin")));
+                    }
+                });
+            });
+        },
+
+        init: function() {
+
+            var stackMargin = UI.stackMargin(this.element, this.options);
+        }
+    });
+
+    // helper
+
+    UI.Utils.matchHeights = function(elements, options) {
+
+        elements = UI.$(elements).css('min-height', '');
+        options  = UI.$.extend({ row : true }, options);
+
+        var matchHeights = function(group){
+
+            if(group.length < 2) return;
+
+            var max = 0;
+
+            group.each(function() {
+                max = Math.max(max, UI.$(this).outerHeight());
+            }).each(function() {
+
+                var element = UI.$(this),
+                    height  = max - (element.css('box-sizing') == 'border-box' ? 0 : (element.outerHeight() - element.height()));
+
+
+                element.css('min-height', height + 'px');
+            });
+        };
+
+        if(options.row) {
+
+            elements.first().width(); // force redraw
+
+            setTimeout(function(){
+
+                var lastoffset = false, group = [];
+
+                elements.each(function() {
+
+                    var ele = UI.$(this), offset = ele.offset().top;
+
+                    if(offset != lastoffset && group.length) {
+
+                        matchHeights(UI.$(group));
+                        group  = [];
+                        offset = ele.offset().top;
+                    }
+
+                    group.push(ele);
+                    lastoffset = offset;
+                });
+
+                if(group.length) {
+                    matchHeights(UI.$(group));
+                }
+
+            }, 0);
+
+        } else {
+            matchHeights(elements);
+        }
+    };
+
+})(UIkit);