iqvoc 4.8.1 → 4.8.2

data/vendor/assets/bower_components/typeahead.js/src/bloodhound/tokenizers.js

@@ -0,0 +1,44 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var tokenizers = (function() {
+  'use strict';
+
+  return {
+    nonword: nonword,
+    whitespace: whitespace,
+    obj: {
+      nonword: getObjTokenizer(nonword),
+      whitespace: getObjTokenizer(whitespace)
+    }
+  };
+
+  function whitespace(str) {
+    str = _.toStr(str);
+    return str ? str.split(/\s+/) : [];
+  }
+
+  function nonword(str) {
+    str = _.toStr(str);
+    return str ? str.split(/\W+/) : [];
+  }
+
+  function getObjTokenizer(tokenizer) {
+    return function setKey(/* key, ... */) {
+      var args = [].slice.call(arguments, 0);
+
+      return function tokenize(o) {
+        var tokens = [];
+
+        _.each(args, function(k) {
+          tokens = tokens.concat(tokenizer(_.toStr(o[k])));
+        });
+
+        return tokens;
+      };
+    };
+  }
+})();

data/vendor/assets/bower_components/typeahead.js/src/bloodhound/transport.js

@@ -0,0 +1,152 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var Transport = (function() {
+  'use strict';
+
+  var pendingRequestsCount = 0,
+      pendingRequests = {},
+      maxPendingRequests = 6,
+      sharedCache = new LruCache(10);
+
+  // constructor
+  // -----------
+
+  function Transport(o) {
+    o = o || {};
+
+    this.cancelled = false;
+    this.lastUrl = null;
+
+    this._send = o.transport ? callbackToDeferred(o.transport) : $.ajax;
+    this._get = o.rateLimiter ? o.rateLimiter(this._get) : this._get;
+
+    // eh, should this even exist? relying on the browser's cache may be enough
+    this._cache = o.cache === false ? new LruCache(0) : sharedCache;
+  }
+
+  // static methods
+  // --------------
+
+  Transport.setMaxPendingRequests = function setMaxPendingRequests(num) {
+    maxPendingRequests = num;
+  };
+
+  Transport.resetCache = function resetCache() {
+    sharedCache.reset();
+  };
+
+  // instance methods
+  // ----------------
+
+  _.mixin(Transport.prototype, {
+
+    // ### private
+
+    _get: function(url, o, cb) {
+      var that = this, jqXhr;
+
+      // #149: don't make a network request if there has been a cancellation
+      // or if the url doesn't match the last url Transport#get was invoked with
+      if (this.cancelled || url !== this.lastUrl) { return; }
+
+      // a request is already in progress, piggyback off of it
+      if (jqXhr = pendingRequests[url]) {
+        jqXhr.done(done).fail(fail);
+      }
+
+      // under the pending request threshold, so fire off a request
+      else if (pendingRequestsCount < maxPendingRequests) {
+        pendingRequestsCount++;
+        pendingRequests[url] =
+          this._send(url, o).done(done).fail(fail).always(always);
+      }
+
+      // at the pending request threshold, so hang out in the on deck circle
+      else {
+        this.onDeckRequestArgs = [].slice.call(arguments, 0);
+      }
+
+      function done(resp) {
+        cb && cb(null, resp);
+        that._cache.set(url, resp);
+      }
+
+      function fail() {
+        cb && cb(true);
+      }
+
+      function always() {
+        pendingRequestsCount--;
+        delete pendingRequests[url];
+
+        // ensures request is always made for the last query
+        if (that.onDeckRequestArgs) {
+          that._get.apply(that, that.onDeckRequestArgs);
+          that.onDeckRequestArgs = null;
+        }
+      }
+    },
+
+    // ### public
+
+    get: function(url, o, cb) {
+      var resp;
+
+      if (_.isFunction(o)) {
+        cb = o;
+        o = {};
+      }
+
+      this.cancelled = false;
+      this.lastUrl = url;
+
+      // in-memory cache hit
+      if (resp = this._cache.get(url)) {
+        // defer to stay consistent with behavior of ajax call
+        _.defer(function() { cb && cb(null, resp); });
+      }
+
+      else {
+        this._get(url, o, cb);
+      }
+
+      // return bool indicating whether or not a cache hit occurred
+      return !!resp;
+    },
+
+    cancel: function() {
+      this.cancelled = true;
+    }
+  });
+
+  return Transport;
+
+  // helper functions
+  // ----------------
+
+  function callbackToDeferred(fn) {
+    return function customSendWrapper(url, o) {
+      var deferred = $.Deferred();
+
+      fn(url, o, onSuccess, onError);
+
+      return deferred;
+
+      function onSuccess(resp) {
+        // defer in case fn is synchronous, otherwise done
+        // and always handlers will be attached after the resolution
+        _.defer(function() { deferred.resolve(resp); });
+      }
+
+      function onError(err) {
+        // defer in case fn is synchronous, otherwise done
+        // and always handlers will be attached after the resolution
+        _.defer(function() { deferred.reject(err); });
+      }
+    };
+  }
+})();

