4453 lines
123 KiB
JavaScript
4453 lines
123 KiB
JavaScript
/*! algoliasearch 3.35.1 | © 2014, 2015 Algolia SAS | github.com/algolia/algoliasearch-client-js */
|
|
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.algoliasearch = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
(function (process){
|
|
/**
|
|
* This is the web browser implementation of `debug()`.
|
|
*
|
|
* Expose `debug()` as the module.
|
|
*/
|
|
|
|
exports = module.exports = require(2);
|
|
exports.log = log;
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
exports.storage = 'undefined' != typeof chrome
|
|
&& 'undefined' != typeof chrome.storage
|
|
? chrome.storage.local
|
|
: localstorage();
|
|
|
|
/**
|
|
* Colors.
|
|
*/
|
|
|
|
exports.colors = [
|
|
'lightseagreen',
|
|
'forestgreen',
|
|
'goldenrod',
|
|
'dodgerblue',
|
|
'darkorchid',
|
|
'crimson'
|
|
];
|
|
|
|
/**
|
|
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
|
|
* and the Firebug extension (any Firefox version) are known
|
|
* to support "%c" CSS customizations.
|
|
*
|
|
* TODO: add a `localStorage` variable to explicitly enable/disable colors
|
|
*/
|
|
|
|
function useColors() {
|
|
// NB: In an Electron preload script, document will be defined but not fully
|
|
// initialized. Since we know we're in Chrome, we'll just detect this case
|
|
// explicitly
|
|
if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
|
|
return true;
|
|
}
|
|
|
|
// is webkit? http://stackoverflow.com/a/16459606/376773
|
|
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
|
|
return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
|
|
// is firebug? http://stackoverflow.com/a/398120/376773
|
|
(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
|
|
// is firefox >= v31?
|
|
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
|
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
|
|
// double check webkit in userAgent just in case we are in a worker
|
|
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
|
|
}
|
|
|
|
/**
|
|
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
|
*/
|
|
|
|
exports.formatters.j = function(v) {
|
|
try {
|
|
return JSON.stringify(v);
|
|
} catch (err) {
|
|
return '[UnexpectedJSONParseError]: ' + err.message;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Colorize log arguments if enabled.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function formatArgs(args) {
|
|
var useColors = this.useColors;
|
|
|
|
args[0] = (useColors ? '%c' : '')
|
|
+ this.namespace
|
|
+ (useColors ? ' %c' : ' ')
|
|
+ args[0]
|
|
+ (useColors ? '%c ' : ' ')
|
|
+ '+' + exports.humanize(this.diff);
|
|
|
|
if (!useColors) return;
|
|
|
|
var c = 'color: ' + this.color;
|
|
args.splice(1, 0, c, 'color: inherit')
|
|
|
|
// the final "%c" is somewhat tricky, because there could be other
|
|
// arguments passed either before or after the %c, so we need to
|
|
// figure out the correct index to insert the CSS into
|
|
var index = 0;
|
|
var lastC = 0;
|
|
args[0].replace(/%[a-zA-Z%]/g, function(match) {
|
|
if ('%%' === match) return;
|
|
index++;
|
|
if ('%c' === match) {
|
|
// we only are interested in the *last* %c
|
|
// (the user may have provided their own)
|
|
lastC = index;
|
|
}
|
|
});
|
|
|
|
args.splice(lastC, 0, c);
|
|
}
|
|
|
|
/**
|
|
* Invokes `console.log()` when available.
|
|
* No-op when `console.log` is not a "function".
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function log() {
|
|
// this hackery is required for IE8/9, where
|
|
// the `console.log` function doesn't have 'apply'
|
|
return 'object' === typeof console
|
|
&& console.log
|
|
&& Function.prototype.apply.call(console.log, console, arguments);
|
|
}
|
|
|
|
/**
|
|
* Save `namespaces`.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api private
|
|
*/
|
|
|
|
function save(namespaces) {
|
|
try {
|
|
if (null == namespaces) {
|
|
exports.storage.removeItem('debug');
|
|
} else {
|
|
exports.storage.debug = namespaces;
|
|
}
|
|
} catch(e) {}
|
|
}
|
|
|
|
/**
|
|
* Load `namespaces`.
|
|
*
|
|
* @return {String} returns the previously persisted debug modes
|
|
* @api private
|
|
*/
|
|
|
|
function load() {
|
|
var r;
|
|
try {
|
|
r = exports.storage.debug;
|
|
} catch(e) {}
|
|
|
|
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
|
|
if (!r && typeof process !== 'undefined' && 'env' in process) {
|
|
r = process.env.DEBUG;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* Enable namespaces listed in `localStorage.debug` initially.
|
|
*/
|
|
|
|
exports.enable(load());
|
|
|
|
/**
|
|
* Localstorage attempts to return the localstorage.
|
|
*
|
|
* This is necessary because safari throws
|
|
* when a user disables cookies/localstorage
|
|
* and you attempt to access it.
|
|
*
|
|
* @return {LocalStorage}
|
|
* @api private
|
|
*/
|
|
|
|
function localstorage() {
|
|
try {
|
|
return window.localStorage;
|
|
} catch (e) {}
|
|
}
|
|
|
|
}).call(this,require(11))
|
|
},{"11":11,"2":2}],2:[function(require,module,exports){
|
|
|
|
/**
|
|
* This is the common logic for both the Node.js and web browser
|
|
* implementations of `debug()`.
|
|
*
|
|
* Expose `debug()` as the module.
|
|
*/
|
|
|
|
exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
|
|
exports.coerce = coerce;
|
|
exports.disable = disable;
|
|
exports.enable = enable;
|
|
exports.enabled = enabled;
|
|
exports.humanize = require(8);
|
|
|
|
/**
|
|
* The currently active debug mode names, and names to skip.
|
|
*/
|
|
|
|
exports.names = [];
|
|
exports.skips = [];
|
|
|
|
/**
|
|
* Map of special "%n" handling functions, for the debug "format" argument.
|
|
*
|
|
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
|
|
*/
|
|
|
|
exports.formatters = {};
|
|
|
|
/**
|
|
* Previous log timestamp.
|
|
*/
|
|
|
|
var prevTime;
|
|
|
|
/**
|
|
* Select a color.
|
|
* @param {String} namespace
|
|
* @return {Number}
|
|
* @api private
|
|
*/
|
|
|
|
function selectColor(namespace) {
|
|
var hash = 0, i;
|
|
|
|
for (i in namespace) {
|
|
hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
|
|
hash |= 0; // Convert to 32bit integer
|
|
}
|
|
|
|
return exports.colors[Math.abs(hash) % exports.colors.length];
|
|
}
|
|
|
|
/**
|
|
* Create a debugger with the given `namespace`.
|
|
*
|
|
* @param {String} namespace
|
|
* @return {Function}
|
|
* @api public
|
|
*/
|
|
|
|
function createDebug(namespace) {
|
|
|
|
function debug() {
|
|
// disabled?
|
|
if (!debug.enabled) return;
|
|
|
|
var self = debug;
|
|
|
|
// set `diff` timestamp
|
|
var curr = +new Date();
|
|
var ms = curr - (prevTime || curr);
|
|
self.diff = ms;
|
|
self.prev = prevTime;
|
|
self.curr = curr;
|
|
prevTime = curr;
|
|
|
|
// turn the `arguments` into a proper Array
|
|
var args = new Array(arguments.length);
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
|
|
args[0] = exports.coerce(args[0]);
|
|
|
|
if ('string' !== typeof args[0]) {
|
|
// anything else let's inspect with %O
|
|
args.unshift('%O');
|
|
}
|
|
|
|
// apply any `formatters` transformations
|
|
var index = 0;
|
|
args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
|
|
// if we encounter an escaped % then don't increase the array index
|
|
if (match === '%%') return match;
|
|
index++;
|
|
var formatter = exports.formatters[format];
|
|
if ('function' === typeof formatter) {
|
|
var val = args[index];
|
|
match = formatter.call(self, val);
|
|
|
|
// now we need to remove `args[index]` since it's inlined in the `format`
|
|
args.splice(index, 1);
|
|
index--;
|
|
}
|
|
return match;
|
|
});
|
|
|
|
// apply env-specific formatting (colors, etc.)
|
|
exports.formatArgs.call(self, args);
|
|
|
|
var logFn = debug.log || exports.log || console.log.bind(console);
|
|
logFn.apply(self, args);
|
|
}
|
|
|
|
debug.namespace = namespace;
|
|
debug.enabled = exports.enabled(namespace);
|
|
debug.useColors = exports.useColors();
|
|
debug.color = selectColor(namespace);
|
|
|
|
// env-specific initialization logic for debug instances
|
|
if ('function' === typeof exports.init) {
|
|
exports.init(debug);
|
|
}
|
|
|
|
return debug;
|
|
}
|
|
|
|
/**
|
|
* Enables a debug mode by namespaces. This can include modes
|
|
* separated by a colon and wildcards.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api public
|
|
*/
|
|
|
|
function enable(namespaces) {
|
|
exports.save(namespaces);
|
|
|
|
exports.names = [];
|
|
exports.skips = [];
|
|
|
|
var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
|
|
var len = split.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
if (!split[i]) continue; // ignore empty strings
|
|
namespaces = split[i].replace(/\*/g, '.*?');
|
|
if (namespaces[0] === '-') {
|
|
exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
|
|
} else {
|
|
exports.names.push(new RegExp('^' + namespaces + '$'));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disable debug output.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function disable() {
|
|
exports.enable('');
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given mode name is enabled, false otherwise.
|
|
*
|
|
* @param {String} name
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
function enabled(name) {
|
|
var i, len;
|
|
for (i = 0, len = exports.skips.length; i < len; i++) {
|
|
if (exports.skips[i].test(name)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (i = 0, len = exports.names.length; i < len; i++) {
|
|
if (exports.names[i].test(name)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Coerce `val`.
|
|
*
|
|
* @param {Mixed} val
|
|
* @return {Mixed}
|
|
* @api private
|
|
*/
|
|
|
|
function coerce(val) {
|
|
if (val instanceof Error) return val.stack || val.message;
|
|
return val;
|
|
}
|
|
|
|
},{"8":8}],3:[function(require,module,exports){
|
|
(function (process,global){
|
|
/*!
|
|
* @overview es6-promise - a tiny implementation of Promises/A+.
|
|
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
|
|
* @license Licensed under MIT license
|
|
* See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
|
|
* @version 4.1.1
|
|
*/
|
|
|
|
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
|
typeof define === 'function' && define.amd ? define(factory) :
|
|
(global.ES6Promise = factory());
|
|
}(this, (function () { 'use strict';
|
|
|
|
function objectOrFunction(x) {
|
|
var type = typeof x;
|
|
return x !== null && (type === 'object' || type === 'function');
|
|
}
|
|
|
|
function isFunction(x) {
|
|
return typeof x === 'function';
|
|
}
|
|
|
|
var _isArray = undefined;
|
|
if (Array.isArray) {
|
|
_isArray = Array.isArray;
|
|
} else {
|
|
_isArray = function (x) {
|
|
return Object.prototype.toString.call(x) === '[object Array]';
|
|
};
|
|
}
|
|
|
|
var isArray = _isArray;
|
|
|
|
var len = 0;
|
|
var vertxNext = undefined;
|
|
var customSchedulerFn = undefined;
|
|
|
|
var asap = function asap(callback, arg) {
|
|
queue[len] = callback;
|
|
queue[len + 1] = arg;
|
|
len += 2;
|
|
if (len === 2) {
|
|
// If len is 2, that means that we need to schedule an async flush.
|
|
// If additional callbacks are queued before the queue is flushed, they
|
|
// will be processed by this flush that we are scheduling.
|
|
if (customSchedulerFn) {
|
|
customSchedulerFn(flush);
|
|
} else {
|
|
scheduleFlush();
|
|
}
|
|
}
|
|
};
|
|
|
|
function setScheduler(scheduleFn) {
|
|
customSchedulerFn = scheduleFn;
|
|
}
|
|
|
|
function setAsap(asapFn) {
|
|
asap = asapFn;
|
|
}
|
|
|
|
var browserWindow = typeof window !== 'undefined' ? window : undefined;
|
|
var browserGlobal = browserWindow || {};
|
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
|
var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && ({}).toString.call(process) === '[object process]';
|
|
|
|
// test for web worker but not in IE10
|
|
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
|
|
|
|
// node
|
|
function useNextTick() {
|
|
// node version 0.10.x displays a deprecation warning when nextTick is used recursively
|
|
// see https://github.com/cujojs/when/issues/410 for details
|
|
return function () {
|
|
return process.nextTick(flush);
|
|
};
|
|
}
|
|
|
|
// vertx
|
|
function useVertxTimer() {
|
|
if (typeof vertxNext !== 'undefined') {
|
|
return function () {
|
|
vertxNext(flush);
|
|
};
|
|
}
|
|
|
|
return useSetTimeout();
|
|
}
|
|
|
|
function useMutationObserver() {
|
|
var iterations = 0;
|
|
var observer = new BrowserMutationObserver(flush);
|
|
var node = document.createTextNode('');
|
|
observer.observe(node, { characterData: true });
|
|
|
|
return function () {
|
|
node.data = iterations = ++iterations % 2;
|
|
};
|
|
}
|
|
|
|
// web worker
|
|
function useMessageChannel() {
|
|
var channel = new MessageChannel();
|
|
channel.port1.onmessage = flush;
|
|
return function () {
|
|
return channel.port2.postMessage(0);
|
|
};
|
|
}
|
|
|
|
function useSetTimeout() {
|
|
// Store setTimeout reference so es6-promise will be unaffected by
|
|
// other code modifying setTimeout (like sinon.useFakeTimers())
|
|
var globalSetTimeout = setTimeout;
|
|
return function () {
|
|
return globalSetTimeout(flush, 1);
|
|
};
|
|
}
|
|
|
|
var queue = new Array(1000);
|
|
function flush() {
|
|
for (var i = 0; i < len; i += 2) {
|
|
var callback = queue[i];
|
|
var arg = queue[i + 1];
|
|
|
|
callback(arg);
|
|
|
|
queue[i] = undefined;
|
|
queue[i + 1] = undefined;
|
|
}
|
|
|
|
len = 0;
|
|
}
|
|
|
|
function attemptVertx() {
|
|
try {
|
|
var r = require;
|
|
var vertx = r('vertx');
|
|
vertxNext = vertx.runOnLoop || vertx.runOnContext;
|
|
return useVertxTimer();
|
|
} catch (e) {
|
|
return useSetTimeout();
|
|
}
|
|
}
|
|
|
|
var scheduleFlush = undefined;
|
|
// Decide what async method to use to triggering processing of queued callbacks:
|
|
if (isNode) {
|
|
scheduleFlush = useNextTick();
|
|
} else if (BrowserMutationObserver) {
|
|
scheduleFlush = useMutationObserver();
|
|
} else if (isWorker) {
|
|
scheduleFlush = useMessageChannel();
|
|
} else if (browserWindow === undefined && typeof require === 'function') {
|
|
scheduleFlush = attemptVertx();
|
|
} else {
|
|
scheduleFlush = useSetTimeout();
|
|
}
|
|
|
|
function then(onFulfillment, onRejection) {
|
|
var _arguments = arguments;
|
|
|
|
var parent = this;
|
|
|
|
var child = new this.constructor(noop);
|
|
|
|
if (child[PROMISE_ID] === undefined) {
|
|
makePromise(child);
|
|
}
|
|
|
|
var _state = parent._state;
|
|
|
|
if (_state) {
|
|
(function () {
|
|
var callback = _arguments[_state - 1];
|
|
asap(function () {
|
|
return invokeCallback(_state, child, callback, parent._result);
|
|
});
|
|
})();
|
|
} else {
|
|
subscribe(parent, child, onFulfillment, onRejection);
|
|
}
|
|
|
|
return child;
|
|
}
|
|
|
|
/**
|
|
`Promise.resolve` returns a promise that will become resolved with the
|
|
passed `value`. It is shorthand for the following:
|
|
|
|
```javascript
|
|
let promise = new Promise(function(resolve, reject){
|
|
resolve(1);
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
let promise = Promise.resolve(1);
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
@method resolve
|
|
@static
|
|
@param {Any} value value that the returned promise will be resolved with
|
|
Useful for tooling.
|
|
@return {Promise} a promise that will become fulfilled with the given
|
|
`value`
|
|
*/
|
|
function resolve$1(object) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
if (object && typeof object === 'object' && object.constructor === Constructor) {
|
|
return object;
|
|
}
|
|
|
|
var promise = new Constructor(noop);
|
|
resolve(promise, object);
|
|
return promise;
|
|
}
|
|
|
|
var PROMISE_ID = Math.random().toString(36).substring(16);
|
|
|
|
function noop() {}
|
|
|
|
var PENDING = void 0;
|
|
var FULFILLED = 1;
|
|
var REJECTED = 2;
|
|
|
|
var GET_THEN_ERROR = new ErrorObject();
|
|
|
|
function selfFulfillment() {
|
|
return new TypeError("You cannot resolve a promise with itself");
|
|
}
|
|
|
|
function cannotReturnOwn() {
|
|
return new TypeError('A promises callback cannot return that same promise.');
|
|
}
|
|
|
|
function getThen(promise) {
|
|
try {
|
|
return promise.then;
|
|
} catch (error) {
|
|
GET_THEN_ERROR.error = error;
|
|
return GET_THEN_ERROR;
|
|
}
|
|
}
|
|
|
|
function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
|
|
try {
|
|
then$$1.call(value, fulfillmentHandler, rejectionHandler);
|
|
} catch (e) {
|
|
return e;
|
|
}
|
|
}
|
|
|
|
function handleForeignThenable(promise, thenable, then$$1) {
|
|
asap(function (promise) {
|
|
var sealed = false;
|
|
var error = tryThen(then$$1, thenable, function (value) {
|
|
if (sealed) {
|
|
return;
|
|
}
|
|
sealed = true;
|
|
if (thenable !== value) {
|
|
resolve(promise, value);
|
|
} else {
|
|
fulfill(promise, value);
|
|
}
|
|
}, function (reason) {
|
|
if (sealed) {
|
|
return;
|
|
}
|
|
sealed = true;
|
|
|
|
reject(promise, reason);
|
|
}, 'Settle: ' + (promise._label || ' unknown promise'));
|
|
|
|
if (!sealed && error) {
|
|
sealed = true;
|
|
reject(promise, error);
|
|
}
|
|
}, promise);
|
|
}
|
|
|
|
function handleOwnThenable(promise, thenable) {
|
|
if (thenable._state === FULFILLED) {
|
|
fulfill(promise, thenable._result);
|
|
} else if (thenable._state === REJECTED) {
|
|
reject(promise, thenable._result);
|
|
} else {
|
|
subscribe(thenable, undefined, function (value) {
|
|
return resolve(promise, value);
|
|
}, function (reason) {
|
|
return reject(promise, reason);
|
|
});
|
|
}
|
|
}
|
|
|
|
function handleMaybeThenable(promise, maybeThenable, then$$1) {
|
|
if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
|
|
handleOwnThenable(promise, maybeThenable);
|
|
} else {
|
|
if (then$$1 === GET_THEN_ERROR) {
|
|
reject(promise, GET_THEN_ERROR.error);
|
|
GET_THEN_ERROR.error = null;
|
|
} else if (then$$1 === undefined) {
|
|
fulfill(promise, maybeThenable);
|
|
} else if (isFunction(then$$1)) {
|
|
handleForeignThenable(promise, maybeThenable, then$$1);
|
|
} else {
|
|
fulfill(promise, maybeThenable);
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolve(promise, value) {
|
|
if (promise === value) {
|
|
reject(promise, selfFulfillment());
|
|
} else if (objectOrFunction(value)) {
|
|
handleMaybeThenable(promise, value, getThen(value));
|
|
} else {
|
|
fulfill(promise, value);
|
|
}
|
|
}
|
|
|
|
function publishRejection(promise) {
|
|
if (promise._onerror) {
|
|
promise._onerror(promise._result);
|
|
}
|
|
|
|
publish(promise);
|
|
}
|
|
|
|
function fulfill(promise, value) {
|
|
if (promise._state !== PENDING) {
|
|
return;
|
|
}
|
|
|
|
promise._result = value;
|
|
promise._state = FULFILLED;
|
|
|
|
if (promise._subscribers.length !== 0) {
|
|
asap(publish, promise);
|
|
}
|
|
}
|
|
|
|
function reject(promise, reason) {
|
|
if (promise._state !== PENDING) {
|
|
return;
|
|
}
|
|
promise._state = REJECTED;
|
|
promise._result = reason;
|
|
|
|
asap(publishRejection, promise);
|
|
}
|
|
|
|
function subscribe(parent, child, onFulfillment, onRejection) {
|
|
var _subscribers = parent._subscribers;
|
|
var length = _subscribers.length;
|
|
|
|
parent._onerror = null;
|
|
|
|
_subscribers[length] = child;
|
|
_subscribers[length + FULFILLED] = onFulfillment;
|
|
_subscribers[length + REJECTED] = onRejection;
|
|
|
|
if (length === 0 && parent._state) {
|
|
asap(publish, parent);
|
|
}
|
|
}
|
|
|
|
function publish(promise) {
|
|
var subscribers = promise._subscribers;
|
|
var settled = promise._state;
|
|
|
|
if (subscribers.length === 0) {
|
|
return;
|
|
}
|
|
|
|
var child = undefined,
|
|
callback = undefined,
|
|
detail = promise._result;
|
|
|
|
for (var i = 0; i < subscribers.length; i += 3) {
|
|
child = subscribers[i];
|
|
callback = subscribers[i + settled];
|
|
|
|
if (child) {
|
|
invokeCallback(settled, child, callback, detail);
|
|
} else {
|
|
callback(detail);
|
|
}
|
|
}
|
|
|
|
promise._subscribers.length = 0;
|
|
}
|
|
|
|
function ErrorObject() {
|
|
this.error = null;
|
|
}
|
|
|
|
var TRY_CATCH_ERROR = new ErrorObject();
|
|
|
|
function tryCatch(callback, detail) {
|
|
try {
|
|
return callback(detail);
|
|
} catch (e) {
|
|
TRY_CATCH_ERROR.error = e;
|
|
return TRY_CATCH_ERROR;
|
|
}
|
|
}
|
|
|
|
function invokeCallback(settled, promise, callback, detail) {
|
|
var hasCallback = isFunction(callback),
|
|
value = undefined,
|
|
error = undefined,
|
|
succeeded = undefined,
|
|
failed = undefined;
|
|
|
|
if (hasCallback) {
|
|
value = tryCatch(callback, detail);
|
|
|
|
if (value === TRY_CATCH_ERROR) {
|
|
failed = true;
|
|
error = value.error;
|
|
value.error = null;
|
|
} else {
|
|
succeeded = true;
|
|
}
|
|
|
|
if (promise === value) {
|
|
reject(promise, cannotReturnOwn());
|
|
return;
|
|
}
|
|
} else {
|
|
value = detail;
|
|
succeeded = true;
|
|
}
|
|
|
|
if (promise._state !== PENDING) {
|
|
// noop
|
|
} else if (hasCallback && succeeded) {
|
|
resolve(promise, value);
|
|
} else if (failed) {
|
|
reject(promise, error);
|
|
} else if (settled === FULFILLED) {
|
|
fulfill(promise, value);
|
|
} else if (settled === REJECTED) {
|
|
reject(promise, value);
|
|
}
|
|
}
|
|
|
|
function initializePromise(promise, resolver) {
|
|
try {
|
|
resolver(function resolvePromise(value) {
|
|
resolve(promise, value);
|
|
}, function rejectPromise(reason) {
|
|
reject(promise, reason);
|
|
});
|
|
} catch (e) {
|
|
reject(promise, e);
|
|
}
|
|
}
|
|
|
|
var id = 0;
|
|
function nextId() {
|
|
return id++;
|
|
}
|
|
|
|
function makePromise(promise) {
|
|
promise[PROMISE_ID] = id++;
|
|
promise._state = undefined;
|
|
promise._result = undefined;
|
|
promise._subscribers = [];
|
|
}
|
|
|
|
function Enumerator$1(Constructor, input) {
|
|
this._instanceConstructor = Constructor;
|
|
this.promise = new Constructor(noop);
|
|
|
|
if (!this.promise[PROMISE_ID]) {
|
|
makePromise(this.promise);
|
|
}
|
|
|
|
if (isArray(input)) {
|
|
this.length = input.length;
|
|
this._remaining = input.length;
|
|
|
|
this._result = new Array(this.length);
|
|
|
|
if (this.length === 0) {
|
|
fulfill(this.promise, this._result);
|
|
} else {
|
|
this.length = this.length || 0;
|
|
this._enumerate(input);
|
|
if (this._remaining === 0) {
|
|
fulfill(this.promise, this._result);
|
|
}
|
|
}
|
|
} else {
|
|
reject(this.promise, validationError());
|
|
}
|
|
}
|
|
|
|
function validationError() {
|
|
return new Error('Array Methods must be provided an Array');
|
|
}
|
|
|
|
Enumerator$1.prototype._enumerate = function (input) {
|
|
for (var i = 0; this._state === PENDING && i < input.length; i++) {
|
|
this._eachEntry(input[i], i);
|
|
}
|
|
};
|
|
|
|
Enumerator$1.prototype._eachEntry = function (entry, i) {
|
|
var c = this._instanceConstructor;
|
|
var resolve$$1 = c.resolve;
|
|
|
|
if (resolve$$1 === resolve$1) {
|
|
var _then = getThen(entry);
|
|
|
|
if (_then === then && entry._state !== PENDING) {
|
|
this._settledAt(entry._state, i, entry._result);
|
|
} else if (typeof _then !== 'function') {
|
|
this._remaining--;
|
|
this._result[i] = entry;
|
|
} else if (c === Promise$2) {
|
|
var promise = new c(noop);
|
|
handleMaybeThenable(promise, entry, _then);
|
|
this._willSettleAt(promise, i);
|
|
} else {
|
|
this._willSettleAt(new c(function (resolve$$1) {
|
|
return resolve$$1(entry);
|
|
}), i);
|
|
}
|
|
} else {
|
|
this._willSettleAt(resolve$$1(entry), i);
|
|
}
|
|
};
|
|
|
|
Enumerator$1.prototype._settledAt = function (state, i, value) {
|
|
var promise = this.promise;
|
|
|
|
if (promise._state === PENDING) {
|
|
this._remaining--;
|
|
|
|
if (state === REJECTED) {
|
|
reject(promise, value);
|
|
} else {
|
|
this._result[i] = value;
|
|
}
|
|
}
|
|
|
|
if (this._remaining === 0) {
|
|
fulfill(promise, this._result);
|
|
}
|
|
};
|
|
|
|
Enumerator$1.prototype._willSettleAt = function (promise, i) {
|
|
var enumerator = this;
|
|
|
|
subscribe(promise, undefined, function (value) {
|
|
return enumerator._settledAt(FULFILLED, i, value);
|
|
}, function (reason) {
|
|
return enumerator._settledAt(REJECTED, i, reason);
|
|
});
|
|
};
|
|
|
|
/**
|
|
`Promise.all` accepts an array of promises, and returns a new promise which
|
|
is fulfilled with an array of fulfillment values for the passed promises, or
|
|
rejected with the reason of the first passed promise to be rejected. It casts all
|
|
elements of the passed iterable to promises as it runs this algorithm.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = resolve(1);
|
|
let promise2 = resolve(2);
|
|
let promise3 = resolve(3);
|
|
let promises = [ promise1, promise2, promise3 ];
|
|
|
|
Promise.all(promises).then(function(array){
|
|
// The array here would be [ 1, 2, 3 ];
|
|
});
|
|
```
|
|
|
|
If any of the `promises` given to `all` are rejected, the first promise
|
|
that is rejected will be given as an argument to the returned promises's
|
|
rejection handler. For example:
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = resolve(1);
|
|
let promise2 = reject(new Error("2"));
|
|
let promise3 = reject(new Error("3"));
|
|
let promises = [ promise1, promise2, promise3 ];
|
|
|
|
Promise.all(promises).then(function(array){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(error) {
|
|
// error.message === "2"
|
|
});
|
|
```
|
|
|
|
@method all
|
|
@static
|
|
@param {Array} entries array of promises
|
|
@param {String} label optional string for labeling the promise.
|
|
Useful for tooling.
|
|
@return {Promise} promise that is fulfilled when all `promises` have been
|
|
fulfilled, or rejected if any of them become rejected.
|
|
@static
|
|
*/
|
|
function all$1(entries) {
|
|
return new Enumerator$1(this, entries).promise;
|
|
}
|
|
|
|
/**
|
|
`Promise.race` returns a new promise which is settled in the same way as the
|
|
first passed promise to settle.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 1');
|
|
}, 200);
|
|
});
|
|
|
|
let promise2 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 2');
|
|
}, 100);
|
|
});
|
|
|
|
Promise.race([promise1, promise2]).then(function(result){
|
|
// result === 'promise 2' because it was resolved before promise1
|
|
// was resolved.
|
|
});
|
|
```
|
|
|
|
`Promise.race` is deterministic in that only the state of the first
|
|
settled promise matters. For example, even if other promises given to the
|
|
`promises` array argument are resolved, but the first settled promise has
|
|
become rejected before the other promises became fulfilled, the returned
|
|
promise will become rejected:
|
|
|
|
```javascript
|
|
let promise1 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 1');
|
|
}, 200);
|
|
});
|
|
|
|
let promise2 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
reject(new Error('promise 2'));
|
|
}, 100);
|
|
});
|
|
|
|
Promise.race([promise1, promise2]).then(function(result){
|
|
// Code here never runs
|
|
}, function(reason){
|
|
// reason.message === 'promise 2' because promise 2 became rejected before
|
|
// promise 1 became fulfilled
|
|
});
|
|
```
|
|
|
|
An example real-world use case is implementing timeouts:
|
|
|
|
```javascript
|
|
Promise.race([ajax('foo.json'), timeout(5000)])
|
|
```
|
|
|
|
@method race
|
|
@static
|
|
@param {Array} promises array of promises to observe
|
|
Useful for tooling.
|
|
@return {Promise} a promise which settles in the same way as the first passed
|
|
promise to settle.
|
|
*/
|
|
function race$1(entries) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
if (!isArray(entries)) {
|
|
return new Constructor(function (_, reject) {
|
|
return reject(new TypeError('You must pass an array to race.'));
|
|
});
|
|
} else {
|
|
return new Constructor(function (resolve, reject) {
|
|
var length = entries.length;
|
|
for (var i = 0; i < length; i++) {
|
|
Constructor.resolve(entries[i]).then(resolve, reject);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
`Promise.reject` returns a promise rejected with the passed `reason`.
|
|
It is shorthand for the following:
|
|
|
|
```javascript
|
|
let promise = new Promise(function(resolve, reject){
|
|
reject(new Error('WHOOPS'));
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
let promise = Promise.reject(new Error('WHOOPS'));
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
@method reject
|
|
@static
|
|
@param {Any} reason value that the returned promise will be rejected with.
|
|
Useful for tooling.
|
|
@return {Promise} a promise rejected with the given `reason`.
|
|
*/
|
|
function reject$1(reason) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
var promise = new Constructor(noop);
|
|
reject(promise, reason);
|
|
return promise;
|
|
}
|
|
|
|
function needsResolver() {
|
|
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
|
|
}
|
|
|
|
function needsNew() {
|
|
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
|
|
}
|
|
|
|
/**
|
|
Promise objects represent the eventual result of an asynchronous operation. The
|
|
primary way of interacting with a promise is through its `then` method, which
|
|
registers callbacks to receive either a promise's eventual value or the reason
|
|
why the promise cannot be fulfilled.
|
|
|
|
Terminology
|
|
-----------
|
|
|
|
- `promise` is an object or function with a `then` method whose behavior conforms to this specification.
|
|
- `thenable` is an object or function that defines a `then` method.
|
|
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
|
|
- `exception` is a value that is thrown using the throw statement.
|
|
- `reason` is a value that indicates why a promise was rejected.
|
|
- `settled` the final resting state of a promise, fulfilled or rejected.
|
|
|
|
A promise can be in one of three states: pending, fulfilled, or rejected.
|
|
|
|
Promises that are fulfilled have a fulfillment value and are in the fulfilled
|
|
state. Promises that are rejected have a rejection reason and are in the
|
|
rejected state. A fulfillment value is never a thenable.
|
|
|
|
Promises can also be said to *resolve* a value. If this value is also a
|
|
promise, then the original promise's settled state will match the value's
|
|
settled state. So a promise that *resolves* a promise that rejects will
|
|
itself reject, and a promise that *resolves* a promise that fulfills will
|
|
itself fulfill.
|
|
|
|
|
|
Basic Usage:
|
|
------------
|
|
|
|
```js
|
|
let promise = new Promise(function(resolve, reject) {
|
|
// on success
|
|
resolve(value);
|
|
|
|
// on failure
|
|
reject(reason);
|
|
});
|
|
|
|
promise.then(function(value) {
|
|
// on fulfillment
|
|
}, function(reason) {
|
|
// on rejection
|
|
});
|
|
```
|
|
|
|
Advanced Usage:
|
|
---------------
|
|
|
|
Promises shine when abstracting away asynchronous interactions such as
|
|
`XMLHttpRequest`s.
|
|
|
|
```js
|
|
function getJSON(url) {
|
|
return new Promise(function(resolve, reject){
|
|
let xhr = new XMLHttpRequest();
|
|
|
|
xhr.open('GET', url);
|
|
xhr.onreadystatechange = handler;
|
|
xhr.responseType = 'json';
|
|
xhr.setRequestHeader('Accept', 'application/json');
|
|
xhr.send();
|
|
|
|
function handler() {
|
|
if (this.readyState === this.DONE) {
|
|
if (this.status === 200) {
|
|
resolve(this.response);
|
|
} else {
|
|
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
|
|
}
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
getJSON('/posts.json').then(function(json) {
|
|
// on fulfillment
|
|
}, function(reason) {
|
|
// on rejection
|
|
});
|
|
```
|
|
|
|
Unlike callbacks, promises are great composable primitives.
|
|
|
|
```js
|
|
Promise.all([
|
|
getJSON('/posts'),
|
|
getJSON('/comments')
|
|
]).then(function(values){
|
|
values[0] // => postsJSON
|
|
values[1] // => commentsJSON
|
|
|
|
return values;
|
|
});
|
|
```
|
|
|
|
@class Promise
|
|
@param {function} resolver
|
|
Useful for tooling.
|
|
@constructor
|
|
*/
|
|
function Promise$2(resolver) {
|
|
this[PROMISE_ID] = nextId();
|
|
this._result = this._state = undefined;
|
|
this._subscribers = [];
|
|
|
|
if (noop !== resolver) {
|
|
typeof resolver !== 'function' && needsResolver();
|
|
this instanceof Promise$2 ? initializePromise(this, resolver) : needsNew();
|
|
}
|
|
}
|
|
|
|
Promise$2.all = all$1;
|
|
Promise$2.race = race$1;
|
|
Promise$2.resolve = resolve$1;
|
|
Promise$2.reject = reject$1;
|
|
Promise$2._setScheduler = setScheduler;
|
|
Promise$2._setAsap = setAsap;
|
|
Promise$2._asap = asap;
|
|
|
|
Promise$2.prototype = {
|
|
constructor: Promise$2,
|
|
|
|
/**
|
|
The primary way of interacting with a promise is through its `then` method,
|
|
which registers callbacks to receive either a promise's eventual value or the
|
|
reason why the promise cannot be fulfilled.
|
|
|
|
```js
|
|
findUser().then(function(user){
|
|
// user is available
|
|
}, function(reason){
|
|
// user is unavailable, and you are given the reason why
|
|
});
|
|
```
|
|
|
|
Chaining
|
|
--------
|
|
|
|
The return value of `then` is itself a promise. This second, 'downstream'
|
|
promise is resolved with the return value of the first promise's fulfillment
|
|
or rejection handler, or rejected if the handler throws an exception.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
return user.name;
|
|
}, function (reason) {
|
|
return 'default name';
|
|
}).then(function (userName) {
|
|
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
|
|
// will be `'default name'`
|
|
});
|
|
|
|
findUser().then(function (user) {
|
|
throw new Error('Found user, but still unhappy');
|
|
}, function (reason) {
|
|
throw new Error('`findUser` rejected and we're unhappy');
|
|
}).then(function (value) {
|
|
// never reached
|
|
}, function (reason) {
|
|
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
|
|
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
|
|
});
|
|
```
|
|
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
throw new PedagogicalException('Upstream error');
|
|
}).then(function (value) {
|
|
// never reached
|
|
}).then(function (value) {
|
|
// never reached
|
|
}, function (reason) {
|
|
// The `PedgagocialException` is propagated all the way down to here
|
|
});
|
|
```
|
|
|
|
Assimilation
|
|
------------
|
|
|
|
Sometimes the value you want to propagate to a downstream promise can only be
|
|
retrieved asynchronously. This can be achieved by returning a promise in the
|
|
fulfillment or rejection handler. The downstream promise will then be pending
|
|
until the returned promise is settled. This is called *assimilation*.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
return findCommentsByAuthor(user);
|
|
}).then(function (comments) {
|
|
// The user's comments are now available
|
|
});
|
|
```
|
|
|
|
If the assimliated promise rejects, then the downstream promise will also reject.
|
|
|
|
```js
|
|
findUser().then(function (user) {
|
|
return findCommentsByAuthor(user);
|
|
}).then(function (comments) {
|
|
// If `findCommentsByAuthor` fulfills, we'll have the value here
|
|
}, function (reason) {
|
|
// If `findCommentsByAuthor` rejects, we'll have the reason here
|
|
});
|
|
```
|
|
|
|
Simple Example
|
|
--------------
|
|
|
|
Synchronous Example
|
|
|
|
```javascript
|
|
let result;
|
|
|
|
try {
|
|
result = findResult();
|
|
// success
|
|
} catch(reason) {
|
|
// failure
|
|
}
|
|
```
|
|
|
|
Errback Example
|
|
|
|
```js
|
|
findResult(function(result, err){
|
|
if (err) {
|
|
// failure
|
|
} else {
|
|
// success
|
|
}
|
|
});
|
|
```
|
|
|
|
Promise Example;
|
|
|
|
```javascript
|
|
findResult().then(function(result){
|
|
// success
|
|
}, function(reason){
|
|
// failure
|
|
});
|
|
```
|
|
|
|
Advanced Example
|
|
--------------
|
|
|
|
Synchronous Example
|
|
|
|
```javascript
|
|
let author, books;
|
|
|
|
try {
|
|
author = findAuthor();
|
|
books = findBooksByAuthor(author);
|
|
// success
|
|
} catch(reason) {
|
|
// failure
|
|
}
|
|
```
|
|
|
|
Errback Example
|
|
|
|
```js
|
|
|
|
function foundBooks(books) {
|
|
|
|
}
|
|
|
|
function failure(reason) {
|
|
|
|
}
|
|
|
|
findAuthor(function(author, err){
|
|
if (err) {
|
|
failure(err);
|
|
// failure
|
|
} else {
|
|
try {
|
|
findBoooksByAuthor(author, function(books, err) {
|
|
if (err) {
|
|
failure(err);
|
|
} else {
|
|
try {
|
|
foundBooks(books);
|
|
} catch(reason) {
|
|
failure(reason);
|
|
}
|
|
}
|
|
});
|
|
} catch(error) {
|
|
failure(err);
|
|
}
|
|
// success
|
|
}
|
|
});
|
|
```
|
|
|
|
Promise Example;
|
|
|
|
```javascript
|
|
findAuthor().
|
|
then(findBooksByAuthor).
|
|
then(function(books){
|
|
// found books
|
|
}).catch(function(reason){
|
|
// something went wrong
|
|
});
|
|
```
|
|
|
|
@method then
|
|
@param {Function} onFulfilled
|
|
@param {Function} onRejected
|
|
Useful for tooling.
|
|
@return {Promise}
|
|
*/
|
|
then: then,
|
|
|
|
/**
|
|
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
|
|
as the catch block of a try/catch statement.
|
|
|
|
```js
|
|
function findAuthor(){
|
|
throw new Error('couldn't find that author');
|
|
}
|
|
|
|
// synchronous
|
|
try {
|
|
findAuthor();
|
|
} catch(reason) {
|
|
// something went wrong
|
|
}
|
|
|
|
// async with promises
|
|
findAuthor().catch(function(reason){
|
|
// something went wrong
|
|
});
|
|
```
|
|
|
|
@method catch
|
|
@param {Function} onRejection
|
|
Useful for tooling.
|
|
@return {Promise}
|
|
*/
|
|
'catch': function _catch(onRejection) {
|
|
return this.then(null, onRejection);
|
|
}
|
|
};
|
|
|
|
/*global self*/
|
|
function polyfill$1() {
|
|
var local = undefined;
|
|
|
|
if (typeof global !== 'undefined') {
|
|
local = global;
|
|
} else if (typeof self !== 'undefined') {
|
|
local = self;
|
|
} else {
|
|
try {
|
|
local = Function('return this')();
|
|
} catch (e) {
|
|
throw new Error('polyfill failed because global object is unavailable in this environment');
|
|
}
|
|
}
|
|
|
|
var P = local.Promise;
|
|
|
|
if (P) {
|
|
var promiseToString = null;
|
|
try {
|
|
promiseToString = Object.prototype.toString.call(P.resolve());
|
|
} catch (e) {
|
|
// silently ignored
|
|
}
|
|
|
|
if (promiseToString === '[object Promise]' && !P.cast) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
local.Promise = Promise$2;
|
|
}
|
|
|
|
// Strange compat..
|
|
Promise$2.polyfill = polyfill$1;
|
|
Promise$2.Promise = Promise$2;
|
|
|
|
return Promise$2;
|
|
|
|
})));
|
|
|
|
|
|
|
|
}).call(this,require(11),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"11":11}],4:[function(require,module,exports){
|
|
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
var toString = Object.prototype.toString;
|
|
|
|
module.exports = function forEach (obj, fn, ctx) {
|
|
if (toString.call(fn) !== '[object Function]') {
|
|
throw new TypeError('iterator must be a function');
|
|
}
|
|
var l = obj.length;
|
|
if (l === +l) {
|
|
for (var i = 0; i < l; i++) {
|
|
fn.call(ctx, obj[i], i, obj);
|
|
}
|
|
} else {
|
|
for (var k in obj) {
|
|
if (hasOwn.call(obj, k)) {
|
|
fn.call(ctx, obj[k], k, obj);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
(function (global){
|
|
var win;
|
|
|
|
if (typeof window !== "undefined") {
|
|
win = window;
|
|
} else if (typeof global !== "undefined") {
|
|
win = global;
|
|
} else if (typeof self !== "undefined"){
|
|
win = self;
|
|
} else {
|
|
win = {};
|
|
}
|
|
|
|
module.exports = win;
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],6:[function(require,module,exports){
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
};
|
|
} else {
|
|
// old school shim for old browsers
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
var toString = {}.toString;
|
|
|
|
module.exports = Array.isArray || function (arr) {
|
|
return toString.call(arr) == '[object Array]';
|
|
};
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
/**
|
|
* Helpers.
|
|
*/
|
|
|
|
var s = 1000;
|
|
var m = s * 60;
|
|
var h = m * 60;
|
|
var d = h * 24;
|
|
var y = d * 365.25;
|
|
|
|
/**
|
|
* Parse or format the given `val`.
|
|
*
|
|
* Options:
|
|
*
|
|
* - `long` verbose formatting [false]
|
|
*
|
|
* @param {String|Number} val
|
|
* @param {Object} [options]
|
|
* @throws {Error} throw an error if val is not a non-empty string or a number
|
|
* @return {String|Number}
|
|
* @api public
|
|
*/
|
|
|
|
module.exports = function(val, options) {
|
|
options = options || {};
|
|
var type = typeof val;
|
|
if (type === 'string' && val.length > 0) {
|
|
return parse(val);
|
|
} else if (type === 'number' && isNaN(val) === false) {
|
|
return options.long ? fmtLong(val) : fmtShort(val);
|
|
}
|
|
throw new Error(
|
|
'val is not a non-empty string or a valid number. val=' +
|
|
JSON.stringify(val)
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Parse the given `str` and return milliseconds.
|
|
*
|
|
* @param {String} str
|
|
* @return {Number}
|
|
* @api private
|
|
*/
|
|
|
|
function parse(str) {
|
|
str = String(str);
|
|
if (str.length > 100) {
|
|
return;
|
|
}
|
|
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
|
|
str
|
|
);
|
|
if (!match) {
|
|
return;
|
|
}
|
|
var n = parseFloat(match[1]);
|
|
var type = (match[2] || 'ms').toLowerCase();
|
|
switch (type) {
|
|
case 'years':
|
|
case 'year':
|
|
case 'yrs':
|
|
case 'yr':
|
|
case 'y':
|
|
return n * y;
|
|
case 'days':
|
|
case 'day':
|
|
case 'd':
|
|
return n * d;
|
|
case 'hours':
|
|
case 'hour':
|
|
case 'hrs':
|
|
case 'hr':
|
|
case 'h':
|
|
return n * h;
|
|
case 'minutes':
|
|
case 'minute':
|
|
case 'mins':
|
|
case 'min':
|
|
case 'm':
|
|
return n * m;
|
|
case 'seconds':
|
|
case 'second':
|
|
case 'secs':
|
|
case 'sec':
|
|
case 's':
|
|
return n * s;
|
|
case 'milliseconds':
|
|
case 'millisecond':
|
|
case 'msecs':
|
|
case 'msec':
|
|
case 'ms':
|
|
return n;
|
|
default:
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Short format for `ms`.
|
|
*
|
|
* @param {Number} ms
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
function fmtShort(ms) {
|
|
if (ms >= d) {
|
|
return Math.round(ms / d) + 'd';
|
|
}
|
|
if (ms >= h) {
|
|
return Math.round(ms / h) + 'h';
|
|
}
|
|
if (ms >= m) {
|
|
return Math.round(ms / m) + 'm';
|
|
}
|
|
if (ms >= s) {
|
|
return Math.round(ms / s) + 's';
|
|
}
|
|
return ms + 'ms';
|
|
}
|
|
|
|
/**
|
|
* Long format for `ms`.
|
|
*
|
|
* @param {Number} ms
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
function fmtLong(ms) {
|
|
return plural(ms, d, 'day') ||
|
|
plural(ms, h, 'hour') ||
|
|
plural(ms, m, 'minute') ||
|
|
plural(ms, s, 'second') ||
|
|
ms + ' ms';
|
|
}
|
|
|
|
/**
|
|
* Pluralization helper.
|
|
*/
|
|
|
|
function plural(ms, n, name) {
|
|
if (ms < n) {
|
|
return;
|
|
}
|
|
if (ms < n * 1.5) {
|
|
return Math.floor(ms / n) + ' ' + name;
|
|
}
|
|
return Math.ceil(ms / n) + ' ' + name + 's';
|
|
}
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// modified from https://github.com/es-shims/es5-shim
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var toStr = Object.prototype.toString;
|
|
var slice = Array.prototype.slice;
|
|
var isArgs = require(10);
|
|
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
|
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
|
|
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
|
|
var dontEnums = [
|
|
'toString',
|
|
'toLocaleString',
|
|
'valueOf',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'constructor'
|
|
];
|
|
var equalsConstructorPrototype = function (o) {
|
|
var ctor = o.constructor;
|
|
return ctor && ctor.prototype === o;
|
|
};
|
|
var excludedKeys = {
|
|
$console: true,
|
|
$external: true,
|
|
$frame: true,
|
|
$frameElement: true,
|
|
$frames: true,
|
|
$innerHeight: true,
|
|
$innerWidth: true,
|
|
$outerHeight: true,
|
|
$outerWidth: true,
|
|
$pageXOffset: true,
|
|
$pageYOffset: true,
|
|
$parent: true,
|
|
$scrollLeft: true,
|
|
$scrollTop: true,
|
|
$scrollX: true,
|
|
$scrollY: true,
|
|
$self: true,
|
|
$webkitIndexedDB: true,
|
|
$webkitStorageInfo: true,
|
|
$window: true
|
|
};
|
|
var hasAutomationEqualityBug = (function () {
|
|
/* global window */
|
|
if (typeof window === 'undefined') { return false; }
|
|
for (var k in window) {
|
|
try {
|
|
if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
|
|
try {
|
|
equalsConstructorPrototype(window[k]);
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}());
|
|
var equalsConstructorPrototypeIfNotBuggy = function (o) {
|
|
/* global window */
|
|
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
|
|
return equalsConstructorPrototype(o);
|
|
}
|
|
try {
|
|
return equalsConstructorPrototype(o);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
var keysShim = function keys(object) {
|
|
var isObject = object !== null && typeof object === 'object';
|
|
var isFunction = toStr.call(object) === '[object Function]';
|
|
var isArguments = isArgs(object);
|
|
var isString = isObject && toStr.call(object) === '[object String]';
|
|
var theKeys = [];
|
|
|
|
if (!isObject && !isFunction && !isArguments) {
|
|
throw new TypeError('Object.keys called on a non-object');
|
|
}
|
|
|
|
var skipProto = hasProtoEnumBug && isFunction;
|
|
if (isString && object.length > 0 && !has.call(object, 0)) {
|
|
for (var i = 0; i < object.length; ++i) {
|
|
theKeys.push(String(i));
|
|
}
|
|
}
|
|
|
|
if (isArguments && object.length > 0) {
|
|
for (var j = 0; j < object.length; ++j) {
|
|
theKeys.push(String(j));
|
|
}
|
|
} else {
|
|
for (var name in object) {
|
|
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
|
|
theKeys.push(String(name));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasDontEnumBug) {
|
|
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
|
|
|
|
for (var k = 0; k < dontEnums.length; ++k) {
|
|
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
|
|
theKeys.push(dontEnums[k]);
|
|
}
|
|
}
|
|
}
|
|
return theKeys;
|
|
};
|
|
|
|
keysShim.shim = function shimObjectKeys() {
|
|
if (Object.keys) {
|
|
var keysWorksWithArguments = (function () {
|
|
// Safari 5.0 bug
|
|
return (Object.keys(arguments) || '').length === 2;
|
|
}(1, 2));
|
|
if (!keysWorksWithArguments) {
|
|
var originalKeys = Object.keys;
|
|
Object.keys = function keys(object) {
|
|
if (isArgs(object)) {
|
|
return originalKeys(slice.call(object));
|
|
} else {
|
|
return originalKeys(object);
|
|
}
|
|
};
|
|
}
|
|
} else {
|
|
Object.keys = keysShim;
|
|
}
|
|
return Object.keys || keysShim;
|
|
};
|
|
|
|
module.exports = keysShim;
|
|
|
|
},{"10":10}],10:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
module.exports = function isArguments(value) {
|
|
var str = toStr.call(value);
|
|
var isArgs = str === '[object Arguments]';
|
|
if (!isArgs) {
|
|
isArgs = str !== '[object Array]' &&
|
|
value !== null &&
|
|
typeof value === 'object' &&
|
|
typeof value.length === 'number' &&
|
|
value.length >= 0 &&
|
|
toStr.call(value.callee) === '[object Function]';
|
|
}
|
|
return isArgs;
|
|
};
|
|
|
|
},{}],11:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
var process = module.exports = {};
|
|
|
|
// cached from whatever global is present so that test runners that stub it
|
|
// don't break things. But we need to wrap it in a try catch in case it is
|
|
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
// function because try/catches deoptimize in certain engines.
|
|
|
|
var cachedSetTimeout;
|
|
var cachedClearTimeout;
|
|
|
|
function defaultSetTimout() {
|
|
throw new Error('setTimeout has not been defined');
|
|
}
|
|
function defaultClearTimeout () {
|
|
throw new Error('clearTimeout has not been defined');
|
|
}
|
|
(function () {
|
|
try {
|
|
if (typeof setTimeout === 'function') {
|
|
cachedSetTimeout = setTimeout;
|
|
} else {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
} catch (e) {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
try {
|
|
if (typeof clearTimeout === 'function') {
|
|
cachedClearTimeout = clearTimeout;
|
|
} else {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} catch (e) {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} ())
|
|
function runTimeout(fun) {
|
|
if (cachedSetTimeout === setTimeout) {
|
|
//normal enviroments in sane situations
|
|
return setTimeout(fun, 0);
|
|
}
|
|
// if setTimeout wasn't available but was latter defined
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
cachedSetTimeout = setTimeout;
|
|
return setTimeout(fun, 0);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedSetTimeout(fun, 0);
|
|
} catch(e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedSetTimeout.call(null, fun, 0);
|
|
} catch(e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
function runClearTimeout(marker) {
|
|
if (cachedClearTimeout === clearTimeout) {
|
|
//normal enviroments in sane situations
|
|
return clearTimeout(marker);
|
|
}
|
|
// if clearTimeout wasn't available but was latter defined
|
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
cachedClearTimeout = clearTimeout;
|
|
return clearTimeout(marker);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedClearTimeout(marker);
|
|
} catch (e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedClearTimeout.call(null, marker);
|
|
} catch (e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
return cachedClearTimeout.call(this, marker);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
var queue = [];
|
|
var draining = false;
|
|
var currentQueue;
|
|
var queueIndex = -1;
|
|
|
|
function cleanUpNextTick() {
|
|
if (!draining || !currentQueue) {
|
|
return;
|
|
}
|
|
draining = false;
|
|
if (currentQueue.length) {
|
|
queue = currentQueue.concat(queue);
|
|
} else {
|
|
queueIndex = -1;
|
|
}
|
|
if (queue.length) {
|
|
drainQueue();
|
|
}
|
|
}
|
|
|
|
function drainQueue() {
|
|
if (draining) {
|
|
return;
|
|
}
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
draining = true;
|
|
|
|
var len = queue.length;
|
|
while(len) {
|
|
currentQueue = queue;
|
|
queue = [];
|
|
while (++queueIndex < len) {
|
|
if (currentQueue) {
|
|
currentQueue[queueIndex].run();
|
|
}
|
|
}
|
|
queueIndex = -1;
|
|
len = queue.length;
|
|
}
|
|
currentQueue = null;
|
|
draining = false;
|
|
runClearTimeout(timeout);
|
|
}
|
|
|
|
process.nextTick = function (fun) {
|
|
var args = new Array(arguments.length - 1);
|
|
if (arguments.length > 1) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
args[i - 1] = arguments[i];
|
|
}
|
|
}
|
|
queue.push(new Item(fun, args));
|
|
if (queue.length === 1 && !draining) {
|
|
runTimeout(drainQueue);
|
|
}
|
|
};
|
|
|
|
// v8 likes predictible objects
|
|
function Item(fun, array) {
|
|
this.fun = fun;
|
|
this.array = array;
|
|
}
|
|
Item.prototype.run = function () {
|
|
this.fun.apply(null, this.array);
|
|
};
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
process.version = ''; // empty string to avoid regexp issues
|
|
process.versions = {};
|
|
|
|
function noop() {}
|
|
|
|
process.on = noop;
|
|
process.addListener = noop;
|
|
process.once = noop;
|
|
process.off = noop;
|
|
process.removeListener = noop;
|
|
process.removeAllListeners = noop;
|
|
process.emit = noop;
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
};
|
|
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
process.umask = function() { return 0; };
|
|
|
|
},{}],12:[function(require,module,exports){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
'use strict';
|
|
|
|
// If obj.hasOwnProperty has been overridden, then calling
|
|
// obj.hasOwnProperty(prop) will break.
|
|
// See: https://github.com/joyent/node/issues/1707
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
module.exports = function(qs, sep, eq, options) {
|
|
sep = sep || '&';
|
|
eq = eq || '=';
|
|
var obj = {};
|
|
|
|
if (typeof qs !== 'string' || qs.length === 0) {
|
|
return obj;
|
|
}
|
|
|
|
var regexp = /\+/g;
|
|
qs = qs.split(sep);
|
|
|
|
var maxKeys = 1000;
|
|
if (options && typeof options.maxKeys === 'number') {
|
|
maxKeys = options.maxKeys;
|
|
}
|
|
|
|
var len = qs.length;
|
|
// maxKeys <= 0 means that we should not limit keys count
|
|
if (maxKeys > 0 && len > maxKeys) {
|
|
len = maxKeys;
|
|
}
|
|
|
|
for (var i = 0; i < len; ++i) {
|
|
var x = qs[i].replace(regexp, '%20'),
|
|
idx = x.indexOf(eq),
|
|
kstr, vstr, k, v;
|
|
|
|
if (idx >= 0) {
|
|
kstr = x.substr(0, idx);
|
|
vstr = x.substr(idx + 1);
|
|
} else {
|
|
kstr = x;
|
|
vstr = '';
|
|
}
|
|
|
|
k = decodeURIComponent(kstr);
|
|
v = decodeURIComponent(vstr);
|
|
|
|
if (!hasOwnProperty(obj, k)) {
|
|
obj[k] = v;
|
|
} else if (isArray(obj[k])) {
|
|
obj[k].push(v);
|
|
} else {
|
|
obj[k] = [obj[k], v];
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
var isArray = Array.isArray || function (xs) {
|
|
return Object.prototype.toString.call(xs) === '[object Array]';
|
|
};
|
|
|
|
},{}],13:[function(require,module,exports){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
'use strict';
|
|
|
|
var stringifyPrimitive = function(v) {
|
|
switch (typeof v) {
|
|
case 'string':
|
|
return v;
|
|
|
|
case 'boolean':
|
|
return v ? 'true' : 'false';
|
|
|
|
case 'number':
|
|
return isFinite(v) ? v : '';
|
|
|
|
default:
|
|
return '';
|
|
}
|
|
};
|
|
|
|
module.exports = function(obj, sep, eq, name) {
|
|
sep = sep || '&';
|
|
eq = eq || '=';
|
|
if (obj === null) {
|
|
obj = undefined;
|
|
}
|
|
|
|
if (typeof obj === 'object') {
|
|
return map(objectKeys(obj), function(k) {
|
|
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
|
|
if (isArray(obj[k])) {
|
|
return map(obj[k], function(v) {
|
|
return ks + encodeURIComponent(stringifyPrimitive(v));
|
|
}).join(sep);
|
|
} else {
|
|
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
|
|
}
|
|
}).join(sep);
|
|
|
|
}
|
|
|
|
if (!name) return '';
|
|
return encodeURIComponent(stringifyPrimitive(name)) + eq +
|
|
encodeURIComponent(stringifyPrimitive(obj));
|
|
};
|
|
|
|
var isArray = Array.isArray || function (xs) {
|
|
return Object.prototype.toString.call(xs) === '[object Array]';
|
|
};
|
|
|
|
function map (xs, f) {
|
|
if (xs.map) return xs.map(f);
|
|
var res = [];
|
|
for (var i = 0; i < xs.length; i++) {
|
|
res.push(f(xs[i], i));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
var objectKeys = Object.keys || function (obj) {
|
|
var res = [];
|
|
for (var key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
exports.decode = exports.parse = require(12);
|
|
exports.encode = exports.stringify = require(13);
|
|
|
|
},{"12":12,"13":13}],15:[function(require,module,exports){
|
|
(function (process){
|
|
module.exports = AlgoliaSearchCore;
|
|
|
|
var errors = require(25);
|
|
var exitPromise = require(26);
|
|
var IndexCore = require(16);
|
|
var store = require(31);
|
|
|
|
// We will always put the API KEY in the JSON body in case of too long API KEY,
|
|
// to avoid query string being too long and failing in various conditions (our server limit, browser limit,
|
|
// proxies limit)
|
|
var MAX_API_KEY_LENGTH = 500;
|
|
var RESET_APP_DATA_TIMER =
|
|
process.env.RESET_APP_DATA_TIMER && parseInt(process.env.RESET_APP_DATA_TIMER, 10) ||
|
|
60 * 2 * 1000; // after 2 minutes reset to first host
|
|
|
|
/*
|
|
* Algolia Search library initialization
|
|
* https://www.algolia.com/
|
|
*
|
|
* @param {string} applicationID - Your applicationID, found in your dashboard
|
|
* @param {string} apiKey - Your API key, found in your dashboard
|
|
* @param {Object} [opts]
|
|
* @param {number} [opts.timeout=2000] - The request timeout set in milliseconds,
|
|
* another request will be issued after this timeout
|
|
* @param {string} [opts.protocol='https:'] - The protocol used to query Algolia Search API.
|
|
* Set to 'http:' to force using http.
|
|
* @param {Object|Array} [opts.hosts={
|
|
* read: [this.applicationID + '-dsn.algolia.net'].concat([
|
|
* this.applicationID + '-1.algolianet.com',
|
|
* this.applicationID + '-2.algolianet.com',
|
|
* this.applicationID + '-3.algolianet.com']
|
|
* ]),
|
|
* write: [this.applicationID + '.algolia.net'].concat([
|
|
* this.applicationID + '-1.algolianet.com',
|
|
* this.applicationID + '-2.algolianet.com',
|
|
* this.applicationID + '-3.algolianet.com']
|
|
* ]) - The hosts to use for Algolia Search API.
|
|
* If you provide them, you will less benefit from our HA implementation
|
|
*/
|
|
function AlgoliaSearchCore(applicationID, apiKey, opts) {
|
|
var debug = require(1)('algoliasearch');
|
|
|
|
var clone = require(22);
|
|
var isArray = require(7);
|
|
var map = require(27);
|
|
|
|
var usage = 'Usage: algoliasearch(applicationID, apiKey, opts)';
|
|
|
|
if (opts._allowEmptyCredentials !== true && !applicationID) {
|
|
throw new errors.AlgoliaSearchError('Please provide an application ID. ' + usage);
|
|
}
|
|
|
|
if (opts._allowEmptyCredentials !== true && !apiKey) {
|
|
throw new errors.AlgoliaSearchError('Please provide an API key. ' + usage);
|
|
}
|
|
|
|
this.applicationID = applicationID;
|
|
this.apiKey = apiKey;
|
|
|
|
this.hosts = {
|
|
read: [],
|
|
write: []
|
|
};
|
|
|
|
opts = opts || {};
|
|
|
|
this._timeouts = opts.timeouts || {
|
|
connect: 1 * 1000, // 500ms connect is GPRS latency
|
|
read: 2 * 1000,
|
|
write: 30 * 1000
|
|
};
|
|
|
|
// backward compat, if opts.timeout is passed, we use it to configure all timeouts like before
|
|
if (opts.timeout) {
|
|
this._timeouts.connect = this._timeouts.read = this._timeouts.write = opts.timeout;
|
|
}
|
|
|
|
var protocol = opts.protocol || 'https:';
|
|
// while we advocate for colon-at-the-end values: 'http:' for `opts.protocol`
|
|
// we also accept `http` and `https`. It's a common error.
|
|
if (!/:$/.test(protocol)) {
|
|
protocol = protocol + ':';
|
|
}
|
|
|
|
if (protocol !== 'http:' && protocol !== 'https:') {
|
|
throw new errors.AlgoliaSearchError('protocol must be `http:` or `https:` (was `' + opts.protocol + '`)');
|
|
}
|
|
|
|
this._checkAppIdData();
|
|
|
|
if (!opts.hosts) {
|
|
var defaultHosts = map(this._shuffleResult, function(hostNumber) {
|
|
return applicationID + '-' + hostNumber + '.algolianet.com';
|
|
});
|
|
|
|
// no hosts given, compute defaults
|
|
var mainSuffix = (opts.dsn === false ? '' : '-dsn') + '.algolia.net';
|
|
this.hosts.read = [this.applicationID + mainSuffix].concat(defaultHosts);
|
|
this.hosts.write = [this.applicationID + '.algolia.net'].concat(defaultHosts);
|
|
} else if (isArray(opts.hosts)) {
|
|
// when passing custom hosts, we need to have a different host index if the number
|
|
// of write/read hosts are different.
|
|
this.hosts.read = clone(opts.hosts);
|
|
this.hosts.write = clone(opts.hosts);
|
|
} else {
|
|
this.hosts.read = clone(opts.hosts.read);
|
|
this.hosts.write = clone(opts.hosts.write);
|
|
}
|
|
|
|
// add protocol and lowercase hosts
|
|
this.hosts.read = map(this.hosts.read, prepareHost(protocol));
|
|
this.hosts.write = map(this.hosts.write, prepareHost(protocol));
|
|
|
|
this.extraHeaders = {};
|
|
|
|
// In some situations you might want to warm the cache
|
|
this.cache = opts._cache || {};
|
|
|
|
this._ua = opts._ua;
|
|
this._useCache = opts._useCache === undefined || opts._cache ? true : opts._useCache;
|
|
this._useRequestCache = this._useCache && opts._useRequestCache;
|
|
this._useFallback = opts.useFallback === undefined ? true : opts.useFallback;
|
|
|
|
this._setTimeout = opts._setTimeout;
|
|
|
|
debug('init done, %j', this);
|
|
}
|
|
|
|
/*
|
|
* Get the index object initialized
|
|
*
|
|
* @param indexName the name of index
|
|
* @param callback the result callback with one argument (the Index instance)
|
|
*/
|
|
AlgoliaSearchCore.prototype.initIndex = function(indexName) {
|
|
return new IndexCore(this, indexName);
|
|
};
|
|
|
|
/**
|
|
* Add an extra field to the HTTP request
|
|
*
|
|
* @param name the header field name
|
|
* @param value the header field value
|
|
*/
|
|
AlgoliaSearchCore.prototype.setExtraHeader = function(name, value) {
|
|
this.extraHeaders[name.toLowerCase()] = value;
|
|
};
|
|
|
|
/**
|
|
* Get the value of an extra HTTP header
|
|
*
|
|
* @param name the header field name
|
|
*/
|
|
AlgoliaSearchCore.prototype.getExtraHeader = function(name) {
|
|
return this.extraHeaders[name.toLowerCase()];
|
|
};
|
|
|
|
/**
|
|
* Remove an extra field from the HTTP request
|
|
*
|
|
* @param name the header field name
|
|
*/
|
|
AlgoliaSearchCore.prototype.unsetExtraHeader = function(name) {
|
|
delete this.extraHeaders[name.toLowerCase()];
|
|
};
|
|
|
|
/**
|
|
* Augment sent x-algolia-agent with more data, each agent part
|
|
* is automatically separated from the others by a semicolon;
|
|
*
|
|
* @param algoliaAgent the agent to add
|
|
*/
|
|
AlgoliaSearchCore.prototype.addAlgoliaAgent = function(algoliaAgent) {
|
|
var algoliaAgentWithDelimiter = '; ' + algoliaAgent;
|
|
|
|
if (this._ua.indexOf(algoliaAgentWithDelimiter) === -1) {
|
|
this._ua += algoliaAgentWithDelimiter;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Wrapper that try all hosts to maximize the quality of service
|
|
*/
|
|
AlgoliaSearchCore.prototype._jsonRequest = function(initialOpts) {
|
|
this._checkAppIdData();
|
|
|
|
var requestDebug = require(1)('algoliasearch:' + initialOpts.url);
|
|
|
|
|
|
var body;
|
|
var cacheID;
|
|
var additionalUA = initialOpts.additionalUA || '';
|
|
var cache = initialOpts.cache;
|
|
var client = this;
|
|
var tries = 0;
|
|
var usingFallback = false;
|
|
var hasFallback = client._useFallback && client._request.fallback && initialOpts.fallback;
|
|
var headers;
|
|
|
|
if (
|
|
this.apiKey.length > MAX_API_KEY_LENGTH &&
|
|
initialOpts.body !== undefined &&
|
|
(initialOpts.body.params !== undefined || // index.search()
|
|
initialOpts.body.requests !== undefined) // client.search()
|
|
) {
|
|
initialOpts.body.apiKey = this.apiKey;
|
|
headers = this._computeRequestHeaders({
|
|
additionalUA: additionalUA,
|
|
withApiKey: false,
|
|
headers: initialOpts.headers
|
|
});
|
|
} else {
|
|
headers = this._computeRequestHeaders({
|
|
additionalUA: additionalUA,
|
|
headers: initialOpts.headers
|
|
});
|
|
}
|
|
|
|
if (initialOpts.body !== undefined) {
|
|
body = safeJSONStringify(initialOpts.body);
|
|
}
|
|
|
|
requestDebug('request start');
|
|
var debugData = [];
|
|
|
|
|
|
function doRequest(requester, reqOpts) {
|
|
client._checkAppIdData();
|
|
|
|
var startTime = new Date();
|
|
|
|
if (client._useCache && !client._useRequestCache) {
|
|
cacheID = initialOpts.url;
|
|
}
|
|
|
|
// as we sometime use POST requests to pass parameters (like query='aa'),
|
|
// the cacheID must also include the body to be different between calls
|
|
if (client._useCache && !client._useRequestCache && body) {
|
|
cacheID += '_body_' + reqOpts.body;
|
|
}
|
|
|
|
// handle cache existence
|
|
if (isCacheValidWithCurrentID(!client._useRequestCache, cache, cacheID)) {
|
|
requestDebug('serving response from cache');
|
|
|
|
var responseText = cache[cacheID];
|
|
|
|
// Cache response must match the type of the original one
|
|
return client._promise.resolve({
|
|
body: JSON.parse(responseText),
|
|
responseText: responseText
|
|
});
|
|
}
|
|
|
|
// if we reached max tries
|
|
if (tries >= client.hosts[initialOpts.hostType].length) {
|
|
if (!hasFallback || usingFallback) {
|
|
requestDebug('could not get any response');
|
|
// then stop
|
|
return client._promise.reject(new errors.AlgoliaSearchError(
|
|
'Cannot connect to the AlgoliaSearch API.' +
|
|
' Send an email to support@algolia.com to report and resolve the issue.' +
|
|
' Application id was: ' + client.applicationID, {debugData: debugData}
|
|
));
|
|
}
|
|
|
|
requestDebug('switching to fallback');
|
|
|
|
// let's try the fallback starting from here
|
|
tries = 0;
|
|
|
|
// method, url and body are fallback dependent
|
|
reqOpts.method = initialOpts.fallback.method;
|
|
reqOpts.url = initialOpts.fallback.url;
|
|
reqOpts.jsonBody = initialOpts.fallback.body;
|
|
if (reqOpts.jsonBody) {
|
|
reqOpts.body = safeJSONStringify(reqOpts.jsonBody);
|
|
}
|
|
// re-compute headers, they could be omitting the API KEY
|
|
headers = client._computeRequestHeaders({
|
|
additionalUA: additionalUA,
|
|
headers: initialOpts.headers
|
|
});
|
|
|
|
reqOpts.timeouts = client._getTimeoutsForRequest(initialOpts.hostType);
|
|
client._setHostIndexByType(0, initialOpts.hostType);
|
|
usingFallback = true; // the current request is now using fallback
|
|
return doRequest(client._request.fallback, reqOpts);
|
|
}
|
|
|
|
var currentHost = client._getHostByType(initialOpts.hostType);
|
|
|
|
var url = currentHost + reqOpts.url;
|
|
var options = {
|
|
body: reqOpts.body,
|
|
jsonBody: reqOpts.jsonBody,
|
|
method: reqOpts.method,
|
|
headers: headers,
|
|
timeouts: reqOpts.timeouts,
|
|
debug: requestDebug,
|
|
forceAuthHeaders: reqOpts.forceAuthHeaders
|
|
};
|
|
|
|
requestDebug('method: %s, url: %s, headers: %j, timeouts: %d',
|
|
options.method, url, options.headers, options.timeouts);
|
|
|
|
if (requester === client._request.fallback) {
|
|
requestDebug('using fallback');
|
|
}
|
|
|
|
// `requester` is any of this._request or this._request.fallback
|
|
// thus it needs to be called using the client as context
|
|
return requester.call(client, url, options).then(success, tryFallback);
|
|
|
|
function success(httpResponse) {
|
|
// compute the status of the response,
|
|
//
|
|
// When in browser mode, using XDR or JSONP, we have no statusCode available
|
|
// So we rely on our API response `status` property.
|
|
// But `waitTask` can set a `status` property which is not the statusCode (it's the task status)
|
|
// So we check if there's a `message` along `status` and it means it's an error
|
|
//
|
|
// That's the only case where we have a response.status that's not the http statusCode
|
|
var status = httpResponse && httpResponse.body && httpResponse.body.message && httpResponse.body.status ||
|
|
|
|
// this is important to check the request statusCode AFTER the body eventual
|
|
// statusCode because some implementations (jQuery XDomainRequest transport) may
|
|
// send statusCode 200 while we had an error
|
|
httpResponse.statusCode ||
|
|
|
|
// When in browser mode, using XDR or JSONP
|
|
// we default to success when no error (no response.status && response.message)
|
|
// If there was a JSON.parse() error then body is null and it fails
|
|
httpResponse && httpResponse.body && 200;
|
|
|
|
requestDebug('received response: statusCode: %s, computed statusCode: %d, headers: %j',
|
|
httpResponse.statusCode, status, httpResponse.headers);
|
|
|
|
var httpResponseOk = Math.floor(status / 100) === 2;
|
|
|
|
var endTime = new Date();
|
|
debugData.push({
|
|
currentHost: currentHost,
|
|
headers: removeCredentials(headers),
|
|
content: body || null,
|
|
contentLength: body !== undefined ? body.length : null,
|
|
method: reqOpts.method,
|
|
timeouts: reqOpts.timeouts,
|
|
url: reqOpts.url,
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
duration: endTime - startTime,
|
|
statusCode: status
|
|
});
|
|
|
|
if (httpResponseOk) {
|
|
if (client._useCache && !client._useRequestCache && cache) {
|
|
cache[cacheID] = httpResponse.responseText;
|
|
}
|
|
|
|
return {
|
|
responseText: httpResponse.responseText,
|
|
body: httpResponse.body
|
|
};
|
|
}
|
|
|
|
var shouldRetry = Math.floor(status / 100) !== 4;
|
|
|
|
if (shouldRetry) {
|
|
tries += 1;
|
|
return retryRequest();
|
|
}
|
|
|
|
requestDebug('unrecoverable error');
|
|
|
|
// no success and no retry => fail
|
|
var unrecoverableError = new errors.AlgoliaSearchError(
|
|
httpResponse.body && httpResponse.body.message, {debugData: debugData, statusCode: status}
|
|
);
|
|
|
|
return client._promise.reject(unrecoverableError);
|
|
}
|
|
|
|
function tryFallback(err) {
|
|
// error cases:
|
|
// While not in fallback mode:
|
|
// - CORS not supported
|
|
// - network error
|
|
// While in fallback mode:
|
|
// - timeout
|
|
// - network error
|
|
// - badly formatted JSONP (script loaded, did not call our callback)
|
|
// In both cases:
|
|
// - uncaught exception occurs (TypeError)
|
|
requestDebug('error: %s, stack: %s', err.message, err.stack);
|
|
|
|
var endTime = new Date();
|
|
debugData.push({
|
|
currentHost: currentHost,
|
|
headers: removeCredentials(headers),
|
|
content: body || null,
|
|
contentLength: body !== undefined ? body.length : null,
|
|
method: reqOpts.method,
|
|
timeouts: reqOpts.timeouts,
|
|
url: reqOpts.url,
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
duration: endTime - startTime
|
|
});
|
|
|
|
if (!(err instanceof errors.AlgoliaSearchError)) {
|
|
err = new errors.Unknown(err && err.message, err);
|
|
}
|
|
|
|
tries += 1;
|
|
|
|
// stop the request implementation when:
|
|
if (
|
|
// we did not generate this error,
|
|
// it comes from a throw in some other piece of code
|
|
err instanceof errors.Unknown ||
|
|
|
|
// server sent unparsable JSON
|
|
err instanceof errors.UnparsableJSON ||
|
|
|
|
// max tries and already using fallback or no fallback
|
|
tries >= client.hosts[initialOpts.hostType].length &&
|
|
(usingFallback || !hasFallback)) {
|
|
// stop request implementation for this command
|
|
err.debugData = debugData;
|
|
return client._promise.reject(err);
|
|
}
|
|
|
|
// When a timeout occurred, retry by raising timeout
|
|
if (err instanceof errors.RequestTimeout) {
|
|
return retryRequestWithHigherTimeout();
|
|
}
|
|
|
|
return retryRequest();
|
|
}
|
|
|
|
function retryRequest() {
|
|
requestDebug('retrying request');
|
|
client._incrementHostIndex(initialOpts.hostType);
|
|
return doRequest(requester, reqOpts);
|
|
}
|
|
|
|
function retryRequestWithHigherTimeout() {
|
|
requestDebug('retrying request with higher timeout');
|
|
client._incrementHostIndex(initialOpts.hostType);
|
|
client._incrementTimeoutMultipler();
|
|
reqOpts.timeouts = client._getTimeoutsForRequest(initialOpts.hostType);
|
|
return doRequest(requester, reqOpts);
|
|
}
|
|
}
|
|
|
|
function isCacheValidWithCurrentID(
|
|
useRequestCache,
|
|
currentCache,
|
|
currentCacheID
|
|
) {
|
|
return (
|
|
client._useCache &&
|
|
useRequestCache &&
|
|
currentCache &&
|
|
currentCache[currentCacheID] !== undefined
|
|
);
|
|
}
|
|
|
|
|
|
function interopCallbackReturn(request, callback) {
|
|
if (isCacheValidWithCurrentID(client._useRequestCache, cache, cacheID)) {
|
|
request.catch(function() {
|
|
// Release the cache on error
|
|
delete cache[cacheID];
|
|
});
|
|
}
|
|
|
|
if (typeof initialOpts.callback === 'function') {
|
|
// either we have a callback
|
|
request.then(function okCb(content) {
|
|
exitPromise(function() {
|
|
initialOpts.callback(null, callback(content));
|
|
}, client._setTimeout || setTimeout);
|
|
}, function nookCb(err) {
|
|
exitPromise(function() {
|
|
initialOpts.callback(err);
|
|
}, client._setTimeout || setTimeout);
|
|
});
|
|
} else {
|
|
// either we are using promises
|
|
return request.then(callback);
|
|
}
|
|
}
|
|
|
|
if (client._useCache && client._useRequestCache) {
|
|
cacheID = initialOpts.url;
|
|
}
|
|
|
|
// as we sometime use POST requests to pass parameters (like query='aa'),
|
|
// the cacheID must also include the body to be different between calls
|
|
if (client._useCache && client._useRequestCache && body) {
|
|
cacheID += '_body_' + body;
|
|
}
|
|
|
|
if (isCacheValidWithCurrentID(client._useRequestCache, cache, cacheID)) {
|
|
requestDebug('serving request from cache');
|
|
|
|
var maybePromiseForCache = cache[cacheID];
|
|
|
|
// In case the cache is warmup with value that is not a promise
|
|
var promiseForCache = typeof maybePromiseForCache.then !== 'function'
|
|
? client._promise.resolve({responseText: maybePromiseForCache})
|
|
: maybePromiseForCache;
|
|
|
|
return interopCallbackReturn(promiseForCache, function(content) {
|
|
// In case of the cache request, return the original value
|
|
return JSON.parse(content.responseText);
|
|
});
|
|
}
|
|
|
|
var request = doRequest(
|
|
client._request, {
|
|
url: initialOpts.url,
|
|
method: initialOpts.method,
|
|
body: body,
|
|
jsonBody: initialOpts.body,
|
|
timeouts: client._getTimeoutsForRequest(initialOpts.hostType),
|
|
forceAuthHeaders: initialOpts.forceAuthHeaders
|
|
}
|
|
);
|
|
|
|
if (client._useCache && client._useRequestCache && cache) {
|
|
cache[cacheID] = request;
|
|
}
|
|
|
|
return interopCallbackReturn(request, function(content) {
|
|
// In case of the first request, return the JSON value
|
|
return content.body;
|
|
});
|
|
};
|
|
|
|
/*
|
|
* Transform search param object in query string
|
|
* @param {object} args arguments to add to the current query string
|
|
* @param {string} params current query string
|
|
* @return {string} the final query string
|
|
*/
|
|
AlgoliaSearchCore.prototype._getSearchParams = function(args, params) {
|
|
if (args === undefined || args === null) {
|
|
return params;
|
|
}
|
|
for (var key in args) {
|
|
if (key !== null && args[key] !== undefined && args.hasOwnProperty(key)) {
|
|
params += params === '' ? '' : '&';
|
|
params += key + '=' + encodeURIComponent(Object.prototype.toString.call(args[key]) === '[object Array]' ? safeJSONStringify(args[key]) : args[key]);
|
|
}
|
|
}
|
|
return params;
|
|
};
|
|
|
|
/**
|
|
* Compute the headers for a request
|
|
*
|
|
* @param [string] options.additionalUA semi-colon separated string with other user agents to add
|
|
* @param [boolean=true] options.withApiKey Send the api key as a header
|
|
* @param [Object] options.headers Extra headers to send
|
|
*/
|
|
AlgoliaSearchCore.prototype._computeRequestHeaders = function(options) {
|
|
var forEach = require(4);
|
|
|
|
var ua = options.additionalUA ?
|
|
this._ua + '; ' + options.additionalUA :
|
|
this._ua;
|
|
|
|
var requestHeaders = {
|
|
'x-algolia-agent': ua,
|
|
'x-algolia-application-id': this.applicationID
|
|
};
|
|
|
|
// browser will inline headers in the url, node.js will use http headers
|
|
// but in some situations, the API KEY will be too long (big secured API keys)
|
|
// so if the request is a POST and the KEY is very long, we will be asked to not put
|
|
// it into headers but in the JSON body
|
|
if (options.withApiKey !== false) {
|
|
requestHeaders['x-algolia-api-key'] = this.apiKey;
|
|
}
|
|
|
|
if (this.userToken) {
|
|
requestHeaders['x-algolia-usertoken'] = this.userToken;
|
|
}
|
|
|
|
if (this.securityTags) {
|
|
requestHeaders['x-algolia-tagfilters'] = this.securityTags;
|
|
}
|
|
|
|
forEach(this.extraHeaders, function addToRequestHeaders(value, key) {
|
|
requestHeaders[key] = value;
|
|
});
|
|
|
|
if (options.headers) {
|
|
forEach(options.headers, function addToRequestHeaders(value, key) {
|
|
requestHeaders[key] = value;
|
|
});
|
|
}
|
|
|
|
return requestHeaders;
|
|
};
|
|
|
|
/**
|
|
* Search through multiple indices at the same time
|
|
* @param {Object[]} queries An array of queries you want to run.
|
|
* @param {string} queries[].indexName The index name you want to target
|
|
* @param {string} [queries[].query] The query to issue on this index. Can also be passed into `params`
|
|
* @param {Object} queries[].params Any search param like hitsPerPage, ..
|
|
* @param {Function} callback Callback to be called
|
|
* @return {Promise|undefined} Returns a promise if no callback given
|
|
*/
|
|
AlgoliaSearchCore.prototype.search = function(queries, opts, callback) {
|
|
var isArray = require(7);
|
|
var map = require(27);
|
|
|
|
var usage = 'Usage: client.search(arrayOfQueries[, callback])';
|
|
|
|
if (!isArray(queries)) {
|
|
throw new Error(usage);
|
|
}
|
|
|
|
if (typeof opts === 'function') {
|
|
callback = opts;
|
|
opts = {};
|
|
} else if (opts === undefined) {
|
|
opts = {};
|
|
}
|
|
|
|
var client = this;
|
|
|
|
var postObj = {
|
|
requests: map(queries, function prepareRequest(query) {
|
|
var params = '';
|
|
|
|
// allow query.query
|
|
// so we are mimicing the index.search(query, params) method
|
|
// {indexName:, query:, params:}
|
|
if (query.query !== undefined) {
|
|
params += 'query=' + encodeURIComponent(query.query);
|
|
}
|
|
|
|
return {
|
|
indexName: query.indexName,
|
|
params: client._getSearchParams(query.params, params)
|
|
};
|
|
})
|
|
};
|
|
|
|
var JSONPParams = map(postObj.requests, function prepareJSONPParams(request, requestId) {
|
|
return requestId + '=' +
|
|
encodeURIComponent(
|
|
'/1/indexes/' + encodeURIComponent(request.indexName) + '?' +
|
|
request.params
|
|
);
|
|
}).join('&');
|
|
|
|
var url = '/1/indexes/*/queries';
|
|
|
|
if (opts.strategy !== undefined) {
|
|
postObj.strategy = opts.strategy;
|
|
}
|
|
|
|
return this._jsonRequest({
|
|
cache: this.cache,
|
|
method: 'POST',
|
|
url: url,
|
|
body: postObj,
|
|
hostType: 'read',
|
|
fallback: {
|
|
method: 'GET',
|
|
url: '/1/indexes/*',
|
|
body: {
|
|
params: JSONPParams
|
|
}
|
|
},
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Search for facet values
|
|
* https://www.algolia.com/doc/rest-api/search#search-for-facet-values
|
|
* This is the top-level API for SFFV.
|
|
*
|
|
* @param {object[]} queries An array of queries to run.
|
|
* @param {string} queries[].indexName Index name, name of the index to search.
|
|
* @param {object} queries[].params Query parameters.
|
|
* @param {string} queries[].params.facetName Facet name, name of the attribute to search for values in.
|
|
* Must be declared as a facet
|
|
* @param {string} queries[].params.facetQuery Query for the facet search
|
|
* @param {string} [queries[].params.*] Any search parameter of Algolia,
|
|
* see https://www.algolia.com/doc/api-client/javascript/search#search-parameters
|
|
* Pagination is not supported. The page and hitsPerPage parameters will be ignored.
|
|
*/
|
|
AlgoliaSearchCore.prototype.searchForFacetValues = function(queries) {
|
|
var isArray = require(7);
|
|
var map = require(27);
|
|
|
|
var usage = 'Usage: client.searchForFacetValues([{indexName, params: {facetName, facetQuery, ...params}}, ...queries])'; // eslint-disable-line max-len
|
|
|
|
if (!isArray(queries)) {
|
|
throw new Error(usage);
|
|
}
|
|
|
|
var client = this;
|
|
|
|
return client._promise.all(map(queries, function performQuery(query) {
|
|
if (
|
|
!query ||
|
|
query.indexName === undefined ||
|
|
query.params.facetName === undefined ||
|
|
query.params.facetQuery === undefined
|
|
) {
|
|
throw new Error(usage);
|
|
}
|
|
|
|
var clone = require(22);
|
|
var omit = require(29);
|
|
|
|
var indexName = query.indexName;
|
|
var params = query.params;
|
|
|
|
var facetName = params.facetName;
|
|
var filteredParams = omit(clone(params), function(keyName) {
|
|
return keyName === 'facetName';
|
|
});
|
|
var searchParameters = client._getSearchParams(filteredParams, '');
|
|
|
|
return client._jsonRequest({
|
|
cache: client.cache,
|
|
method: 'POST',
|
|
url:
|
|
'/1/indexes/' +
|
|
encodeURIComponent(indexName) +
|
|
'/facets/' +
|
|
encodeURIComponent(facetName) +
|
|
'/query',
|
|
hostType: 'read',
|
|
body: {params: searchParameters}
|
|
});
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Set the extra security tagFilters header
|
|
* @param {string|array} tags The list of tags defining the current security filters
|
|
*/
|
|
AlgoliaSearchCore.prototype.setSecurityTags = function(tags) {
|
|
if (Object.prototype.toString.call(tags) === '[object Array]') {
|
|
var strTags = [];
|
|
for (var i = 0; i < tags.length; ++i) {
|
|
if (Object.prototype.toString.call(tags[i]) === '[object Array]') {
|
|
var oredTags = [];
|
|
for (var j = 0; j < tags[i].length; ++j) {
|
|
oredTags.push(tags[i][j]);
|
|
}
|
|
strTags.push('(' + oredTags.join(',') + ')');
|
|
} else {
|
|
strTags.push(tags[i]);
|
|
}
|
|
}
|
|
tags = strTags.join(',');
|
|
}
|
|
|
|
this.securityTags = tags;
|
|
};
|
|
|
|
/**
|
|
* Set the extra user token header
|
|
* @param {string} userToken The token identifying a uniq user (used to apply rate limits)
|
|
*/
|
|
AlgoliaSearchCore.prototype.setUserToken = function(userToken) {
|
|
this.userToken = userToken;
|
|
};
|
|
|
|
/**
|
|
* Clear all queries in client's cache
|
|
* @return undefined
|
|
*/
|
|
AlgoliaSearchCore.prototype.clearCache = function() {
|
|
this.cache = {};
|
|
};
|
|
|
|
/**
|
|
* Set the number of milliseconds a request can take before automatically being terminated.
|
|
* @deprecated
|
|
* @param {Number} milliseconds
|
|
*/
|
|
AlgoliaSearchCore.prototype.setRequestTimeout = function(milliseconds) {
|
|
if (milliseconds) {
|
|
this._timeouts.connect = this._timeouts.read = this._timeouts.write = milliseconds;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Set the three different (connect, read, write) timeouts to be used when requesting
|
|
* @param {Object} timeouts
|
|
*/
|
|
AlgoliaSearchCore.prototype.setTimeouts = function(timeouts) {
|
|
this._timeouts = timeouts;
|
|
};
|
|
|
|
/**
|
|
* Get the three different (connect, read, write) timeouts to be used when requesting
|
|
* @param {Object} timeouts
|
|
*/
|
|
AlgoliaSearchCore.prototype.getTimeouts = function() {
|
|
return this._timeouts;
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._getAppIdData = function() {
|
|
var data = store.get(this.applicationID);
|
|
if (data !== null) this._cacheAppIdData(data);
|
|
return data;
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._setAppIdData = function(data) {
|
|
data.lastChange = (new Date()).getTime();
|
|
this._cacheAppIdData(data);
|
|
return store.set(this.applicationID, data);
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._checkAppIdData = function() {
|
|
var data = this._getAppIdData();
|
|
var now = (new Date()).getTime();
|
|
if (data === null || now - data.lastChange > RESET_APP_DATA_TIMER) {
|
|
return this._resetInitialAppIdData(data);
|
|
}
|
|
|
|
return data;
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._resetInitialAppIdData = function(data) {
|
|
var newData = data || {};
|
|
newData.hostIndexes = {read: 0, write: 0};
|
|
newData.timeoutMultiplier = 1;
|
|
newData.shuffleResult = newData.shuffleResult || shuffle([1, 2, 3]);
|
|
return this._setAppIdData(newData);
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._cacheAppIdData = function(data) {
|
|
this._hostIndexes = data.hostIndexes;
|
|
this._timeoutMultiplier = data.timeoutMultiplier;
|
|
this._shuffleResult = data.shuffleResult;
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._partialAppIdDataUpdate = function(newData) {
|
|
var foreach = require(4);
|
|
var currentData = this._getAppIdData();
|
|
foreach(newData, function(value, key) {
|
|
currentData[key] = value;
|
|
});
|
|
|
|
return this._setAppIdData(currentData);
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._getHostByType = function(hostType) {
|
|
return this.hosts[hostType][this._getHostIndexByType(hostType)];
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._getTimeoutMultiplier = function() {
|
|
return this._timeoutMultiplier;
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._getHostIndexByType = function(hostType) {
|
|
return this._hostIndexes[hostType];
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._setHostIndexByType = function(hostIndex, hostType) {
|
|
var clone = require(22);
|
|
var newHostIndexes = clone(this._hostIndexes);
|
|
newHostIndexes[hostType] = hostIndex;
|
|
this._partialAppIdDataUpdate({hostIndexes: newHostIndexes});
|
|
return hostIndex;
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._incrementHostIndex = function(hostType) {
|
|
return this._setHostIndexByType(
|
|
(this._getHostIndexByType(hostType) + 1) % this.hosts[hostType].length, hostType
|
|
);
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._incrementTimeoutMultipler = function() {
|
|
var timeoutMultiplier = Math.max(this._timeoutMultiplier + 1, 4);
|
|
return this._partialAppIdDataUpdate({timeoutMultiplier: timeoutMultiplier});
|
|
};
|
|
|
|
AlgoliaSearchCore.prototype._getTimeoutsForRequest = function(hostType) {
|
|
return {
|
|
connect: this._timeouts.connect * this._timeoutMultiplier,
|
|
complete: this._timeouts[hostType] * this._timeoutMultiplier
|
|
};
|
|
};
|
|
|
|
function prepareHost(protocol) {
|
|
return function prepare(host) {
|
|
return protocol + '//' + host.toLowerCase();
|
|
};
|
|
}
|
|
|
|
// Prototype.js < 1.7, a widely used library, defines a weird
|
|
// Array.prototype.toJSON function that will fail to stringify our content
|
|
// appropriately
|
|
// refs:
|
|
// - https://groups.google.com/forum/#!topic/prototype-core/E-SAVvV_V9Q
|
|
// - https://github.com/sstephenson/prototype/commit/038a2985a70593c1a86c230fadbdfe2e4898a48c
|
|
// - http://stackoverflow.com/a/3148441/147079
|
|
function safeJSONStringify(obj) {
|
|
/* eslint no-extend-native:0 */
|
|
|
|
if (Array.prototype.toJSON === undefined) {
|
|
return JSON.stringify(obj);
|
|
}
|
|
|
|
var toJSON = Array.prototype.toJSON;
|
|
delete Array.prototype.toJSON;
|
|
var out = JSON.stringify(obj);
|
|
Array.prototype.toJSON = toJSON;
|
|
|
|
return out;
|
|
}
|
|
|
|
function shuffle(array) {
|
|
var currentIndex = array.length;
|
|
var temporaryValue;
|
|
var randomIndex;
|
|
|
|
// While there remain elements to shuffle...
|
|
while (currentIndex !== 0) {
|
|
// Pick a remaining element...
|
|
randomIndex = Math.floor(Math.random() * currentIndex);
|
|
currentIndex -= 1;
|
|
|
|
// And swap it with the current element.
|
|
temporaryValue = array[currentIndex];
|
|
array[currentIndex] = array[randomIndex];
|
|
array[randomIndex] = temporaryValue;
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
function removeCredentials(headers) {
|
|
var newHeaders = {};
|
|
|
|
for (var headerName in headers) {
|
|
if (Object.prototype.hasOwnProperty.call(headers, headerName)) {
|
|
var value;
|
|
|
|
if (headerName === 'x-algolia-api-key' || headerName === 'x-algolia-application-id') {
|
|
value = '**hidden for security purposes**';
|
|
} else {
|
|
value = headers[headerName];
|
|
}
|
|
|
|
newHeaders[headerName] = value;
|
|
}
|
|
}
|
|
|
|
return newHeaders;
|
|
}
|
|
|
|
}).call(this,require(11))
|
|
},{"1":1,"11":11,"16":16,"22":22,"25":25,"26":26,"27":27,"29":29,"31":31,"4":4,"7":7}],16:[function(require,module,exports){
|
|
var buildSearchMethod = require(21);
|
|
var deprecate = require(23);
|
|
var deprecatedMessage = require(24);
|
|
|
|
module.exports = IndexCore;
|
|
|
|
/*
|
|
* Index class constructor.
|
|
* You should not use this method directly but use initIndex() function
|
|
*/
|
|
function IndexCore(algoliasearch, indexName) {
|
|
this.indexName = indexName;
|
|
this.as = algoliasearch;
|
|
this.typeAheadArgs = null;
|
|
this.typeAheadValueOption = null;
|
|
|
|
// make sure every index instance has it's own cache
|
|
this.cache = {};
|
|
}
|
|
|
|
/*
|
|
* Clear all queries in cache
|
|
*/
|
|
IndexCore.prototype.clearCache = function() {
|
|
this.cache = {};
|
|
};
|
|
|
|
/*
|
|
* Search inside the index using XMLHttpRequest request (Using a POST query to
|
|
* minimize number of OPTIONS queries: Cross-Origin Resource Sharing).
|
|
*
|
|
* @param {string} [query] the full text query
|
|
* @param {object} [args] (optional) if set, contains an object with query parameters:
|
|
* - page: (integer) Pagination parameter used to select the page to retrieve.
|
|
* Page is zero-based and defaults to 0. Thus,
|
|
* to retrieve the 10th page you need to set page=9
|
|
* - hitsPerPage: (integer) Pagination parameter used to select the number of hits per page. Defaults to 20.
|
|
* - attributesToRetrieve: a string that contains the list of object attributes
|
|
* you want to retrieve (let you minimize the answer size).
|
|
* Attributes are separated with a comma (for example "name,address").
|
|
* You can also use an array (for example ["name","address"]).
|
|
* By default, all attributes are retrieved. You can also use '*' to retrieve all
|
|
* values when an attributesToRetrieve setting is specified for your index.
|
|
* - attributesToHighlight: a string that contains the list of attributes you
|
|
* want to highlight according to the query.
|
|
* Attributes are separated by a comma. You can also use an array (for example ["name","address"]).
|
|
* If an attribute has no match for the query, the raw value is returned.
|
|
* By default all indexed text attributes are highlighted.
|
|
* You can use `*` if you want to highlight all textual attributes.
|
|
* Numerical attributes are not highlighted.
|
|
* A matchLevel is returned for each highlighted attribute and can contain:
|
|
* - full: if all the query terms were found in the attribute,
|
|
* - partial: if only some of the query terms were found,
|
|
* - none: if none of the query terms were found.
|
|
* - attributesToSnippet: a string that contains the list of attributes to snippet alongside
|
|
* the number of words to return (syntax is `attributeName:nbWords`).
|
|
* Attributes are separated by a comma (Example: attributesToSnippet=name:10,content:10).
|
|
* You can also use an array (Example: attributesToSnippet: ['name:10','content:10']).
|
|
* By default no snippet is computed.
|
|
* - minWordSizefor1Typo: the minimum number of characters in a query word to accept one typo in this word.
|
|
* Defaults to 3.
|
|
* - minWordSizefor2Typos: the minimum number of characters in a query word
|
|
* to accept two typos in this word. Defaults to 7.
|
|
* - getRankingInfo: if set to 1, the result hits will contain ranking
|
|
* information in _rankingInfo attribute.
|
|
* - aroundLatLng: search for entries around a given
|
|
* latitude/longitude (specified as two floats separated by a comma).
|
|
* For example aroundLatLng=47.316669,5.016670).
|
|
* You can specify the maximum distance in meters with the aroundRadius parameter (in meters)
|
|
* and the precision for ranking with aroundPrecision
|
|
* (for example if you set aroundPrecision=100, two objects that are distant of
|
|
* less than 100m will be considered as identical for "geo" ranking parameter).
|
|
* At indexing, you should specify geoloc of an object with the _geoloc attribute
|
|
* (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
|
|
* - insideBoundingBox: search entries inside a given area defined by the two extreme points
|
|
* of a rectangle (defined by 4 floats: p1Lat,p1Lng,p2Lat,p2Lng).
|
|
* For example insideBoundingBox=47.3165,4.9665,47.3424,5.0201).
|
|
* At indexing, you should specify geoloc of an object with the _geoloc attribute
|
|
* (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
|
|
* - numericFilters: a string that contains the list of numeric filters you want to
|
|
* apply separated by a comma.
|
|
* The syntax of one filter is `attributeName` followed by `operand` followed by `value`.
|
|
* Supported operands are `<`, `<=`, `=`, `>` and `>=`.
|
|
* You can have multiple conditions on one attribute like for example numericFilters=price>100,price<1000.
|
|
* You can also use an array (for example numericFilters: ["price>100","price<1000"]).
|
|
* - tagFilters: filter the query by a set of tags. You can AND tags by separating them by commas.
|
|
* To OR tags, you must add parentheses. For example, tags=tag1,(tag2,tag3) means tag1 AND (tag2 OR tag3).
|
|
* You can also use an array, for example tagFilters: ["tag1",["tag2","tag3"]]
|
|
* means tag1 AND (tag2 OR tag3).
|
|
* At indexing, tags should be added in the _tags** attribute
|
|
* of objects (for example {"_tags":["tag1","tag2"]}).
|
|
* - facetFilters: filter the query by a list of facets.
|
|
* Facets are separated by commas and each facet is encoded as `attributeName:value`.
|
|
* For example: `facetFilters=category:Book,author:John%20Doe`.
|
|
* You can also use an array (for example `["category:Book","author:John%20Doe"]`).
|
|
* - facets: List of object attributes that you want to use for faceting.
|
|
* Comma separated list: `"category,author"` or array `['category','author']`
|
|
* Only attributes that have been added in **attributesForFaceting** index setting
|
|
* can be used in this parameter.
|
|
* You can also use `*` to perform faceting on all attributes specified in **attributesForFaceting**.
|
|
* - queryType: select how the query words are interpreted, it can be one of the following value:
|
|
* - prefixAll: all query words are interpreted as prefixes,
|
|
* - prefixLast: only the last word is interpreted as a prefix (default behavior),
|
|
* - prefixNone: no query word is interpreted as a prefix. This option is not recommended.
|
|
* - optionalWords: a string that contains the list of words that should
|
|
* be considered as optional when found in the query.
|
|
* Comma separated and array are accepted.
|
|
* - distinct: If set to 1, enable the distinct feature (disabled by default)
|
|
* if the attributeForDistinct index setting is set.
|
|
* This feature is similar to the SQL "distinct" keyword: when enabled
|
|
* in a query with the distinct=1 parameter,
|
|
* all hits containing a duplicate value for the attributeForDistinct attribute are removed from results.
|
|
* For example, if the chosen attribute is show_name and several hits have
|
|
* the same value for show_name, then only the best
|
|
* one is kept and others are removed.
|
|
* - restrictSearchableAttributes: List of attributes you want to use for
|
|
* textual search (must be a subset of the attributesToIndex index setting)
|
|
* either comma separated or as an array
|
|
* @param {function} [callback] the result callback called with two arguments:
|
|
* error: null or Error('message'). If false, the content contains the error.
|
|
* content: the server answer that contains the list of results.
|
|
*/
|
|
IndexCore.prototype.search = buildSearchMethod('query');
|
|
|
|
/*
|
|
* -- BETA --
|
|
* Search a record similar to the query inside the index using XMLHttpRequest request (Using a POST query to
|
|
* minimize number of OPTIONS queries: Cross-Origin Resource Sharing).
|
|
*
|
|
* @param {string} [query] the similar query
|
|
* @param {object} [args] (optional) if set, contains an object with query parameters.
|
|
* All search parameters are supported (see search function), restrictSearchableAttributes and facetFilters
|
|
* are the two most useful to restrict the similar results and get more relevant content
|
|
*/
|
|
IndexCore.prototype.similarSearch = deprecate(
|
|
buildSearchMethod('similarQuery'),
|
|
deprecatedMessage(
|
|
'index.similarSearch(query[, callback])',
|
|
'index.search({ similarQuery: query }[, callback])'
|
|
)
|
|
);
|
|
|
|
/*
|
|
* Browse index content. The response content will have a `cursor` property that you can use
|
|
* to browse subsequent pages for this query. Use `index.browseFrom(cursor)` when you want.
|
|
*
|
|
* @param {string} query - The full text query
|
|
* @param {Object} [queryParameters] - Any search query parameter
|
|
* @param {Function} [callback] - The result callback called with two arguments
|
|
* error: null or Error('message')
|
|
* content: the server answer with the browse result
|
|
* @return {Promise|undefined} Returns a promise if no callback given
|
|
* @example
|
|
* index.browse('cool songs', {
|
|
* tagFilters: 'public,comments',
|
|
* hitsPerPage: 500
|
|
* }, callback);
|
|
* @see {@link https://www.algolia.com/doc/rest_api#Browse|Algolia REST API Documentation}
|
|
*/
|
|
IndexCore.prototype.browse = function(query, queryParameters, callback) {
|
|
var merge = require(28);
|
|
|
|
var indexObj = this;
|
|
|
|
var page;
|
|
var hitsPerPage;
|
|
|
|
// we check variadic calls that are not the one defined
|
|
// .browse()/.browse(fn)
|
|
// => page = 0
|
|
if (arguments.length === 0 || arguments.length === 1 && typeof arguments[0] === 'function') {
|
|
page = 0;
|
|
callback = arguments[0];
|
|
query = undefined;
|
|
} else if (typeof arguments[0] === 'number') {
|
|
// .browse(2)/.browse(2, 10)/.browse(2, fn)/.browse(2, 10, fn)
|
|
page = arguments[0];
|
|
if (typeof arguments[1] === 'number') {
|
|
hitsPerPage = arguments[1];
|
|
} else if (typeof arguments[1] === 'function') {
|
|
callback = arguments[1];
|
|
hitsPerPage = undefined;
|
|
}
|
|
query = undefined;
|
|
queryParameters = undefined;
|
|
} else if (typeof arguments[0] === 'object') {
|
|
// .browse(queryParameters)/.browse(queryParameters, cb)
|
|
if (typeof arguments[1] === 'function') {
|
|
callback = arguments[1];
|
|
}
|
|
queryParameters = arguments[0];
|
|
query = undefined;
|
|
} else if (typeof arguments[0] === 'string' && typeof arguments[1] === 'function') {
|
|
// .browse(query, cb)
|
|
callback = arguments[1];
|
|
queryParameters = undefined;
|
|
}
|
|
|
|
// otherwise it's a .browse(query)/.browse(query, queryParameters)/.browse(query, queryParameters, cb)
|
|
|
|
// get search query parameters combining various possible calls
|
|
// to .browse();
|
|
queryParameters = merge({}, queryParameters || {}, {
|
|
page: page,
|
|
hitsPerPage: hitsPerPage,
|
|
query: query
|
|
});
|
|
|
|
var params = this.as._getSearchParams(queryParameters, '');
|
|
|
|
return this.as._jsonRequest({
|
|
method: 'POST',
|
|
url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/browse',
|
|
body: {params: params},
|
|
hostType: 'read',
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
/*
|
|
* Continue browsing from a previous position (cursor), obtained via a call to `.browse()`.
|
|
*
|
|
* @param {string} query - The full text query
|
|
* @param {Object} [queryParameters] - Any search query parameter
|
|
* @param {Function} [callback] - The result callback called with two arguments
|
|
* error: null or Error('message')
|
|
* content: the server answer with the browse result
|
|
* @return {Promise|undefined} Returns a promise if no callback given
|
|
* @example
|
|
* index.browseFrom('14lkfsakl32', callback);
|
|
* @see {@link https://www.algolia.com/doc/rest_api#Browse|Algolia REST API Documentation}
|
|
*/
|
|
IndexCore.prototype.browseFrom = function(cursor, callback) {
|
|
return this.as._jsonRequest({
|
|
method: 'POST',
|
|
url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/browse',
|
|
body: {cursor: cursor},
|
|
hostType: 'read',
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
/*
|
|
* Search for facet values
|
|
* https://www.algolia.com/doc/rest-api/search#search-for-facet-values
|
|
*
|
|
* @param {string} params.facetName Facet name, name of the attribute to search for values in.
|
|
* Must be declared as a facet
|
|
* @param {string} params.facetQuery Query for the facet search
|
|
* @param {string} [params.*] Any search parameter of Algolia,
|
|
* see https://www.algolia.com/doc/api-client/javascript/search#search-parameters
|
|
* Pagination is not supported. The page and hitsPerPage parameters will be ignored.
|
|
* @param callback (optional)
|
|
*/
|
|
IndexCore.prototype.searchForFacetValues = function(params, callback) {
|
|
var clone = require(22);
|
|
var omit = require(29);
|
|
var usage = 'Usage: index.searchForFacetValues({facetName, facetQuery, ...params}[, callback])';
|
|
|
|
if (params.facetName === undefined || params.facetQuery === undefined) {
|
|
throw new Error(usage);
|
|
}
|
|
|
|
var facetName = params.facetName;
|
|
var filteredParams = omit(clone(params), function(keyName) {
|
|
return keyName === 'facetName';
|
|
});
|
|
var searchParameters = this.as._getSearchParams(filteredParams, '');
|
|
|
|
return this.as._jsonRequest({
|
|
method: 'POST',
|
|
url: '/1/indexes/' +
|
|
encodeURIComponent(this.indexName) + '/facets/' + encodeURIComponent(facetName) + '/query',
|
|
hostType: 'read',
|
|
body: {params: searchParameters},
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
IndexCore.prototype.searchFacet = deprecate(function(params, callback) {
|
|
return this.searchForFacetValues(params, callback);
|
|
}, deprecatedMessage(
|
|
'index.searchFacet(params[, callback])',
|
|
'index.searchForFacetValues(params[, callback])'
|
|
));
|
|
|
|
IndexCore.prototype._search = function(params, url, callback, additionalUA) {
|
|
return this.as._jsonRequest({
|
|
cache: this.cache,
|
|
method: 'POST',
|
|
url: url || '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',
|
|
body: {params: params},
|
|
hostType: 'read',
|
|
fallback: {
|
|
method: 'GET',
|
|
url: '/1/indexes/' + encodeURIComponent(this.indexName),
|
|
body: {params: params}
|
|
},
|
|
callback: callback,
|
|
additionalUA: additionalUA
|
|
});
|
|
};
|
|
|
|
/*
|
|
* Get an object from this index
|
|
*
|
|
* @param objectID the unique identifier of the object to retrieve
|
|
* @param attrs (optional) if set, contains the array of attribute names to retrieve
|
|
* @param callback (optional) the result callback called with two arguments
|
|
* error: null or Error('message')
|
|
* content: the object to retrieve or the error message if a failure occurred
|
|
*/
|
|
IndexCore.prototype.getObject = function(objectID, attrs, callback) {
|
|
var indexObj = this;
|
|
|
|
if (arguments.length === 1 || typeof attrs === 'function') {
|
|
callback = attrs;
|
|
attrs = undefined;
|
|
}
|
|
|
|
var params = '';
|
|
if (attrs !== undefined) {
|
|
params = '?attributes=';
|
|
for (var i = 0; i < attrs.length; ++i) {
|
|
if (i !== 0) {
|
|
params += ',';
|
|
}
|
|
params += attrs[i];
|
|
}
|
|
}
|
|
|
|
return this.as._jsonRequest({
|
|
method: 'GET',
|
|
url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID) + params,
|
|
hostType: 'read',
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
/*
|
|
* Get several objects from this index
|
|
*
|
|
* @param objectIDs the array of unique identifier of objects to retrieve
|
|
*/
|
|
IndexCore.prototype.getObjects = function(objectIDs, attributesToRetrieve, callback) {
|
|
var isArray = require(7);
|
|
var map = require(27);
|
|
|
|
var usage = 'Usage: index.getObjects(arrayOfObjectIDs[, callback])';
|
|
|
|
if (!isArray(objectIDs)) {
|
|
throw new Error(usage);
|
|
}
|
|
|
|
var indexObj = this;
|
|
|
|
if (arguments.length === 1 || typeof attributesToRetrieve === 'function') {
|
|
callback = attributesToRetrieve;
|
|
attributesToRetrieve = undefined;
|
|
}
|
|
|
|
var body = {
|
|
requests: map(objectIDs, function prepareRequest(objectID) {
|
|
var request = {
|
|
indexName: indexObj.indexName,
|
|
objectID: objectID
|
|
};
|
|
|
|
if (attributesToRetrieve) {
|
|
request.attributesToRetrieve = attributesToRetrieve.join(',');
|
|
}
|
|
|
|
return request;
|
|
})
|
|
};
|
|
|
|
return this.as._jsonRequest({
|
|
method: 'POST',
|
|
url: '/1/indexes/*/objects',
|
|
hostType: 'read',
|
|
body: body,
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
IndexCore.prototype.as = null;
|
|
IndexCore.prototype.indexName = null;
|
|
IndexCore.prototype.typeAheadArgs = null;
|
|
IndexCore.prototype.typeAheadValueOption = null;
|
|
|
|
},{"21":21,"22":22,"23":23,"24":24,"27":27,"28":28,"29":29,"7":7}],17:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var AlgoliaSearchCore = require(15);
|
|
var createAlgoliasearch = require(18);
|
|
|
|
module.exports = createAlgoliasearch(AlgoliaSearchCore, 'Browser (lite)');
|
|
|
|
},{"15":15,"18":18}],18:[function(require,module,exports){
|
|
(function (process){
|
|
'use strict';
|
|
|
|
var global = require(5);
|
|
var Promise = global.Promise || require(3).Promise;
|
|
|
|
// This is the standalone browser build entry point
|
|
// Browser implementation of the Algolia Search JavaScript client,
|
|
// using XMLHttpRequest, XDomainRequest and JSONP as fallback
|
|
module.exports = function createAlgoliasearch(AlgoliaSearch, uaSuffix) {
|
|
var inherits = require(6);
|
|
var errors = require(25);
|
|
var inlineHeaders = require(19);
|
|
var jsonpRequest = require(20);
|
|
var places = require(30);
|
|
uaSuffix = uaSuffix || '';
|
|
|
|
if (process.env.NODE_ENV === 'debug') {
|
|
require(1).enable('algoliasearch*');
|
|
}
|
|
|
|
function algoliasearch(applicationID, apiKey, opts) {
|
|
var cloneDeep = require(22);
|
|
|
|
opts = cloneDeep(opts || {});
|
|
|
|
opts._ua = opts._ua || algoliasearch.ua;
|
|
|
|
return new AlgoliaSearchBrowser(applicationID, apiKey, opts);
|
|
}
|
|
|
|
algoliasearch.version = require(32);
|
|
|
|
algoliasearch.ua =
|
|
'Algolia for JavaScript (' + algoliasearch.version + '); ' + uaSuffix;
|
|
|
|
algoliasearch.initPlaces = places(algoliasearch);
|
|
|
|
// we expose into window no matter how we are used, this will allow
|
|
// us to easily debug any website running algolia
|
|
global.__algolia = {
|
|
debug: require(1),
|
|
algoliasearch: algoliasearch
|
|
};
|
|
|
|
var support = {
|
|
hasXMLHttpRequest: 'XMLHttpRequest' in global,
|
|
hasXDomainRequest: 'XDomainRequest' in global
|
|
};
|
|
|
|
if (support.hasXMLHttpRequest) {
|
|
support.cors = 'withCredentials' in new XMLHttpRequest();
|
|
}
|
|
|
|
function AlgoliaSearchBrowser() {
|
|
// call AlgoliaSearch constructor
|
|
AlgoliaSearch.apply(this, arguments);
|
|
}
|
|
|
|
inherits(AlgoliaSearchBrowser, AlgoliaSearch);
|
|
|
|
AlgoliaSearchBrowser.prototype._request = function request(url, opts) {
|
|
return new Promise(function wrapRequest(resolve, reject) {
|
|
// no cors or XDomainRequest, no request
|
|
if (!support.cors && !support.hasXDomainRequest) {
|
|
// very old browser, not supported
|
|
reject(new errors.Network('CORS not supported'));
|
|
return;
|
|
}
|
|
|
|
url = inlineHeaders(url, opts.headers);
|
|
|
|
var body = opts.body;
|
|
var req = support.cors ? new XMLHttpRequest() : new XDomainRequest();
|
|
var reqTimeout;
|
|
var timedOut;
|
|
var connected = false;
|
|
|
|
reqTimeout = setTimeout(onTimeout, opts.timeouts.connect);
|
|
// we set an empty onprogress listener
|
|
// so that XDomainRequest on IE9 is not aborted
|
|
// refs:
|
|
// - https://github.com/algolia/algoliasearch-client-js/issues/76
|
|
// - https://social.msdn.microsoft.com/Forums/ie/en-US/30ef3add-767c-4436-b8a9-f1ca19b4812e/ie9-rtm-xdomainrequest-issued-requests-may-abort-if-all-event-handlers-not-specified?forum=iewebdevelopment
|
|
req.onprogress = onProgress;
|
|
if ('onreadystatechange' in req) req.onreadystatechange = onReadyStateChange;
|
|
req.onload = onLoad;
|
|
req.onerror = onError;
|
|
|
|
// do not rely on default XHR async flag, as some analytics code like hotjar
|
|
// breaks it and set it to false by default
|
|
if (req instanceof XMLHttpRequest) {
|
|
req.open(opts.method, url, true);
|
|
|
|
// The Analytics API never accepts Auth headers as query string
|
|
// this option exists specifically for them.
|
|
if (opts.forceAuthHeaders) {
|
|
req.setRequestHeader(
|
|
'x-algolia-application-id',
|
|
opts.headers['x-algolia-application-id']
|
|
);
|
|
req.setRequestHeader(
|
|
'x-algolia-api-key',
|
|
opts.headers['x-algolia-api-key']
|
|
);
|
|
}
|
|
} else {
|
|
req.open(opts.method, url);
|
|
}
|
|
|
|
// headers are meant to be sent after open
|
|
if (support.cors) {
|
|
if (body) {
|
|
if (opts.method === 'POST') {
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Simple_requests
|
|
req.setRequestHeader('content-type', 'application/x-www-form-urlencoded');
|
|
} else {
|
|
req.setRequestHeader('content-type', 'application/json');
|
|
}
|
|
}
|
|
req.setRequestHeader('accept', 'application/json');
|
|
}
|
|
|
|
if (body) {
|
|
req.send(body);
|
|
} else {
|
|
req.send();
|
|
}
|
|
|
|
// event object not received in IE8, at least
|
|
// but we do not use it, still important to note
|
|
function onLoad(/* event */) {
|
|
// When browser does not supports req.timeout, we can
|
|
// have both a load and timeout event, since handled by a dumb setTimeout
|
|
if (timedOut) {
|
|
return;
|
|
}
|
|
|
|
clearTimeout(reqTimeout);
|
|
|
|
var out;
|
|
|
|
try {
|
|
out = {
|
|
body: JSON.parse(req.responseText),
|
|
responseText: req.responseText,
|
|
statusCode: req.status,
|
|
// XDomainRequest does not have any response headers
|
|
headers: req.getAllResponseHeaders && req.getAllResponseHeaders() || {}
|
|
};
|
|
} catch (e) {
|
|
out = new errors.UnparsableJSON({
|
|
more: req.responseText
|
|
});
|
|
}
|
|
|
|
if (out instanceof errors.UnparsableJSON) {
|
|
reject(out);
|
|
} else {
|
|
resolve(out);
|
|
}
|
|
}
|
|
|
|
function onError(event) {
|
|
if (timedOut) {
|
|
return;
|
|
}
|
|
|
|
clearTimeout(reqTimeout);
|
|
|
|
// error event is trigerred both with XDR/XHR on:
|
|
// - DNS error
|
|
// - unallowed cross domain request
|
|
reject(
|
|
new errors.Network({
|
|
more: event
|
|
})
|
|
);
|
|
}
|
|
|
|
function onTimeout() {
|
|
timedOut = true;
|
|
req.abort();
|
|
|
|
reject(new errors.RequestTimeout());
|
|
}
|
|
|
|
function onConnect() {
|
|
connected = true;
|
|
clearTimeout(reqTimeout);
|
|
reqTimeout = setTimeout(onTimeout, opts.timeouts.complete);
|
|
}
|
|
|
|
function onProgress() {
|
|
if (!connected) onConnect();
|
|
}
|
|
|
|
function onReadyStateChange() {
|
|
if (!connected && req.readyState > 1) onConnect();
|
|
}
|
|
});
|
|
};
|
|
|
|
AlgoliaSearchBrowser.prototype._request.fallback = function requestFallback(url, opts) {
|
|
url = inlineHeaders(url, opts.headers);
|
|
|
|
return new Promise(function wrapJsonpRequest(resolve, reject) {
|
|
jsonpRequest(url, opts, function jsonpRequestDone(err, content) {
|
|
if (err) {
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
resolve(content);
|
|
});
|
|
});
|
|
};
|
|
|
|
AlgoliaSearchBrowser.prototype._promise = {
|
|
reject: function rejectPromise(val) {
|
|
return Promise.reject(val);
|
|
},
|
|
resolve: function resolvePromise(val) {
|
|
return Promise.resolve(val);
|
|
},
|
|
delay: function delayPromise(ms) {
|
|
return new Promise(function resolveOnTimeout(resolve/* , reject*/) {
|
|
setTimeout(resolve, ms);
|
|
});
|
|
},
|
|
all: function all(promises) {
|
|
return Promise.all(promises);
|
|
}
|
|
};
|
|
|
|
return algoliasearch;
|
|
};
|
|
|
|
}).call(this,require(11))
|
|
},{"1":1,"11":11,"19":19,"20":20,"22":22,"25":25,"3":3,"30":30,"32":32,"5":5,"6":6}],19:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = inlineHeaders;
|
|
|
|
var encode = require(13);
|
|
|
|
function inlineHeaders(url, headers) {
|
|
if (/\?/.test(url)) {
|
|
url += '&';
|
|
} else {
|
|
url += '?';
|
|
}
|
|
|
|
return url + encode(headers);
|
|
}
|
|
|
|
},{"13":13}],20:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = jsonpRequest;
|
|
|
|
var errors = require(25);
|
|
|
|
var JSONPCounter = 0;
|
|
|
|
function jsonpRequest(url, opts, cb) {
|
|
if (opts.method !== 'GET') {
|
|
cb(new Error('Method ' + opts.method + ' ' + url + ' is not supported by JSONP.'));
|
|
return;
|
|
}
|
|
|
|
opts.debug('JSONP: start');
|
|
|
|
var cbCalled = false;
|
|
var timedOut = false;
|
|
|
|
JSONPCounter += 1;
|
|
var head = document.getElementsByTagName('head')[0];
|
|
var script = document.createElement('script');
|
|
var cbName = 'algoliaJSONP_' + JSONPCounter;
|
|
var done = false;
|
|
|
|
window[cbName] = function(data) {
|
|
removeGlobals();
|
|
|
|
if (timedOut) {
|
|
opts.debug('JSONP: Late answer, ignoring');
|
|
return;
|
|
}
|
|
|
|
cbCalled = true;
|
|
|
|
clean();
|
|
|
|
cb(null, {
|
|
body: data,
|
|
responseText: JSON.stringify(data)/* ,
|
|
// We do not send the statusCode, there's no statusCode in JSONP, it will be
|
|
// computed using data.status && data.message like with XDR
|
|
statusCode*/
|
|
});
|
|
};
|
|
|
|
// add callback by hand
|
|
url += '&callback=' + cbName;
|
|
|
|
// add body params manually
|
|
if (opts.jsonBody && opts.jsonBody.params) {
|
|
url += '&' + opts.jsonBody.params;
|
|
}
|
|
|
|
var ontimeout = setTimeout(timeout, opts.timeouts.complete);
|
|
|
|
// script onreadystatechange needed only for
|
|
// <= IE8
|
|
// https://github.com/angular/angular.js/issues/4523
|
|
script.onreadystatechange = readystatechange;
|
|
script.onload = success;
|
|
script.onerror = error;
|
|
|
|
script.async = true;
|
|
script.defer = true;
|
|
script.src = url;
|
|
head.appendChild(script);
|
|
|
|
function success() {
|
|
opts.debug('JSONP: success');
|
|
|
|
if (done || timedOut) {
|
|
return;
|
|
}
|
|
|
|
done = true;
|
|
|
|
// script loaded but did not call the fn => script loading error
|
|
if (!cbCalled) {
|
|
opts.debug('JSONP: Fail. Script loaded but did not call the callback');
|
|
clean();
|
|
cb(new errors.JSONPScriptFail());
|
|
}
|
|
}
|
|
|
|
function readystatechange() {
|
|
if (this.readyState === 'loaded' || this.readyState === 'complete') {
|
|
success();
|
|
}
|
|
}
|
|
|
|
function clean() {
|
|
clearTimeout(ontimeout);
|
|
script.onload = null;
|
|
script.onreadystatechange = null;
|
|
script.onerror = null;
|
|
head.removeChild(script);
|
|
}
|
|
|
|
function removeGlobals() {
|
|
try {
|
|
delete window[cbName];
|
|
delete window[cbName + '_loaded'];
|
|
} catch (e) {
|
|
window[cbName] = window[cbName + '_loaded'] = undefined;
|
|
}
|
|
}
|
|
|
|
function timeout() {
|
|
opts.debug('JSONP: Script timeout');
|
|
timedOut = true;
|
|
clean();
|
|
cb(new errors.RequestTimeout());
|
|
}
|
|
|
|
function error() {
|
|
opts.debug('JSONP: Script error');
|
|
|
|
if (done || timedOut) {
|
|
return;
|
|
}
|
|
|
|
clean();
|
|
cb(new errors.JSONPScriptError());
|
|
}
|
|
}
|
|
|
|
},{"25":25}],21:[function(require,module,exports){
|
|
module.exports = buildSearchMethod;
|
|
|
|
var errors = require(25);
|
|
|
|
/**
|
|
* Creates a search method to be used in clients
|
|
* @param {string} queryParam the name of the attribute used for the query
|
|
* @param {string} url the url
|
|
* @return {function} the search method
|
|
*/
|
|
function buildSearchMethod(queryParam, url) {
|
|
/**
|
|
* The search method. Prepares the data and send the query to Algolia.
|
|
* @param {string} query the string used for query search
|
|
* @param {object} args additional parameters to send with the search
|
|
* @param {function} [callback] the callback to be called with the client gets the answer
|
|
* @return {undefined|Promise} If the callback is not provided then this methods returns a Promise
|
|
*/
|
|
return function search(query, args, callback) {
|
|
// warn V2 users on how to search
|
|
if (typeof query === 'function' && typeof args === 'object' ||
|
|
typeof callback === 'object') {
|
|
// .search(query, params, cb)
|
|
// .search(cb, params)
|
|
throw new errors.AlgoliaSearchError('index.search usage is index.search(query, params, cb)');
|
|
}
|
|
|
|
// Normalizing the function signature
|
|
if (arguments.length === 0 || typeof query === 'function') {
|
|
// Usage : .search(), .search(cb)
|
|
callback = query;
|
|
query = '';
|
|
} else if (arguments.length === 1 || typeof args === 'function') {
|
|
// Usage : .search(query/args), .search(query, cb)
|
|
callback = args;
|
|
args = undefined;
|
|
}
|
|
// At this point we have 3 arguments with values
|
|
|
|
// Usage : .search(args) // careful: typeof null === 'object'
|
|
if (typeof query === 'object' && query !== null) {
|
|
args = query;
|
|
query = undefined;
|
|
} else if (query === undefined || query === null) { // .search(undefined/null)
|
|
query = '';
|
|
}
|
|
|
|
var params = '';
|
|
|
|
if (query !== undefined) {
|
|
params += queryParam + '=' + encodeURIComponent(query);
|
|
}
|
|
|
|
var additionalUA;
|
|
if (args !== undefined) {
|
|
if (args.additionalUA) {
|
|
additionalUA = args.additionalUA;
|
|
delete args.additionalUA;
|
|
}
|
|
// `_getSearchParams` will augment params, do not be fooled by the = versus += from previous if
|
|
params = this.as._getSearchParams(args, params);
|
|
}
|
|
|
|
|
|
return this._search(params, url, callback, additionalUA);
|
|
};
|
|
}
|
|
|
|
},{"25":25}],22:[function(require,module,exports){
|
|
module.exports = function clone(obj) {
|
|
return JSON.parse(JSON.stringify(obj));
|
|
};
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
module.exports = function deprecate(fn, message) {
|
|
var warned = false;
|
|
|
|
function deprecated() {
|
|
if (!warned) {
|
|
/* eslint no-console:0 */
|
|
console.warn(message);
|
|
warned = true;
|
|
}
|
|
|
|
return fn.apply(this, arguments);
|
|
}
|
|
|
|
return deprecated;
|
|
};
|
|
|
|
},{}],24:[function(require,module,exports){
|
|
module.exports = function deprecatedMessage(previousUsage, newUsage) {
|
|
var githubAnchorLink = previousUsage.toLowerCase()
|
|
.replace(/[\.\(\)]/g, '');
|
|
|
|
return 'algoliasearch: `' + previousUsage + '` was replaced by `' + newUsage +
|
|
'`. Please see https://github.com/algolia/algoliasearch-client-javascript/wiki/Deprecated#' + githubAnchorLink;
|
|
};
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// This file hosts our error definitions
|
|
// We use custom error "types" so that we can act on them when we need it
|
|
// e.g.: if error instanceof errors.UnparsableJSON then..
|
|
|
|
var inherits = require(6);
|
|
|
|
function AlgoliaSearchError(message, extraProperties) {
|
|
var forEach = require(4);
|
|
|
|
var error = this;
|
|
|
|
// try to get a stacktrace
|
|
if (typeof Error.captureStackTrace === 'function') {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
} else {
|
|
error.stack = (new Error()).stack || 'Cannot get a stacktrace, browser is too old';
|
|
}
|
|
|
|
this.name = 'AlgoliaSearchError';
|
|
this.message = message || 'Unknown error';
|
|
|
|
if (extraProperties) {
|
|
forEach(extraProperties, function addToErrorObject(value, key) {
|
|
error[key] = value;
|
|
});
|
|
}
|
|
}
|
|
|
|
inherits(AlgoliaSearchError, Error);
|
|
|
|
function createCustomError(name, message) {
|
|
function AlgoliaSearchCustomError() {
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
|
|
|
// custom message not set, use default
|
|
if (typeof args[0] !== 'string') {
|
|
args.unshift(message);
|
|
}
|
|
|
|
AlgoliaSearchError.apply(this, args);
|
|
this.name = 'AlgoliaSearch' + name + 'Error';
|
|
}
|
|
|
|
inherits(AlgoliaSearchCustomError, AlgoliaSearchError);
|
|
|
|
return AlgoliaSearchCustomError;
|
|
}
|
|
|
|
// late exports to let various fn defs and inherits take place
|
|
module.exports = {
|
|
AlgoliaSearchError: AlgoliaSearchError,
|
|
UnparsableJSON: createCustomError(
|
|
'UnparsableJSON',
|
|
'Could not parse the incoming response as JSON, see err.more for details'
|
|
),
|
|
RequestTimeout: createCustomError(
|
|
'RequestTimeout',
|
|
'Request timed out before getting a response'
|
|
),
|
|
Network: createCustomError(
|
|
'Network',
|
|
'Network issue, see err.more for details'
|
|
),
|
|
JSONPScriptFail: createCustomError(
|
|
'JSONPScriptFail',
|
|
'<script> was loaded but did not call our provided callback'
|
|
),
|
|
ValidUntilNotFound: createCustomError(
|
|
'ValidUntilNotFound',
|
|
'The SecuredAPIKey does not have a validUntil parameter.'
|
|
),
|
|
JSONPScriptError: createCustomError(
|
|
'JSONPScriptError',
|
|
'<script> unable to load due to an `error` event on it'
|
|
),
|
|
ObjectNotFound: createCustomError(
|
|
'ObjectNotFound',
|
|
'Object not found'
|
|
),
|
|
Unknown: createCustomError(
|
|
'Unknown',
|
|
'Unknown error occured'
|
|
)
|
|
};
|
|
|
|
},{"4":4,"6":6}],26:[function(require,module,exports){
|
|
// Parse cloud does not supports setTimeout
|
|
// We do not store a setTimeout reference in the client everytime
|
|
// We only fallback to a fake setTimeout when not available
|
|
// setTimeout cannot be override globally sadly
|
|
module.exports = function exitPromise(fn, _setTimeout) {
|
|
_setTimeout(fn, 0);
|
|
};
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
var foreach = require(4);
|
|
|
|
module.exports = function map(arr, fn) {
|
|
var newArr = [];
|
|
foreach(arr, function(item, itemIndex) {
|
|
newArr.push(fn(item, itemIndex, arr));
|
|
});
|
|
return newArr;
|
|
};
|
|
|
|
},{"4":4}],28:[function(require,module,exports){
|
|
var foreach = require(4);
|
|
|
|
module.exports = function merge(destination/* , sources */) {
|
|
var sources = Array.prototype.slice.call(arguments);
|
|
|
|
foreach(sources, function(source) {
|
|
for (var keyName in source) {
|
|
if (source.hasOwnProperty(keyName)) {
|
|
if (typeof destination[keyName] === 'object' && typeof source[keyName] === 'object') {
|
|
destination[keyName] = merge({}, destination[keyName], source[keyName]);
|
|
} else if (source[keyName] !== undefined) {
|
|
destination[keyName] = source[keyName];
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
return destination;
|
|
};
|
|
|
|
},{"4":4}],29:[function(require,module,exports){
|
|
module.exports = function omit(obj, test) {
|
|
var keys = require(9);
|
|
var foreach = require(4);
|
|
|
|
var filtered = {};
|
|
|
|
foreach(keys(obj), function doFilter(keyName) {
|
|
if (test(keyName) !== true) {
|
|
filtered[keyName] = obj[keyName];
|
|
}
|
|
});
|
|
|
|
return filtered;
|
|
};
|
|
|
|
},{"4":4,"9":9}],30:[function(require,module,exports){
|
|
module.exports = createPlacesClient;
|
|
|
|
var qs3 = require(14);
|
|
var buildSearchMethod = require(21);
|
|
|
|
function createPlacesClient(algoliasearch) {
|
|
return function places(appID, apiKey, opts) {
|
|
var cloneDeep = require(22);
|
|
|
|
opts = opts && cloneDeep(opts) || {};
|
|
opts.hosts = opts.hosts || [
|
|
'places-dsn.algolia.net',
|
|
'places-1.algolianet.com',
|
|
'places-2.algolianet.com',
|
|
'places-3.algolianet.com'
|
|
];
|
|
|
|
// allow initPlaces() no arguments => community rate limited
|
|
if (arguments.length === 0 || typeof appID === 'object' || appID === undefined) {
|
|
appID = '';
|
|
apiKey = '';
|
|
opts._allowEmptyCredentials = true;
|
|
}
|
|
|
|
var client = algoliasearch(appID, apiKey, opts);
|
|
var index = client.initIndex('places');
|
|
index.search = buildSearchMethod('query', '/1/places/query');
|
|
index.reverse = function(options, callback) {
|
|
var encoded = qs3.encode(options);
|
|
|
|
return this.as._jsonRequest({
|
|
method: 'GET',
|
|
url: '/1/places/reverse?' + encoded,
|
|
hostType: 'read',
|
|
callback: callback
|
|
});
|
|
};
|
|
|
|
index.getObject = function(objectID, callback) {
|
|
return this.as._jsonRequest({
|
|
method: 'GET',
|
|
url: '/1/places/' + encodeURIComponent(objectID),
|
|
hostType: 'read',
|
|
callback: callback
|
|
});
|
|
};
|
|
return index;
|
|
};
|
|
}
|
|
|
|
},{"14":14,"21":21,"22":22}],31:[function(require,module,exports){
|
|
(function (global){
|
|
var debug = require(1)('algoliasearch:src/hostIndexState.js');
|
|
var localStorageNamespace = 'algoliasearch-client-js';
|
|
|
|
var store;
|
|
var moduleStore = {
|
|
state: {},
|
|
set: function(key, data) {
|
|
this.state[key] = data;
|
|
return this.state[key];
|
|
},
|
|
get: function(key) {
|
|
return this.state[key] || null;
|
|
}
|
|
};
|
|
|
|
var localStorageStore = {
|
|
set: function(key, data) {
|
|
moduleStore.set(key, data); // always replicate localStorageStore to moduleStore in case of failure
|
|
|
|
try {
|
|
var namespace = JSON.parse(global.localStorage[localStorageNamespace]);
|
|
namespace[key] = data;
|
|
global.localStorage[localStorageNamespace] = JSON.stringify(namespace);
|
|
return namespace[key];
|
|
} catch (e) {
|
|
return localStorageFailure(key, e);
|
|
}
|
|
},
|
|
get: function(key) {
|
|
try {
|
|
return JSON.parse(global.localStorage[localStorageNamespace])[key] || null;
|
|
} catch (e) {
|
|
return localStorageFailure(key, e);
|
|
}
|
|
}
|
|
};
|
|
|
|
function localStorageFailure(key, e) {
|
|
debug('localStorage failed with', e);
|
|
cleanup();
|
|
store = moduleStore;
|
|
return store.get(key);
|
|
}
|
|
|
|
store = supportsLocalStorage() ? localStorageStore : moduleStore;
|
|
|
|
module.exports = {
|
|
get: getOrSet,
|
|
set: getOrSet,
|
|
supportsLocalStorage: supportsLocalStorage
|
|
};
|
|
|
|
function getOrSet(key, data) {
|
|
if (arguments.length === 1) {
|
|
return store.get(key);
|
|
}
|
|
|
|
return store.set(key, data);
|
|
}
|
|
|
|
function supportsLocalStorage() {
|
|
try {
|
|
if ('localStorage' in global &&
|
|
global.localStorage !== null) {
|
|
if (!global.localStorage[localStorageNamespace]) {
|
|
// actual creation of the namespace
|
|
global.localStorage.setItem(localStorageNamespace, JSON.stringify({}));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// In case of any error on localStorage, we clean our own namespace, this should handle
|
|
// quota errors when a lot of keys + data are used
|
|
function cleanup() {
|
|
try {
|
|
global.localStorage.removeItem(localStorageNamespace);
|
|
} catch (_) {
|
|
// nothing to do
|
|
}
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"1":1}],32:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = '3.35.1';
|
|
|
|
},{}]},{},[17])(17)
|
|
}); |