xooie 1.0.4 → 1.0.5

data/vendor/assets/javascripts/xooie/dialog.js

@@ -0,0 +1,132 @@
+/*
+*   Copyright 2012 Comcast
+*
+*   Licensed under the Apache License, Version 2.0 (the "License");
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the License at
+*
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+*   Unless required by applicable law or agreed to in writing, software
+*   distributed under the License is distributed on an "AS IS" BASIS,
+*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*   See the License for the specific language governing permissions and
+*   limitations under the License.
+*/
+
+define('xooie/dialog', ['jquery', 'xooie/base'], function($, Base) {
+
+    var Dialog = Base('dialog', function(){
+        var self = this;
+
+        this.id = Dialog._counter++;
+
+        Dialog._instances[this.id] = this;
+
+        this.root.attr('data-dialog-id', this.id);
+
+        //add accessibility attributes
+        this.root.find(this.options.containerSelector).attr('role', 'dialog');
+
+        this.root.addClass('xooie-dialog');
+
+        this.handlers = {
+            mouseup: function(event){
+                Dialog.close(self.id);
+            },
+
+            keyup: function(event){
+                if([13,32].indexOf(event.which) !== -1){
+                    Dialog.close(self.id);
+                }
+            }
+        };
+    });
+
+    Dialog.setDefaultOptions({
+        closeButtonSelector: '[data-role="closeButton"]',
+        containerSelector: '[data-role="container"]',
+
+        dialogActiveClass: 'is-dialog-active'
+    });
+
+    Dialog.setCSSRules({
+        '.xooie-dialog': {
+            position: 'fixed',
+            top: 0,
+            bottom: 0,
+            left: 0,
+            right: 0
+        }
+    });
+
+    Dialog.prototype.activate = function(){
+        this.root.addClass(this.options.dialogActiveClass);
+
+        if(Dialog._active === this) {
+            return;
+        }
+
+        if(Dialog._active){
+            Dialog._active.deactivate();
+        }
+
+        this.root.find(this.options.closeButtonSelector)
+                 .on(this.handlers);
+
+        Dialog._active = this;
+
+        this.root.trigger('dialogActive');
+    };
+
+    Dialog.prototype.deactivate = function(){
+        this.root.removeClass(this.options.dialogActiveClass);
+
+        if (Dialog._active !== this) {
+            return;
+        }
+
+        this.root.find(this.options.closeButtonSelector)
+                 .off(this.handlers);
+
+        Dialog._active = null;
+
+        this.root.trigger('dialogInactive');
+    };
+
+    Dialog._instances = [];
+    Dialog._counter = 0;
+    Dialog._active = null;
+    Dialog._queue = [];
+
+    Dialog.open = function(id){
+        //get dialog instance
+        var dialog = this._instances[id];
+
+        if (typeof dialog === 'undefined' || this._active === dialog){
+            return;
+        }
+
+        if (this._active) {
+            this._queue.push(dialog);
+        } else {
+            dialog.activate();
+        }
+
+    };
+
+    Dialog.close = function(){
+        //get dialog instance
+        if(!this._active) {
+            return;
+        }
+
+        this._active.deactivate();
+
+        if (this._queue.length > 0) {
+            this._queue.pop().activate();
+        }
+    };
+
+    return Dialog;
+});

data/vendor/assets/javascripts/xooie/dropdown.js

