iqvoc 4.8.1 → 4.8.2

data/vendor/assets/bower_components/typeahead.js/src/typeahead/dropdown.js

@@ -0,0 +1,245 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var Dropdown = (function() {
+  'use strict';
+
+  // constructor
+  // -----------
+
+  function Dropdown(o) {
+    var that = this, onSuggestionClick, onSuggestionMouseEnter,
+        onSuggestionMouseLeave;
+
+    o = o || {};
+
+    if (!o.menu) {
+      $.error('menu is required');
+    }
+
+    this.isOpen = false;
+    this.isEmpty = true;
+
+    this.datasets = _.map(o.datasets, initializeDataset);
+
+    // bound functions
+    onSuggestionClick = _.bind(this._onSuggestionClick, this);
+    onSuggestionMouseEnter = _.bind(this._onSuggestionMouseEnter, this);
+    onSuggestionMouseLeave = _.bind(this._onSuggestionMouseLeave, this);
+
+    this.$menu = $(o.menu)
+    .on('click.tt', '.tt-suggestion', onSuggestionClick)
+    .on('mouseenter.tt', '.tt-suggestion', onSuggestionMouseEnter)
+    .on('mouseleave.tt', '.tt-suggestion', onSuggestionMouseLeave);
+
+    _.each(this.datasets, function(dataset) {
+      that.$menu.append(dataset.getRoot());
+      dataset.onSync('rendered', that._onRendered, that);
+    });
+  }
+
+  // instance methods
+  // ----------------
+
+  _.mixin(Dropdown.prototype, EventEmitter, {
+
+    // ### private
+
+    _onSuggestionClick: function onSuggestionClick($e) {
+      this.trigger('suggestionClicked', $($e.currentTarget));
+    },
+
+    _onSuggestionMouseEnter: function onSuggestionMouseEnter($e) {
+      this._removeCursor();
+      this._setCursor($($e.currentTarget), true);
+    },
+
+    _onSuggestionMouseLeave: function onSuggestionMouseLeave() {
+      this._removeCursor();
+    },
+
+    _onRendered: function onRendered() {
+      this.isEmpty = _.every(this.datasets, isDatasetEmpty);
+
+      this.isEmpty ? this._hide() : (this.isOpen && this._show());
+
+      this.trigger('datasetRendered');
+
+      function isDatasetEmpty(dataset) { return dataset.isEmpty(); }
+    },
+
+    _hide: function() {
+      this.$menu.hide();
+    },
+
+    _show: function() {
+      // can't use jQuery#show because $menu is a span element we want
+      // display: block; not dislay: inline;
+      this.$menu.css('display', 'block');
+    },
+
+    _getSuggestions: function getSuggestions() {
+      return this.$menu.find('.tt-suggestion');
+    },
+
+    _getCursor: function getCursor() {
+      return this.$menu.find('.tt-cursor').first();
+    },
+
+    _setCursor: function setCursor($el, silent) {
+      $el.first().addClass('tt-cursor');
+
+      !silent && this.trigger('cursorMoved');
+    },
+
+    _removeCursor: function removeCursor() {
+      this._getCursor().removeClass('tt-cursor');
+    },
+
+    _moveCursor: function moveCursor(increment) {
+      var $suggestions, $oldCursor, newCursorIndex, $newCursor;
+
+      if (!this.isOpen) { return; }
+
+      $oldCursor = this._getCursor();
+      $suggestions = this._getSuggestions();
+
+      this._removeCursor();
+
+      // shifting before and after modulo to deal with -1 index
+      newCursorIndex = $suggestions.index($oldCursor) + increment;
+      newCursorIndex = (newCursorIndex + 1) % ($suggestions.length + 1) - 1;
+
+      if (newCursorIndex === -1) {
+        this.trigger('cursorRemoved');
+
+        return;
+      }
+
+      else if (newCursorIndex < -1) {
+        newCursorIndex = $suggestions.length - 1;
+      }
+
+      this._setCursor($newCursor = $suggestions.eq(newCursorIndex));
+
+      // in the case of scrollable overflow
+      // make sure the cursor is visible in the menu
+      this._ensureVisible($newCursor);
+    },
+
+    _ensureVisible: function ensureVisible($el) {
+      var elTop, elBottom, menuScrollTop, menuHeight;
+
+      elTop = $el.position().top;
+      elBottom = elTop + $el.outerHeight(true);
+      menuScrollTop = this.$menu.scrollTop();
+      menuHeight = this.$menu.height() +
+        parseInt(this.$menu.css('paddingTop'), 10) +
+        parseInt(this.$menu.css('paddingBottom'), 10);
+
+      if (elTop < 0) {
+        this.$menu.scrollTop(menuScrollTop + elTop);
+      }
+
+      else if (menuHeight < elBottom) {
+        this.$menu.scrollTop(menuScrollTop + (elBottom - menuHeight));
+      }
+    },
+
+    // ### public
+
+    close: function close() {
+      if (this.isOpen) {
+        this.isOpen = false;
+
+        this._removeCursor();
+        this._hide();
+
+        this.trigger('closed');
+      }
+    },
+
+    open: function open() {
+      if (!this.isOpen) {
+        this.isOpen = true;
+
+        !this.isEmpty && this._show();
+
+        this.trigger('opened');
+      }
+    },
+
+    setLanguageDirection: function setLanguageDirection(dir) {
+      this.$menu.css(dir === 'ltr' ? css.ltr : css.rtl);
+    },
+
+    moveCursorUp: function moveCursorUp() {
+      this._moveCursor(-1);
+    },
+
+    moveCursorDown: function moveCursorDown() {
+      this._moveCursor(+1);
+    },
+
+    getDatumForSuggestion: function getDatumForSuggestion($el) {
+      var datum = null;
+
+      if ($el.length) {
+        datum = {
+          raw: Dataset.extractDatum($el),
+          value: Dataset.extractValue($el),
+          datasetName: Dataset.extractDatasetName($el)
+        };
+      }
+
+      return datum;
+    },
+
+    getDatumForCursor: function getDatumForCursor() {
+      return this.getDatumForSuggestion(this._getCursor().first());
+    },
+
+    getDatumForTopSuggestion: function getDatumForTopSuggestion() {
+      return this.getDatumForSuggestion(this._getSuggestions().first());
+    },
+
+    update: function update(query) {
+      _.each(this.datasets, updateDataset);
+
+      function updateDataset(dataset) { dataset.update(query); }
+    },
+
+    empty: function empty() {
+      _.each(this.datasets, clearDataset);
+      this.isEmpty = true;
+
+      function clearDataset(dataset) { dataset.clear(); }
+    },
+
+    isVisible: function isVisible() {
+      return this.isOpen && !this.isEmpty;
+    },
+
+    destroy: function destroy() {
+      this.$menu.off('.tt');
+
+      this.$menu = null;
+
+      _.each(this.datasets, destroyDataset);
+
+      function destroyDataset(dataset) { dataset.destroy(); }
+    }
+  });
+
+  return Dropdown;
+
+  // helper functions
+  // ----------------
+
+  function initializeDataset(oDataset) {
+    return new Dataset(oDataset);
+  }
+})();

