iqvoc 4.8.1 → 4.8.2

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

@@ -0,0 +1,15 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var html = (function() {
+  return {
+    wrapper: '<span class="twitter-typeahead"></span>',
+    dropdown: '<span class="tt-dropdown-menu"></span>',
+    dataset: '<div class="tt-dataset-%CLASS%"></div>',
+    suggestions: '<span class="tt-suggestions"></span>',
+    suggestion: '<div class="tt-suggestion"></div>'
+  };
+})();

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

@@ -0,0 +1,311 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var Input = (function() {
+  'use strict';
+
+  var specialKeyCodeMap;
+
+  specialKeyCodeMap = {
+    9: 'tab',
+    27: 'esc',
+    37: 'left',
+    39: 'right',
+    13: 'enter',
+    38: 'up',
+    40: 'down'
+  };
+
+  // constructor
+  // -----------
+
+  function Input(o) {
+    var that = this, onBlur, onFocus, onKeydown, onInput;
+
+    o = o || {};
+
+    if (!o.input) {
+      $.error('input is missing');
+    }
+
+    // bound functions
+    onBlur = _.bind(this._onBlur, this);
+    onFocus = _.bind(this._onFocus, this);
+    onKeydown = _.bind(this._onKeydown, this);
+    onInput = _.bind(this._onInput, this);
+
+    this.$hint = $(o.hint);
+    this.$input = $(o.input)
+    .on('blur.tt', onBlur)
+    .on('focus.tt', onFocus)
+    .on('keydown.tt', onKeydown);
+
+    // if no hint, noop all the hint related functions
+    if (this.$hint.length === 0) {
+      this.setHint =
+      this.getHint =
+      this.clearHint =
+      this.clearHintIfInvalid = _.noop;
+    }
+
+    // ie7 and ie8 don't support the input event
+    // ie9 doesn't fire the input event when characters are removed
+    // not sure if ie10 is compatible
+    if (!_.isMsie()) {
+      this.$input.on('input.tt', onInput);
+    }
+
+    else {
+      this.$input.on('keydown.tt keypress.tt cut.tt paste.tt', function($e) {
+        // if a special key triggered this, ignore it
+        if (specialKeyCodeMap[$e.which || $e.keyCode]) { return; }
+
+        // give the browser a chance to update the value of the input
+        // before checking to see if the query changed
+        _.defer(_.bind(that._onInput, that, $e));
+      });
+    }
+
+    // the query defaults to whatever the value of the input is
+    // on initialization, it'll most likely be an empty string
+    this.query = this.$input.val();
+
+    // helps with calculating the width of the input's value
+    this.$overflowHelper = buildOverflowHelper(this.$input);
+  }
+
+  // static methods
+  // --------------
+
+  Input.normalizeQuery = function(str) {
+    // strips leading whitespace and condenses all whitespace
+    return (str || '').replace(/^\s*/g, '').replace(/\s{2,}/g, ' ');
+  };
+
+  // instance methods
+  // ----------------
+
+  _.mixin(Input.prototype, EventEmitter, {
+
+    // ### private
+
+    _onBlur: function onBlur() {
+      this.resetInputValue();
+      this.trigger('blurred');
+    },
+
+    _onFocus: function onFocus() {
+      this.trigger('focused');
+    },
+
+    _onKeydown: function onKeydown($e) {
+      // which is normalized and consistent (but not for ie)
+      var keyName = specialKeyCodeMap[$e.which || $e.keyCode];
+
+      this._managePreventDefault(keyName, $e);
+      if (keyName && this._shouldTrigger(keyName, $e)) {
+        this.trigger(keyName + 'Keyed', $e);
+      }
+    },
+
+    _onInput: function onInput() {
+      this._checkInputValue();
+    },
+
+    _managePreventDefault: function managePreventDefault(keyName, $e) {
+      var preventDefault, hintValue, inputValue;
+
+      switch (keyName) {
+        case 'tab':
+          hintValue = this.getHint();
+          inputValue = this.getInputValue();
+
+          preventDefault = hintValue &&
+            hintValue !== inputValue &&
+            !withModifier($e);
+          break;
+
+        case 'up':
+        case 'down':
+          preventDefault = !withModifier($e);
+          break;
+
+        default:
+          preventDefault = false;
+      }
+
+      preventDefault && $e.preventDefault();
+    },
+
+    _shouldTrigger: function shouldTrigger(keyName, $e) {
+      var trigger;
+
+      switch (keyName) {
+        case 'tab':
+          trigger = !withModifier($e);
+          break;
+
+        default:
+          trigger = true;
+      }
+
+      return trigger;
+    },
+
+    _checkInputValue: function checkInputValue() {
+      var inputValue, areEquivalent, hasDifferentWhitespace;
+
+      inputValue = this.getInputValue();
+      areEquivalent = areQueriesEquivalent(inputValue, this.query);
+      hasDifferentWhitespace = areEquivalent ?
+        this.query.length !== inputValue.length : false;
+
+      this.query = inputValue;
+
+      if (!areEquivalent) {
+        this.trigger('queryChanged', this.query);
+      }
+
+      else if (hasDifferentWhitespace) {
+        this.trigger('whitespaceChanged', this.query);
+      }
+    },
+
+    // ### public
+
+    focus: function focus() {
+      this.$input.focus();
+    },
+
+    blur: function blur() {
+      this.$input.blur();
+    },
+
+    getQuery: function getQuery() {
+      return this.query;
+    },
+
+    setQuery: function setQuery(query) {
+      this.query = query;
+    },
+
+    getInputValue: function getInputValue() {
+      return this.$input.val();
+    },
+
+    setInputValue: function setInputValue(value, silent) {
+      this.$input.val(value);
+
+      // silent prevents any additional events from being triggered
+      silent ? this.clearHint() : this._checkInputValue();
+    },
+
+    resetInputValue: function resetInputValue() {
+      this.setInputValue(this.query, true);
+    },
+
+    getHint: function getHint() {
+      return this.$hint.val();
+    },
+
+    setHint: function setHint(value) {
+      this.$hint.val(value);
+    },
+
+    clearHint: function clearHint() {
+      this.setHint('');
+    },
+
+    clearHintIfInvalid: function clearHintIfInvalid() {
+      var val, hint, valIsPrefixOfHint, isValid;
+
+      val = this.getInputValue();
+      hint = this.getHint();
+      valIsPrefixOfHint = val !== hint && hint.indexOf(val) === 0;
+      isValid = val !== '' && valIsPrefixOfHint && !this.hasOverflow();
+
+      !isValid && this.clearHint();
+    },
+
+    getLanguageDirection: function getLanguageDirection() {
+      return (this.$input.css('direction') || 'ltr').toLowerCase();
+    },
+
+    hasOverflow: function hasOverflow() {
+      // 2 is arbitrary, just picking a small number to handle edge cases
+      var constraint = this.$input.width() - 2;
+
+      this.$overflowHelper.text(this.getInputValue());
+
+      return this.$overflowHelper.width() >= constraint;
+    },
+
+    isCursorAtEnd: function() {
+      var valueLength, selectionStart, range;
+
+      valueLength = this.$input.val().length;
+      selectionStart = this.$input[0].selectionStart;
+
+      if (_.isNumber(selectionStart)) {
+       return selectionStart === valueLength;
+      }
+
+      else if (document.selection) {
+        // NOTE: this won't work unless the input has focus, the good news
+        // is this code should only get called when the input has focus
+        range = document.selection.createRange();
+        range.moveStart('character', -valueLength);
+
+        return valueLength === range.text.length;
+      }
+
+      return true;
+    },
+
+    destroy: function destroy() {
+      this.$hint.off('.tt');
+      this.$input.off('.tt');
+
+      this.$hint = this.$input = this.$overflowHelper = null;
+    }
+  });
+
+  return Input;
+
+  // helper functions
+  // ----------------
+
+  function buildOverflowHelper($input) {
+    return $('<pre aria-hidden="true"></pre>')
+    .css({
+      // position helper off-screen
+      position: 'absolute',
+      visibility: 'hidden',
+      // avoid line breaks and whitespace collapsing
+      whiteSpace: 'pre',
+      // use same font css as input to calculate accurate width
+      fontFamily: $input.css('font-family'),
+      fontSize: $input.css('font-size'),
+      fontStyle: $input.css('font-style'),
+      fontVariant: $input.css('font-variant'),
+      fontWeight: $input.css('font-weight'),
+      wordSpacing: $input.css('word-spacing'),
+      letterSpacing: $input.css('letter-spacing'),
+      textIndent: $input.css('text-indent'),
+      textRendering: $input.css('text-rendering'),
+      textTransform: $input.css('text-transform')
+    })
+    .insertAfter($input);
+  }
+
+  function areQueriesEquivalent(a, b) {
+    return Input.normalizeQuery(a) === Input.normalizeQuery(b);
+  }
+
+  function withModifier($e) {
+    return $e.altKey || $e.ctrlKey || $e.metaKey || $e.shiftKey;
+  }
+})();

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