@@ -0,0 +1,273 @@
+/*
+*   Copyright 2012 Comcast
+*
+*   Licensed under the Apache License, Version 2.0 (the "License");
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the License at
+*
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+*   Unless required by applicable law or agreed to in writing, software
+*   distributed under the License is distributed on an "AS IS" BASIS,
+*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*   See the License for the specific language governing permissions and
+*   limitations under the License.
+*/
+
+define('xooie/dropdown', ['jquery', 'xooie/base'], function($, Base) {
+    
+   var parseWhich = function(which) {
+        if (typeof which === 'string') {
+            which = which.split(',');
+            return which.map(function(string){ return parseInt(string, 10); });
+        } else if (typeof which === 'number') {
+            return [which];
+        }
+
+        return which;
+     };
+
+    var Dropdown = Base('dropdown', function() {
+        var self = this,
+            handles = self.getHandle(),
+            expanders = self.getExpander();
+
+        this.handlers = {
+            off: function(event){
+                if ((typeof event.data.not !== 'undefined' && ($(event.data.not).is($(this)) || $(event.target).parents(event.data.not).length > 0)) || (typeof event.data.which !== 'undefined' && event.data.which.indexOf(event.which) === -1) || ($(event.target).is(self.getExpander(event.data.index)) || $(event.target).parents(self.options.dropdownExpanderSelector).length > 0) && !$(event.target).is($(this))) {
+                    return true;
+                }
+
+                event.preventDefault();
+
+                self.collapse(event.data.index, event.data);
+            },
+
+            on: function(event){
+                var index = event.data.index || parseInt($(this).attr('data-dropdown-index'), 10),
+                    delay = event.data.delay,
+                    handle = $(this);
+
+                if ((typeof event.data.not !== 'undefined' && ($(event.data.not).is($(this)) || $(event.target).parents(event.data.not).length > 0)) || typeof event.data.which !== 'undefined' && event.data.which.indexOf(event.which) === -1) {
+                    return true;
+                }
+
+                event.preventDefault();
+
+                self.expand(index, event.data);
+            }
+        };
+
+        this.timers = {
+            expand: [],
+            collapse: [],
+            throttle: []
+        };
+
+        this.addHandlers('on');
+
+        this.root.on({
+            dropdownExpand: function(event, index){
+                self.removeHandlers('on', index);
+
+                self.addHandlers('off', index);
+
+                $(this).attr('aria-selected', true);
+                self.getExpander(index).attr('aria-hidden', false);
+            },
+
+            dropdownCollapse: function(event, index){
+                self.removeHandlers('off', index);
+
+                self.addHandlers('on', index);
+
+                $(this).attr('aria-selected', false);
+                self.getExpander(index).attr('aria-hidden', true);
+            }
+        }, this.options.dropdownHandleSelector);
+
+        this.root.on('xooie-init.dropdown xooie-refresh.dropdown', function(){
+            handles.each(function(index){
+                var handle = $(this),
+                    expander = expanders.eq(index);
+
+
+                handle.attr({
+                    'data-dropdown-index': index,
+                    'aria-selected': false
+                });
+                expander.attr({
+                    'data-dropdown-index': index,
+                    'aria-hidden': true
+                });
+            });
+        });
+
+        expanders.on('mouseover focus', function(){
+            var index = parseInt($(this).attr('data-dropdown-index'), 10);
+
+            if (self.timers.collapse[index]){
+                self.timers.collapse[index] = clearTimeout(self.timers.collapse[index]);
+
+                $(this).on('mouseleave blur', {index: index}, function(event){
+                    self.collapse(event.data.index, 0);
+                    $(this).unbind(event);
+                });
+            }
+        });
+
+    });
+
+    Dropdown.setDefaultOptions({
+        dropdownHandleSelector: '[data-role="dropdown-handle"]',
+        dropdownExpanderSelector: '[data-role="dropdown-content"]',
+
+        activeDropdownClass: 'is-dropdown-active',
+
+        throttleDelay: 300,
+        triggers: {
+            on: {
+                focus: {
+                    delay: 0
+                }
+            },
+            off: {
+                blur: {
+                    delay: 0
+                }
+            }
+        }
+
+    });
+
+    Dropdown.prototype.getTriggerHandle = function(triggerData, index){
+        var handles = this.getHandle(index);
+
+        if (triggerData.selector) {
+            return triggerData.selector === 'document' ? $(document) : $(triggerData.selector);
+        } else {
+            return handles;
+        }
+    };
+
+    Dropdown.prototype.addHandlers = function(state, index){
+        var trigger, handle, triggerData, countName;
+
+        triggerData = this.options.triggers[state];
+
+        for (trigger in triggerData) {
+            if (typeof triggerData[trigger].which !== 'undefined') {
+                triggerData[trigger].which = parseWhich(triggerData[trigger].which);
+            }
+
+            countName = [trigger,state,'count'].join('-');
+
+            handle = this.getTriggerHandle(triggerData[trigger], index);
+
+            handle.data(countName, handle.data(countName) + 1 || 1);
+
+            handle.on(trigger, $.extend({delay: 0, index: index}, triggerData[trigger]), this.handlers[state]);
+        }
+    };
+
+    Dropdown.prototype.removeHandlers = function(state, index){
+        var trigger, handle, triggerData, countName, eventCount;
+
+        triggerData = this.options.triggers[state];
+
+        for (trigger in triggerData) {
+            handle = this.getTriggerHandle(triggerData[trigger], index);
+
+            countName = [trigger,state,'count'].join('-');
+
+            eventCount = handle.data(countName) - 1;
+
+            if (eventCount <= 0) {
+                handle.unbind(trigger, this.handlers[state]);
+
+                handle.data(countName, 0);
+            } else {
+                handle.data(countName, eventCount);
+            }
+        }
+    };
+
+    Dropdown.prototype.getHandle = function(index){
+        var handles = this.root.find(this.options.dropdownHandleSelector);
+
+        return (typeof index !== 'undefined' && index >= 0) ? handles.eq(index) : handles;
+    };
+
+    Dropdown.prototype.getExpander = function(index){
+        var selectorString;
+
+        if (typeof index === 'undefined' || isNaN(index)) {
+            selectorString = this.options.dropdownExpanderSelector;
+        } else {
+            selectorString = this.options.dropdownExpanderSelector + '[data-dropdown-index="' + index + '"]';
+        }
+
+        return this.root.find(selectorString);
+    };
+
+    Dropdown.prototype.setState = function(index, data, active){
+        if (typeof index === 'undefined' || isNaN(index)) {
+            return;
+        }
+
+        var state = active ? 'expand' : 'collapse',
+            counterState = active ? 'collapse' : 'expand',
+            delay = data.delay;
+
+        this.timers[counterState][index] = clearTimeout(this.timers[counterState][index]);
+
+        if (this.timers.throttle[index] || this.timers[state][index]) {
+            return;
+        }
+
+        this.timers[state][index] = setTimeout(function(i, _state, _active, _data) {
+            var expander = this.getExpander(i),
+                handle = this.getHandle(i),
+                self = this;
+
+            this.timers[_state][i] = clearTimeout(this.timers[_state][i]);
+
+            expander.toggleClass(this.options.activeDropdownClass, _active);
+            this.getHandle(i).toggleClass(this.options.activeDropdownClass, _active);
+
+            if (_active){
+                handle.trigger('dropdownExpand', [i, _data]);
+                //this.setFocus(expander);
+            } else {
+                handle.trigger('dropdownCollapse', [i, _data]);
+            }
+
+            if (this.options.throttleDelay > 0){
+                this.timers.throttle[i] = setTimeout(function(){
+                    self.timers.throttle[i] = clearTimeout(self.timers.throttle[i]);
+                }, this.options.throttleDelay);
+            }
+
+        }.bind(this, index, state, active, data), delay);
+    };
+
+    Dropdown.prototype.expand = function(index, data) {
+        if (!this.getHandle(index).hasClass(this.options.activeDropdownClass)) {
+            this.setState(index, data, true);
+        }
+    };
+
+    Dropdown.prototype.collapse = function(index, data) {
+        if (this.getHandle(index).hasClass(this.options.activeDropdownClass)) {
+            this.setState(index, data, false);
+        }
+    };
+
+    Dropdown.prototype.setFocus = function(element){
+        element.find('a,input,textarea,button,select,iframe,[tabindex][tabindex!=-1]')
+               .first()
+               .focus();
+    };
+
+    return Dropdown;
+});