data/vendor/assets/bower_components/typeahead.js/src/typeahead/event_bus.js

@@ -0,0 +1,38 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var EventBus = (function() {
+  'use strict';
+
+  var namespace = 'typeahead:';
+
+  // constructor
+  // -----------
+
+  function EventBus(o) {
+    if (!o || !o.el) {
+      $.error('EventBus initialized without el');
+    }
+
+    this.$el = $(o.el);
+  }
+
+  // instance methods
+  // ----------------
+
+  _.mixin(EventBus.prototype, {
+
+    // ### public
+
+    trigger: function(type) {
+      var args = [].slice.call(arguments, 1);
+
+      this.$el.trigger(namespace + type, args);
+    }
+  });
+
+  return EventBus;
+})();

data/vendor/assets/bower_components/typeahead.js/src/typeahead/event_emitter.js

@@ -0,0 +1,119 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+// inspired by https://github.com/jharding/boomerang
+
+var EventEmitter = (function() {
+  'use strict';
+
+  var splitter = /\s+/, nextTick = getNextTick();
+
+  return {
+    onSync: onSync,
+    onAsync: onAsync,
+    off: off,
+    trigger: trigger
+  };
+
+  function on(method, types, cb, context) {
+    var type;
+
+    if (!cb) { return this; }
+
+    types = types.split(splitter);
+    cb = context ? bindContext(cb, context) : cb;
+
+    this._callbacks = this._callbacks || {};
+
+    while (type = types.shift()) {
+      this._callbacks[type] = this._callbacks[type] || { sync: [], async: [] };
+      this._callbacks[type][method].push(cb);
+    }
+
+    return this;
+  }
+
+  function onAsync(types, cb, context) {
+    return on.call(this, 'async', types, cb, context);
+  }
+
+  function onSync(types, cb, context) {
+    return on.call(this, 'sync', types, cb, context);
+  }
+
+  function off(types) {
+    var type;
+
+    if (!this._callbacks) { return this; }
+
+    types = types.split(splitter);
+
+    while (type = types.shift()) {
+      delete this._callbacks[type];
+    }
+
+    return this;
+  }
+
+  function trigger(types) {
+    var type, callbacks, args, syncFlush, asyncFlush;
+
+    if (!this._callbacks) { return this; }
+
+    types = types.split(splitter);
+    args = [].slice.call(arguments, 1);
+
+    while ((type = types.shift()) && (callbacks = this._callbacks[type])) {
+      syncFlush = getFlush(callbacks.sync, this, [type].concat(args));
+      asyncFlush = getFlush(callbacks.async, this, [type].concat(args));
+
+      syncFlush() && nextTick(asyncFlush);
+    }
+
+    return this;
+  }
+
+  function getFlush(callbacks, context, args) {
+    return flush;
+
+    function flush() {
+      var cancelled;
+
+      for (var i = 0, len = callbacks.length; !cancelled && i < len; i += 1) {
+        // only cancel if the callback explicitly returns false
+        cancelled = callbacks[i].apply(context, args) === false;
+      }
+
+      return !cancelled;
+    }
+  }
+
+  function getNextTick() {
+    var nextTickFn;
+
+    // IE10+
+    if (window.setImmediate) {
+      nextTickFn = function nextTickSetImmediate(fn) {
+        setImmediate(function() { fn(); });
+      };
+    }
+
+    // old browsers
+    else {
+      nextTickFn = function nextTickSetTimeout(fn) {
+        setTimeout(function() { fn(); }, 0);
+      };
+    }
+
+    return nextTickFn;
+  }
+
+  function bindContext(fn, context) {
+    return fn.bind ?
+      fn.bind(context) :
+      function() { fn.apply(context, [].slice.call(arguments, 0)); };
+  }
+})();