data/vendor/assets/bower_components/typeahead.js/src/bloodhound/version.js

@@ -0,0 +1,7 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var VERSION = '%VERSION%';

data/vendor/assets/bower_components/typeahead.js/src/common/utils.js

@@ -0,0 +1,152 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var _ = (function() {
+  'use strict';
+
+  return {
+    isMsie: function() {
+      // from https://github.com/ded/bowser/blob/master/bowser.js
+      return (/(msie|trident)/i).test(navigator.userAgent) ?
+        navigator.userAgent.match(/(msie |rv:)(\d+(.\d+)?)/i)[2] : false;
+    },
+
+    isBlankString: function(str) { return !str || /^\s*$/.test(str); },
+
+    // http://stackoverflow.com/a/6969486
+    escapeRegExChars: function(str) {
+      return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+    },
+
+    isString: function(obj) { return typeof obj === 'string'; },
+
+    isNumber: function(obj) { return typeof obj === 'number'; },
+
+    isArray: $.isArray,
+
+    isFunction: $.isFunction,
+
+    isObject: $.isPlainObject,
+
+    isUndefined: function(obj) { return typeof obj === 'undefined'; },
+
+    toStr: function toStr(s) {
+      return (_.isUndefined(s) || s === null) ? '' : s + '';
+    },
+
+    bind: $.proxy,
+
+    each: function(collection, cb) {
+      // stupid argument order for jQuery.each
+      $.each(collection, reverseArgs);
+
+      function reverseArgs(index, value) { return cb(value, index); }
+    },
+
+    map: $.map,
+
+    filter: $.grep,
+
+    every: function(obj, test) {
+      var result = true;
+
+      if (!obj) { return result; }
+
+      $.each(obj, function(key, val) {
+        if (!(result = test.call(null, val, key, obj))) {
+          return false;
+        }
+      });
+
+      return !!result;
+    },
+
+    some: function(obj, test) {
+      var result = false;
+
+      if (!obj) { return result; }
+
+      $.each(obj, function(key, val) {
+        if (result = test.call(null, val, key, obj)) {
+          return false;
+        }
+      });
+
+      return !!result;
+    },
+
+    mixin: $.extend,
+
+    getUniqueId: (function() {
+      var counter = 0;
+      return function() { return counter++; };
+    })(),
+
+    templatify: function templatify(obj) {
+      return $.isFunction(obj) ? obj : template;
+
+      function template() { return String(obj); }
+    },
+
+    defer: function(fn) { setTimeout(fn, 0); },
+
+    debounce: function(func, wait, immediate) {
+      var timeout, result;
+
+      return function() {
+        var context = this, args = arguments, later, callNow;
+
+        later = function() {
+          timeout = null;
+          if (!immediate) { result = func.apply(context, args); }
+        };
+
+        callNow = immediate && !timeout;
+
+        clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+
+        if (callNow) { result = func.apply(context, args); }
+
+        return result;
+      };
+    },
+
+    throttle: function(func, wait) {
+      var context, args, timeout, result, previous, later;
+
+      previous = 0;
+      later = function() {
+        previous = new Date();
+        timeout = null;
+        result = func.apply(context, args);
+      };
+
+      return function() {
+        var now = new Date(),
+            remaining = wait - (now - previous);
+
+        context = this;
+        args = arguments;
+
+        if (remaining <= 0) {
+          clearTimeout(timeout);
+          timeout = null;
+          previous = now;
+          result = func.apply(context, args);
+        }
+
+        else if (!timeout) {
+          timeout = setTimeout(later, remaining);
+        }
+
+        return result;
+      };
+    },
+
+    noop: function() {}
+  };
+})();

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