data/vendor/assets/javascripts/xooie/event_handler.js

@@ -14,9 +14,10 @@
 *   limitations under the License.
 */
 
-define('xooie/event_handler', ['jquery', 'xooie/helpers'], function($, helpers) {
+define('xooie/event_handler', ['jquery', 'xooie/helpers'], function ($, helpers) {
+  'use strict';
 
-  var EventHandler = function(namespace) {
+  var EventHandler = function (namespace) {
     this.namespace = namespace;
 
     this.handlers = {};
@@ -25,20 +26,17 @@ define('xooie/event_handler', ['jquery', 'xooie/helpers'], function($, helpers)
   };
 
   function format(type, namespace) {
-    if (!namespace) {
-      return type;
-    } else {
-      return type + '.' + namespace;
-    }
+    return !namespace ? type : type + '.' + namespace;
   }
 
-  EventHandler.prototype.add = function(type, method) {
-    var self = this,
-        formattedType, t;
+  EventHandler.prototype.add = function (type, method) {
+    var self, formattedType, t;
+
+    self = this;
 
     if (helpers.isObject(type) && helpers.isUndefined(method)) {
-      for(t in type) {
-        if (helpers.isFunction(type[t])) {
+      for (t in type) {
+        if (type.hasOwnProperty(t) && helpers.isFunction(type[t])) {
           this.add(t, type[t]);
         }
       }
@@ -49,7 +47,7 @@ define('xooie/event_handler', ['jquery', 'xooie/helpers'], function($, helpers)
     formattedType = format(type, this.namespace);
 
     if (helpers.isUndefined(this.handlers[formattedType])) {
-      this.handlers[formattedType] = function(e) {
+      this.handlers[formattedType] = function (e) {
         self.fire(e, this, arguments);
       };
     }
@@ -61,15 +59,15 @@ define('xooie/event_handler', ['jquery', 'xooie/helpers'], function($, helpers)
     this._callbacks[type].add(method);
   };
 
-  EventHandler.prototype.clear = function(type) {
-    delete(this.handlers[format(type, this.namespace)]);
+  EventHandler.prototype.clear = function (type) {
+    delete (this.handlers[format(type, this.namespace)]);
 
     if (!helpers.isUndefined(this._callbacks[type])) {
       this._callbacks[type].empty();
     }
   };
 
-  EventHandler.prototype.fire = function(event, context, args) {
+  EventHandler.prototype.fire = function (event, context, args) {
     if (event.namespace && event.namespace !== this.namespace) {
       return;
     }

data/vendor/assets/javascripts/xooie/helpers.js

@@ -18,10 +18,11 @@
 
 // Adds Array.prototype.indexOf functionality to IE<9 (From MDN)
 if (!Array.prototype.indexOf) {
-  Array.prototype.indexOf = function (searchElement , fromIndex) {
-    var i,
-        pivot = (fromIndex) ? fromIndex : 0,
-        length;
+  Array.prototype.indexOf = function (searchElement, fromIndex) {
+    'use strict';
+    var i, pivot, length;
+
+    pivot = fromIndex || 0;
 
     if (!this) {
       throw new TypeError();
@@ -37,7 +38,7 @@ if (!Array.prototype.indexOf) {
       pivot = length - Math.abs(pivot);
     }
 
-    for (i = pivot; i < length; i++) {
+    for (i = pivot; i < length; i += 1) {
       if (this[i] === searchElement) {
         return i;
       }
@@ -48,25 +49,29 @@ if (!Array.prototype.indexOf) {
 
 // Adds Function.prototype.bind to browsers that do not support it
 if (!Function.prototype.bind) {
-    Function.prototype.bind = function(context) {
-        var f = this,
-            args = Array.prototype.slice.call(arguments, 1);
+  Function.prototype.bind = function (context) {
+    'use strict';
+    var f, args;
+
+    f = this;
+    args = Array.prototype.slice.call(arguments, 1);
 
-        return function() {
-            return f.apply(context, args.concat(Array.prototype.slice.call(arguments)));
-        };
+    return function () {
+      return f.apply(context, args.concat(Array.prototype.slice.call(arguments)));
     };
+  };
 }
 
-
 /**
  * class Xooie.helpers
  *
  * A collection of helper methods used by Xooie modules.
  **/
 
-define('xooie/helpers', ['jquery'], function($){
-  var helpers = {};
+define('xooie/helpers', [], function () {
+  'use strict';
+
+  var helpers = {
 /**
  * Xooie.helpers.toAry(str) -> Array
  * - str (String | Array): The string to be converted to an array, or an array.
@@ -74,32 +79,37 @@ define('xooie/helpers', ['jquery'], function($){
  * Converts a string to an array, or returns the passed argument if it is already an array.  Used
  * when parsing data attributes that can be either a space-delineated string or an array.
  **/
-  helpers.toAry = function(str) {
-    if (typeof str === 'string') {
-      return str.split(/\s+/);
-    } else if (str instanceof Array) {
-      return str;
-    }
-  };
+    toAry: function (str) {
+      if (typeof str === 'string') {
+        return str.split(/\s+/);
+      }
 
-  helpers.toInt = function(int) {
-    return parseInt(int, 10);
-  };
+      if (str instanceof Array) {
+        return str;
+      }
+    },
 
-  helpers.isArray = Array.isArray || function(ary) {
-    return Array.prototype.toString(ary) === '[object Array]';
-  };
+    toInt: function (int) {
+      return parseInt(int, 10);
+    },
 
-  helpers.isObject = function(obj) {
-    return Object.prototype.toString(obj) === '[object Object]';
-  };
+    isArray: (function () {
+      return Array.isArray || function (ary) {
+        return Array.prototype.toString(ary) === '[object Array]';
+      };
+    }()),
 
-  helpers.isUndefined = function(obj) {
-    return obj === void 0;
-  };
+    isObject: function (obj) {
+      return Object.prototype.toString(obj) === '[object Object]';
+    },
+
+    isUndefined: function (obj) {
+      return obj === undefined;
+    },
 
-  helpers.isFunction = function(func) {
-    return typeof func === 'function';
+    isFunction: function (func) {
+      return typeof func === 'function';
+    }
   };
 
   return helpers;