@@ -0,0 +1,129 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+(function() {
+  'use strict';
+
+  var old, typeaheadKey, methods;
+
+  old = $.fn.typeahead;
+
+  typeaheadKey = 'ttTypeahead';
+
+  methods = {
+    // supported signatures:
+    // function(o, dataset, dataset, ...)
+    // function(o, [dataset, dataset, ...])
+    initialize: function initialize(o, datasets) {
+      datasets = _.isArray(datasets) ? datasets : [].slice.call(arguments, 1);
+
+      o = o || {};
+
+      return this.each(attach);
+
+      function attach() {
+        var $input = $(this), eventBus, typeahead;
+
+        _.each(datasets, function(d) {
+          // HACK: force highlight as a top-level config
+          d.highlight = !!o.highlight;
+        });
+
+        typeahead = new Typeahead({
+          input: $input,
+          eventBus: eventBus = new EventBus({ el: $input }),
+          withHint: _.isUndefined(o.hint) ? true : !!o.hint,
+          minLength: o.minLength,
+          autoselect: o.autoselect,
+          datasets: datasets
+        });
+
+        $input.data(typeaheadKey, typeahead);
+      }
+    },
+
+    open: function open() {
+      return this.each(openTypeahead);
+
+      function openTypeahead() {
+        var $input = $(this), typeahead;
+
+        if (typeahead = $input.data(typeaheadKey)) {
+          typeahead.open();
+        }
+      }
+    },
+
+    close: function close() {
+      return this.each(closeTypeahead);
+
+      function closeTypeahead() {
+        var $input = $(this), typeahead;
+
+        if (typeahead = $input.data(typeaheadKey)) {
+          typeahead.close();
+        }
+      }
+    },
+
+    val: function val(newVal) {
+      // mirror jQuery#val functionality: reads opearte on first match,
+      // write operates on all matches
+      return !arguments.length ? getVal(this.first()) : this.each(setVal);
+
+      function setVal() {
+        var $input = $(this), typeahead;
+
+        if (typeahead = $input.data(typeaheadKey)) {
+          typeahead.setVal(newVal);
+        }
+      }
+
+      function getVal($input) {
+        var typeahead, query;
+
+        if (typeahead = $input.data(typeaheadKey)) {
+          query = typeahead.getVal();
+        }
+
+        return query;
+      }
+    },
+
+    destroy: function destroy() {
+      return this.each(unattach);
+
+      function unattach() {
+        var $input = $(this), typeahead;
+
+        if (typeahead = $input.data(typeaheadKey)) {
+          typeahead.destroy();
+          $input.removeData(typeaheadKey);
+        }
+      }
+    }
+  };
+
+  $.fn.typeahead = function(method) {
+    var tts;
+
+    // methods that should only act on intialized typeaheads
+    if (methods[method] && method !== 'initialize') {
+      // filter out non-typeahead inputs
+      tts = this.filter(function() { return !!$(this).data(typeaheadKey); });
+      return methods[method].apply(tts, [].slice.call(arguments, 1));
+    }
+
+    else {
+      return methods.initialize.apply(this, arguments);
+    }
+  };
+
+  $.fn.typeahead.noConflict = function noConflict() {
+    $.fn.typeahead = old;
+    return this;
+  };
+})();