@@ -0,0 +1,77 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var css = (function() {
+  'use strict';
+
+  var css =  {
+    wrapper: {
+      position: 'relative',
+      display: 'inline-block'
+    },
+    hint: {
+      position: 'absolute',
+      top: '0',
+      left: '0',
+      borderColor: 'transparent',
+      boxShadow: 'none',
+      // #741: fix hint opacity issue on iOS
+      opacity: '1'
+    },
+    input: {
+      position: 'relative',
+      verticalAlign: 'top',
+      backgroundColor: 'transparent'
+    },
+    inputWithNoHint: {
+      position: 'relative',
+      verticalAlign: 'top'
+    },
+    dropdown: {
+      position: 'absolute',
+      top: '100%',
+      left: '0',
+      zIndex: '100',
+      display: 'none'
+    },
+    suggestions: {
+      display: 'block'
+    },
+    suggestion: {
+      whiteSpace: 'nowrap',
+      cursor: 'pointer'
+    },
+    suggestionChild: {
+      whiteSpace: 'normal'
+    },
+    ltr: {
+      left: '0',
+      right: 'auto'
+    },
+    rtl: {
+      left: 'auto',
+      right:' 0'
+    }
+  };
+
+  // ie specific styling
+  if (_.isMsie()) {
+     // ie6-8 (and 9?) doesn't fire hover and click events for elements with
+     // transparent backgrounds, for a workaround, use 1x1 transparent gif
+    _.mixin(css.input, {
+      backgroundImage: 'url(data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)'
+    });
+  }
+
+  // ie7 and under specific styling
+  if (_.isMsie() && _.isMsie() <= 7) {
+    // if someone can tell me why this is necessary to align
+    // the hint with the query in ie7, i'll send you $5 - @JakeHarding
+    _.mixin(css.input, { marginTop: '-1px' });
+  }
+
+  return css;
+})();

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

