uikit-on-rails 1.5.0

data/vendor/assets/javascripts/uikit/components/form-password.js

@@ -0,0 +1,67 @@
+/*! UIkit 2.27.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-form-password", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+
+})(function(UI){
+
+    "use strict";
+
+    UI.component('formPassword', {
+
+        defaults: {
+            "lblShow": "Show",
+            "lblHide": "Hide"
+        },
+
+        boot: function() {
+            // init code
+            UI.$html.on("click.formpassword.uikit", "[data-uk-form-password]", function(e) {
+
+                var ele = UI.$(this);
+
+                if (!ele.data("formPassword")) {
+
+                    e.preventDefault();
+
+                    UI.formPassword(ele, UI.Utils.options(ele.attr("data-uk-form-password")));
+                    ele.trigger("click");
+                }
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.on("click", function(e) {
+
+                e.preventDefault();
+
+                if($this.input.length) {
+                    var type = $this.input.attr("type");
+                    $this.input.attr("type", type=="text" ? "password":"text");
+                    $this.element.html($this.options[type=="text" ? "lblShow":"lblHide"]);
+                }
+            });
+
+            this.input = this.element.next("input").length ? this.element.next("input") : this.element.prev("input");
+            this.element.html(this.options[this.input.is("[type='password']") ? "lblShow":"lblHide"]);
+
+
+            this.element.data("formPassword", this);
+        }
+    });
+
+    return UI.formPassword;
+});

data/vendor/assets/javascripts/uikit/components/form-select.js

@@ -0,0 +1,85 @@
+/*! UIkit 2.27.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-form-select", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+
+})(function(UI){
+
+    "use strict";
+
+    UI.component('formSelect', {
+
+        defaults: {
+            'target': '>span:first',
+            'activeClass': 'uk-active'
+        },
+
+        boot: function() {
+            // init code
+            UI.ready(function(context) {
+
+                UI.$("[data-uk-form-select]", context).each(function(){
+
+                    var ele = UI.$(this);
+
+                    if (!ele.data("formSelect")) {
+                        UI.formSelect(ele, UI.Utils.options(ele.attr("data-uk-form-select")));
+                    }
+                });
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.target  = this.find(this.options.target);
+            this.select  = this.find('select');
+
+            // init + on change event
+            this.select.on({
+
+                change: (function(){
+
+                    var select = $this.select[0], fn = function(){
+
+                        try {
+
+                            if($this.options.target === 'input') {
+                                $this.target.val(select.options[select.selectedIndex].text);
+                            } else {
+                                $this.target.text(select.options[select.selectedIndex].text);
+                            }
+
+                        } catch(e) {}
+
+                        $this.element[$this.select.val() ? 'addClass':'removeClass']($this.options.activeClass);
+
+                        return fn;
+                    };
+
+                    return fn();
+                })(),
+
+                focus: function(){ $this.target.addClass('uk-focus') },
+                blur: function(){ $this.target.removeClass('uk-focus') },
+                mouseenter: function(){ $this.target.addClass('uk-hover') },
+                mouseleave: function(){ $this.target.removeClass('uk-hover') }
+            });
+
+            this.element.data("formSelect", this);
+        }
+    });
+
+    return UI.formSelect;
+});

data/vendor/assets/javascripts/uikit/components/grid-parallax.js

@@ -0,0 +1,168 @@
+/*! UIkit 2.27.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-grid-parallax", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+
+})(function(UI){
+
+    var parallaxes  = [], checkParallaxes = function() {
+
+            requestAnimationFrame(function(){
+                for (var i=0; i < parallaxes.length; i++) {
+                    parallaxes[i].process();
+                }
+            });
+        };
+
+
+    UI.component('gridparallax', {
+
+        defaults: {
+            target   : false,
+            smooth   : 150,
+            translate     : 150
+        },
+
+        boot: function() {
+
+            // listen to scroll and resize
+            UI.$doc.on("scrolling.uk.document", checkParallaxes);
+            UI.$win.on("load resize orientationchange", UI.Utils.debounce(function(){
+                checkParallaxes();
+            }, 50));
+
+            // init code
+            UI.ready(function(context) {
+
+                UI.$('[data-uk-grid-parallax]', context).each(function() {
+
+                    var parallax = UI.$(this);
+
+                    if (!parallax.data("gridparallax")) {
+                        UI.gridparallax(parallax, UI.Utils.options(parallax.attr("data-uk-grid-parallax")));
+                    }
+                });
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.initItems().process();
+            parallaxes.push(this);
+
+            UI.$win.on('load resize orientationchange', (function() {
+
+                var fn = function() {
+                    var columns  = getcolumns($this.element);
+
+                    $this.element.css('margin-bottom', '');
+
+                    if (columns > 1) {
+                        $this.element.css('margin-bottom', $this.options.translate + parseInt($this.element.css('margin-bottom')));
+                    }
+                };
+
+                UI.$(function() { fn(); });
+
+                return UI.Utils.debounce(fn, 50);
+            })());
+        },
+
+        initItems: function() {
+
+            var smooth = this.options.smooth;
+
+            this.items = (this.options.target ? this.element.find(this.options.target) : this.element.children()).each(function(){
+                UI.$(this).css({
+                    transition: 'transform '+smooth+'ms linear',
+                    transform: ''
+                });
+            });
+
+            return this;
+        },
+
+        process: function() {
+
+            var percent  = percentageInViewport(this.element),
+                columns  = getcolumns(this.element),
+                items    = this.items,
+                mods     = [(columns-1)];
+
+            if (columns == 1 || !percent) {
+                items.css('transform', '');
+                return;
+            }
+
+            while(mods.length < columns) {
+               if(!(mods[mods.length-1] - 2)) break;
+               mods.push(mods[mods.length-1] - 2);
+            }
+
+            var translate  = this.options.translate, percenttranslate = percent * translate;
+
+            items.each(function(idx, ele, translate){
+                translate = mods.indexOf((idx+1) % columns) != -1 ? percenttranslate : percenttranslate / 8;
+                UI.$(this).css('transform', 'translate3d(0,'+(translate)+'px, 0)');
+            });
+        }
+
+    });
+
+
+    function getcolumns(element) {
+
+        var children = element.children(),
+            first    = children.filter(':visible:first'),
+            top      = first[0].offsetTop + first.outerHeight();
+
+        for (var column=0;column<children.length;column++) {
+            if (children[column].offsetTop >= top)  break;
+        }
+
+        return column || 1;
+    }
+
+    function percentageInViewport(element) {
+
+        var top       = element.offset().top,
+            height    = element.outerHeight(),
+            scrolltop = UIkit.$win.scrollTop(),
+            wh        = window.innerHeight,
+            distance, percentage, percent;
+
+        if (top > (scrolltop + wh)) {
+            percent = 0;
+        } else if ((top + height) < scrolltop) {
+            percent = 1;
+        } else {
+
+            if ((top + height) < wh) {
+                percent = (scrolltop < wh ? scrolltop : scrolltop - wh) / (top+height);
+            } else {
+
+                distance   = (scrolltop + wh) - top;
+                percentage = Math.round(distance / ((wh + height) / 100));
+                percent    = percentage/100;
+            }
+
+            if (top < wh) {
+                percent = percent * scrolltop / ((top + height) - wh);
+            }
+        }
+
+        return percent > 1 ? 1:percent;
+    }
+});

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

@@ -0,0 +1,540 @@
+/*! UIkit 2.27.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-grid", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+
+})(function(UI){
+
+    "use strict";
+
+    UI.component('grid', {
+
+        defaults: {
+            colwidth  : 'auto',
+            animation : true,
+            duration  : 300,
+            gutter    : 0,
+            controls  : false,
+            filter    : false,
+            origin    : UI.langdirection
+        },
+
+        boot:  function() {
+
+            // init code
+            UI.ready(function(context) {
+
+                UI.$('[data-uk-grid]', context).each(function(){
+
+                    var ele = UI.$(this);
+
+                    if(!ele.data("grid")) {
+                        UI.grid(ele, UI.Utils.options(ele.attr('data-uk-grid')));
+                    }
+                });
+            });
+        },
+
+        init: function() {
+
+            var $this = this, gutter = String(this.options.gutter).trim().split(' ');
+
+            this.gutterv  = parseInt(gutter[0], 10);
+            this.gutterh  = parseInt((gutter[1] || gutter[0]), 10);
+
+            // make sure parent element has the right position property
+            this.element.css({'position': 'relative'});
+
+            this.controls = null;
+            this.origin   = this.options.origin;
+
+            if (this.options.controls) {
+
+                this.controls = UI.$(this.options.controls);
+
+                // filter
+                this.controls.on('click', '[data-uk-filter]', function(e){
+                    e.preventDefault();
+                    $this.filter(UI.$(this).attr('data-uk-filter'));
+                });
+
+                // sort
+                this.controls.on('click', '[data-uk-sort]', function(e){
+                    e.preventDefault();
+                    var cmd = UI.$(this).attr('data-uk-sort').split(':');
+                    $this.sort(cmd[0], cmd[1]);
+                });
+            }
+
+            UI.$win.on('load resize orientationchange', UI.Utils.debounce(function(){
+
+                if ($this.currentfilter) {
+                    $this.filter($this.currentfilter);
+                } else {
+                    this.update();
+                }
+
+            }.bind(this), 100));
+
+            this.on('display.uk.check', function(){
+                if ($this.element.is(":visible"))  $this.update();
+            });
+
+            UI.domObserve(this.element, function(e) {
+                $this.update();
+            });
+
+            if (this.options.filter !== false) {
+                this.filter(this.options.filter);
+            } else {
+                this.update();
+            }
+        },
+
+        _prepareElements: function() {
+
+            var children = this.element.children(':not([data-grid-prepared])'), css;
+
+            // exit if no already prepared elements found
+            if (!children.length) {
+                return;
+            }
+
+            css = {
+                'position'   : 'absolute',
+                'box-sizing' : 'border-box',
+                'width'      : this.options.colwidth == 'auto' ? '' : this.options.colwidth
+            };
+
+            if (this.options.gutter) {
+
+                css['padding-'+this.origin] = this.gutterh;
+                css['padding-bottom'] = this.gutterv;
+
+                this.element.css('margin-'+this.origin, this.gutterh * -1);
+            }
+
+            children.attr('data-grid-prepared', 'true').css(css);
+        },
+
+        update: function(elements) {
+
+            var $this = this;
+
+            this._prepareElements();
+
+            elements = elements || this.element.children(':visible');
+
+            var children  = elements,
+                maxwidth  = this.element.width() + (2*this.gutterh) + 2,
+                left      = 0,
+                top       = 0,
+                positions = [],
+
+                item, width, height, pos, posi, i, z, max, size;
+
+            this.trigger('beforeupdate.uk.grid', [children]);
+
+            children.each(function(index){
+
+                size   = getElementSize(this);
+
+                item   = UI.$(this);
+                width  = size.outerWidth;
+                height = size.outerHeight;
+                left   = 0;
+                top    = 0;
+
+                for (i=0,max=positions.length;i<max;i++) {
+
+                    pos = positions[i];
+
+                    if (left <= pos.aX) { left = pos.aX; }
+                    if (maxwidth < (left + width)) { left = 0; }
+                    if (top <= pos.aY) { top = pos.aY; }
+                }
+
+                posi = {
+                    "ele"    : item,
+                    "top"    : top,
+                    "width"  : width,
+                    "height" : height,
+                    "aY"     : (top  + height),
+                    "aX"     : (left + width)
+                };
+
+                posi[$this.origin] = left;
+
+                positions.push(posi);
+            });
+
+            var posPrev, maxHeight = 0, positionto;
+
+            // fix top
+            for (i=0,max=positions.length;i<max;i++) {
+
+                pos = positions[i];
+                top = 0;
+
+                for (z=0;z<i;z++) {
+
+                    posPrev = positions[z];
+
+                    // (posPrev.left + 1) fixex 1px bug when using % based widths
+                    if (pos[this.origin] < posPrev.aX && (posPrev[this.origin] +1) < pos.aX) {
+                        top = posPrev.aY;
+                    }
+                }
+
+                pos.top = top;
+                pos.aY  = top + pos.height;
+
+                maxHeight = Math.max(maxHeight, pos.aY);
+            }
+
+            maxHeight = maxHeight - this.gutterv;
+
+            if (this.options.animation) {
+
+                this.element.stop().animate({'height': maxHeight}, 100);
+
+                positions.forEach(function(pos){
+
+                    positionto = {"top": pos.top, opacity: 1};
+                    positionto[$this.origin] = pos[$this.origin];
+
+                    pos.ele.stop().animate(positionto, this.options.duration);
+                }.bind(this));
+
+            } else {
+
+                this.element.css('height', maxHeight);
+
+                positions.forEach(function(pos){
+                    positionto = {"top": pos.top, opacity: 1};
+                    positionto[$this.origin] = pos[$this.origin];
+                    pos.ele.css(positionto);
+                }.bind(this));
+            }
+
+            // make sure to trigger possible scrollpies etc.
+            setTimeout(function() {
+                UI.$doc.trigger('scrolling.uk.document');
+            }, 2 * this.options.duration * (this.options.animation ? 1:0));
+
+            this.trigger('afterupdate.uk.grid', [children]);
+        },
+
+        filter: function(filter) {
+
+            this.currentfilter = filter;
+
+            filter = filter || [];
+
+            if (typeof(filter) === 'number') {
+                filter = filter.toString();
+            }
+
+            if (typeof(filter) === 'string') {
+                filter = filter.split(/,/).map(function(item){ return item.trim(); });
+            }
+
+            var $this = this, children = this.element.children(), elements = {"visible": [], "hidden": []}, visible, hidden;
+
+            children.each(function(index){
+
+                var ele = UI.$(this), f = ele.attr('data-uk-filter'), infilter = filter.length ? false : true;
+
+                if (f) {
+
+                    f = f.split(/,/).map(function(item){ return item.trim(); });
+
+                    filter.forEach(function(item){
+                        if (f.indexOf(item) > -1) infilter = true;
+                    });
+                }
+
+                elements[infilter ? "visible":"hidden"].push(ele);
+            });
+
+            // convert to jQuery collections
+            elements.hidden  = UI.$(elements.hidden).map(function () {return this[0];});
+            elements.visible = UI.$(elements.visible).map(function () {return this[0];});
+
+            elements.hidden.attr('aria-hidden', 'true').filter(':visible').fadeOut(this.options.duration);
+            elements.visible.attr('aria-hidden', 'false').filter(':hidden').css('opacity', 0).show();
+
+            $this.update(elements.visible);
+
+            if (this.controls && this.controls.length) {
+                this.controls.find('[data-uk-filter]').removeClass('uk-active').filter('[data-uk-filter="'+filter+'"]').addClass('uk-active');
+            }
+        },
+
+        sort: function(by, order){
+
+            order = order || 1;
+
+            // covert from string (asc|desc) to number
+            if (typeof(order) === 'string') {
+                order = order.toLowerCase() == 'desc' ? -1 : 1;
+            }
+
+            var elements = this.element.children();
+
+            elements.sort(function(a, b){
+
+                a = UI.$(a);
+                b = UI.$(b);
+
+                return (b.data(by) || '') < (a.data(by) || '') ? order : (order*-1);
+
+            }).appendTo(this.element);
+
+            this.update(elements.filter(':visible'));
+
+            if (this.controls && this.controls.length) {
+                this.controls.find('[data-uk-sort]').removeClass('uk-active').filter('[data-uk-sort="'+by+':'+(order == -1 ? 'desc':'asc')+'"]').addClass('uk-active');
+            }
+        }
+    });
+
+
+    /*!
+    * getSize v1.2.2
+    * measure size of elements
+    * MIT license
+    * https://github.com/desandro/get-size
+    */
+    function _getSize() {
+
+        var prefixes = 'Webkit Moz ms Ms O'.split(' ');
+        var docElemStyle = document.documentElement.style;
+
+        function getStyleProperty( propName ) {
+            if ( !propName ) {
+                return;
+            }
+
+            // test standard property first
+            if ( typeof docElemStyle[ propName ] === 'string' ) {
+                return propName;
+            }
+
+            // capitalize
+            propName = propName.charAt(0).toUpperCase() + propName.slice(1);
+
+            // test vendor specific properties
+            var prefixed;
+            for ( var i=0, len = prefixes.length; i < len; i++ ) {
+                prefixed = prefixes[i] + propName;
+                if ( typeof docElemStyle[ prefixed ] === 'string' ) {
+                    return prefixed;
+                }
+            }
+        }
+
+        // -------------------------- helpers -------------------------- //
+
+        // get a number from a string, not a percentage
+        function getStyleSize( value ) {
+            var num = parseFloat( value );
+            // not a percent like '100%', and a number
+            var isValid = value.indexOf('%') === -1 && !isNaN( num );
+            return isValid && num;
+        }
+
+        function noop() {}
+
+        var logError = typeof console === 'undefined' ? noop : function( message ) {
+            console.error( message );
+        };
+
+        // -------------------------- measurements -------------------------- //
+
+        var measurements = [
+            'paddingLeft',
+            'paddingRight',
+            'paddingTop',
+            'paddingBottom',
+            'marginLeft',
+            'marginRight',
+            'marginTop',
+            'marginBottom',
+            'borderLeftWidth',
+            'borderRightWidth',
+            'borderTopWidth',
+            'borderBottomWidth'
+        ];
+
+        function getZeroSize() {
+            var size = {
+                width: 0,
+                height: 0,
+                innerWidth: 0,
+                innerHeight: 0,
+                outerWidth: 0,
+                outerHeight: 0
+            };
+            for ( var i=0, len = measurements.length; i < len; i++ ) {
+                var measurement = measurements[i];
+                size[ measurement ] = 0;
+            }
+            return size;
+        }
+
+
+        // -------------------------- setup -------------------------- //
+
+        var isSetup = false;
+        var getStyle, boxSizingProp, isBoxSizeOuter;
+
+        /**
+        * setup vars and functions
+        * do it on initial getSize(), rather than on script load
+        * For Firefox bug https://bugzilla.mozilla.org/show_bug.cgi?id=548397
+        */
+        function setup() {
+            // setup once
+            if ( isSetup ) {
+                return;
+            }
+            isSetup = true;
+
+            var getComputedStyle = window.getComputedStyle;
+            getStyle = ( function() {
+                var getStyleFn = getComputedStyle ?
+                function( elem ) {
+                    return getComputedStyle( elem, null );
+                } :
+                function( elem ) {
+                    return elem.currentStyle;
+                };
+
+                return function getStyle( elem ) {
+                    var style = getStyleFn( elem );
+                    if ( !style ) {
+                        logError( 'Style returned ' + style +
+                        '. Are you running this code in a hidden iframe on Firefox? ' +
+                        'See http://bit.ly/getsizebug1' );
+                    }
+                    return style;
+                };
+            })();
+
+            // -------------------------- box sizing -------------------------- //
+
+            boxSizingProp = getStyleProperty('boxSizing');
+
+            /**
+            * WebKit measures the outer-width on style.width on border-box elems
+            * IE & Firefox measures the inner-width
+            */
+            if ( boxSizingProp ) {
+                var div = document.createElement('div');
+                div.style.width = '200px';
+                div.style.padding = '1px 2px 3px 4px';
+                div.style.borderStyle = 'solid';
+                div.style.borderWidth = '1px 2px 3px 4px';
+                div.style[ boxSizingProp ] = 'border-box';
+
+                var body = document.body || document.documentElement;
+                body.appendChild( div );
+                var style = getStyle( div );
+
+                isBoxSizeOuter = getStyleSize( style.width ) === 200;
+                body.removeChild( div );
+            }
+
+        }
+
+        // -------------------------- getSize -------------------------- //
+
+        function getSize( elem ) {
+            setup();
+
+            // use querySeletor if elem is string
+            if ( typeof elem === 'string' ) {
+                elem = document.querySelector( elem );
+            }
+
+            // do not proceed on non-objects
+            if ( !elem || typeof elem !== 'object' || !elem.nodeType ) {
+                return;
+            }
+
+            var style = getStyle( elem );
+
+            // if hidden, everything is 0
+            if ( style.display === 'none' ) {
+                return getZeroSize();
+            }
+
+            var size = {};
+            size.width = elem.offsetWidth;
+            size.height = elem.offsetHeight;
+
+            var isBorderBox = size.isBorderBox = !!( boxSizingProp &&
+                style[ boxSizingProp ] && style[ boxSizingProp ] === 'border-box' );
+
+            // get all measurements
+            for ( var i=0, len = measurements.length; i < len; i++ ) {
+                var measurement = measurements[i];
+                var value = style[ measurement ];
+
+                var num = parseFloat( value );
+                // any 'auto', 'medium' value will be 0
+                size[ measurement ] = !isNaN( num ) ? num : 0;
+            }
+
+            var paddingWidth = size.paddingLeft + size.paddingRight;
+            var paddingHeight = size.paddingTop + size.paddingBottom;
+            var marginWidth = size.marginLeft + size.marginRight;
+            var marginHeight = size.marginTop + size.marginBottom;
+            var borderWidth = size.borderLeftWidth + size.borderRightWidth;
+            var borderHeight = size.borderTopWidth + size.borderBottomWidth;
+
+            var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
+
+            // overwrite width and height if we can get it from style
+            var styleWidth = getStyleSize( style.width );
+            if ( styleWidth !== false ) {
+                size.width = styleWidth +
+                // add padding and border unless it's already including it
+                ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
+            }
+
+            var styleHeight = getStyleSize( style.height );
+            if ( styleHeight !== false ) {
+                size.height = styleHeight +
+                // add padding and border unless it's already including it
+                ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
+            }
+
+            size.innerWidth = size.width - ( paddingWidth + borderWidth );
+            size.innerHeight = size.height - ( paddingHeight + borderHeight );
+
+            size.outerWidth = size.width + marginWidth;
+            size.outerHeight = size.height + marginHeight;
+
+            return size;
+        }
+
+        return getSize;
+
+    }
+
+    function getElementSize(ele) {
+        return _getSize()(ele);
+    }
+});