data/vendor/assets/bower_components/typeahead.js/src/typeahead/highlight.js

@@ -0,0 +1,84 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+// inspired by https://github.com/jharding/bearhug
+
+var highlight = (function(doc) {
+  'use strict';
+
+  var defaults = {
+        node: null,
+        pattern: null,
+        tagName: 'strong',
+        className: null,
+        wordsOnly: false,
+        caseSensitive: false
+      };
+
+  return function hightlight(o) {
+    var regex;
+
+    o = _.mixin({}, defaults, o);
+
+    if (!o.node || !o.pattern) {
+      // fail silently
+      return;
+    }
+
+    // support wrapping multiple patterns
+    o.pattern = _.isArray(o.pattern) ? o.pattern : [o.pattern];
+
+    regex = getRegex(o.pattern, o.caseSensitive, o.wordsOnly);
+    traverse(o.node, hightlightTextNode);
+
+    function hightlightTextNode(textNode) {
+      var match, patternNode, wrapperNode;
+
+      if (match = regex.exec(textNode.data)) {
+        wrapperNode = doc.createElement(o.tagName);
+        o.className && (wrapperNode.className = o.className);
+
+        patternNode = textNode.splitText(match.index);
+        patternNode.splitText(match[0].length);
+        wrapperNode.appendChild(patternNode.cloneNode(true));
+
+        textNode.parentNode.replaceChild(wrapperNode, patternNode);
+      }
+
+      return !!match;
+    }
+
+    function traverse(el, hightlightTextNode) {
+      var childNode, TEXT_NODE_TYPE = 3;
+
+      for (var i = 0; i < el.childNodes.length; i++) {
+        childNode = el.childNodes[i];
+
+        if (childNode.nodeType === TEXT_NODE_TYPE) {
+          i += hightlightTextNode(childNode) ? 1 : 0;
+        }
+
+        else {
+          traverse(childNode, hightlightTextNode);
+        }
+      }
+    }
+  };
+
+  function getRegex(patterns, caseSensitive, wordsOnly) {
+    var escapedPatterns = [], regexStr;
+
+    for (var i = 0, len = patterns.length; i < len; i++) {
+      escapedPatterns.push(_.escapeRegExChars(patterns[i]));
+    }
+
+    regexStr = wordsOnly ?
+      '\\b(' + escapedPatterns.join('|') + ')\\b' :
+      '(' + escapedPatterns.join('|') + ')';
+
+    return caseSensitive ? new RegExp(regexStr) : new RegExp(regexStr, 'i');
+  }
+})(window.document);