@@ -0,0 +1,210 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var Dataset = (function() {
+  'use strict';
+
+  var datasetKey = 'ttDataset', valueKey = 'ttValue', datumKey = 'ttDatum';
+
+  // constructor
+  // -----------
+
+  function Dataset(o) {
+    o = o || {};
+    o.templates = o.templates || {};
+
+    if (!o.source) {
+      $.error('missing source');
+    }
+
+    if (o.name && !isValidName(o.name)) {
+      $.error('invalid dataset name: ' + o.name);
+    }
+
+    // tracks the last query the dataset was updated for
+    this.query = null;
+
+    this.highlight = !!o.highlight;
+    this.name = o.name || _.getUniqueId();
+
+    this.source = o.source;
+    this.displayFn = getDisplayFn(o.display || o.displayKey);
+
+    this.templates = getTemplates(o.templates, this.displayFn);
+
+    this.$el = $(html.dataset.replace('%CLASS%', this.name));
+  }
+
+  // static methods
+  // --------------
+
+  Dataset.extractDatasetName = function extractDatasetName(el) {
+    return $(el).data(datasetKey);
+  };
+
+  Dataset.extractValue = function extractDatum(el) {
+    return $(el).data(valueKey);
+  };
+
+  Dataset.extractDatum = function extractDatum(el) {
+    return $(el).data(datumKey);
+  };
+
+  // instance methods
+  // ----------------
+
+  _.mixin(Dataset.prototype, EventEmitter, {
+
+    // ### private
+
+    _render: function render(query, suggestions) {
+      if (!this.$el) { return; }
+
+      var that = this, hasSuggestions;
+
+      this.$el.empty();
+      hasSuggestions = suggestions && suggestions.length;
+
+      if (!hasSuggestions && this.templates.empty) {
+        this.$el
+        .html(getEmptyHtml())
+        .prepend(that.templates.header ? getHeaderHtml() : null)
+        .append(that.templates.footer ? getFooterHtml() : null);
+      }
+
+      else if (hasSuggestions) {
+        this.$el
+        .html(getSuggestionsHtml())
+        .prepend(that.templates.header ? getHeaderHtml() : null)
+        .append(that.templates.footer ? getFooterHtml() : null);
+      }
+
+      this.trigger('rendered');
+
+      function getEmptyHtml() {
+        return that.templates.empty({ query: query, isEmpty: true });
+      }
+
+      function getSuggestionsHtml() {
+        var $suggestions, nodes;
+
+        $suggestions = $(html.suggestions).css(css.suggestions);
+
+        // jQuery#append doesn't support arrays as the first argument
+        // until version 1.8, see http://bugs.jquery.com/ticket/11231
+        nodes = _.map(suggestions, getSuggestionNode);
+        $suggestions.append.apply($suggestions, nodes);
+
+        that.highlight && highlight({
+          className: 'tt-highlight',
+          node: $suggestions[0],
+          pattern: query
+        });
+
+        return $suggestions;
+
+        function getSuggestionNode(suggestion) {
+          var $el;
+
+          $el = $(html.suggestion)
+          .append(that.templates.suggestion(suggestion))
+          .data(datasetKey, that.name)
+          .data(valueKey, that.displayFn(suggestion))
+          .data(datumKey, suggestion);
+
+          $el.children().each(function() { $(this).css(css.suggestionChild); });
+
+          return $el;
+        }
+      }
+
+      function getHeaderHtml() {
+        return that.templates.header({
+          query: query,
+          isEmpty: !hasSuggestions
+        });
+      }
+
+      function getFooterHtml() {
+        return that.templates.footer({
+          query: query,
+          isEmpty: !hasSuggestions
+        });
+      }
+    },
+
+    // ### public
+
+    getRoot: function getRoot() {
+      return this.$el;
+    },
+
+    update: function update(query) {
+      var that = this;
+
+      this.query = query;
+      this.canceled = false;
+      this.source(query, render);
+
+      function render(suggestions) {
+        // if the update has been canceled or if the query has changed
+        // do not render the suggestions as they've become outdated
+        if (!that.canceled && query === that.query) {
+          that._render(query, suggestions);
+        }
+      }
+    },
+
+    cancel: function cancel() {
+      this.canceled = true;
+    },
+
+    clear: function clear() {
+      this.cancel();
+      this.$el.empty();
+      this.trigger('rendered');
+    },
+
+    isEmpty: function isEmpty() {
+      return this.$el.is(':empty');
+    },
+
+    destroy: function destroy() {
+      this.$el = null;
+    }
+  });
+
+  return Dataset;
+
+  // helper functions
+  // ----------------
+
+  function getDisplayFn(display) {
+    display = display || 'value';
+
+    return _.isFunction(display) ? display : displayFn;
+
+    function displayFn(obj) { return obj[display]; }
+  }
+
+  function getTemplates(templates, displayFn) {
+    return {
+      empty: templates.empty && _.templatify(templates.empty),
+      header: templates.header && _.templatify(templates.header),
+      footer: templates.footer && _.templatify(templates.footer),
+      suggestion: templates.suggestion || suggestionTemplate
+    };
+
+    function suggestionTemplate(context) {
+      return '<p>' + displayFn(context) + '</p>';
+    }
+  }
+
+  function isValidName(str) {
+    // dashes, underscores, letters, and numbers
+    return (/^[_a-zA-Z0-9-]+$/).test(str);
+  }
+})();