16297 lines
477 KiB
JavaScript
16297 lines
477 KiB
JavaScript
/*! elasticsearch-js - v0.0.1 - 2013-11-11
|
|
* https://github.com/elasticsearch/elasticsearch-js
|
|
* Copyright (c) 2013 Spencer Alger; Licensed Apache License */
|
|
// built using browserify
|
|
|
|
!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.elasticsearch=e():"undefined"!=typeof global?global.elasticsearch=e():"undefined"!=typeof self&&(self.elasticsearch=e())}(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);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.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){
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
|
|
|
|
//
|
|
// The shims in this file are not fully implemented shims for the ES5
|
|
// features, but do work for the particular usecases there is in
|
|
// the other modules.
|
|
//
|
|
|
|
var toString = Object.prototype.toString;
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
// Array.isArray is supported in IE9
|
|
function isArray(xs) {
|
|
return toString.call(xs) === '[object Array]';
|
|
}
|
|
exports.isArray = typeof Array.isArray === 'function' ? Array.isArray : isArray;
|
|
|
|
// Array.prototype.indexOf is supported in IE9
|
|
exports.indexOf = function indexOf(xs, x) {
|
|
if (xs.indexOf) return xs.indexOf(x);
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (x === xs[i]) return i;
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
// Array.prototype.filter is supported in IE9
|
|
exports.filter = function filter(xs, fn) {
|
|
if (xs.filter) return xs.filter(fn);
|
|
var res = [];
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (fn(xs[i], i, xs)) res.push(xs[i]);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
// Array.prototype.forEach is supported in IE9
|
|
exports.forEach = function forEach(xs, fn, self) {
|
|
if (xs.forEach) return xs.forEach(fn, self);
|
|
for (var i = 0; i < xs.length; i++) {
|
|
fn.call(self, xs[i], i, xs);
|
|
}
|
|
};
|
|
|
|
// Array.prototype.map is supported in IE9
|
|
exports.map = function map(xs, fn) {
|
|
if (xs.map) return xs.map(fn);
|
|
var out = new Array(xs.length);
|
|
for (var i = 0; i < xs.length; i++) {
|
|
out[i] = fn(xs[i], i, xs);
|
|
}
|
|
return out;
|
|
};
|
|
|
|
// Array.prototype.reduce is supported in IE9
|
|
exports.reduce = function reduce(array, callback, opt_initialValue) {
|
|
if (array.reduce) return array.reduce(callback, opt_initialValue);
|
|
var value, isValueSet = false;
|
|
|
|
if (2 < arguments.length) {
|
|
value = opt_initialValue;
|
|
isValueSet = true;
|
|
}
|
|
for (var i = 0, l = array.length; l > i; ++i) {
|
|
if (array.hasOwnProperty(i)) {
|
|
if (isValueSet) {
|
|
value = callback(value, array[i], i, array);
|
|
}
|
|
else {
|
|
value = array[i];
|
|
isValueSet = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
// String.prototype.substr - negative index don't work in IE8
|
|
if ('ab'.substr(-1) !== 'b') {
|
|
exports.substr = function (str, start, length) {
|
|
// did we get a negative start, calculate how much it is from the beginning of the string
|
|
if (start < 0) start = str.length + start;
|
|
|
|
// call the original function
|
|
return str.substr(start, length);
|
|
};
|
|
} else {
|
|
exports.substr = function (str, start, length) {
|
|
return str.substr(start, length);
|
|
};
|
|
}
|
|
|
|
// String.prototype.trim is supported in IE9
|
|
exports.trim = function (str) {
|
|
if (str.trim) return str.trim();
|
|
return str.replace(/^\s+|\s+$/g, '');
|
|
};
|
|
|
|
// Function.prototype.bind is supported in IE9
|
|
exports.bind = function () {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
var fn = args.shift();
|
|
if (fn.bind) return fn.bind.apply(fn, args);
|
|
var self = args.shift();
|
|
return function () {
|
|
fn.apply(self, args.concat([Array.prototype.slice.call(arguments)]));
|
|
};
|
|
};
|
|
|
|
// Object.create is supported in IE9
|
|
function create(prototype, properties) {
|
|
var object;
|
|
if (prototype === null) {
|
|
object = { '__proto__' : null };
|
|
}
|
|
else {
|
|
if (typeof prototype !== 'object') {
|
|
throw new TypeError(
|
|
'typeof prototype[' + (typeof prototype) + '] != \'object\''
|
|
);
|
|
}
|
|
var Type = function () {};
|
|
Type.prototype = prototype;
|
|
object = new Type();
|
|
object.__proto__ = prototype;
|
|
}
|
|
if (typeof properties !== 'undefined' && Object.defineProperties) {
|
|
Object.defineProperties(object, properties);
|
|
}
|
|
return object;
|
|
}
|
|
exports.create = typeof Object.create === 'function' ? Object.create : create;
|
|
|
|
// Object.keys and Object.getOwnPropertyNames is supported in IE9 however
|
|
// they do show a description and number property on Error objects
|
|
function notObject(object) {
|
|
return ((typeof object != "object" && typeof object != "function") || object === null);
|
|
}
|
|
|
|
function keysShim(object) {
|
|
if (notObject(object)) {
|
|
throw new TypeError("Object.keys called on a non-object");
|
|
}
|
|
|
|
var result = [];
|
|
for (var name in object) {
|
|
if (hasOwnProperty.call(object, name)) {
|
|
result.push(name);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// getOwnPropertyNames is almost the same as Object.keys one key feature
|
|
// is that it returns hidden properties, since that can't be implemented,
|
|
// this feature gets reduced so it just shows the length property on arrays
|
|
function propertyShim(object) {
|
|
if (notObject(object)) {
|
|
throw new TypeError("Object.getOwnPropertyNames called on a non-object");
|
|
}
|
|
|
|
var result = keysShim(object);
|
|
if (exports.isArray(object) && exports.indexOf(object, 'length') === -1) {
|
|
result.push('length');
|
|
}
|
|
return result;
|
|
}
|
|
|
|
var keys = typeof Object.keys === 'function' ? Object.keys : keysShim;
|
|
var getOwnPropertyNames = typeof Object.getOwnPropertyNames === 'function' ?
|
|
Object.getOwnPropertyNames : propertyShim;
|
|
|
|
if (new Error().hasOwnProperty('description')) {
|
|
var ERROR_PROPERTY_FILTER = function (obj, array) {
|
|
if (toString.call(obj) === '[object Error]') {
|
|
array = exports.filter(array, function (name) {
|
|
return name !== 'description' && name !== 'number' && name !== 'message';
|
|
});
|
|
}
|
|
return array;
|
|
};
|
|
|
|
exports.keys = function (object) {
|
|
return ERROR_PROPERTY_FILTER(object, keys(object));
|
|
};
|
|
exports.getOwnPropertyNames = function (object) {
|
|
return ERROR_PROPERTY_FILTER(object, getOwnPropertyNames(object));
|
|
};
|
|
} else {
|
|
exports.keys = keys;
|
|
exports.getOwnPropertyNames = getOwnPropertyNames;
|
|
}
|
|
|
|
// Object.getOwnPropertyDescriptor - supported in IE8 but only on dom elements
|
|
function valueObject(value, key) {
|
|
return { value: value[key] };
|
|
}
|
|
|
|
if (typeof Object.getOwnPropertyDescriptor === 'function') {
|
|
try {
|
|
Object.getOwnPropertyDescriptor({'a': 1}, 'a');
|
|
exports.getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
} catch (e) {
|
|
// IE8 dom element issue - use a try catch and default to valueObject
|
|
exports.getOwnPropertyDescriptor = function (value, key) {
|
|
try {
|
|
return Object.getOwnPropertyDescriptor(value, key);
|
|
} catch (e) {
|
|
return valueObject(value, key);
|
|
}
|
|
};
|
|
}
|
|
} else {
|
|
exports.getOwnPropertyDescriptor = valueObject;
|
|
}
|
|
|
|
},{}],3:[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.
|
|
|
|
// UTILITY
|
|
var util = require('util');
|
|
var shims = require('_shims');
|
|
var pSlice = Array.prototype.slice;
|
|
|
|
// 1. The assert module provides functions that throw
|
|
// AssertionError's when particular conditions are not met. The
|
|
// assert module must conform to the following interface.
|
|
|
|
var assert = module.exports = ok;
|
|
|
|
// 2. The AssertionError is defined in assert.
|
|
// new assert.AssertionError({ message: message,
|
|
// actual: actual,
|
|
// expected: expected })
|
|
|
|
assert.AssertionError = function AssertionError(options) {
|
|
this.name = 'AssertionError';
|
|
this.actual = options.actual;
|
|
this.expected = options.expected;
|
|
this.operator = options.operator;
|
|
this.message = options.message || getMessage(this);
|
|
};
|
|
|
|
// assert.AssertionError instanceof Error
|
|
util.inherits(assert.AssertionError, Error);
|
|
|
|
function replacer(key, value) {
|
|
if (util.isUndefined(value)) {
|
|
return '' + value;
|
|
}
|
|
if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
|
|
return value.toString();
|
|
}
|
|
if (util.isFunction(value) || util.isRegExp(value)) {
|
|
return value.toString();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function truncate(s, n) {
|
|
if (util.isString(s)) {
|
|
return s.length < n ? s : s.slice(0, n);
|
|
} else {
|
|
return s;
|
|
}
|
|
}
|
|
|
|
function getMessage(self) {
|
|
return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
|
|
self.operator + ' ' +
|
|
truncate(JSON.stringify(self.expected, replacer), 128);
|
|
}
|
|
|
|
// At present only the three keys mentioned above are used and
|
|
// understood by the spec. Implementations or sub modules can pass
|
|
// other keys to the AssertionError's constructor - they will be
|
|
// ignored.
|
|
|
|
// 3. All of the following functions must throw an AssertionError
|
|
// when a corresponding condition is not met, with a message that
|
|
// may be undefined if not provided. All assertion methods provide
|
|
// both the actual and expected values to the assertion error for
|
|
// display purposes.
|
|
|
|
function fail(actual, expected, message, operator, stackStartFunction) {
|
|
throw new assert.AssertionError({
|
|
message: message,
|
|
actual: actual,
|
|
expected: expected,
|
|
operator: operator,
|
|
stackStartFunction: stackStartFunction
|
|
});
|
|
}
|
|
|
|
// EXTENSION! allows for well behaved errors defined elsewhere.
|
|
assert.fail = fail;
|
|
|
|
// 4. Pure assertion tests whether a value is truthy, as determined
|
|
// by !!guard.
|
|
// assert.ok(guard, message_opt);
|
|
// This statement is equivalent to assert.equal(true, !!guard,
|
|
// message_opt);. To test strictly for the value true, use
|
|
// assert.strictEqual(true, guard, message_opt);.
|
|
|
|
function ok(value, message) {
|
|
if (!value) fail(value, true, message, '==', assert.ok);
|
|
}
|
|
assert.ok = ok;
|
|
|
|
// 5. The equality assertion tests shallow, coercive equality with
|
|
// ==.
|
|
// assert.equal(actual, expected, message_opt);
|
|
|
|
assert.equal = function equal(actual, expected, message) {
|
|
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
|
|
};
|
|
|
|
// 6. The non-equality assertion tests for whether two objects are not equal
|
|
// with != assert.notEqual(actual, expected, message_opt);
|
|
|
|
assert.notEqual = function notEqual(actual, expected, message) {
|
|
if (actual == expected) {
|
|
fail(actual, expected, message, '!=', assert.notEqual);
|
|
}
|
|
};
|
|
|
|
// 7. The equivalence assertion tests a deep equality relation.
|
|
// assert.deepEqual(actual, expected, message_opt);
|
|
|
|
assert.deepEqual = function deepEqual(actual, expected, message) {
|
|
if (!_deepEqual(actual, expected)) {
|
|
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
|
|
}
|
|
};
|
|
|
|
function _deepEqual(actual, expected) {
|
|
// 7.1. All identical values are equivalent, as determined by ===.
|
|
if (actual === expected) {
|
|
return true;
|
|
|
|
} else if (util.isBuffer(actual) && util.isBuffer(expected)) {
|
|
if (actual.length != expected.length) return false;
|
|
|
|
for (var i = 0; i < actual.length; i++) {
|
|
if (actual[i] !== expected[i]) return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
// 7.2. If the expected value is a Date object, the actual value is
|
|
// equivalent if it is also a Date object that refers to the same time.
|
|
} else if (util.isDate(actual) && util.isDate(expected)) {
|
|
return actual.getTime() === expected.getTime();
|
|
|
|
// 7.3 If the expected value is a RegExp object, the actual value is
|
|
// equivalent if it is also a RegExp object with the same source and
|
|
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
|
|
} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
|
|
return actual.source === expected.source &&
|
|
actual.global === expected.global &&
|
|
actual.multiline === expected.multiline &&
|
|
actual.lastIndex === expected.lastIndex &&
|
|
actual.ignoreCase === expected.ignoreCase;
|
|
|
|
// 7.4. Other pairs that do not both pass typeof value == 'object',
|
|
// equivalence is determined by ==.
|
|
} else if (!util.isObject(actual) && !util.isObject(expected)) {
|
|
return actual == expected;
|
|
|
|
// 7.5 For all other Object pairs, including Array objects, equivalence is
|
|
// determined by having the same number of owned properties (as verified
|
|
// with Object.prototype.hasOwnProperty.call), the same set of keys
|
|
// (although not necessarily the same order), equivalent values for every
|
|
// corresponding key, and an identical 'prototype' property. Note: this
|
|
// accounts for both named and indexed properties on Arrays.
|
|
} else {
|
|
return objEquiv(actual, expected);
|
|
}
|
|
}
|
|
|
|
function isArguments(object) {
|
|
return Object.prototype.toString.call(object) == '[object Arguments]';
|
|
}
|
|
|
|
function objEquiv(a, b) {
|
|
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
|
|
return false;
|
|
// an identical 'prototype' property.
|
|
if (a.prototype !== b.prototype) return false;
|
|
//~~~I've managed to break Object.keys through screwy arguments passing.
|
|
// Converting to array solves the problem.
|
|
if (isArguments(a)) {
|
|
if (!isArguments(b)) {
|
|
return false;
|
|
}
|
|
a = pSlice.call(a);
|
|
b = pSlice.call(b);
|
|
return _deepEqual(a, b);
|
|
}
|
|
try {
|
|
var ka = shims.keys(a),
|
|
kb = shims.keys(b),
|
|
key, i;
|
|
} catch (e) {//happens when one is a string literal and the other isn't
|
|
return false;
|
|
}
|
|
// having the same number of owned properties (keys incorporates
|
|
// hasOwnProperty)
|
|
if (ka.length != kb.length)
|
|
return false;
|
|
//the same set of keys (although not necessarily the same order),
|
|
ka.sort();
|
|
kb.sort();
|
|
//~~~cheap key test
|
|
for (i = ka.length - 1; i >= 0; i--) {
|
|
if (ka[i] != kb[i])
|
|
return false;
|
|
}
|
|
//equivalent values for every corresponding key, and
|
|
//~~~possibly expensive deep test
|
|
for (i = ka.length - 1; i >= 0; i--) {
|
|
key = ka[i];
|
|
if (!_deepEqual(a[key], b[key])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 8. The non-equivalence assertion tests for any deep inequality.
|
|
// assert.notDeepEqual(actual, expected, message_opt);
|
|
|
|
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
|
|
if (_deepEqual(actual, expected)) {
|
|
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
|
|
}
|
|
};
|
|
|
|
// 9. The strict equality assertion tests strict equality, as determined by ===.
|
|
// assert.strictEqual(actual, expected, message_opt);
|
|
|
|
assert.strictEqual = function strictEqual(actual, expected, message) {
|
|
if (actual !== expected) {
|
|
fail(actual, expected, message, '===', assert.strictEqual);
|
|
}
|
|
};
|
|
|
|
// 10. The strict non-equality assertion tests for strict inequality, as
|
|
// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
|
|
|
|
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
|
|
if (actual === expected) {
|
|
fail(actual, expected, message, '!==', assert.notStrictEqual);
|
|
}
|
|
};
|
|
|
|
function expectedException(actual, expected) {
|
|
if (!actual || !expected) {
|
|
return false;
|
|
}
|
|
|
|
if (Object.prototype.toString.call(expected) == '[object RegExp]') {
|
|
return expected.test(actual);
|
|
} else if (actual instanceof expected) {
|
|
return true;
|
|
} else if (expected.call({}, actual) === true) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function _throws(shouldThrow, block, expected, message) {
|
|
var actual;
|
|
|
|
if (util.isString(expected)) {
|
|
message = expected;
|
|
expected = null;
|
|
}
|
|
|
|
try {
|
|
block();
|
|
} catch (e) {
|
|
actual = e;
|
|
}
|
|
|
|
message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
|
|
(message ? ' ' + message : '.');
|
|
|
|
if (shouldThrow && !actual) {
|
|
fail(actual, expected, 'Missing expected exception' + message);
|
|
}
|
|
|
|
if (!shouldThrow && expectedException(actual, expected)) {
|
|
fail(actual, expected, 'Got unwanted exception' + message);
|
|
}
|
|
|
|
if ((shouldThrow && actual && expected &&
|
|
!expectedException(actual, expected)) || (!shouldThrow && actual)) {
|
|
throw actual;
|
|
}
|
|
}
|
|
|
|
// 11. Expected to throw an error:
|
|
// assert.throws(block, Error_opt, message_opt);
|
|
|
|
assert.throws = function(block, /*optional*/error, /*optional*/message) {
|
|
_throws.apply(this, [true].concat(pSlice.call(arguments)));
|
|
};
|
|
|
|
// EXTENSION! This is annoying to write outside this module.
|
|
assert.doesNotThrow = function(block, /*optional*/message) {
|
|
_throws.apply(this, [false].concat(pSlice.call(arguments)));
|
|
};
|
|
|
|
assert.ifError = function(err) { if (err) {throw err;}};
|
|
},{"_shims":2,"util":8}],4:[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.
|
|
|
|
var util = require('util');
|
|
|
|
function EventEmitter() {
|
|
this._events = this._events || {};
|
|
this._maxListeners = this._maxListeners || undefined;
|
|
}
|
|
module.exports = EventEmitter;
|
|
|
|
// Backwards-compat with node 0.10.x
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
|
|
EventEmitter.prototype._events = undefined;
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
|
// added to it. This is a useful default which helps finding memory leaks.
|
|
EventEmitter.defaultMaxListeners = 10;
|
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
|
// that to be increased. Set to zero for unlimited.
|
|
EventEmitter.prototype.setMaxListeners = function(n) {
|
|
if (!util.isNumber(n) || n < 0)
|
|
throw TypeError('n must be a positive number');
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.emit = function(type) {
|
|
var er, handler, len, args, i, listeners;
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// If there is no 'error' event listener then throw.
|
|
if (type === 'error') {
|
|
if (!this._events.error ||
|
|
(util.isObject(this._events.error) && !this._events.error.length)) {
|
|
er = arguments[1];
|
|
if (er instanceof Error) {
|
|
throw er; // Unhandled 'error' event
|
|
} else {
|
|
throw TypeError('Uncaught, unspecified "error" event.');
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
handler = this._events[type];
|
|
|
|
if (util.isUndefined(handler))
|
|
return false;
|
|
|
|
if (util.isFunction(handler)) {
|
|
switch (arguments.length) {
|
|
// fast cases
|
|
case 1:
|
|
handler.call(this);
|
|
break;
|
|
case 2:
|
|
handler.call(this, arguments[1]);
|
|
break;
|
|
case 3:
|
|
handler.call(this, arguments[1], arguments[2]);
|
|
break;
|
|
// slower
|
|
default:
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
handler.apply(this, args);
|
|
}
|
|
} else if (util.isObject(handler)) {
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
|
|
listeners = handler.slice();
|
|
len = listeners.length;
|
|
for (i = 0; i < len; i++)
|
|
listeners[i].apply(this, args);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
EventEmitter.prototype.addListener = function(type, listener) {
|
|
var m;
|
|
|
|
if (!util.isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// To avoid recursion in the case that type === "newListener"! Before
|
|
// adding it to the listeners, first emit "newListener".
|
|
if (this._events.newListener)
|
|
this.emit('newListener', type,
|
|
util.isFunction(listener.listener) ?
|
|
listener.listener : listener);
|
|
|
|
if (!this._events[type])
|
|
// Optimize the case of one listener. Don't need the extra array object.
|
|
this._events[type] = listener;
|
|
else if (util.isObject(this._events[type]))
|
|
// If we've already got an array, just append.
|
|
this._events[type].push(listener);
|
|
else
|
|
// Adding the second element, need to change to array.
|
|
this._events[type] = [this._events[type], listener];
|
|
|
|
// Check for listener leak
|
|
if (util.isObject(this._events[type]) && !this._events[type].warned) {
|
|
var m;
|
|
if (!util.isUndefined(this._maxListeners)) {
|
|
m = this._maxListeners;
|
|
} else {
|
|
m = EventEmitter.defaultMaxListeners;
|
|
}
|
|
|
|
if (m && m > 0 && this._events[type].length > m) {
|
|
this._events[type].warned = true;
|
|
console.error('(node) warning: possible EventEmitter memory ' +
|
|
'leak detected. %d listeners added. ' +
|
|
'Use emitter.setMaxListeners() to increase limit.',
|
|
this._events[type].length);
|
|
console.trace();
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
|
|
EventEmitter.prototype.once = function(type, listener) {
|
|
if (!util.isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
function g() {
|
|
this.removeListener(type, g);
|
|
listener.apply(this, arguments);
|
|
}
|
|
|
|
g.listener = listener;
|
|
this.on(type, g);
|
|
|
|
return this;
|
|
};
|
|
|
|
// emits a 'removeListener' event iff the listener was removed
|
|
EventEmitter.prototype.removeListener = function(type, listener) {
|
|
var list, position, length, i;
|
|
|
|
if (!util.isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events || !this._events[type])
|
|
return this;
|
|
|
|
list = this._events[type];
|
|
length = list.length;
|
|
position = -1;
|
|
|
|
if (list === listener ||
|
|
(util.isFunction(list.listener) && list.listener === listener)) {
|
|
delete this._events[type];
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
|
|
} else if (util.isObject(list)) {
|
|
for (i = length; i-- > 0;) {
|
|
if (list[i] === listener ||
|
|
(list[i].listener && list[i].listener === listener)) {
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (position < 0)
|
|
return this;
|
|
|
|
if (list.length === 1) {
|
|
list.length = 0;
|
|
delete this._events[type];
|
|
} else {
|
|
list.splice(position, 1);
|
|
}
|
|
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) {
|
|
var key, listeners;
|
|
|
|
if (!this._events)
|
|
return this;
|
|
|
|
// not listening for removeListener, no need to emit
|
|
if (!this._events.removeListener) {
|
|
if (arguments.length === 0)
|
|
this._events = {};
|
|
else if (this._events[type])
|
|
delete this._events[type];
|
|
return this;
|
|
}
|
|
|
|
// emit removeListener for all listeners on all events
|
|
if (arguments.length === 0) {
|
|
for (key in this._events) {
|
|
if (key === 'removeListener') continue;
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners('removeListener');
|
|
this._events = {};
|
|
return this;
|
|
}
|
|
|
|
listeners = this._events[type];
|
|
|
|
if (util.isFunction(listeners)) {
|
|
this.removeListener(type, listeners);
|
|
} else {
|
|
// LIFO order
|
|
while (listeners.length)
|
|
this.removeListener(type, listeners[listeners.length - 1]);
|
|
}
|
|
delete this._events[type];
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.listeners = function(type) {
|
|
var ret;
|
|
if (!this._events || !this._events[type])
|
|
ret = [];
|
|
else if (util.isFunction(this._events[type]))
|
|
ret = [this._events[type]];
|
|
else
|
|
ret = this._events[type].slice();
|
|
return ret;
|
|
};
|
|
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
var ret;
|
|
if (!emitter._events || !emitter._events[type])
|
|
ret = 0;
|
|
else if (util.isFunction(emitter._events[type]))
|
|
ret = 1;
|
|
else
|
|
ret = emitter._events[type].length;
|
|
return ret;
|
|
};
|
|
},{"util":8}],5:[function(require,module,exports){
|
|
var process=require("__browserify_process");// 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.
|
|
|
|
var util = require('util');
|
|
var shims = require('_shims');
|
|
|
|
// resolves . and .. elements in a path array with directory names there
|
|
// must be no slashes, empty elements, or device names (c:\) in the array
|
|
// (so also no leading and trailing slashes - it does not distinguish
|
|
// relative and absolute paths)
|
|
function normalizeArray(parts, allowAboveRoot) {
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
|
var last = parts[i];
|
|
if (last === '.') {
|
|
parts.splice(i, 1);
|
|
} else if (last === '..') {
|
|
parts.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
parts.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (allowAboveRoot) {
|
|
for (; up--; up) {
|
|
parts.unshift('..');
|
|
}
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
// Split a filename into [root, dir, basename, ext], unix version
|
|
// 'root' is just a slash, or nothing.
|
|
var splitPathRe =
|
|
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
|
var splitPath = function(filename) {
|
|
return splitPathRe.exec(filename).slice(1);
|
|
};
|
|
|
|
// path.resolve([from ...], to)
|
|
// posix version
|
|
exports.resolve = function() {
|
|
var resolvedPath = '',
|
|
resolvedAbsolute = false;
|
|
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
var path = (i >= 0) ? arguments[i] : process.cwd();
|
|
|
|
// Skip empty and invalid entries
|
|
if (!util.isString(path)) {
|
|
throw new TypeError('Arguments to path.resolve must be strings');
|
|
} else if (!path) {
|
|
continue;
|
|
}
|
|
|
|
resolvedPath = path + '/' + resolvedPath;
|
|
resolvedAbsolute = path.charAt(0) === '/';
|
|
}
|
|
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
|
|
// Normalize the path
|
|
resolvedPath = normalizeArray(shims.filter(resolvedPath.split('/'), function(p) {
|
|
return !!p;
|
|
}), !resolvedAbsolute).join('/');
|
|
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
|
};
|
|
|
|
// path.normalize(path)
|
|
// posix version
|
|
exports.normalize = function(path) {
|
|
var isAbsolute = exports.isAbsolute(path),
|
|
trailingSlash = shims.substr(path, -1) === '/';
|
|
|
|
// Normalize the path
|
|
path = normalizeArray(shims.filter(path.split('/'), function(p) {
|
|
return !!p;
|
|
}), !isAbsolute).join('/');
|
|
|
|
if (!path && !isAbsolute) {
|
|
path = '.';
|
|
}
|
|
if (path && trailingSlash) {
|
|
path += '/';
|
|
}
|
|
|
|
return (isAbsolute ? '/' : '') + path;
|
|
};
|
|
|
|
// posix version
|
|
exports.isAbsolute = function(path) {
|
|
return path.charAt(0) === '/';
|
|
};
|
|
|
|
// posix version
|
|
exports.join = function() {
|
|
var paths = Array.prototype.slice.call(arguments, 0);
|
|
return exports.normalize(shims.filter(paths, function(p, index) {
|
|
if (!util.isString(p)) {
|
|
throw new TypeError('Arguments to path.join must be strings');
|
|
}
|
|
return p;
|
|
}).join('/'));
|
|
};
|
|
|
|
|
|
// path.relative(from, to)
|
|
// posix version
|
|
exports.relative = function(from, to) {
|
|
from = exports.resolve(from).substr(1);
|
|
to = exports.resolve(to).substr(1);
|
|
|
|
function trim(arr) {
|
|
var start = 0;
|
|
for (; start < arr.length; start++) {
|
|
if (arr[start] !== '') break;
|
|
}
|
|
|
|
var end = arr.length - 1;
|
|
for (; end >= 0; end--) {
|
|
if (arr[end] !== '') break;
|
|
}
|
|
|
|
if (start > end) return [];
|
|
return arr.slice(start, end - start + 1);
|
|
}
|
|
|
|
var fromParts = trim(from.split('/'));
|
|
var toParts = trim(to.split('/'));
|
|
|
|
var length = Math.min(fromParts.length, toParts.length);
|
|
var samePartsLength = length;
|
|
for (var i = 0; i < length; i++) {
|
|
if (fromParts[i] !== toParts[i]) {
|
|
samePartsLength = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var outputParts = [];
|
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
|
outputParts.push('..');
|
|
}
|
|
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
|
|
return outputParts.join('/');
|
|
};
|
|
|
|
exports.sep = '/';
|
|
exports.delimiter = ':';
|
|
|
|
exports.dirname = function(path) {
|
|
var result = splitPath(path),
|
|
root = result[0],
|
|
dir = result[1];
|
|
|
|
if (!root && !dir) {
|
|
// No dirname whatsoever
|
|
return '.';
|
|
}
|
|
|
|
if (dir) {
|
|
// It has a dirname, strip trailing slash
|
|
dir = dir.substr(0, dir.length - 1);
|
|
}
|
|
|
|
return root + dir;
|
|
};
|
|
|
|
|
|
exports.basename = function(path, ext) {
|
|
var f = splitPath(path)[2];
|
|
// TODO: make this comparison case-insensitive on windows?
|
|
if (ext && f.substr(-1 * ext.length) === ext) {
|
|
f = f.substr(0, f.length - ext.length);
|
|
}
|
|
return f;
|
|
};
|
|
|
|
|
|
exports.extname = function(path) {
|
|
return splitPath(path)[3];
|
|
};
|
|
|
|
},{"__browserify_process":12,"_shims":2,"util":8}],6:[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.
|
|
|
|
// Query String Utilities
|
|
|
|
var QueryString = exports;
|
|
var util = require('util');
|
|
var shims = require('_shims');
|
|
var Buffer = require('buffer').Buffer;
|
|
|
|
// 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);
|
|
}
|
|
|
|
|
|
function charCode(c) {
|
|
return c.charCodeAt(0);
|
|
}
|
|
|
|
|
|
// a safe fast alternative to decodeURIComponent
|
|
QueryString.unescapeBuffer = function(s, decodeSpaces) {
|
|
var out = new Buffer(s.length);
|
|
var state = 'CHAR'; // states: CHAR, HEX0, HEX1
|
|
var n, m, hexchar;
|
|
|
|
for (var inIndex = 0, outIndex = 0; inIndex <= s.length; inIndex++) {
|
|
var c = s.charCodeAt(inIndex);
|
|
switch (state) {
|
|
case 'CHAR':
|
|
switch (c) {
|
|
case charCode('%'):
|
|
n = 0;
|
|
m = 0;
|
|
state = 'HEX0';
|
|
break;
|
|
case charCode('+'):
|
|
if (decodeSpaces) c = charCode(' ');
|
|
// pass thru
|
|
default:
|
|
out[outIndex++] = c;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 'HEX0':
|
|
state = 'HEX1';
|
|
hexchar = c;
|
|
if (charCode('0') <= c && c <= charCode('9')) {
|
|
n = c - charCode('0');
|
|
} else if (charCode('a') <= c && c <= charCode('f')) {
|
|
n = c - charCode('a') + 10;
|
|
} else if (charCode('A') <= c && c <= charCode('F')) {
|
|
n = c - charCode('A') + 10;
|
|
} else {
|
|
out[outIndex++] = charCode('%');
|
|
out[outIndex++] = c;
|
|
state = 'CHAR';
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 'HEX1':
|
|
state = 'CHAR';
|
|
if (charCode('0') <= c && c <= charCode('9')) {
|
|
m = c - charCode('0');
|
|
} else if (charCode('a') <= c && c <= charCode('f')) {
|
|
m = c - charCode('a') + 10;
|
|
} else if (charCode('A') <= c && c <= charCode('F')) {
|
|
m = c - charCode('A') + 10;
|
|
} else {
|
|
out[outIndex++] = charCode('%');
|
|
out[outIndex++] = hexchar;
|
|
out[outIndex++] = c;
|
|
break;
|
|
}
|
|
out[outIndex++] = 16 * n + m;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// TODO support returning arbitrary buffers.
|
|
|
|
return out.slice(0, outIndex - 1);
|
|
};
|
|
|
|
|
|
QueryString.unescape = function(s, decodeSpaces) {
|
|
return QueryString.unescapeBuffer(s, decodeSpaces).toString();
|
|
};
|
|
|
|
|
|
QueryString.escape = function(str) {
|
|
return encodeURIComponent(str);
|
|
};
|
|
|
|
var stringifyPrimitive = function(v) {
|
|
if (util.isString(v))
|
|
return v;
|
|
if (util.isBoolean(v))
|
|
return v ? 'true' : 'false';
|
|
if (util.isNumber(v))
|
|
return isFinite(v) ? v : '';
|
|
return '';
|
|
};
|
|
|
|
|
|
QueryString.stringify = QueryString.encode = function(obj, sep, eq, name) {
|
|
sep = sep || '&';
|
|
eq = eq || '=';
|
|
if (util.isNull(obj)) {
|
|
obj = undefined;
|
|
}
|
|
|
|
if (util.isObject(obj)) {
|
|
return shims.map(shims.keys(obj), function(k) {
|
|
var ks = QueryString.escape(stringifyPrimitive(k)) + eq;
|
|
if (util.isArray(obj[k])) {
|
|
return shims.map(obj[k], function(v) {
|
|
return ks + QueryString.escape(stringifyPrimitive(v));
|
|
}).join(sep);
|
|
} else {
|
|
return ks + QueryString.escape(stringifyPrimitive(obj[k]));
|
|
}
|
|
}).join(sep);
|
|
|
|
}
|
|
|
|
if (!name) return '';
|
|
return QueryString.escape(stringifyPrimitive(name)) + eq +
|
|
QueryString.escape(stringifyPrimitive(obj));
|
|
};
|
|
|
|
// Parse a key=val string.
|
|
QueryString.parse = QueryString.decode = function(qs, sep, eq, options) {
|
|
sep = sep || '&';
|
|
eq = eq || '=';
|
|
var obj = {};
|
|
|
|
if (!util.isString(qs) || qs.length === 0) {
|
|
return obj;
|
|
}
|
|
|
|
var regexp = /\+/g;
|
|
qs = qs.split(sep);
|
|
|
|
var maxKeys = 1000;
|
|
if (options && util.isNumber(options.maxKeys)) {
|
|
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 = '';
|
|
}
|
|
|
|
try {
|
|
k = decodeURIComponent(kstr);
|
|
v = decodeURIComponent(vstr);
|
|
} catch (e) {
|
|
k = QueryString.unescape(kstr, true);
|
|
v = QueryString.unescape(vstr, true);
|
|
}
|
|
|
|
if (!hasOwnProperty(obj, k)) {
|
|
obj[k] = v;
|
|
} else if (util.isArray(obj[k])) {
|
|
obj[k].push(v);
|
|
} else {
|
|
obj[k] = [obj[k], v];
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
},{"_shims":2,"buffer":10,"util":8}],7:[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.
|
|
|
|
var punycode = { encode : function (s) { return s } };
|
|
var util = require('util');
|
|
var shims = require('_shims');
|
|
|
|
exports.parse = urlParse;
|
|
exports.resolve = urlResolve;
|
|
exports.resolveObject = urlResolveObject;
|
|
exports.format = urlFormat;
|
|
|
|
exports.Url = Url;
|
|
|
|
function Url() {
|
|
this.protocol = null;
|
|
this.slashes = null;
|
|
this.auth = null;
|
|
this.host = null;
|
|
this.port = null;
|
|
this.hostname = null;
|
|
this.hash = null;
|
|
this.search = null;
|
|
this.query = null;
|
|
this.pathname = null;
|
|
this.path = null;
|
|
this.href = null;
|
|
}
|
|
|
|
// Reference: RFC 3986, RFC 1808, RFC 2396
|
|
|
|
// define these here so at least they only have to be
|
|
// compiled once on the first module load.
|
|
var protocolPattern = /^([a-z0-9.+-]+:)/i,
|
|
portPattern = /:[0-9]*$/,
|
|
|
|
// RFC 2396: characters reserved for delimiting URLs.
|
|
// We actually just auto-escape these.
|
|
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
|
|
|
|
// RFC 2396: characters not allowed for various reasons.
|
|
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
|
|
|
|
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
|
|
autoEscape = ['\''].concat(unwise),
|
|
// Characters that are never ever allowed in a hostname.
|
|
// Note that any invalid chars are also handled, but these
|
|
// are the ones that are *expected* to be seen, so we fast-path
|
|
// them.
|
|
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
|
|
hostEndingChars = ['/', '?', '#'],
|
|
hostnameMaxLen = 255,
|
|
hostnamePartPattern = /^[a-z0-9A-Z_-]{0,63}$/,
|
|
hostnamePartStart = /^([a-z0-9A-Z_-]{0,63})(.*)$/,
|
|
// protocols that can allow "unsafe" and "unwise" chars.
|
|
unsafeProtocol = {
|
|
'javascript': true,
|
|
'javascript:': true
|
|
},
|
|
// protocols that never have a hostname.
|
|
hostlessProtocol = {
|
|
'javascript': true,
|
|
'javascript:': true
|
|
},
|
|
// protocols that always contain a // bit.
|
|
slashedProtocol = {
|
|
'http': true,
|
|
'https': true,
|
|
'ftp': true,
|
|
'gopher': true,
|
|
'file': true,
|
|
'http:': true,
|
|
'https:': true,
|
|
'ftp:': true,
|
|
'gopher:': true,
|
|
'file:': true
|
|
},
|
|
querystring = require('querystring');
|
|
|
|
function urlParse(url, parseQueryString, slashesDenoteHost) {
|
|
if (url && util.isObject(url) && url instanceof Url) return url;
|
|
|
|
var u = new Url;
|
|
u.parse(url, parseQueryString, slashesDenoteHost);
|
|
return u;
|
|
}
|
|
|
|
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
|
|
if (!util.isString(url)) {
|
|
throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
|
|
}
|
|
|
|
var rest = url;
|
|
|
|
// trim before proceeding.
|
|
// This is to support parse stuff like " http://foo.com \n"
|
|
rest = shims.trim(rest);
|
|
|
|
var proto = protocolPattern.exec(rest);
|
|
if (proto) {
|
|
proto = proto[0];
|
|
var lowerProto = proto.toLowerCase();
|
|
this.protocol = lowerProto;
|
|
rest = rest.substr(proto.length);
|
|
}
|
|
|
|
// figure out if it's got a host
|
|
// user@server is *always* interpreted as a hostname, and url
|
|
// resolution will treat //foo/bar as host=foo,path=bar because that's
|
|
// how the browser resolves relative URLs.
|
|
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
|
|
var slashes = rest.substr(0, 2) === '//';
|
|
if (slashes && !(proto && hostlessProtocol[proto])) {
|
|
rest = rest.substr(2);
|
|
this.slashes = true;
|
|
}
|
|
}
|
|
|
|
if (!hostlessProtocol[proto] &&
|
|
(slashes || (proto && !slashedProtocol[proto]))) {
|
|
|
|
// there's a hostname.
|
|
// the first instance of /, ?, ;, or # ends the host.
|
|
//
|
|
// If there is an @ in the hostname, then non-host chars *are* allowed
|
|
// to the left of the last @ sign, unless some host-ending character
|
|
// comes *before* the @-sign.
|
|
// URLs are obnoxious.
|
|
//
|
|
// ex:
|
|
// http://a@b@c/ => user:a@b host:c
|
|
// http://a@b?@c => user:a host:c path:/?@c
|
|
|
|
// v0.12 TODO(isaacs): This is not quite how Chrome does things.
|
|
// Review our test case against browsers more comprehensively.
|
|
|
|
// find the first instance of any hostEndingChars
|
|
var hostEnd = -1;
|
|
for (var i = 0; i < hostEndingChars.length; i++) {
|
|
var hec = rest.indexOf(hostEndingChars[i]);
|
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
|
|
hostEnd = hec;
|
|
}
|
|
|
|
// at this point, either we have an explicit point where the
|
|
// auth portion cannot go past, or the last @ char is the decider.
|
|
var auth, atSign;
|
|
if (hostEnd === -1) {
|
|
// atSign can be anywhere.
|
|
atSign = rest.lastIndexOf('@');
|
|
} else {
|
|
// atSign must be in auth portion.
|
|
// http://a@b/c@d => host:b auth:a path:/c@d
|
|
atSign = rest.lastIndexOf('@', hostEnd);
|
|
}
|
|
|
|
// Now we have a portion which is definitely the auth.
|
|
// Pull that off.
|
|
if (atSign !== -1) {
|
|
auth = rest.slice(0, atSign);
|
|
rest = rest.slice(atSign + 1);
|
|
this.auth = decodeURIComponent(auth);
|
|
}
|
|
|
|
// the host is the remaining to the left of the first non-host char
|
|
hostEnd = -1;
|
|
for (var i = 0; i < nonHostChars.length; i++) {
|
|
var hec = rest.indexOf(nonHostChars[i]);
|
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
|
|
hostEnd = hec;
|
|
}
|
|
// if we still have not hit it, then the entire thing is a host.
|
|
if (hostEnd === -1)
|
|
hostEnd = rest.length;
|
|
|
|
this.host = rest.slice(0, hostEnd);
|
|
rest = rest.slice(hostEnd);
|
|
|
|
// pull out port.
|
|
this.parseHost();
|
|
|
|
// we've indicated that there is a hostname,
|
|
// so even if it's empty, it has to be present.
|
|
this.hostname = this.hostname || '';
|
|
|
|
// if hostname begins with [ and ends with ]
|
|
// assume that it's an IPv6 address.
|
|
var ipv6Hostname = this.hostname[0] === '[' &&
|
|
this.hostname[this.hostname.length - 1] === ']';
|
|
|
|
// validate a little.
|
|
if (!ipv6Hostname) {
|
|
var hostparts = this.hostname.split(/\./);
|
|
for (var i = 0, l = hostparts.length; i < l; i++) {
|
|
var part = hostparts[i];
|
|
if (!part) continue;
|
|
if (!part.match(hostnamePartPattern)) {
|
|
var newpart = '';
|
|
for (var j = 0, k = part.length; j < k; j++) {
|
|
if (part.charCodeAt(j) > 127) {
|
|
// we replace non-ASCII char with a temporary placeholder
|
|
// we need this to make sure size of hostname is not
|
|
// broken by replacing non-ASCII by nothing
|
|
newpart += 'x';
|
|
} else {
|
|
newpart += part[j];
|
|
}
|
|
}
|
|
// we test again with ASCII char only
|
|
if (!newpart.match(hostnamePartPattern)) {
|
|
var validParts = hostparts.slice(0, i);
|
|
var notHost = hostparts.slice(i + 1);
|
|
var bit = part.match(hostnamePartStart);
|
|
if (bit) {
|
|
validParts.push(bit[1]);
|
|
notHost.unshift(bit[2]);
|
|
}
|
|
if (notHost.length) {
|
|
rest = '/' + notHost.join('.') + rest;
|
|
}
|
|
this.hostname = validParts.join('.');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.hostname.length > hostnameMaxLen) {
|
|
this.hostname = '';
|
|
} else {
|
|
// hostnames are always lower case.
|
|
this.hostname = this.hostname.toLowerCase();
|
|
}
|
|
|
|
if (!ipv6Hostname) {
|
|
// IDNA Support: Returns a puny coded representation of "domain".
|
|
// It only converts the part of the domain name that
|
|
// has non ASCII characters. I.e. it dosent matter if
|
|
// you call it with a domain that already is in ASCII.
|
|
var domainArray = this.hostname.split('.');
|
|
var newOut = [];
|
|
for (var i = 0; i < domainArray.length; ++i) {
|
|
var s = domainArray[i];
|
|
newOut.push(s.match(/[^A-Za-z0-9_-]/) ?
|
|
'xn--' + punycode.encode(s) : s);
|
|
}
|
|
this.hostname = newOut.join('.');
|
|
}
|
|
|
|
var p = this.port ? ':' + this.port : '';
|
|
var h = this.hostname || '';
|
|
this.host = h + p;
|
|
this.href += this.host;
|
|
|
|
// strip [ and ] from the hostname
|
|
// the host field still retains them, though
|
|
if (ipv6Hostname) {
|
|
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
|
|
if (rest[0] !== '/') {
|
|
rest = '/' + rest;
|
|
}
|
|
}
|
|
}
|
|
|
|
// now rest is set to the post-host stuff.
|
|
// chop off any delim chars.
|
|
if (!unsafeProtocol[lowerProto]) {
|
|
|
|
// First, make 100% sure that any "autoEscape" chars get
|
|
// escaped, even if encodeURIComponent doesn't think they
|
|
// need to be.
|
|
for (var i = 0, l = autoEscape.length; i < l; i++) {
|
|
var ae = autoEscape[i];
|
|
var esc = encodeURIComponent(ae);
|
|
if (esc === ae) {
|
|
esc = escape(ae);
|
|
}
|
|
rest = rest.split(ae).join(esc);
|
|
}
|
|
}
|
|
|
|
|
|
// chop off from the tail first.
|
|
var hash = rest.indexOf('#');
|
|
if (hash !== -1) {
|
|
// got a fragment string.
|
|
this.hash = rest.substr(hash);
|
|
rest = rest.slice(0, hash);
|
|
}
|
|
var qm = rest.indexOf('?');
|
|
if (qm !== -1) {
|
|
this.search = rest.substr(qm);
|
|
this.query = rest.substr(qm + 1);
|
|
if (parseQueryString) {
|
|
this.query = querystring.parse(this.query);
|
|
}
|
|
rest = rest.slice(0, qm);
|
|
} else if (parseQueryString) {
|
|
// no query string, but parseQueryString still requested
|
|
this.search = '';
|
|
this.query = {};
|
|
}
|
|
if (rest) this.pathname = rest;
|
|
if (slashedProtocol[lowerProto] &&
|
|
this.hostname && !this.pathname) {
|
|
this.pathname = '/';
|
|
}
|
|
|
|
//to support http.request
|
|
if (this.pathname || this.search) {
|
|
var p = this.pathname || '';
|
|
var s = this.search || '';
|
|
this.path = p + s;
|
|
}
|
|
|
|
// finally, reconstruct the href based on what has been validated.
|
|
this.href = this.format();
|
|
return this;
|
|
};
|
|
|
|
// format a parsed object into a url string
|
|
function urlFormat(obj) {
|
|
// ensure it's an object, and not a string url.
|
|
// If it's an obj, this is a no-op.
|
|
// this way, you can call url_format() on strings
|
|
// to clean up potentially wonky urls.
|
|
if (util.isString(obj)) obj = urlParse(obj);
|
|
if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
|
|
return obj.format();
|
|
}
|
|
|
|
Url.prototype.format = function() {
|
|
var auth = this.auth || '';
|
|
if (auth) {
|
|
auth = encodeURIComponent(auth);
|
|
auth = auth.replace(/%3A/i, ':');
|
|
auth += '@';
|
|
}
|
|
|
|
var protocol = this.protocol || '',
|
|
pathname = this.pathname || '',
|
|
hash = this.hash || '',
|
|
host = false,
|
|
query = '';
|
|
|
|
if (this.host) {
|
|
host = auth + this.host;
|
|
} else if (this.hostname) {
|
|
host = auth + (this.hostname.indexOf(':') === -1 ?
|
|
this.hostname :
|
|
'[' + this.hostname + ']');
|
|
if (this.port) {
|
|
host += ':' + this.port;
|
|
}
|
|
}
|
|
|
|
if (this.query &&
|
|
util.isObject(this.query) &&
|
|
shims.keys(this.query).length) {
|
|
query = querystring.stringify(this.query);
|
|
}
|
|
|
|
var search = this.search || (query && ('?' + query)) || '';
|
|
|
|
if (protocol && shims.substr(protocol, -1) !== ':') protocol += ':';
|
|
|
|
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
|
|
// unless they had them to begin with.
|
|
if (this.slashes ||
|
|
(!protocol || slashedProtocol[protocol]) && host !== false) {
|
|
host = '//' + (host || '');
|
|
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
|
|
} else if (!host) {
|
|
host = '';
|
|
}
|
|
|
|
if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
|
|
if (search && search.charAt(0) !== '?') search = '?' + search;
|
|
|
|
pathname = pathname.replace(/[?#]/g, function(match) {
|
|
return encodeURIComponent(match);
|
|
});
|
|
search = search.replace('#', '%23');
|
|
|
|
return protocol + host + pathname + search + hash;
|
|
};
|
|
|
|
function urlResolve(source, relative) {
|
|
return urlParse(source, false, true).resolve(relative);
|
|
}
|
|
|
|
Url.prototype.resolve = function(relative) {
|
|
return this.resolveObject(urlParse(relative, false, true)).format();
|
|
};
|
|
|
|
function urlResolveObject(source, relative) {
|
|
if (!source) return relative;
|
|
return urlParse(source, false, true).resolveObject(relative);
|
|
}
|
|
|
|
Url.prototype.resolveObject = function(relative) {
|
|
if (util.isString(relative)) {
|
|
var rel = new Url();
|
|
rel.parse(relative, false, true);
|
|
relative = rel;
|
|
}
|
|
|
|
var result = new Url();
|
|
shims.forEach(shims.keys(this), function(k) {
|
|
result[k] = this[k];
|
|
}, this);
|
|
|
|
// hash is always overridden, no matter what.
|
|
// even href="" will remove it.
|
|
result.hash = relative.hash;
|
|
|
|
// if the relative url is empty, then there's nothing left to do here.
|
|
if (relative.href === '') {
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
// hrefs like //foo/bar always cut to the protocol.
|
|
if (relative.slashes && !relative.protocol) {
|
|
// take everything except the protocol from relative
|
|
shims.forEach(shims.keys(relative), function(k) {
|
|
if (k !== 'protocol')
|
|
result[k] = relative[k];
|
|
});
|
|
|
|
//urlParse appends trailing / to urls like http://www.example.com
|
|
if (slashedProtocol[result.protocol] &&
|
|
result.hostname && !result.pathname) {
|
|
result.path = result.pathname = '/';
|
|
}
|
|
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
if (relative.protocol && relative.protocol !== result.protocol) {
|
|
// if it's a known url protocol, then changing
|
|
// the protocol does weird things
|
|
// first, if it's not file:, then we MUST have a host,
|
|
// and if there was a path
|
|
// to begin with, then we MUST have a path.
|
|
// if it is file:, then the host is dropped,
|
|
// because that's known to be hostless.
|
|
// anything else is assumed to be absolute.
|
|
if (!slashedProtocol[relative.protocol]) {
|
|
shims.forEach(shims.keys(relative), function(k) {
|
|
result[k] = relative[k];
|
|
});
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
result.protocol = relative.protocol;
|
|
if (!relative.host && !hostlessProtocol[relative.protocol]) {
|
|
var relPath = (relative.pathname || '').split('/');
|
|
while (relPath.length && !(relative.host = relPath.shift()));
|
|
if (!relative.host) relative.host = '';
|
|
if (!relative.hostname) relative.hostname = '';
|
|
if (relPath[0] !== '') relPath.unshift('');
|
|
if (relPath.length < 2) relPath.unshift('');
|
|
result.pathname = relPath.join('/');
|
|
} else {
|
|
result.pathname = relative.pathname;
|
|
}
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
result.host = relative.host || '';
|
|
result.auth = relative.auth;
|
|
result.hostname = relative.hostname || relative.host;
|
|
result.port = relative.port;
|
|
// to support http.request
|
|
if (result.pathname || result.search) {
|
|
var p = result.pathname || '';
|
|
var s = result.search || '';
|
|
result.path = p + s;
|
|
}
|
|
result.slashes = result.slashes || relative.slashes;
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
|
|
isRelAbs = (
|
|
relative.host ||
|
|
relative.pathname && relative.pathname.charAt(0) === '/'
|
|
),
|
|
mustEndAbs = (isRelAbs || isSourceAbs ||
|
|
(result.host && relative.pathname)),
|
|
removeAllDots = mustEndAbs,
|
|
srcPath = result.pathname && result.pathname.split('/') || [],
|
|
relPath = relative.pathname && relative.pathname.split('/') || [],
|
|
psychotic = result.protocol && !slashedProtocol[result.protocol];
|
|
|
|
// if the url is a non-slashed url, then relative
|
|
// links like ../.. should be able
|
|
// to crawl up to the hostname, as well. This is strange.
|
|
// result.protocol has already been set by now.
|
|
// Later on, put the first path part into the host field.
|
|
if (psychotic) {
|
|
result.hostname = '';
|
|
result.port = null;
|
|
if (result.host) {
|
|
if (srcPath[0] === '') srcPath[0] = result.host;
|
|
else srcPath.unshift(result.host);
|
|
}
|
|
result.host = '';
|
|
if (relative.protocol) {
|
|
relative.hostname = null;
|
|
relative.port = null;
|
|
if (relative.host) {
|
|
if (relPath[0] === '') relPath[0] = relative.host;
|
|
else relPath.unshift(relative.host);
|
|
}
|
|
relative.host = null;
|
|
}
|
|
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
|
|
}
|
|
|
|
if (isRelAbs) {
|
|
// it's absolute.
|
|
result.host = (relative.host || relative.host === '') ?
|
|
relative.host : result.host;
|
|
result.hostname = (relative.hostname || relative.hostname === '') ?
|
|
relative.hostname : result.hostname;
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
srcPath = relPath;
|
|
// fall through to the dot-handling below.
|
|
} else if (relPath.length) {
|
|
// it's relative
|
|
// throw away the existing file, and take the new path instead.
|
|
if (!srcPath) srcPath = [];
|
|
srcPath.pop();
|
|
srcPath = srcPath.concat(relPath);
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
} else if (!util.isNullOrUndefined(relative.search)) {
|
|
// just pull out the search.
|
|
// like href='?foo'.
|
|
// Put this after the other two cases because it simplifies the booleans
|
|
if (psychotic) {
|
|
result.hostname = result.host = srcPath.shift();
|
|
//occationaly the auth can get stuck only in host
|
|
//this especialy happens in cases like
|
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
|
var authInHost = result.host && result.host.indexOf('@') > 0 ?
|
|
result.host.split('@') : false;
|
|
if (authInHost) {
|
|
result.auth = authInHost.shift();
|
|
result.host = result.hostname = authInHost.shift();
|
|
}
|
|
}
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
//to support http.request
|
|
if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
|
|
result.path = (result.pathname ? result.pathname : '') +
|
|
(result.search ? result.search : '');
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
if (!srcPath.length) {
|
|
// no path at all. easy.
|
|
// we've already handled the other stuff above.
|
|
result.pathname = null;
|
|
//to support http.request
|
|
if (result.search) {
|
|
result.path = '/' + result.search;
|
|
} else {
|
|
result.path = null;
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
// if a url ENDs in . or .., then it must get a trailing slash.
|
|
// however, if it ends in anything else non-slashy,
|
|
// then it must NOT get a trailing slash.
|
|
var last = srcPath.slice(-1)[0];
|
|
var hasTrailingSlash = (
|
|
(result.host || relative.host) && (last === '.' || last === '..') ||
|
|
last === '');
|
|
|
|
// strip single dots, resolve double dots to parent dir
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = srcPath.length; i >= 0; i--) {
|
|
last = srcPath[i];
|
|
if (last == '.') {
|
|
srcPath.splice(i, 1);
|
|
} else if (last === '..') {
|
|
srcPath.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
srcPath.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (!mustEndAbs && !removeAllDots) {
|
|
for (; up--; up) {
|
|
srcPath.unshift('..');
|
|
}
|
|
}
|
|
|
|
if (mustEndAbs && srcPath[0] !== '' &&
|
|
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
|
|
srcPath.unshift('');
|
|
}
|
|
|
|
if (hasTrailingSlash && (shims.substr(srcPath.join('/'), -1) !== '/')) {
|
|
srcPath.push('');
|
|
}
|
|
|
|
var isAbsolute = srcPath[0] === '' ||
|
|
(srcPath[0] && srcPath[0].charAt(0) === '/');
|
|
|
|
// put the host back
|
|
if (psychotic) {
|
|
result.hostname = result.host = isAbsolute ? '' :
|
|
srcPath.length ? srcPath.shift() : '';
|
|
//occationaly the auth can get stuck only in host
|
|
//this especialy happens in cases like
|
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
|
var authInHost = result.host && result.host.indexOf('@') > 0 ?
|
|
result.host.split('@') : false;
|
|
if (authInHost) {
|
|
result.auth = authInHost.shift();
|
|
result.host = result.hostname = authInHost.shift();
|
|
}
|
|
}
|
|
|
|
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
|
|
|
|
if (mustEndAbs && !isAbsolute) {
|
|
srcPath.unshift('');
|
|
}
|
|
|
|
if (!srcPath.length) {
|
|
result.pathname = null;
|
|
result.path = null;
|
|
} else {
|
|
result.pathname = srcPath.join('/');
|
|
}
|
|
|
|
//to support request.http
|
|
if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
|
|
result.path = (result.pathname ? result.pathname : '') +
|
|
(result.search ? result.search : '');
|
|
}
|
|
result.auth = relative.auth || result.auth;
|
|
result.slashes = result.slashes || relative.slashes;
|
|
result.href = result.format();
|
|
return result;
|
|
};
|
|
|
|
Url.prototype.parseHost = function() {
|
|
var host = this.host;
|
|
var port = portPattern.exec(host);
|
|
if (port) {
|
|
port = port[0];
|
|
if (port !== ':') {
|
|
this.port = port.substr(1);
|
|
}
|
|
host = host.substr(0, host.length - port.length);
|
|
}
|
|
if (host) this.hostname = host;
|
|
};
|
|
},{"_shims":2,"querystring":6,"util":8}],8:[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.
|
|
|
|
var shims = require('_shims');
|
|
|
|
var formatRegExp = /%[sdj%]/g;
|
|
exports.format = function(f) {
|
|
if (!isString(f)) {
|
|
var objects = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
objects.push(inspect(arguments[i]));
|
|
}
|
|
return objects.join(' ');
|
|
}
|
|
|
|
var i = 1;
|
|
var args = arguments;
|
|
var len = args.length;
|
|
var str = String(f).replace(formatRegExp, function(x) {
|
|
if (x === '%%') return '%';
|
|
if (i >= len) return x;
|
|
switch (x) {
|
|
case '%s': return String(args[i++]);
|
|
case '%d': return Number(args[i++]);
|
|
case '%j':
|
|
try {
|
|
return JSON.stringify(args[i++]);
|
|
} catch (_) {
|
|
return '[Circular]';
|
|
}
|
|
default:
|
|
return x;
|
|
}
|
|
});
|
|
for (var x = args[i]; i < len; x = args[++i]) {
|
|
if (isNull(x) || !isObject(x)) {
|
|
str += ' ' + x;
|
|
} else {
|
|
str += ' ' + inspect(x);
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Echos the value of a value. Trys to print the value out
|
|
* in the best way possible given the different types.
|
|
*
|
|
* @param {Object} obj The object to print out.
|
|
* @param {Object} opts Optional options object that alters the output.
|
|
*/
|
|
/* legacy: obj, showHidden, depth, colors*/
|
|
function inspect(obj, opts) {
|
|
// default options
|
|
var ctx = {
|
|
seen: [],
|
|
stylize: stylizeNoColor
|
|
};
|
|
// legacy...
|
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|
if (isBoolean(opts)) {
|
|
// legacy...
|
|
ctx.showHidden = opts;
|
|
} else if (opts) {
|
|
// got an "options" object
|
|
exports._extend(ctx, opts);
|
|
}
|
|
// set default options
|
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|
return formatValue(ctx, obj, ctx.depth);
|
|
}
|
|
exports.inspect = inspect;
|
|
|
|
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|
inspect.colors = {
|
|
'bold' : [1, 22],
|
|
'italic' : [3, 23],
|
|
'underline' : [4, 24],
|
|
'inverse' : [7, 27],
|
|
'white' : [37, 39],
|
|
'grey' : [90, 39],
|
|
'black' : [30, 39],
|
|
'blue' : [34, 39],
|
|
'cyan' : [36, 39],
|
|
'green' : [32, 39],
|
|
'magenta' : [35, 39],
|
|
'red' : [31, 39],
|
|
'yellow' : [33, 39]
|
|
};
|
|
|
|
// Don't use 'blue' not visible on cmd.exe
|
|
inspect.styles = {
|
|
'special': 'cyan',
|
|
'number': 'yellow',
|
|
'boolean': 'yellow',
|
|
'undefined': 'grey',
|
|
'null': 'bold',
|
|
'string': 'green',
|
|
'date': 'magenta',
|
|
// "name": intentionally not styling
|
|
'regexp': 'red'
|
|
};
|
|
|
|
|
|
function stylizeWithColor(str, styleType) {
|
|
var style = inspect.styles[styleType];
|
|
|
|
if (style) {
|
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
|
'\u001b[' + inspect.colors[style][1] + 'm';
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
|
|
|
|
function stylizeNoColor(str, styleType) {
|
|
return str;
|
|
}
|
|
|
|
|
|
function arrayToHash(array) {
|
|
var hash = {};
|
|
|
|
shims.forEach(array, function(val, idx) {
|
|
hash[val] = true;
|
|
});
|
|
|
|
return hash;
|
|
}
|
|
|
|
|
|
function formatValue(ctx, value, recurseTimes) {
|
|
// Provide a hook for user-specified inspect functions.
|
|
// Check that value is an object with an inspect function on it
|
|
if (ctx.customInspect &&
|
|
value &&
|
|
isFunction(value.inspect) &&
|
|
// Filter out the util module, it's inspect function is special
|
|
value.inspect !== exports.inspect &&
|
|
// Also filter out any prototype objects using the circular check.
|
|
!(value.constructor && value.constructor.prototype === value)) {
|
|
var ret = value.inspect(recurseTimes);
|
|
if (!isString(ret)) {
|
|
ret = formatValue(ctx, ret, recurseTimes);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Primitive types cannot have properties
|
|
var primitive = formatPrimitive(ctx, value);
|
|
if (primitive) {
|
|
return primitive;
|
|
}
|
|
|
|
// Look up the keys of the object.
|
|
var keys = shims.keys(value);
|
|
var visibleKeys = arrayToHash(keys);
|
|
|
|
if (ctx.showHidden) {
|
|
keys = shims.getOwnPropertyNames(value);
|
|
}
|
|
|
|
// Some type of object without properties can be shortcutted.
|
|
if (keys.length === 0) {
|
|
if (isFunction(value)) {
|
|
var name = value.name ? ': ' + value.name : '';
|
|
return ctx.stylize('[Function' + name + ']', 'special');
|
|
}
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
}
|
|
if (isDate(value)) {
|
|
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
|
}
|
|
if (isError(value)) {
|
|
return formatError(value);
|
|
}
|
|
}
|
|
|
|
var base = '', array = false, braces = ['{', '}'];
|
|
|
|
// Make Array say that they are Array
|
|
if (isArray(value)) {
|
|
array = true;
|
|
braces = ['[', ']'];
|
|
}
|
|
|
|
// Make functions say that they are functions
|
|
if (isFunction(value)) {
|
|
var n = value.name ? ': ' + value.name : '';
|
|
base = ' [Function' + n + ']';
|
|
}
|
|
|
|
// Make RegExps say that they are RegExps
|
|
if (isRegExp(value)) {
|
|
base = ' ' + RegExp.prototype.toString.call(value);
|
|
}
|
|
|
|
// Make dates with properties first say the date
|
|
if (isDate(value)) {
|
|
base = ' ' + Date.prototype.toUTCString.call(value);
|
|
}
|
|
|
|
// Make error with message first say the error
|
|
if (isError(value)) {
|
|
base = ' ' + formatError(value);
|
|
}
|
|
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
return braces[0] + base + braces[1];
|
|
}
|
|
|
|
if (recurseTimes < 0) {
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
} else {
|
|
return ctx.stylize('[Object]', 'special');
|
|
}
|
|
}
|
|
|
|
ctx.seen.push(value);
|
|
|
|
var output;
|
|
if (array) {
|
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
} else {
|
|
output = keys.map(function(key) {
|
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
});
|
|
}
|
|
|
|
ctx.seen.pop();
|
|
|
|
return reduceToSingleString(output, base, braces);
|
|
}
|
|
|
|
|
|
function formatPrimitive(ctx, value) {
|
|
if (isUndefined(value))
|
|
return ctx.stylize('undefined', 'undefined');
|
|
if (isString(value)) {
|
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
|
.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"') + '\'';
|
|
return ctx.stylize(simple, 'string');
|
|
}
|
|
if (isNumber(value))
|
|
return ctx.stylize('' + value, 'number');
|
|
if (isBoolean(value))
|
|
return ctx.stylize('' + value, 'boolean');
|
|
// For some reason typeof null is "object", so special case here.
|
|
if (isNull(value))
|
|
return ctx.stylize('null', 'null');
|
|
}
|
|
|
|
|
|
function formatError(value) {
|
|
return '[' + Error.prototype.toString.call(value) + ']';
|
|
}
|
|
|
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|
var output = [];
|
|
for (var i = 0, l = value.length; i < l; ++i) {
|
|
if (hasOwnProperty(value, String(i))) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
String(i), true));
|
|
} else {
|
|
output.push('');
|
|
}
|
|
}
|
|
|
|
shims.forEach(keys, function(key) {
|
|
if (!key.match(/^\d+$/)) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
key, true));
|
|
}
|
|
});
|
|
return output;
|
|
}
|
|
|
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
|
var name, str, desc;
|
|
desc = shims.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
|
if (desc.get) {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Getter/Setter]', 'special');
|
|
} else {
|
|
str = ctx.stylize('[Getter]', 'special');
|
|
}
|
|
} else {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Setter]', 'special');
|
|
}
|
|
}
|
|
|
|
if (!hasOwnProperty(visibleKeys, key)) {
|
|
name = '[' + key + ']';
|
|
}
|
|
if (!str) {
|
|
if (shims.indexOf(ctx.seen, desc.value) < 0) {
|
|
if (isNull(recurseTimes)) {
|
|
str = formatValue(ctx, desc.value, null);
|
|
} else {
|
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|
}
|
|
if (str.indexOf('\n') > -1) {
|
|
if (array) {
|
|
str = str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n').substr(2);
|
|
} else {
|
|
str = '\n' + str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n');
|
|
}
|
|
}
|
|
} else {
|
|
str = ctx.stylize('[Circular]', 'special');
|
|
}
|
|
}
|
|
if (isUndefined(name)) {
|
|
if (array && key.match(/^\d+$/)) {
|
|
return str;
|
|
}
|
|
name = JSON.stringify('' + key);
|
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|
name = name.substr(1, name.length - 2);
|
|
name = ctx.stylize(name, 'name');
|
|
} else {
|
|
name = name.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"')
|
|
.replace(/(^"|"$)/g, "'");
|
|
name = ctx.stylize(name, 'string');
|
|
}
|
|
}
|
|
|
|
return name + ': ' + str;
|
|
}
|
|
|
|
|
|
function reduceToSingleString(output, base, braces) {
|
|
var numLinesEst = 0;
|
|
var length = shims.reduce(output, function(prev, cur) {
|
|
numLinesEst++;
|
|
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
|
}, 0);
|
|
|
|
if (length > 60) {
|
|
return braces[0] +
|
|
(base === '' ? '' : base + '\n ') +
|
|
' ' +
|
|
output.join(',\n ') +
|
|
' ' +
|
|
braces[1];
|
|
}
|
|
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
|
}
|
|
|
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|
// because it is fragile and can be easily faked with `Object.create()`.
|
|
function isArray(ar) {
|
|
return shims.isArray(ar);
|
|
}
|
|
exports.isArray = isArray;
|
|
|
|
function isBoolean(arg) {
|
|
return typeof arg === 'boolean';
|
|
}
|
|
exports.isBoolean = isBoolean;
|
|
|
|
function isNull(arg) {
|
|
return arg === null;
|
|
}
|
|
exports.isNull = isNull;
|
|
|
|
function isNullOrUndefined(arg) {
|
|
return arg == null;
|
|
}
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
exports.isNumber = isNumber;
|
|
|
|
function isString(arg) {
|
|
return typeof arg === 'string';
|
|
}
|
|
exports.isString = isString;
|
|
|
|
function isSymbol(arg) {
|
|
return typeof arg === 'symbol';
|
|
}
|
|
exports.isSymbol = isSymbol;
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
exports.isUndefined = isUndefined;
|
|
|
|
function isRegExp(re) {
|
|
return isObject(re) && objectToString(re) === '[object RegExp]';
|
|
}
|
|
exports.isRegExp = isRegExp;
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg;
|
|
}
|
|
exports.isObject = isObject;
|
|
|
|
function isDate(d) {
|
|
return isObject(d) && objectToString(d) === '[object Date]';
|
|
}
|
|
exports.isDate = isDate;
|
|
|
|
function isError(e) {
|
|
return isObject(e) && objectToString(e) === '[object Error]';
|
|
}
|
|
exports.isError = isError;
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
exports.isFunction = isFunction;
|
|
|
|
function isPrimitive(arg) {
|
|
return arg === null ||
|
|
typeof arg === 'boolean' ||
|
|
typeof arg === 'number' ||
|
|
typeof arg === 'string' ||
|
|
typeof arg === 'symbol' || // ES6 symbol
|
|
typeof arg === 'undefined';
|
|
}
|
|
exports.isPrimitive = isPrimitive;
|
|
|
|
function isBuffer(arg) {
|
|
return arg && typeof arg === 'object'
|
|
&& typeof arg.copy === 'function'
|
|
&& typeof arg.fill === 'function'
|
|
&& typeof arg.binarySlice === 'function'
|
|
;
|
|
}
|
|
exports.isBuffer = isBuffer;
|
|
|
|
function objectToString(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
|
|
|
|
function pad(n) {
|
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
}
|
|
|
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
|
'Oct', 'Nov', 'Dec'];
|
|
|
|
// 26 Feb 16:19:34
|
|
function timestamp() {
|
|
var d = new Date();
|
|
var time = [pad(d.getHours()),
|
|
pad(d.getMinutes()),
|
|
pad(d.getSeconds())].join(':');
|
|
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
|
}
|
|
|
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
|
exports.log = function() {
|
|
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
|
};
|
|
|
|
|
|
/**
|
|
* Inherit the prototype methods from one constructor into another.
|
|
*
|
|
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|
* during bootstrapping this function needs to be rewritten using some native
|
|
* functions as prototype setup using normal JavaScript does not work as
|
|
* expected during bootstrapping (see mirror.js in r114903).
|
|
*
|
|
* @param {function} ctor Constructor function which needs to inherit the
|
|
* prototype.
|
|
* @param {function} superCtor Constructor function to inherit prototype from.
|
|
*/
|
|
exports.inherits = function(ctor, superCtor) {
|
|
ctor.super_ = superCtor;
|
|
ctor.prototype = shims.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
};
|
|
|
|
exports._extend = function(origin, add) {
|
|
// Don't do anything if add isn't an object
|
|
if (!add || !isObject(add)) return origin;
|
|
|
|
var keys = shims.keys(add);
|
|
var i = keys.length;
|
|
while (i--) {
|
|
origin[keys[i]] = add[keys[i]];
|
|
}
|
|
return origin;
|
|
};
|
|
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
},{"_shims":2}],9:[function(require,module,exports){
|
|
exports.readIEEE754 = function(buffer, offset, isBE, mLen, nBytes) {
|
|
var e, m,
|
|
eLen = nBytes * 8 - mLen - 1,
|
|
eMax = (1 << eLen) - 1,
|
|
eBias = eMax >> 1,
|
|
nBits = -7,
|
|
i = isBE ? 0 : (nBytes - 1),
|
|
d = isBE ? 1 : -1,
|
|
s = buffer[offset + i];
|
|
|
|
i += d;
|
|
|
|
e = s & ((1 << (-nBits)) - 1);
|
|
s >>= (-nBits);
|
|
nBits += eLen;
|
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
|
|
|
|
m = e & ((1 << (-nBits)) - 1);
|
|
e >>= (-nBits);
|
|
nBits += mLen;
|
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
|
|
|
|
if (e === 0) {
|
|
e = 1 - eBias;
|
|
} else if (e === eMax) {
|
|
return m ? NaN : ((s ? -1 : 1) * Infinity);
|
|
} else {
|
|
m = m + Math.pow(2, mLen);
|
|
e = e - eBias;
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
|
|
};
|
|
|
|
exports.writeIEEE754 = function(buffer, value, offset, isBE, mLen, nBytes) {
|
|
var e, m, c,
|
|
eLen = nBytes * 8 - mLen - 1,
|
|
eMax = (1 << eLen) - 1,
|
|
eBias = eMax >> 1,
|
|
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
|
|
i = isBE ? (nBytes - 1) : 0,
|
|
d = isBE ? -1 : 1,
|
|
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
|
|
|
|
value = Math.abs(value);
|
|
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0;
|
|
e = eMax;
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2);
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--;
|
|
c *= 2;
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c;
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias);
|
|
}
|
|
if (value * c >= 2) {
|
|
e++;
|
|
c /= 2;
|
|
}
|
|
|
|
if (e + eBias >= eMax) {
|
|
m = 0;
|
|
e = eMax;
|
|
} else if (e + eBias >= 1) {
|
|
m = (value * c - 1) * Math.pow(2, mLen);
|
|
e = e + eBias;
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
|
e = 0;
|
|
}
|
|
}
|
|
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
|
|
|
|
e = (e << mLen) | m;
|
|
eLen += mLen;
|
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
|
|
|
|
buffer[offset + i - d] |= s * 128;
|
|
};
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
var assert;
|
|
exports.Buffer = Buffer;
|
|
exports.SlowBuffer = Buffer;
|
|
Buffer.poolSize = 8192;
|
|
exports.INSPECT_MAX_BYTES = 50;
|
|
|
|
function stringtrim(str) {
|
|
if (str.trim) return str.trim();
|
|
return str.replace(/^\s+|\s+$/g, '');
|
|
}
|
|
|
|
function Buffer(subject, encoding, offset) {
|
|
if(!assert) assert= require('assert');
|
|
if (!(this instanceof Buffer)) {
|
|
return new Buffer(subject, encoding, offset);
|
|
}
|
|
this.parent = this;
|
|
this.offset = 0;
|
|
|
|
// Work-around: node's base64 implementation
|
|
// allows for non-padded strings while base64-js
|
|
// does not..
|
|
if (encoding == "base64" && typeof subject == "string") {
|
|
subject = stringtrim(subject);
|
|
while (subject.length % 4 != 0) {
|
|
subject = subject + "=";
|
|
}
|
|
}
|
|
|
|
var type;
|
|
|
|
// Are we slicing?
|
|
if (typeof offset === 'number') {
|
|
this.length = coerce(encoding);
|
|
// slicing works, with limitations (no parent tracking/update)
|
|
// check https://github.com/toots/buffer-browserify/issues/19
|
|
for (var i = 0; i < this.length; i++) {
|
|
this[i] = subject.get(i+offset);
|
|
}
|
|
} else {
|
|
// Find the length
|
|
switch (type = typeof subject) {
|
|
case 'number':
|
|
this.length = coerce(subject);
|
|
break;
|
|
|
|
case 'string':
|
|
this.length = Buffer.byteLength(subject, encoding);
|
|
break;
|
|
|
|
case 'object': // Assume object is an array
|
|
this.length = coerce(subject.length);
|
|
break;
|
|
|
|
default:
|
|
throw new Error('First argument needs to be a number, ' +
|
|
'array or string.');
|
|
}
|
|
|
|
// Treat array-ish objects as a byte array.
|
|
if (isArrayIsh(subject)) {
|
|
for (var i = 0; i < this.length; i++) {
|
|
if (subject instanceof Buffer) {
|
|
this[i] = subject.readUInt8(i);
|
|
}
|
|
else {
|
|
this[i] = subject[i];
|
|
}
|
|
}
|
|
} else if (type == 'string') {
|
|
// We are a string
|
|
this.length = this.write(subject, 0, encoding);
|
|
} else if (type === 'number') {
|
|
for (var i = 0; i < this.length; i++) {
|
|
this[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.get = function get(i) {
|
|
if (i < 0 || i >= this.length) throw new Error('oob');
|
|
return this[i];
|
|
};
|
|
|
|
Buffer.prototype.set = function set(i, v) {
|
|
if (i < 0 || i >= this.length) throw new Error('oob');
|
|
return this[i] = v;
|
|
};
|
|
|
|
Buffer.byteLength = function (str, encoding) {
|
|
switch (encoding || "utf8") {
|
|
case 'hex':
|
|
return str.length / 2;
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8ToBytes(str).length;
|
|
|
|
case 'ascii':
|
|
case 'binary':
|
|
return str.length;
|
|
|
|
case 'base64':
|
|
return base64ToBytes(str).length;
|
|
|
|
default:
|
|
throw new Error('Unknown encoding');
|
|
}
|
|
};
|
|
|
|
Buffer.prototype.utf8Write = function (string, offset, length) {
|
|
var bytes, pos;
|
|
return Buffer._charsWritten = blitBuffer(utf8ToBytes(string), this, offset, length);
|
|
};
|
|
|
|
Buffer.prototype.asciiWrite = function (string, offset, length) {
|
|
var bytes, pos;
|
|
return Buffer._charsWritten = blitBuffer(asciiToBytes(string), this, offset, length);
|
|
};
|
|
|
|
Buffer.prototype.binaryWrite = Buffer.prototype.asciiWrite;
|
|
|
|
Buffer.prototype.base64Write = function (string, offset, length) {
|
|
var bytes, pos;
|
|
return Buffer._charsWritten = blitBuffer(base64ToBytes(string), this, offset, length);
|
|
};
|
|
|
|
Buffer.prototype.base64Slice = function (start, end) {
|
|
var bytes = Array.prototype.slice.apply(this, arguments)
|
|
return require("base64-js").fromByteArray(bytes);
|
|
};
|
|
|
|
Buffer.prototype.utf8Slice = function () {
|
|
var bytes = Array.prototype.slice.apply(this, arguments);
|
|
var res = "";
|
|
var tmp = "";
|
|
var i = 0;
|
|
while (i < bytes.length) {
|
|
if (bytes[i] <= 0x7F) {
|
|
res += decodeUtf8Char(tmp) + String.fromCharCode(bytes[i]);
|
|
tmp = "";
|
|
} else
|
|
tmp += "%" + bytes[i].toString(16);
|
|
|
|
i++;
|
|
}
|
|
|
|
return res + decodeUtf8Char(tmp);
|
|
}
|
|
|
|
Buffer.prototype.asciiSlice = function () {
|
|
var bytes = Array.prototype.slice.apply(this, arguments);
|
|
var ret = "";
|
|
for (var i = 0; i < bytes.length; i++)
|
|
ret += String.fromCharCode(bytes[i]);
|
|
return ret;
|
|
}
|
|
|
|
Buffer.prototype.binarySlice = Buffer.prototype.asciiSlice;
|
|
|
|
Buffer.prototype.inspect = function() {
|
|
var out = [],
|
|
len = this.length;
|
|
for (var i = 0; i < len; i++) {
|
|
out[i] = toHex(this[i]);
|
|
if (i == exports.INSPECT_MAX_BYTES) {
|
|
out[i + 1] = '...';
|
|
break;
|
|
}
|
|
}
|
|
return '<Buffer ' + out.join(' ') + '>';
|
|
};
|
|
|
|
|
|
Buffer.prototype.hexSlice = function(start, end) {
|
|
var len = this.length;
|
|
|
|
if (!start || start < 0) start = 0;
|
|
if (!end || end < 0 || end > len) end = len;
|
|
|
|
var out = '';
|
|
for (var i = start; i < end; i++) {
|
|
out += toHex(this[i]);
|
|
}
|
|
return out;
|
|
};
|
|
|
|
|
|
Buffer.prototype.toString = function(encoding, start, end) {
|
|
encoding = String(encoding || 'utf8').toLowerCase();
|
|
start = +start || 0;
|
|
if (typeof end == 'undefined') end = this.length;
|
|
|
|
// Fastpath empty strings
|
|
if (+end == start) {
|
|
return '';
|
|
}
|
|
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return this.hexSlice(start, end);
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return this.utf8Slice(start, end);
|
|
|
|
case 'ascii':
|
|
return this.asciiSlice(start, end);
|
|
|
|
case 'binary':
|
|
return this.binarySlice(start, end);
|
|
|
|
case 'base64':
|
|
return this.base64Slice(start, end);
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
return this.ucs2Slice(start, end);
|
|
|
|
default:
|
|
throw new Error('Unknown encoding');
|
|
}
|
|
};
|
|
|
|
|
|
Buffer.prototype.hexWrite = function(string, offset, length) {
|
|
offset = +offset || 0;
|
|
var remaining = this.length - offset;
|
|
if (!length) {
|
|
length = remaining;
|
|
} else {
|
|
length = +length;
|
|
if (length > remaining) {
|
|
length = remaining;
|
|
}
|
|
}
|
|
|
|
// must be an even number of digits
|
|
var strLen = string.length;
|
|
if (strLen % 2) {
|
|
throw new Error('Invalid hex string');
|
|
}
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2;
|
|
}
|
|
for (var i = 0; i < length; i++) {
|
|
var byte = parseInt(string.substr(i * 2, 2), 16);
|
|
if (isNaN(byte)) throw new Error('Invalid hex string');
|
|
this[offset + i] = byte;
|
|
}
|
|
Buffer._charsWritten = i * 2;
|
|
return i;
|
|
};
|
|
|
|
|
|
Buffer.prototype.write = function(string, offset, length, encoding) {
|
|
// Support both (string, offset, length, encoding)
|
|
// and the legacy (string, encoding, offset, length)
|
|
if (isFinite(offset)) {
|
|
if (!isFinite(length)) {
|
|
encoding = length;
|
|
length = undefined;
|
|
}
|
|
} else { // legacy
|
|
var swap = encoding;
|
|
encoding = offset;
|
|
offset = length;
|
|
length = swap;
|
|
}
|
|
|
|
offset = +offset || 0;
|
|
var remaining = this.length - offset;
|
|
if (!length) {
|
|
length = remaining;
|
|
} else {
|
|
length = +length;
|
|
if (length > remaining) {
|
|
length = remaining;
|
|
}
|
|
}
|
|
encoding = String(encoding || 'utf8').toLowerCase();
|
|
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return this.hexWrite(string, offset, length);
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return this.utf8Write(string, offset, length);
|
|
|
|
case 'ascii':
|
|
return this.asciiWrite(string, offset, length);
|
|
|
|
case 'binary':
|
|
return this.binaryWrite(string, offset, length);
|
|
|
|
case 'base64':
|
|
return this.base64Write(string, offset, length);
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
return this.ucs2Write(string, offset, length);
|
|
|
|
default:
|
|
throw new Error('Unknown encoding');
|
|
}
|
|
};
|
|
|
|
// slice(start, end)
|
|
function clamp(index, len, defaultValue) {
|
|
if (typeof index !== 'number') return defaultValue;
|
|
index = ~~index; // Coerce to integer.
|
|
if (index >= len) return len;
|
|
if (index >= 0) return index;
|
|
index += len;
|
|
if (index >= 0) return index;
|
|
return 0;
|
|
}
|
|
|
|
Buffer.prototype.slice = function(start, end) {
|
|
var len = this.length;
|
|
start = clamp(start, len, 0);
|
|
end = clamp(end, len, len);
|
|
return new Buffer(this, end - start, +start);
|
|
};
|
|
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
|
Buffer.prototype.copy = function(target, target_start, start, end) {
|
|
var source = this;
|
|
start || (start = 0);
|
|
if (end === undefined || isNaN(end)) {
|
|
end = this.length;
|
|
}
|
|
target_start || (target_start = 0);
|
|
|
|
if (end < start) throw new Error('sourceEnd < sourceStart');
|
|
|
|
// Copy 0 bytes; we're done
|
|
if (end === start) return 0;
|
|
if (target.length == 0 || source.length == 0) return 0;
|
|
|
|
if (target_start < 0 || target_start >= target.length) {
|
|
throw new Error('targetStart out of bounds');
|
|
}
|
|
|
|
if (start < 0 || start >= source.length) {
|
|
throw new Error('sourceStart out of bounds');
|
|
}
|
|
|
|
if (end < 0 || end > source.length) {
|
|
throw new Error('sourceEnd out of bounds');
|
|
}
|
|
|
|
// Are we oob?
|
|
if (end > this.length) {
|
|
end = this.length;
|
|
}
|
|
|
|
if (target.length - target_start < end - start) {
|
|
end = target.length - target_start + start;
|
|
}
|
|
|
|
var temp = [];
|
|
for (var i=start; i<end; i++) {
|
|
assert.ok(typeof this[i] !== 'undefined', "copying undefined buffer bytes!");
|
|
temp.push(this[i]);
|
|
}
|
|
|
|
for (var i=target_start; i<target_start+temp.length; i++) {
|
|
target[i] = temp[i-target_start];
|
|
}
|
|
};
|
|
|
|
// fill(value, start=0, end=buffer.length)
|
|
Buffer.prototype.fill = function fill(value, start, end) {
|
|
value || (value = 0);
|
|
start || (start = 0);
|
|
end || (end = this.length);
|
|
|
|
if (typeof value === 'string') {
|
|
value = value.charCodeAt(0);
|
|
}
|
|
if (!(typeof value === 'number') || isNaN(value)) {
|
|
throw new Error('value is not a number');
|
|
}
|
|
|
|
if (end < start) throw new Error('end < start');
|
|
|
|
// Fill 0 bytes; we're done
|
|
if (end === start) return 0;
|
|
if (this.length == 0) return 0;
|
|
|
|
if (start < 0 || start >= this.length) {
|
|
throw new Error('start out of bounds');
|
|
}
|
|
|
|
if (end < 0 || end > this.length) {
|
|
throw new Error('end out of bounds');
|
|
}
|
|
|
|
for (var i = start; i < end; i++) {
|
|
this[i] = value;
|
|
}
|
|
}
|
|
|
|
// Static methods
|
|
Buffer.isBuffer = function isBuffer(b) {
|
|
return b instanceof Buffer || b instanceof Buffer;
|
|
};
|
|
|
|
Buffer.concat = function (list, totalLength) {
|
|
if (!isArray(list)) {
|
|
throw new Error("Usage: Buffer.concat(list, [totalLength])\n \
|
|
list should be an Array.");
|
|
}
|
|
|
|
if (list.length === 0) {
|
|
return new Buffer(0);
|
|
} else if (list.length === 1) {
|
|
return list[0];
|
|
}
|
|
|
|
if (typeof totalLength !== 'number') {
|
|
totalLength = 0;
|
|
for (var i = 0; i < list.length; i++) {
|
|
var buf = list[i];
|
|
totalLength += buf.length;
|
|
}
|
|
}
|
|
|
|
var buffer = new Buffer(totalLength);
|
|
var pos = 0;
|
|
for (var i = 0; i < list.length; i++) {
|
|
var buf = list[i];
|
|
buf.copy(buffer, pos);
|
|
pos += buf.length;
|
|
}
|
|
return buffer;
|
|
};
|
|
|
|
Buffer.isEncoding = function(encoding) {
|
|
switch ((encoding + '').toLowerCase()) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
case 'raw':
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// helpers
|
|
|
|
function coerce(length) {
|
|
// Coerce length to a number (possibly NaN), round up
|
|
// in case it's fractional (e.g. 123.456) then do a
|
|
// double negate to coerce a NaN to 0. Easy, right?
|
|
length = ~~Math.ceil(+length);
|
|
return length < 0 ? 0 : length;
|
|
}
|
|
|
|
function isArray(subject) {
|
|
return (Array.isArray ||
|
|
function(subject){
|
|
return {}.toString.apply(subject) == '[object Array]'
|
|
})
|
|
(subject)
|
|
}
|
|
|
|
function isArrayIsh(subject) {
|
|
return isArray(subject) || Buffer.isBuffer(subject) ||
|
|
subject && typeof subject === 'object' &&
|
|
typeof subject.length === 'number';
|
|
}
|
|
|
|
function toHex(n) {
|
|
if (n < 16) return '0' + n.toString(16);
|
|
return n.toString(16);
|
|
}
|
|
|
|
function utf8ToBytes(str) {
|
|
var byteArray = [];
|
|
for (var i = 0; i < str.length; i++)
|
|
if (str.charCodeAt(i) <= 0x7F)
|
|
byteArray.push(str.charCodeAt(i));
|
|
else {
|
|
var h = encodeURIComponent(str.charAt(i)).substr(1).split('%');
|
|
for (var j = 0; j < h.length; j++)
|
|
byteArray.push(parseInt(h[j], 16));
|
|
}
|
|
|
|
return byteArray;
|
|
}
|
|
|
|
function asciiToBytes(str) {
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; i++ )
|
|
// Node's code seems to be doing this and not & 0x7F..
|
|
byteArray.push( str.charCodeAt(i) & 0xFF );
|
|
|
|
return byteArray;
|
|
}
|
|
|
|
function base64ToBytes(str) {
|
|
return require("base64-js").toByteArray(str);
|
|
}
|
|
|
|
function blitBuffer(src, dst, offset, length) {
|
|
var pos, i = 0;
|
|
while (i < length) {
|
|
if ((i+offset >= dst.length) || (i >= src.length))
|
|
break;
|
|
|
|
dst[i + offset] = src[i];
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
function decodeUtf8Char(str) {
|
|
try {
|
|
return decodeURIComponent(str);
|
|
} catch (err) {
|
|
return String.fromCharCode(0xFFFD); // UTF 8 invalid char
|
|
}
|
|
}
|
|
|
|
// read/write bit-twiddling
|
|
|
|
Buffer.prototype.readUInt8 = function(offset, noAssert) {
|
|
var buffer = this;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
if (offset >= buffer.length) return;
|
|
|
|
return buffer[offset];
|
|
};
|
|
|
|
function readUInt16(buffer, offset, isBigEndian, noAssert) {
|
|
var val = 0;
|
|
|
|
|
|
if (!noAssert) {
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 1 < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
if (offset >= buffer.length) return 0;
|
|
|
|
if (isBigEndian) {
|
|
val = buffer[offset] << 8;
|
|
if (offset + 1 < buffer.length) {
|
|
val |= buffer[offset + 1];
|
|
}
|
|
} else {
|
|
val = buffer[offset];
|
|
if (offset + 1 < buffer.length) {
|
|
val |= buffer[offset + 1] << 8;
|
|
}
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
Buffer.prototype.readUInt16LE = function(offset, noAssert) {
|
|
return readUInt16(this, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.readUInt16BE = function(offset, noAssert) {
|
|
return readUInt16(this, offset, true, noAssert);
|
|
};
|
|
|
|
function readUInt32(buffer, offset, isBigEndian, noAssert) {
|
|
var val = 0;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 3 < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
if (offset >= buffer.length) return 0;
|
|
|
|
if (isBigEndian) {
|
|
if (offset + 1 < buffer.length)
|
|
val = buffer[offset + 1] << 16;
|
|
if (offset + 2 < buffer.length)
|
|
val |= buffer[offset + 2] << 8;
|
|
if (offset + 3 < buffer.length)
|
|
val |= buffer[offset + 3];
|
|
val = val + (buffer[offset] << 24 >>> 0);
|
|
} else {
|
|
if (offset + 2 < buffer.length)
|
|
val = buffer[offset + 2] << 16;
|
|
if (offset + 1 < buffer.length)
|
|
val |= buffer[offset + 1] << 8;
|
|
val |= buffer[offset];
|
|
if (offset + 3 < buffer.length)
|
|
val = val + (buffer[offset + 3] << 24 >>> 0);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
Buffer.prototype.readUInt32LE = function(offset, noAssert) {
|
|
return readUInt32(this, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.readUInt32BE = function(offset, noAssert) {
|
|
return readUInt32(this, offset, true, noAssert);
|
|
};
|
|
|
|
|
|
/*
|
|
* Signed integer types, yay team! A reminder on how two's complement actually
|
|
* works. The first bit is the signed bit, i.e. tells us whether or not the
|
|
* number should be positive or negative. If the two's complement value is
|
|
* positive, then we're done, as it's equivalent to the unsigned representation.
|
|
*
|
|
* Now if the number is positive, you're pretty much done, you can just leverage
|
|
* the unsigned translations and return those. Unfortunately, negative numbers
|
|
* aren't quite that straightforward.
|
|
*
|
|
* At first glance, one might be inclined to use the traditional formula to
|
|
* translate binary numbers between the positive and negative values in two's
|
|
* complement. (Though it doesn't quite work for the most negative value)
|
|
* Mainly:
|
|
* - invert all the bits
|
|
* - add one to the result
|
|
*
|
|
* Of course, this doesn't quite work in Javascript. Take for example the value
|
|
* of -128. This could be represented in 16 bits (big-endian) as 0xff80. But of
|
|
* course, Javascript will do the following:
|
|
*
|
|
* > ~0xff80
|
|
* -65409
|
|
*
|
|
* Whoh there, Javascript, that's not quite right. But wait, according to
|
|
* Javascript that's perfectly correct. When Javascript ends up seeing the
|
|
* constant 0xff80, it has no notion that it is actually a signed number. It
|
|
* assumes that we've input the unsigned value 0xff80. Thus, when it does the
|
|
* binary negation, it casts it into a signed value, (positive 0xff80). Then
|
|
* when you perform binary negation on that, it turns it into a negative number.
|
|
*
|
|
* Instead, we're going to have to use the following general formula, that works
|
|
* in a rather Javascript friendly way. I'm glad we don't support this kind of
|
|
* weird numbering scheme in the kernel.
|
|
*
|
|
* (BIT-MAX - (unsigned)val + 1) * -1
|
|
*
|
|
* The astute observer, may think that this doesn't make sense for 8-bit numbers
|
|
* (really it isn't necessary for them). However, when you get 16-bit numbers,
|
|
* you do. Let's go back to our prior example and see how this will look:
|
|
*
|
|
* (0xffff - 0xff80 + 1) * -1
|
|
* (0x007f + 1) * -1
|
|
* (0x0080) * -1
|
|
*/
|
|
Buffer.prototype.readInt8 = function(offset, noAssert) {
|
|
var buffer = this;
|
|
var neg;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
if (offset >= buffer.length) return;
|
|
|
|
neg = buffer[offset] & 0x80;
|
|
if (!neg) {
|
|
return (buffer[offset]);
|
|
}
|
|
|
|
return ((0xff - buffer[offset] + 1) * -1);
|
|
};
|
|
|
|
function readInt16(buffer, offset, isBigEndian, noAssert) {
|
|
var neg, val;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 1 < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
val = readUInt16(buffer, offset, isBigEndian, noAssert);
|
|
neg = val & 0x8000;
|
|
if (!neg) {
|
|
return val;
|
|
}
|
|
|
|
return (0xffff - val + 1) * -1;
|
|
}
|
|
|
|
Buffer.prototype.readInt16LE = function(offset, noAssert) {
|
|
return readInt16(this, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.readInt16BE = function(offset, noAssert) {
|
|
return readInt16(this, offset, true, noAssert);
|
|
};
|
|
|
|
function readInt32(buffer, offset, isBigEndian, noAssert) {
|
|
var neg, val;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 3 < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
val = readUInt32(buffer, offset, isBigEndian, noAssert);
|
|
neg = val & 0x80000000;
|
|
if (!neg) {
|
|
return (val);
|
|
}
|
|
|
|
return (0xffffffff - val + 1) * -1;
|
|
}
|
|
|
|
Buffer.prototype.readInt32LE = function(offset, noAssert) {
|
|
return readInt32(this, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.readInt32BE = function(offset, noAssert) {
|
|
return readInt32(this, offset, true, noAssert);
|
|
};
|
|
|
|
function readFloat(buffer, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset + 3 < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
return require('./buffer_ieee754').readIEEE754(buffer, offset, isBigEndian,
|
|
23, 4);
|
|
}
|
|
|
|
Buffer.prototype.readFloatLE = function(offset, noAssert) {
|
|
return readFloat(this, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.readFloatBE = function(offset, noAssert) {
|
|
return readFloat(this, offset, true, noAssert);
|
|
};
|
|
|
|
function readDouble(buffer, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset + 7 < buffer.length,
|
|
'Trying to read beyond buffer length');
|
|
}
|
|
|
|
return require('./buffer_ieee754').readIEEE754(buffer, offset, isBigEndian,
|
|
52, 8);
|
|
}
|
|
|
|
Buffer.prototype.readDoubleLE = function(offset, noAssert) {
|
|
return readDouble(this, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.readDoubleBE = function(offset, noAssert) {
|
|
return readDouble(this, offset, true, noAssert);
|
|
};
|
|
|
|
|
|
/*
|
|
* We have to make sure that the value is a valid integer. This means that it is
|
|
* non-negative. It has no fractional component and that it does not exceed the
|
|
* maximum allowed value.
|
|
*
|
|
* value The number to check for validity
|
|
*
|
|
* max The maximum value
|
|
*/
|
|
function verifuint(value, max) {
|
|
assert.ok(typeof (value) == 'number',
|
|
'cannot write a non-number as a number');
|
|
|
|
assert.ok(value >= 0,
|
|
'specified a negative value for writing an unsigned value');
|
|
|
|
assert.ok(value <= max, 'value is larger than maximum value for type');
|
|
|
|
assert.ok(Math.floor(value) === value, 'value has a fractional component');
|
|
}
|
|
|
|
Buffer.prototype.writeUInt8 = function(value, offset, noAssert) {
|
|
var buffer = this;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset < buffer.length,
|
|
'trying to write beyond buffer length');
|
|
|
|
verifuint(value, 0xff);
|
|
}
|
|
|
|
if (offset < buffer.length) {
|
|
buffer[offset] = value;
|
|
}
|
|
};
|
|
|
|
function writeUInt16(buffer, value, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 1 < buffer.length,
|
|
'trying to write beyond buffer length');
|
|
|
|
verifuint(value, 0xffff);
|
|
}
|
|
|
|
for (var i = 0; i < Math.min(buffer.length - offset, 2); i++) {
|
|
buffer[offset + i] =
|
|
(value & (0xff << (8 * (isBigEndian ? 1 - i : i)))) >>>
|
|
(isBigEndian ? 1 - i : i) * 8;
|
|
}
|
|
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16LE = function(value, offset, noAssert) {
|
|
writeUInt16(this, value, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
|
|
writeUInt16(this, value, offset, true, noAssert);
|
|
};
|
|
|
|
function writeUInt32(buffer, value, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 3 < buffer.length,
|
|
'trying to write beyond buffer length');
|
|
|
|
verifuint(value, 0xffffffff);
|
|
}
|
|
|
|
for (var i = 0; i < Math.min(buffer.length - offset, 4); i++) {
|
|
buffer[offset + i] =
|
|
(value >>> (isBigEndian ? 3 - i : i) * 8) & 0xff;
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
|
|
writeUInt32(this, value, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
|
|
writeUInt32(this, value, offset, true, noAssert);
|
|
};
|
|
|
|
|
|
/*
|
|
* We now move onto our friends in the signed number category. Unlike unsigned
|
|
* numbers, we're going to have to worry a bit more about how we put values into
|
|
* arrays. Since we are only worrying about signed 32-bit values, we're in
|
|
* slightly better shape. Unfortunately, we really can't do our favorite binary
|
|
* & in this system. It really seems to do the wrong thing. For example:
|
|
*
|
|
* > -32 & 0xff
|
|
* 224
|
|
*
|
|
* What's happening above is really: 0xe0 & 0xff = 0xe0. However, the results of
|
|
* this aren't treated as a signed number. Ultimately a bad thing.
|
|
*
|
|
* What we're going to want to do is basically create the unsigned equivalent of
|
|
* our representation and pass that off to the wuint* functions. To do that
|
|
* we're going to do the following:
|
|
*
|
|
* - if the value is positive
|
|
* we can pass it directly off to the equivalent wuint
|
|
* - if the value is negative
|
|
* we do the following computation:
|
|
* mb + val + 1, where
|
|
* mb is the maximum unsigned value in that byte size
|
|
* val is the Javascript negative integer
|
|
*
|
|
*
|
|
* As a concrete value, take -128. In signed 16 bits this would be 0xff80. If
|
|
* you do out the computations:
|
|
*
|
|
* 0xffff - 128 + 1
|
|
* 0xffff - 127
|
|
* 0xff80
|
|
*
|
|
* You can then encode this value as the signed version. This is really rather
|
|
* hacky, but it should work and get the job done which is our goal here.
|
|
*/
|
|
|
|
/*
|
|
* A series of checks to make sure we actually have a signed 32-bit number
|
|
*/
|
|
function verifsint(value, max, min) {
|
|
assert.ok(typeof (value) == 'number',
|
|
'cannot write a non-number as a number');
|
|
|
|
assert.ok(value <= max, 'value larger than maximum allowed value');
|
|
|
|
assert.ok(value >= min, 'value smaller than minimum allowed value');
|
|
|
|
assert.ok(Math.floor(value) === value, 'value has a fractional component');
|
|
}
|
|
|
|
function verifIEEE754(value, max, min) {
|
|
assert.ok(typeof (value) == 'number',
|
|
'cannot write a non-number as a number');
|
|
|
|
assert.ok(value <= max, 'value larger than maximum allowed value');
|
|
|
|
assert.ok(value >= min, 'value smaller than minimum allowed value');
|
|
}
|
|
|
|
Buffer.prototype.writeInt8 = function(value, offset, noAssert) {
|
|
var buffer = this;
|
|
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset < buffer.length,
|
|
'Trying to write beyond buffer length');
|
|
|
|
verifsint(value, 0x7f, -0x80);
|
|
}
|
|
|
|
if (value >= 0) {
|
|
buffer.writeUInt8(value, offset, noAssert);
|
|
} else {
|
|
buffer.writeUInt8(0xff + value + 1, offset, noAssert);
|
|
}
|
|
};
|
|
|
|
function writeInt16(buffer, value, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 1 < buffer.length,
|
|
'Trying to write beyond buffer length');
|
|
|
|
verifsint(value, 0x7fff, -0x8000);
|
|
}
|
|
|
|
if (value >= 0) {
|
|
writeUInt16(buffer, value, offset, isBigEndian, noAssert);
|
|
} else {
|
|
writeUInt16(buffer, 0xffff + value + 1, offset, isBigEndian, noAssert);
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeInt16LE = function(value, offset, noAssert) {
|
|
writeInt16(this, value, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.writeInt16BE = function(value, offset, noAssert) {
|
|
writeInt16(this, value, offset, true, noAssert);
|
|
};
|
|
|
|
function writeInt32(buffer, value, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 3 < buffer.length,
|
|
'Trying to write beyond buffer length');
|
|
|
|
verifsint(value, 0x7fffffff, -0x80000000);
|
|
}
|
|
|
|
if (value >= 0) {
|
|
writeUInt32(buffer, value, offset, isBigEndian, noAssert);
|
|
} else {
|
|
writeUInt32(buffer, 0xffffffff + value + 1, offset, isBigEndian, noAssert);
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeInt32LE = function(value, offset, noAssert) {
|
|
writeInt32(this, value, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.writeInt32BE = function(value, offset, noAssert) {
|
|
writeInt32(this, value, offset, true, noAssert);
|
|
};
|
|
|
|
function writeFloat(buffer, value, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 3 < buffer.length,
|
|
'Trying to write beyond buffer length');
|
|
|
|
verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38);
|
|
}
|
|
|
|
require('./buffer_ieee754').writeIEEE754(buffer, value, offset, isBigEndian,
|
|
23, 4);
|
|
}
|
|
|
|
Buffer.prototype.writeFloatLE = function(value, offset, noAssert) {
|
|
writeFloat(this, value, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.writeFloatBE = function(value, offset, noAssert) {
|
|
writeFloat(this, value, offset, true, noAssert);
|
|
};
|
|
|
|
function writeDouble(buffer, value, offset, isBigEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert.ok(value !== undefined && value !== null,
|
|
'missing value');
|
|
|
|
assert.ok(typeof (isBigEndian) === 'boolean',
|
|
'missing or invalid endian');
|
|
|
|
assert.ok(offset !== undefined && offset !== null,
|
|
'missing offset');
|
|
|
|
assert.ok(offset + 7 < buffer.length,
|
|
'Trying to write beyond buffer length');
|
|
|
|
verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308);
|
|
}
|
|
|
|
require('./buffer_ieee754').writeIEEE754(buffer, value, offset, isBigEndian,
|
|
52, 8);
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleLE = function(value, offset, noAssert) {
|
|
writeDouble(this, value, offset, false, noAssert);
|
|
};
|
|
|
|
Buffer.prototype.writeDoubleBE = function(value, offset, noAssert) {
|
|
writeDouble(this, value, offset, true, noAssert);
|
|
};
|
|
|
|
},{"./buffer_ieee754":9,"assert":3,"base64-js":11}],11:[function(require,module,exports){
|
|
(function (exports) {
|
|
'use strict';
|
|
|
|
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
|
|
function b64ToByteArray(b64) {
|
|
var i, j, l, tmp, placeHolders, arr;
|
|
|
|
if (b64.length % 4 > 0) {
|
|
throw 'Invalid string. Length must be a multiple of 4';
|
|
}
|
|
|
|
// the number of equal signs (place holders)
|
|
// if there are two placeholders, than the two characters before it
|
|
// represent one byte
|
|
// if there is only one, then the three characters before it represent 2 bytes
|
|
// this is just a cheap hack to not do indexOf twice
|
|
placeHolders = b64.indexOf('=');
|
|
placeHolders = placeHolders > 0 ? b64.length - placeHolders : 0;
|
|
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
arr = [];//new Uint8Array(b64.length * 3 / 4 - placeHolders);
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
l = placeHolders > 0 ? b64.length - 4 : b64.length;
|
|
|
|
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
|
tmp = (lookup.indexOf(b64[i]) << 18) | (lookup.indexOf(b64[i + 1]) << 12) | (lookup.indexOf(b64[i + 2]) << 6) | lookup.indexOf(b64[i + 3]);
|
|
arr.push((tmp & 0xFF0000) >> 16);
|
|
arr.push((tmp & 0xFF00) >> 8);
|
|
arr.push(tmp & 0xFF);
|
|
}
|
|
|
|
if (placeHolders === 2) {
|
|
tmp = (lookup.indexOf(b64[i]) << 2) | (lookup.indexOf(b64[i + 1]) >> 4);
|
|
arr.push(tmp & 0xFF);
|
|
} else if (placeHolders === 1) {
|
|
tmp = (lookup.indexOf(b64[i]) << 10) | (lookup.indexOf(b64[i + 1]) << 4) | (lookup.indexOf(b64[i + 2]) >> 2);
|
|
arr.push((tmp >> 8) & 0xFF);
|
|
arr.push(tmp & 0xFF);
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
|
|
function uint8ToBase64(uint8) {
|
|
var i,
|
|
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
|
|
output = "",
|
|
temp, length;
|
|
|
|
function tripletToBase64 (num) {
|
|
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
|
|
};
|
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
|
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
|
|
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
|
|
output += tripletToBase64(temp);
|
|
}
|
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
|
switch (extraBytes) {
|
|
case 1:
|
|
temp = uint8[uint8.length - 1];
|
|
output += lookup[temp >> 2];
|
|
output += lookup[(temp << 4) & 0x3F];
|
|
output += '==';
|
|
break;
|
|
case 2:
|
|
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]);
|
|
output += lookup[temp >> 10];
|
|
output += lookup[(temp >> 4) & 0x3F];
|
|
output += lookup[(temp << 2) & 0x3F];
|
|
output += '=';
|
|
break;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
module.exports.toByteArray = b64ToByteArray;
|
|
module.exports.fromByteArray = uint8ToBase64;
|
|
}());
|
|
|
|
},{}],12:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
|
|
var process = module.exports = {};
|
|
|
|
process.nextTick = (function () {
|
|
var canSetImmediate = typeof window !== 'undefined'
|
|
&& window.setImmediate;
|
|
var canPost = typeof window !== 'undefined'
|
|
&& window.postMessage && window.addEventListener
|
|
;
|
|
|
|
if (canSetImmediate) {
|
|
return function (f) { return window.setImmediate(f) };
|
|
}
|
|
|
|
if (canPost) {
|
|
var queue = [];
|
|
window.addEventListener('message', function (ev) {
|
|
if (ev.source === window && ev.data === 'process-tick') {
|
|
ev.stopPropagation();
|
|
if (queue.length > 0) {
|
|
var fn = queue.shift();
|
|
fn();
|
|
}
|
|
}
|
|
}, true);
|
|
|
|
return function nextTick(fn) {
|
|
queue.push(fn);
|
|
window.postMessage('process-tick', '*');
|
|
};
|
|
}
|
|
|
|
return function nextTick(fn) {
|
|
setTimeout(fn, 0);
|
|
};
|
|
})();
|
|
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
}
|
|
|
|
// TODO(shtylman)
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
|
|
},{}],13:[function(require,module,exports){
|
|
var global=typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};/**
|
|
* @license
|
|
* Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
|
|
* Build: `lodash modern -o ./dist/lodash.js`
|
|
* Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
|
|
* Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
|
|
* Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
* Available under MIT license <http://lodash.com/license>
|
|
*/
|
|
;(function() {
|
|
|
|
/** Used as a safe reference for `undefined` in pre ES5 environments */
|
|
var undefined;
|
|
|
|
/** Used to pool arrays and objects used internally */
|
|
var arrayPool = [],
|
|
objectPool = [];
|
|
|
|
/** Used to generate unique IDs */
|
|
var idCounter = 0;
|
|
|
|
/** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */
|
|
var keyPrefix = +new Date + '';
|
|
|
|
/** Used as the size when optimizations are enabled for large arrays */
|
|
var largeArraySize = 75;
|
|
|
|
/** Used as the max size of the `arrayPool` and `objectPool` */
|
|
var maxPoolSize = 40;
|
|
|
|
/** Used to detect and test whitespace */
|
|
var whitespace = (
|
|
// whitespace
|
|
' \t\x0B\f\xA0\ufeff' +
|
|
|
|
// line terminators
|
|
'\n\r\u2028\u2029' +
|
|
|
|
// unicode category "Zs" space separators
|
|
'\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
|
|
);
|
|
|
|
/** Used to match empty string literals in compiled template source */
|
|
var reEmptyStringLeading = /\b__p \+= '';/g,
|
|
reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
|
|
reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
|
|
|
|
/**
|
|
* Used to match ES6 template delimiters
|
|
* http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6
|
|
*/
|
|
var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
|
|
|
|
/** Used to match regexp flags from their coerced string values */
|
|
var reFlags = /\w*$/;
|
|
|
|
/** Used to detected named functions */
|
|
var reFuncName = /^\s*function[ \n\r\t]+\w/;
|
|
|
|
/** Used to match "interpolate" template delimiters */
|
|
var reInterpolate = /<%=([\s\S]+?)%>/g;
|
|
|
|
/** Used to match leading whitespace and zeros to be removed */
|
|
var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');
|
|
|
|
/** Used to ensure capturing order of template delimiters */
|
|
var reNoMatch = /($^)/;
|
|
|
|
/** Used to detect functions containing a `this` reference */
|
|
var reThis = /\bthis\b/;
|
|
|
|
/** Used to match unescaped characters in compiled string literals */
|
|
var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
|
|
|
|
/** Used to assign default `context` object properties */
|
|
var contextProps = [
|
|
'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object',
|
|
'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',
|
|
'parseInt', 'setImmediate', 'setTimeout'
|
|
];
|
|
|
|
/** Used to make template sourceURLs easier to identify */
|
|
var templateCounter = 0;
|
|
|
|
/** `Object#toString` result shortcuts */
|
|
var argsClass = '[object Arguments]',
|
|
arrayClass = '[object Array]',
|
|
boolClass = '[object Boolean]',
|
|
dateClass = '[object Date]',
|
|
funcClass = '[object Function]',
|
|
numberClass = '[object Number]',
|
|
objectClass = '[object Object]',
|
|
regexpClass = '[object RegExp]',
|
|
stringClass = '[object String]';
|
|
|
|
/** Used to identify object classifications that `_.clone` supports */
|
|
var cloneableClasses = {};
|
|
cloneableClasses[funcClass] = false;
|
|
cloneableClasses[argsClass] = cloneableClasses[arrayClass] =
|
|
cloneableClasses[boolClass] = cloneableClasses[dateClass] =
|
|
cloneableClasses[numberClass] = cloneableClasses[objectClass] =
|
|
cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;
|
|
|
|
/** Used as an internal `_.debounce` options object */
|
|
var debounceOptions = {
|
|
'leading': false,
|
|
'maxWait': 0,
|
|
'trailing': false
|
|
};
|
|
|
|
/** Used as the property descriptor for `__bindData__` */
|
|
var descriptor = {
|
|
'configurable': false,
|
|
'enumerable': false,
|
|
'value': null,
|
|
'writable': false
|
|
};
|
|
|
|
/** Used to determine if values are of the language type Object */
|
|
var objectTypes = {
|
|
'boolean': false,
|
|
'function': true,
|
|
'object': true,
|
|
'number': false,
|
|
'string': false,
|
|
'undefined': false
|
|
};
|
|
|
|
/** Used to escape characters for inclusion in compiled string literals */
|
|
var stringEscapes = {
|
|
'\\': '\\',
|
|
"'": "'",
|
|
'\n': 'n',
|
|
'\r': 'r',
|
|
'\t': 't',
|
|
'\u2028': 'u2028',
|
|
'\u2029': 'u2029'
|
|
};
|
|
|
|
/** Used as a reference to the global object */
|
|
var root = (objectTypes[typeof window] && window) || this;
|
|
|
|
/** Detect free variable `exports` */
|
|
var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
|
|
|
|
/** Detect free variable `module` */
|
|
var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
|
|
|
|
/** Detect the popular CommonJS extension `module.exports` */
|
|
var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
|
|
|
|
/** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
|
|
var freeGlobal = objectTypes[typeof global] && global;
|
|
if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
|
|
root = freeGlobal;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* The base implementation of `_.indexOf` without support for binary searches
|
|
* or `fromIndex` constraints.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to search.
|
|
* @param {*} value The value to search for.
|
|
* @param {number} [fromIndex=0] The index to search from.
|
|
* @returns {number} Returns the index of the matched value or `-1`.
|
|
*/
|
|
function baseIndexOf(array, value, fromIndex) {
|
|
var index = (fromIndex || 0) - 1,
|
|
length = array ? array.length : 0;
|
|
|
|
while (++index < length) {
|
|
if (array[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* An implementation of `_.contains` for cache objects that mimics the return
|
|
* signature of `_.indexOf` by returning `0` if the value is found, else `-1`.
|
|
*
|
|
* @private
|
|
* @param {Object} cache The cache object to inspect.
|
|
* @param {*} value The value to search for.
|
|
* @returns {number} Returns `0` if `value` is found, else `-1`.
|
|
*/
|
|
function cacheIndexOf(cache, value) {
|
|
var type = typeof value;
|
|
cache = cache.cache;
|
|
|
|
if (type == 'boolean' || value == null) {
|
|
return cache[value] ? 0 : -1;
|
|
}
|
|
if (type != 'number' && type != 'string') {
|
|
type = 'object';
|
|
}
|
|
var key = type == 'number' ? value : keyPrefix + value;
|
|
cache = (cache = cache[type]) && cache[key];
|
|
|
|
return type == 'object'
|
|
? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)
|
|
: (cache ? 0 : -1);
|
|
}
|
|
|
|
/**
|
|
* Adds a given value to the corresponding cache object.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to add to the cache.
|
|
*/
|
|
function cachePush(value) {
|
|
var cache = this.cache,
|
|
type = typeof value;
|
|
|
|
if (type == 'boolean' || value == null) {
|
|
cache[value] = true;
|
|
} else {
|
|
if (type != 'number' && type != 'string') {
|
|
type = 'object';
|
|
}
|
|
var key = type == 'number' ? value : keyPrefix + value,
|
|
typeCache = cache[type] || (cache[type] = {});
|
|
|
|
if (type == 'object') {
|
|
(typeCache[key] || (typeCache[key] = [])).push(value);
|
|
} else {
|
|
typeCache[key] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Used by `_.max` and `_.min` as the default callback when a given
|
|
* collection is a string value.
|
|
*
|
|
* @private
|
|
* @param {string} value The character to inspect.
|
|
* @returns {number} Returns the code unit of given character.
|
|
*/
|
|
function charAtCallback(value) {
|
|
return value.charCodeAt(0);
|
|
}
|
|
|
|
/**
|
|
* Used by `sortBy` to compare transformed `collection` elements, stable sorting
|
|
* them in ascending order.
|
|
*
|
|
* @private
|
|
* @param {Object} a The object to compare to `b`.
|
|
* @param {Object} b The object to compare to `a`.
|
|
* @returns {number} Returns the sort order indicator of `1` or `-1`.
|
|
*/
|
|
function compareAscending(a, b) {
|
|
var ac = a.criteria,
|
|
bc = b.criteria;
|
|
|
|
// ensure a stable sort in V8 and other engines
|
|
// http://code.google.com/p/v8/issues/detail?id=90
|
|
if (ac !== bc) {
|
|
if (ac > bc || typeof ac == 'undefined') {
|
|
return 1;
|
|
}
|
|
if (ac < bc || typeof bc == 'undefined') {
|
|
return -1;
|
|
}
|
|
}
|
|
// The JS engine embedded in Adobe applications like InDesign has a buggy
|
|
// `Array#sort` implementation that causes it, under certain circumstances,
|
|
// to return the same value for `a` and `b`.
|
|
// See https://github.com/jashkenas/underscore/pull/1247
|
|
return a.index - b.index;
|
|
}
|
|
|
|
/**
|
|
* Creates a cache object to optimize linear searches of large arrays.
|
|
*
|
|
* @private
|
|
* @param {Array} [array=[]] The array to search.
|
|
* @returns {null|Object} Returns the cache object or `null` if caching should not be used.
|
|
*/
|
|
function createCache(array) {
|
|
var index = -1,
|
|
length = array.length,
|
|
first = array[0],
|
|
mid = array[(length / 2) | 0],
|
|
last = array[length - 1];
|
|
|
|
if (first && typeof first == 'object' &&
|
|
mid && typeof mid == 'object' && last && typeof last == 'object') {
|
|
return false;
|
|
}
|
|
var cache = getObject();
|
|
cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;
|
|
|
|
var result = getObject();
|
|
result.array = array;
|
|
result.cache = cache;
|
|
result.push = cachePush;
|
|
|
|
while (++index < length) {
|
|
result.push(array[index]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Used by `template` to escape characters for inclusion in compiled
|
|
* string literals.
|
|
*
|
|
* @private
|
|
* @param {string} match The matched character to escape.
|
|
* @returns {string} Returns the escaped character.
|
|
*/
|
|
function escapeStringChar(match) {
|
|
return '\\' + stringEscapes[match];
|
|
}
|
|
|
|
/**
|
|
* Gets an array from the array pool or creates a new one if the pool is empty.
|
|
*
|
|
* @private
|
|
* @returns {Array} The array from the pool.
|
|
*/
|
|
function getArray() {
|
|
return arrayPool.pop() || [];
|
|
}
|
|
|
|
/**
|
|
* Gets an object from the object pool or creates a new one if the pool is empty.
|
|
*
|
|
* @private
|
|
* @returns {Object} The object from the pool.
|
|
*/
|
|
function getObject() {
|
|
return objectPool.pop() || {
|
|
'array': null,
|
|
'cache': null,
|
|
'criteria': null,
|
|
'false': false,
|
|
'index': 0,
|
|
'null': false,
|
|
'number': null,
|
|
'object': null,
|
|
'push': null,
|
|
'string': null,
|
|
'true': false,
|
|
'undefined': false,
|
|
'value': null
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Releases the given array back to the array pool.
|
|
*
|
|
* @private
|
|
* @param {Array} [array] The array to release.
|
|
*/
|
|
function releaseArray(array) {
|
|
array.length = 0;
|
|
if (arrayPool.length < maxPoolSize) {
|
|
arrayPool.push(array);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Releases the given object back to the object pool.
|
|
*
|
|
* @private
|
|
* @param {Object} [object] The object to release.
|
|
*/
|
|
function releaseObject(object) {
|
|
var cache = object.cache;
|
|
if (cache) {
|
|
releaseObject(cache);
|
|
}
|
|
object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;
|
|
if (objectPool.length < maxPoolSize) {
|
|
objectPool.push(object);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Slices the `collection` from the `start` index up to, but not including,
|
|
* the `end` index.
|
|
*
|
|
* Note: This function is used instead of `Array#slice` to support node lists
|
|
* in IE < 9 and to ensure dense arrays are returned.
|
|
*
|
|
* @private
|
|
* @param {Array|Object|string} collection The collection to slice.
|
|
* @param {number} start The start index.
|
|
* @param {number} end The end index.
|
|
* @returns {Array} Returns the new array.
|
|
*/
|
|
function slice(array, start, end) {
|
|
start || (start = 0);
|
|
if (typeof end == 'undefined') {
|
|
end = array ? array.length : 0;
|
|
}
|
|
var index = -1,
|
|
length = end - start || 0,
|
|
result = Array(length < 0 ? 0 : length);
|
|
|
|
while (++index < length) {
|
|
result[index] = array[start + index];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Create a new `lodash` function using the given context object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {Object} [context=root] The context object.
|
|
* @returns {Function} Returns the `lodash` function.
|
|
*/
|
|
function runInContext(context) {
|
|
// Avoid issues with some ES3 environments that attempt to use values, named
|
|
// after built-in constructors like `Object`, for the creation of literals.
|
|
// ES5 clears this up by stating that literals must use built-in constructors.
|
|
// See http://es5.github.io/#x11.1.5.
|
|
context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;
|
|
|
|
/** Native constructor references */
|
|
var Array = context.Array,
|
|
Boolean = context.Boolean,
|
|
Date = context.Date,
|
|
Function = context.Function,
|
|
Math = context.Math,
|
|
Number = context.Number,
|
|
Object = context.Object,
|
|
RegExp = context.RegExp,
|
|
String = context.String,
|
|
TypeError = context.TypeError;
|
|
|
|
/**
|
|
* Used for `Array` method references.
|
|
*
|
|
* Normally `Array.prototype` would suffice, however, using an array literal
|
|
* avoids issues in Narwhal.
|
|
*/
|
|
var arrayRef = [];
|
|
|
|
/** Used for native method references */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to restore the original `_` reference in `noConflict` */
|
|
var oldDash = context._;
|
|
|
|
/** Used to resolve the internal [[Class]] of values */
|
|
var toString = objectProto.toString;
|
|
|
|
/** Used to detect if a method is native */
|
|
var reNative = RegExp('^' +
|
|
String(toString)
|
|
.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
|
|
.replace(/toString| for [^\]]+/g, '.*?') + '$'
|
|
);
|
|
|
|
/** Native method shortcuts */
|
|
var ceil = Math.ceil,
|
|
clearTimeout = context.clearTimeout,
|
|
floor = Math.floor,
|
|
fnToString = Function.prototype.toString,
|
|
getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
|
|
hasOwnProperty = objectProto.hasOwnProperty,
|
|
now = reNative.test(now = Date.now) && now || function() { return +new Date; },
|
|
push = arrayRef.push,
|
|
setTimeout = context.setTimeout,
|
|
splice = arrayRef.splice;
|
|
|
|
/** Used to detect `setImmediate` in Node.js */
|
|
var setImmediate = typeof (setImmediate = freeGlobal && moduleExports && freeGlobal.setImmediate) == 'function' &&
|
|
!reNative.test(setImmediate) && setImmediate;
|
|
|
|
/** Used to set meta data on functions */
|
|
var defineProperty = (function() {
|
|
// IE 8 only accepts DOM elements
|
|
try {
|
|
var o = {},
|
|
func = reNative.test(func = Object.defineProperty) && func,
|
|
result = func(o, o, o) && func;
|
|
} catch(e) { }
|
|
return result;
|
|
}());
|
|
|
|
/* Native method shortcuts for methods with the same name as other `lodash` methods */
|
|
var nativeCreate = reNative.test(nativeCreate = Object.create) && nativeCreate,
|
|
nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,
|
|
nativeIsFinite = context.isFinite,
|
|
nativeIsNaN = context.isNaN,
|
|
nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys,
|
|
nativeMax = Math.max,
|
|
nativeMin = Math.min,
|
|
nativeParseInt = context.parseInt,
|
|
nativeRandom = Math.random;
|
|
|
|
/** Used to lookup a built-in constructor by [[Class]] */
|
|
var ctorByClass = {};
|
|
ctorByClass[arrayClass] = Array;
|
|
ctorByClass[boolClass] = Boolean;
|
|
ctorByClass[dateClass] = Date;
|
|
ctorByClass[funcClass] = Function;
|
|
ctorByClass[objectClass] = Object;
|
|
ctorByClass[numberClass] = Number;
|
|
ctorByClass[regexpClass] = RegExp;
|
|
ctorByClass[stringClass] = String;
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Creates a `lodash` object which wraps the given value to enable intuitive
|
|
* method chaining.
|
|
*
|
|
* In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
|
|
* `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,
|
|
* and `unshift`
|
|
*
|
|
* Chaining is supported in custom builds as long as the `value` method is
|
|
* implicitly or explicitly included in the build.
|
|
*
|
|
* The chainable wrapper functions are:
|
|
* `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,
|
|
* `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`,
|
|
* `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`,
|
|
* `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,
|
|
* `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,
|
|
* `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
|
|
* `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`,
|
|
* `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`,
|
|
* `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`,
|
|
* `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`,
|
|
* and `zip`
|
|
*
|
|
* The non-chainable wrapper functions are:
|
|
* `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`,
|
|
* `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`,
|
|
* `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,
|
|
* `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`,
|
|
* `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`,
|
|
* `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`,
|
|
* `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`,
|
|
* `template`, `unescape`, `uniqueId`, and `value`
|
|
*
|
|
* The wrapper functions `first` and `last` return wrapped values when `n` is
|
|
* provided, otherwise they return unwrapped values.
|
|
*
|
|
* Explicit chaining can be enabled by using the `_.chain` method.
|
|
*
|
|
* @name _
|
|
* @constructor
|
|
* @category Chaining
|
|
* @param {*} value The value to wrap in a `lodash` instance.
|
|
* @returns {Object} Returns a `lodash` instance.
|
|
* @example
|
|
*
|
|
* var wrapped = _([1, 2, 3]);
|
|
*
|
|
* // returns an unwrapped value
|
|
* wrapped.reduce(function(sum, num) {
|
|
* return sum + num;
|
|
* });
|
|
* // => 6
|
|
*
|
|
* // returns a wrapped value
|
|
* var squares = wrapped.map(function(num) {
|
|
* return num * num;
|
|
* });
|
|
*
|
|
* _.isArray(squares);
|
|
* // => false
|
|
*
|
|
* _.isArray(squares.value());
|
|
* // => true
|
|
*/
|
|
function lodash(value) {
|
|
// don't wrap if already wrapped, even if wrapped by a different `lodash` constructor
|
|
return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))
|
|
? value
|
|
: new lodashWrapper(value);
|
|
}
|
|
|
|
/**
|
|
* A fast path for creating `lodash` wrapper objects.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to wrap in a `lodash` instance.
|
|
* @param {boolean} chainAll A flag to enable chaining for all methods
|
|
* @returns {Object} Returns a `lodash` instance.
|
|
*/
|
|
function lodashWrapper(value, chainAll) {
|
|
this.__chain__ = !!chainAll;
|
|
this.__wrapped__ = value;
|
|
}
|
|
// ensure `new lodashWrapper` is an instance of `lodash`
|
|
lodashWrapper.prototype = lodash.prototype;
|
|
|
|
/**
|
|
* An object used to flag environments features.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Object
|
|
*/
|
|
var support = lodash.support = {};
|
|
|
|
/**
|
|
* Detect if functions can be decompiled by `Function#toString`
|
|
* (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.funcDecomp = !reNative.test(context.WinRTError) && reThis.test(runInContext);
|
|
|
|
/**
|
|
* Detect if `Function#name` is supported (all but IE).
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.funcNames = typeof Function.name == 'string';
|
|
|
|
/**
|
|
* By default, the template delimiters used by Lo-Dash are similar to those in
|
|
* embedded Ruby (ERB). Change the following template settings to use alternative
|
|
* delimiters.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Object
|
|
*/
|
|
lodash.templateSettings = {
|
|
|
|
/**
|
|
* Used to detect `data` property values to be HTML-escaped.
|
|
*
|
|
* @memberOf _.templateSettings
|
|
* @type RegExp
|
|
*/
|
|
'escape': /<%-([\s\S]+?)%>/g,
|
|
|
|
/**
|
|
* Used to detect code to be evaluated.
|
|
*
|
|
* @memberOf _.templateSettings
|
|
* @type RegExp
|
|
*/
|
|
'evaluate': /<%([\s\S]+?)%>/g,
|
|
|
|
/**
|
|
* Used to detect `data` property values to inject.
|
|
*
|
|
* @memberOf _.templateSettings
|
|
* @type RegExp
|
|
*/
|
|
'interpolate': reInterpolate,
|
|
|
|
/**
|
|
* Used to reference the data object in the template text.
|
|
*
|
|
* @memberOf _.templateSettings
|
|
* @type string
|
|
*/
|
|
'variable': '',
|
|
|
|
/**
|
|
* Used to import variables into the compiled template.
|
|
*
|
|
* @memberOf _.templateSettings
|
|
* @type Object
|
|
*/
|
|
'imports': {
|
|
|
|
/**
|
|
* A reference to the `lodash` function.
|
|
*
|
|
* @memberOf _.templateSettings.imports
|
|
* @type Function
|
|
*/
|
|
'_': lodash
|
|
}
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* The base implementation of `_.bind` that creates the bound function and
|
|
* sets its meta data.
|
|
*
|
|
* @private
|
|
* @param {Array} bindData The bind data array.
|
|
* @returns {Function} Returns the new bound function.
|
|
*/
|
|
function baseBind(bindData) {
|
|
var func = bindData[0],
|
|
partialArgs = bindData[2],
|
|
thisArg = bindData[4];
|
|
|
|
function bound() {
|
|
// `Function#bind` spec
|
|
// http://es5.github.io/#x15.3.4.5
|
|
if (partialArgs) {
|
|
var args = partialArgs.slice();
|
|
push.apply(args, arguments);
|
|
}
|
|
// mimic the constructor's `return` behavior
|
|
// http://es5.github.io/#x13.2.2
|
|
if (this instanceof bound) {
|
|
// ensure `new bound` is an instance of `func`
|
|
var thisBinding = baseCreate(func.prototype),
|
|
result = func.apply(thisBinding, args || arguments);
|
|
return isObject(result) ? result : thisBinding;
|
|
}
|
|
return func.apply(thisArg, args || arguments);
|
|
}
|
|
setBindData(bound, bindData);
|
|
return bound;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.clone` without argument juggling or support
|
|
* for `thisArg` binding.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to clone.
|
|
* @param {boolean} [isDeep=false] Specify a deep clone.
|
|
* @param {Function} [callback] The function to customize cloning values.
|
|
* @param {Array} [stackA=[]] Tracks traversed source objects.
|
|
* @param {Array} [stackB=[]] Associates clones with source counterparts.
|
|
* @returns {*} Returns the cloned value.
|
|
*/
|
|
function baseClone(value, isDeep, callback, stackA, stackB) {
|
|
if (callback) {
|
|
var result = callback(value);
|
|
if (typeof result != 'undefined') {
|
|
return result;
|
|
}
|
|
}
|
|
// inspect [[Class]]
|
|
var isObj = isObject(value);
|
|
if (isObj) {
|
|
var className = toString.call(value);
|
|
if (!cloneableClasses[className]) {
|
|
return value;
|
|
}
|
|
var ctor = ctorByClass[className];
|
|
switch (className) {
|
|
case boolClass:
|
|
case dateClass:
|
|
return new ctor(+value);
|
|
|
|
case numberClass:
|
|
case stringClass:
|
|
return new ctor(value);
|
|
|
|
case regexpClass:
|
|
result = ctor(value.source, reFlags.exec(value));
|
|
result.lastIndex = value.lastIndex;
|
|
return result;
|
|
}
|
|
} else {
|
|
return value;
|
|
}
|
|
var isArr = isArray(value);
|
|
if (isDeep) {
|
|
// check for circular references and return corresponding clone
|
|
var initedStack = !stackA;
|
|
stackA || (stackA = getArray());
|
|
stackB || (stackB = getArray());
|
|
|
|
var length = stackA.length;
|
|
while (length--) {
|
|
if (stackA[length] == value) {
|
|
return stackB[length];
|
|
}
|
|
}
|
|
result = isArr ? ctor(value.length) : {};
|
|
}
|
|
else {
|
|
result = isArr ? slice(value) : assign({}, value);
|
|
}
|
|
// add array properties assigned by `RegExp#exec`
|
|
if (isArr) {
|
|
if (hasOwnProperty.call(value, 'index')) {
|
|
result.index = value.index;
|
|
}
|
|
if (hasOwnProperty.call(value, 'input')) {
|
|
result.input = value.input;
|
|
}
|
|
}
|
|
// exit for shallow clone
|
|
if (!isDeep) {
|
|
return result;
|
|
}
|
|
// add the source value to the stack of traversed objects
|
|
// and associate it with its clone
|
|
stackA.push(value);
|
|
stackB.push(result);
|
|
|
|
// recursively populate clone (susceptible to call stack limits)
|
|
(isArr ? forEach : forOwn)(value, function(objValue, key) {
|
|
result[key] = baseClone(objValue, isDeep, callback, stackA, stackB);
|
|
});
|
|
|
|
if (initedStack) {
|
|
releaseArray(stackA);
|
|
releaseArray(stackB);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.create` without support for assigning
|
|
* properties to the created object.
|
|
*
|
|
* @private
|
|
* @param {Object} prototype The object to inherit from.
|
|
* @returns {Object} Returns the new object.
|
|
*/
|
|
function baseCreate(prototype, properties) {
|
|
return isObject(prototype) ? nativeCreate(prototype) : {};
|
|
}
|
|
// fallback for browsers without `Object.create`
|
|
if (!nativeCreate) {
|
|
baseCreate = (function() {
|
|
function Object() {}
|
|
return function(prototype) {
|
|
if (isObject(prototype)) {
|
|
Object.prototype = prototype;
|
|
var result = new Object;
|
|
Object.prototype = null;
|
|
}
|
|
return result || context.Object();
|
|
};
|
|
}());
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.createCallback` without support for creating
|
|
* "_.pluck" or "_.where" style callbacks.
|
|
*
|
|
* @private
|
|
* @param {*} [func=identity] The value to convert to a callback.
|
|
* @param {*} [thisArg] The `this` binding of the created callback.
|
|
* @param {number} [argCount] The number of arguments the callback accepts.
|
|
* @returns {Function} Returns a callback function.
|
|
*/
|
|
function baseCreateCallback(func, thisArg, argCount) {
|
|
if (typeof func != 'function') {
|
|
return identity;
|
|
}
|
|
// exit early for no `thisArg` or already bound by `Function#bind`
|
|
if (typeof thisArg == 'undefined' || !('prototype' in func)) {
|
|
return func;
|
|
}
|
|
var bindData = func.__bindData__;
|
|
if (typeof bindData == 'undefined') {
|
|
if (support.funcNames) {
|
|
bindData = !func.name;
|
|
}
|
|
bindData = bindData || !support.funcDecomp;
|
|
if (!bindData) {
|
|
var source = fnToString.call(func);
|
|
if (!support.funcNames) {
|
|
bindData = !reFuncName.test(source);
|
|
}
|
|
if (!bindData) {
|
|
// checks if `func` references the `this` keyword and stores the result
|
|
bindData = reThis.test(source);
|
|
setBindData(func, bindData);
|
|
}
|
|
}
|
|
}
|
|
// exit early if there are no `this` references or `func` is bound
|
|
if (bindData === false || (bindData !== true && bindData[1] & 1)) {
|
|
return func;
|
|
}
|
|
switch (argCount) {
|
|
case 1: return function(value) {
|
|
return func.call(thisArg, value);
|
|
};
|
|
case 2: return function(a, b) {
|
|
return func.call(thisArg, a, b);
|
|
};
|
|
case 3: return function(value, index, collection) {
|
|
return func.call(thisArg, value, index, collection);
|
|
};
|
|
case 4: return function(accumulator, value, index, collection) {
|
|
return func.call(thisArg, accumulator, value, index, collection);
|
|
};
|
|
}
|
|
return bind(func, thisArg);
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `createWrapper` that creates the wrapper and
|
|
* sets its meta data.
|
|
*
|
|
* @private
|
|
* @param {Array} bindData The bind data array.
|
|
* @returns {Function} Returns the new function.
|
|
*/
|
|
function baseCreateWrapper(bindData) {
|
|
var func = bindData[0],
|
|
bitmask = bindData[1],
|
|
partialArgs = bindData[2],
|
|
partialRightArgs = bindData[3],
|
|
thisArg = bindData[4],
|
|
arity = bindData[5];
|
|
|
|
var isBind = bitmask & 1,
|
|
isBindKey = bitmask & 2,
|
|
isCurry = bitmask & 4,
|
|
isCurryBound = bitmask & 8,
|
|
key = func;
|
|
|
|
function bound() {
|
|
var thisBinding = isBind ? thisArg : this;
|
|
if (partialArgs) {
|
|
var args = partialArgs.slice();
|
|
push.apply(args, arguments);
|
|
}
|
|
if (partialRightArgs || isCurry) {
|
|
args || (args = slice(arguments));
|
|
if (partialRightArgs) {
|
|
push.apply(args, partialRightArgs);
|
|
}
|
|
if (isCurry && args.length < arity) {
|
|
bitmask |= 16 & ~32;
|
|
return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
|
|
}
|
|
}
|
|
args || (args = arguments);
|
|
if (isBindKey) {
|
|
func = thisBinding[key];
|
|
}
|
|
if (this instanceof bound) {
|
|
thisBinding = baseCreate(func.prototype);
|
|
var result = func.apply(thisBinding, args);
|
|
return isObject(result) ? result : thisBinding;
|
|
}
|
|
return func.apply(thisBinding, args);
|
|
}
|
|
setBindData(bound, bindData);
|
|
return bound;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.difference` that accepts a single array
|
|
* of values to exclude.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to process.
|
|
* @param {Array} [values] The array of values to exclude.
|
|
* @returns {Array} Returns a new array of filtered values.
|
|
*/
|
|
function baseDifference(array, values) {
|
|
var index = -1,
|
|
indexOf = getIndexOf(),
|
|
length = array ? array.length : 0,
|
|
isLarge = length >= largeArraySize && indexOf === baseIndexOf,
|
|
result = [];
|
|
|
|
if (isLarge) {
|
|
var cache = createCache(values);
|
|
if (cache) {
|
|
indexOf = cacheIndexOf;
|
|
values = cache;
|
|
} else {
|
|
isLarge = false;
|
|
}
|
|
}
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (indexOf(values, value) < 0) {
|
|
result.push(value);
|
|
}
|
|
}
|
|
if (isLarge) {
|
|
releaseObject(values);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.flatten` without support for callback
|
|
* shorthands or `thisArg` binding.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to flatten.
|
|
* @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
|
|
* @param {boolean} [isStrict=false] A flag to restrict flattening to arrays and `arguments` objects.
|
|
* @param {number} [fromIndex=0] The index to start from.
|
|
* @returns {Array} Returns a new flattened array.
|
|
*/
|
|
function baseFlatten(array, isShallow, isStrict, fromIndex) {
|
|
var index = (fromIndex || 0) - 1,
|
|
length = array ? array.length : 0,
|
|
result = [];
|
|
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
|
|
if (value && typeof value == 'object' && typeof value.length == 'number'
|
|
&& (isArray(value) || isArguments(value))) {
|
|
// recursively flatten arrays (susceptible to call stack limits)
|
|
if (!isShallow) {
|
|
value = baseFlatten(value, isShallow, isStrict);
|
|
}
|
|
var valIndex = -1,
|
|
valLength = value.length,
|
|
resIndex = result.length;
|
|
|
|
result.length += valLength;
|
|
while (++valIndex < valLength) {
|
|
result[resIndex++] = value[valIndex];
|
|
}
|
|
} else if (!isStrict) {
|
|
result.push(value);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.isEqual`, without support for `thisArg` binding,
|
|
* that allows partial "_.where" style comparisons.
|
|
*
|
|
* @private
|
|
* @param {*} a The value to compare.
|
|
* @param {*} b The other value to compare.
|
|
* @param {Function} [callback] The function to customize comparing values.
|
|
* @param {Function} [isWhere=false] A flag to indicate performing partial comparisons.
|
|
* @param {Array} [stackA=[]] Tracks traversed `a` objects.
|
|
* @param {Array} [stackB=[]] Tracks traversed `b` objects.
|
|
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
|
*/
|
|
function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
|
|
// used to indicate that when comparing objects, `a` has at least the properties of `b`
|
|
if (callback) {
|
|
var result = callback(a, b);
|
|
if (typeof result != 'undefined') {
|
|
return !!result;
|
|
}
|
|
}
|
|
// exit early for identical values
|
|
if (a === b) {
|
|
// treat `+0` vs. `-0` as not equal
|
|
return a !== 0 || (1 / a == 1 / b);
|
|
}
|
|
var type = typeof a,
|
|
otherType = typeof b;
|
|
|
|
// exit early for unlike primitive values
|
|
if (a === a &&
|
|
!(a && objectTypes[type]) &&
|
|
!(b && objectTypes[otherType])) {
|
|
return false;
|
|
}
|
|
// exit early for `null` and `undefined` avoiding ES3's Function#call behavior
|
|
// http://es5.github.io/#x15.3.4.4
|
|
if (a == null || b == null) {
|
|
return a === b;
|
|
}
|
|
// compare [[Class]] names
|
|
var className = toString.call(a),
|
|
otherClass = toString.call(b);
|
|
|
|
if (className == argsClass) {
|
|
className = objectClass;
|
|
}
|
|
if (otherClass == argsClass) {
|
|
otherClass = objectClass;
|
|
}
|
|
if (className != otherClass) {
|
|
return false;
|
|
}
|
|
switch (className) {
|
|
case boolClass:
|
|
case dateClass:
|
|
// coerce dates and booleans to numbers, dates to milliseconds and booleans
|
|
// to `1` or `0` treating invalid dates coerced to `NaN` as not equal
|
|
return +a == +b;
|
|
|
|
case numberClass:
|
|
// treat `NaN` vs. `NaN` as equal
|
|
return (a != +a)
|
|
? b != +b
|
|
// but treat `+0` vs. `-0` as not equal
|
|
: (a == 0 ? (1 / a == 1 / b) : a == +b);
|
|
|
|
case regexpClass:
|
|
case stringClass:
|
|
// coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
|
|
// treat string primitives and their corresponding object instances as equal
|
|
return a == String(b);
|
|
}
|
|
var isArr = className == arrayClass;
|
|
if (!isArr) {
|
|
// unwrap any `lodash` wrapped values
|
|
var aWrapped = hasOwnProperty.call(a, '__wrapped__'),
|
|
bWrapped = hasOwnProperty.call(b, '__wrapped__');
|
|
|
|
if (aWrapped || bWrapped) {
|
|
return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);
|
|
}
|
|
// exit for functions and DOM nodes
|
|
if (className != objectClass) {
|
|
return false;
|
|
}
|
|
// in older versions of Opera, `arguments` objects have `Array` constructors
|
|
var ctorA = a.constructor,
|
|
ctorB = b.constructor;
|
|
|
|
// non `Object` object instances with different constructors are not equal
|
|
if (ctorA != ctorB &&
|
|
!(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
|
|
('constructor' in a && 'constructor' in b)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
// assume cyclic structures are equal
|
|
// the algorithm for detecting cyclic structures is adapted from ES 5.1
|
|
// section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
|
|
var initedStack = !stackA;
|
|
stackA || (stackA = getArray());
|
|
stackB || (stackB = getArray());
|
|
|
|
var length = stackA.length;
|
|
while (length--) {
|
|
if (stackA[length] == a) {
|
|
return stackB[length] == b;
|
|
}
|
|
}
|
|
var size = 0;
|
|
result = true;
|
|
|
|
// add `a` and `b` to the stack of traversed objects
|
|
stackA.push(a);
|
|
stackB.push(b);
|
|
|
|
// recursively compare objects and arrays (susceptible to call stack limits)
|
|
if (isArr) {
|
|
length = a.length;
|
|
size = b.length;
|
|
|
|
// compare lengths to determine if a deep comparison is necessary
|
|
result = size == a.length;
|
|
if (!result && !isWhere) {
|
|
return result;
|
|
}
|
|
// deep compare the contents, ignoring non-numeric properties
|
|
while (size--) {
|
|
var index = length,
|
|
value = b[size];
|
|
|
|
if (isWhere) {
|
|
while (index--) {
|
|
if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
// deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
|
|
// which, in this case, is more costly
|
|
forIn(b, function(value, key, b) {
|
|
if (hasOwnProperty.call(b, key)) {
|
|
// count the number of properties.
|
|
size++;
|
|
// deep compare each property value.
|
|
return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB));
|
|
}
|
|
});
|
|
|
|
if (result && !isWhere) {
|
|
// ensure both objects have the same number of properties
|
|
forIn(a, function(value, key, a) {
|
|
if (hasOwnProperty.call(a, key)) {
|
|
// `size` will be `-1` if `a` has more properties than `b`
|
|
return (result = --size > -1);
|
|
}
|
|
});
|
|
}
|
|
if (initedStack) {
|
|
releaseArray(stackA);
|
|
releaseArray(stackB);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.merge` without argument juggling or support
|
|
* for `thisArg` binding.
|
|
*
|
|
* @private
|
|
* @param {Object} object The destination object.
|
|
* @param {Object} source The source object.
|
|
* @param {Function} [callback] The function to customize merging properties.
|
|
* @param {Array} [stackA=[]] Tracks traversed source objects.
|
|
* @param {Array} [stackB=[]] Associates values with source counterparts.
|
|
*/
|
|
function baseMerge(object, source, callback, stackA, stackB) {
|
|
(isArray(source) ? forEach : forOwn)(source, function(source, key) {
|
|
var found,
|
|
isArr,
|
|
result = source,
|
|
value = object[key];
|
|
|
|
if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
|
|
// avoid merging previously merged cyclic sources
|
|
var stackLength = stackA.length;
|
|
while (stackLength--) {
|
|
if ((found = stackA[stackLength] == source)) {
|
|
value = stackB[stackLength];
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
var isShallow;
|
|
if (callback) {
|
|
result = callback(value, source);
|
|
if ((isShallow = typeof result != 'undefined')) {
|
|
value = result;
|
|
}
|
|
}
|
|
if (!isShallow) {
|
|
value = isArr
|
|
? (isArray(value) ? value : [])
|
|
: (isPlainObject(value) ? value : {});
|
|
}
|
|
// add `source` and associated `value` to the stack of traversed objects
|
|
stackA.push(source);
|
|
stackB.push(value);
|
|
|
|
// recursively merge objects and arrays (susceptible to call stack limits)
|
|
if (!isShallow) {
|
|
baseMerge(value, source, callback, stackA, stackB);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (callback) {
|
|
result = callback(value, source);
|
|
if (typeof result == 'undefined') {
|
|
result = source;
|
|
}
|
|
}
|
|
if (typeof result != 'undefined') {
|
|
value = result;
|
|
}
|
|
}
|
|
object[key] = value;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.random` without argument juggling or support
|
|
* for returning floating-point numbers.
|
|
*
|
|
* @private
|
|
* @param {number} min The minimum possible value.
|
|
* @param {number} max The maximum possible value.
|
|
* @returns {number} Returns a random number.
|
|
*/
|
|
function baseRandom(min, max) {
|
|
return min + floor(nativeRandom() * (max - min + 1));
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.uniq` without support for callback shorthands
|
|
* or `thisArg` binding.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to process.
|
|
* @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
|
|
* @param {Function} [callback] The function called per iteration.
|
|
* @returns {Array} Returns a duplicate-value-free array.
|
|
*/
|
|
function baseUniq(array, isSorted, callback) {
|
|
var index = -1,
|
|
indexOf = getIndexOf(),
|
|
length = array ? array.length : 0,
|
|
result = [];
|
|
|
|
var isLarge = !isSorted && length >= largeArraySize && indexOf === baseIndexOf,
|
|
seen = (callback || isLarge) ? getArray() : result;
|
|
|
|
if (isLarge) {
|
|
var cache = createCache(seen);
|
|
if (cache) {
|
|
indexOf = cacheIndexOf;
|
|
seen = cache;
|
|
} else {
|
|
isLarge = false;
|
|
seen = callback ? seen : (releaseArray(seen), result);
|
|
}
|
|
}
|
|
while (++index < length) {
|
|
var value = array[index],
|
|
computed = callback ? callback(value, index, array) : value;
|
|
|
|
if (isSorted
|
|
? !index || seen[seen.length - 1] !== computed
|
|
: indexOf(seen, computed) < 0
|
|
) {
|
|
if (callback || isLarge) {
|
|
seen.push(computed);
|
|
}
|
|
result.push(value);
|
|
}
|
|
}
|
|
if (isLarge) {
|
|
releaseArray(seen.array);
|
|
releaseObject(seen);
|
|
} else if (callback) {
|
|
releaseArray(seen);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that aggregates a collection, creating an object composed
|
|
* of keys generated from the results of running each element of the collection
|
|
* through a callback. The given `setter` function sets the keys and values
|
|
* of the composed object.
|
|
*
|
|
* @private
|
|
* @param {Function} setter The setter function.
|
|
* @returns {Function} Returns the new aggregator function.
|
|
*/
|
|
function createAggregator(setter) {
|
|
return function(collection, callback, thisArg) {
|
|
var result = {};
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
if (typeof length == 'number') {
|
|
while (++index < length) {
|
|
var value = collection[index];
|
|
setter(result, value, callback(value, index, collection), collection);
|
|
}
|
|
} else {
|
|
forOwn(collection, function(value, key, collection) {
|
|
setter(result, value, callback(value, key, collection), collection);
|
|
});
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a function that, when called, either curries or invokes `func`
|
|
* with an optional `this` binding and partially applied arguments.
|
|
*
|
|
* @private
|
|
* @param {Function|string} func The function or method name to reference.
|
|
* @param {number} bitmask The bitmask of method flags to compose.
|
|
* The bitmask may be composed of the following flags:
|
|
* 1 - `_.bind`
|
|
* 2 - `_.bindKey`
|
|
* 4 - `_.curry`
|
|
* 8 - `_.curry` (bound)
|
|
* 16 - `_.partial`
|
|
* 32 - `_.partialRight`
|
|
* @param {Array} [partialArgs] An array of arguments to prepend to those
|
|
* provided to the new function.
|
|
* @param {Array} [partialRightArgs] An array of arguments to append to those
|
|
* provided to the new function.
|
|
* @param {*} [thisArg] The `this` binding of `func`.
|
|
* @param {number} [arity] The arity of `func`.
|
|
* @returns {Function} Returns the new function.
|
|
*/
|
|
function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
|
|
var isBind = bitmask & 1,
|
|
isBindKey = bitmask & 2,
|
|
isCurry = bitmask & 4,
|
|
isCurryBound = bitmask & 8,
|
|
isPartial = bitmask & 16,
|
|
isPartialRight = bitmask & 32;
|
|
|
|
if (!isBindKey && !isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
if (isPartial && !partialArgs.length) {
|
|
bitmask &= ~16;
|
|
isPartial = partialArgs = false;
|
|
}
|
|
if (isPartialRight && !partialRightArgs.length) {
|
|
bitmask &= ~32;
|
|
isPartialRight = partialRightArgs = false;
|
|
}
|
|
var bindData = func && func.__bindData__;
|
|
if (bindData && bindData !== true) {
|
|
bindData = bindData.slice();
|
|
|
|
// set `thisBinding` is not previously bound
|
|
if (isBind && !(bindData[1] & 1)) {
|
|
bindData[4] = thisArg;
|
|
}
|
|
// set if previously bound but not currently (subsequent curried functions)
|
|
if (!isBind && bindData[1] & 1) {
|
|
bitmask |= 8;
|
|
}
|
|
// set curried arity if not yet set
|
|
if (isCurry && !(bindData[1] & 4)) {
|
|
bindData[5] = arity;
|
|
}
|
|
// append partial left arguments
|
|
if (isPartial) {
|
|
push.apply(bindData[2] || (bindData[2] = []), partialArgs);
|
|
}
|
|
// append partial right arguments
|
|
if (isPartialRight) {
|
|
push.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
|
|
}
|
|
// merge flags
|
|
bindData[1] |= bitmask;
|
|
return createWrapper.apply(null, bindData);
|
|
}
|
|
// fast path for `_.bind`
|
|
var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
|
|
return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
|
|
}
|
|
|
|
/**
|
|
* Used by `escape` to convert characters to HTML entities.
|
|
*
|
|
* @private
|
|
* @param {string} match The matched character to escape.
|
|
* @returns {string} Returns the escaped character.
|
|
*/
|
|
function escapeHtmlChar(match) {
|
|
return htmlEscapes[match];
|
|
}
|
|
|
|
/**
|
|
* Gets the appropriate "indexOf" function. If the `_.indexOf` method is
|
|
* customized, this method returns the custom method, otherwise it returns
|
|
* the `baseIndexOf` function.
|
|
*
|
|
* @private
|
|
* @returns {Function} Returns the "indexOf" function.
|
|
*/
|
|
function getIndexOf() {
|
|
var result = (result = lodash.indexOf) === indexOf ? baseIndexOf : result;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Sets `this` binding data on a given function.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to set data on.
|
|
* @param {Array} value The data array to set.
|
|
*/
|
|
var setBindData = !defineProperty ? noop : function(func, value) {
|
|
descriptor.value = value;
|
|
defineProperty(func, '__bindData__', descriptor);
|
|
};
|
|
|
|
/**
|
|
* A fallback implementation of `isPlainObject` which checks if a given value
|
|
* is an object created by the `Object` constructor, assuming objects created
|
|
* by the `Object` constructor have no inherited enumerable properties and that
|
|
* there are no `Object.prototype` extensions.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
|
|
*/
|
|
function shimIsPlainObject(value) {
|
|
var ctor,
|
|
result;
|
|
|
|
// avoid non Object objects, `arguments` objects, and DOM elements
|
|
if (!(value && toString.call(value) == objectClass) ||
|
|
(ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor))) {
|
|
return false;
|
|
}
|
|
// In most environments an object's own properties are iterated before
|
|
// its inherited properties. If the last iterated property is an object's
|
|
// own property then there are no inherited enumerable properties.
|
|
forIn(value, function(value, key) {
|
|
result = key;
|
|
});
|
|
return typeof result == 'undefined' || hasOwnProperty.call(value, result);
|
|
}
|
|
|
|
/**
|
|
* Used by `unescape` to convert HTML entities to characters.
|
|
*
|
|
* @private
|
|
* @param {string} match The matched character to unescape.
|
|
* @returns {string} Returns the unescaped character.
|
|
*/
|
|
function unescapeHtmlChar(match) {
|
|
return htmlUnescapes[match];
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Checks if `value` is an `arguments` object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`.
|
|
* @example
|
|
*
|
|
* (function() { return _.isArguments(arguments); })(1, 2, 3);
|
|
* // => true
|
|
*
|
|
* _.isArguments([1, 2, 3]);
|
|
* // => false
|
|
*/
|
|
function isArguments(value) {
|
|
return value && typeof value == 'object' && typeof value.length == 'number' &&
|
|
toString.call(value) == argsClass || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is an array.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is an array, else `false`.
|
|
* @example
|
|
*
|
|
* (function() { return _.isArray(arguments); })();
|
|
* // => false
|
|
*
|
|
* _.isArray([1, 2, 3]);
|
|
* // => true
|
|
*/
|
|
var isArray = nativeIsArray || function(value) {
|
|
return value && typeof value == 'object' && typeof value.length == 'number' &&
|
|
toString.call(value) == arrayClass || false;
|
|
};
|
|
|
|
/**
|
|
* A fallback implementation of `Object.keys` which produces an array of the
|
|
* given object's own enumerable property names.
|
|
*
|
|
* @private
|
|
* @type Function
|
|
* @param {Object} object The object to inspect.
|
|
* @returns {Array} Returns an array of property names.
|
|
*/
|
|
var shimKeys = function(object) {
|
|
var index, iterable = object, result = [];
|
|
if (!iterable) return result;
|
|
if (!(objectTypes[typeof object])) return result;
|
|
for (index in iterable) {
|
|
if (hasOwnProperty.call(iterable, index)) {
|
|
result.push(index);
|
|
}
|
|
}
|
|
return result
|
|
};
|
|
|
|
/**
|
|
* Creates an array composed of the own enumerable property names of an object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to inspect.
|
|
* @returns {Array} Returns an array of property names.
|
|
* @example
|
|
*
|
|
* _.keys({ 'one': 1, 'two': 2, 'three': 3 });
|
|
* // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
|
|
*/
|
|
var keys = !nativeKeys ? shimKeys : function(object) {
|
|
if (!isObject(object)) {
|
|
return [];
|
|
}
|
|
return nativeKeys(object);
|
|
};
|
|
|
|
/**
|
|
* Used to convert characters to HTML entities:
|
|
*
|
|
* Though the `>` character is escaped for symmetry, characters like `>` and `/`
|
|
* don't require escaping in HTML and have no special meaning unless they're part
|
|
* of a tag or an unquoted attribute value.
|
|
* http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
|
|
*/
|
|
var htmlEscapes = {
|
|
'&': '&',
|
|
'<': '<',
|
|
'>': '>',
|
|
'"': '"',
|
|
"'": '''
|
|
};
|
|
|
|
/** Used to convert HTML entities to characters */
|
|
var htmlUnescapes = invert(htmlEscapes);
|
|
|
|
/** Used to match HTML entities and HTML characters */
|
|
var reEscapedHtml = RegExp('(' + keys(htmlUnescapes).join('|') + ')', 'g'),
|
|
reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Assigns own enumerable properties of source object(s) to the destination
|
|
* object. Subsequent sources will overwrite property assignments of previous
|
|
* sources. If a callback is provided it will be executed to produce the
|
|
* assigned values. The callback is bound to `thisArg` and invoked with two
|
|
* arguments; (objectValue, sourceValue).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @alias extend
|
|
* @category Objects
|
|
* @param {Object} object The destination object.
|
|
* @param {...Object} [source] The source objects.
|
|
* @param {Function} [callback] The function to customize assigning values.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns the destination object.
|
|
* @example
|
|
*
|
|
* _.assign({ 'name': 'fred' }, { 'employer': 'slate' });
|
|
* // => { 'name': 'fred', 'employer': 'slate' }
|
|
*
|
|
* var defaults = _.partialRight(_.assign, function(a, b) {
|
|
* return typeof a == 'undefined' ? b : a;
|
|
* });
|
|
*
|
|
* var object = { 'name': 'barney' };
|
|
* defaults(object, { 'name': 'fred', 'employer': 'slate' });
|
|
* // => { 'name': 'barney', 'employer': 'slate' }
|
|
*/
|
|
var assign = function(object, source, guard) {
|
|
var index, iterable = object, result = iterable;
|
|
if (!iterable) return result;
|
|
var args = arguments,
|
|
argsIndex = 0,
|
|
argsLength = typeof guard == 'number' ? 2 : args.length;
|
|
if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
|
|
var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);
|
|
} else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
|
|
callback = args[--argsLength];
|
|
}
|
|
while (++argsIndex < argsLength) {
|
|
iterable = args[argsIndex];
|
|
if (iterable && objectTypes[typeof iterable]) {
|
|
var ownIndex = -1,
|
|
ownProps = objectTypes[typeof iterable] && keys(iterable),
|
|
length = ownProps ? ownProps.length : 0;
|
|
|
|
while (++ownIndex < length) {
|
|
index = ownProps[ownIndex];
|
|
result[index] = callback ? callback(result[index], iterable[index]) : iterable[index];
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
};
|
|
|
|
/**
|
|
* Creates a clone of `value`. If `isDeep` is `true` nested objects will also
|
|
* be cloned, otherwise they will be assigned by reference. If a callback
|
|
* is provided it will be executed to produce the cloned values. If the
|
|
* callback returns `undefined` cloning will be handled by the method instead.
|
|
* The callback is bound to `thisArg` and invoked with one argument; (value).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to clone.
|
|
* @param {boolean} [isDeep=false] Specify a deep clone.
|
|
* @param {Function} [callback] The function to customize cloning values.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the cloned value.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* var shallow = _.clone(characters);
|
|
* shallow[0] === characters[0];
|
|
* // => true
|
|
*
|
|
* var deep = _.clone(characters, true);
|
|
* deep[0] === characters[0];
|
|
* // => false
|
|
*
|
|
* _.mixin({
|
|
* 'clone': _.partialRight(_.clone, function(value) {
|
|
* return _.isElement(value) ? value.cloneNode(false) : undefined;
|
|
* })
|
|
* });
|
|
*
|
|
* var clone = _.clone(document.body);
|
|
* clone.childNodes.length;
|
|
* // => 0
|
|
*/
|
|
function clone(value, isDeep, callback, thisArg) {
|
|
// allows working with "Collections" methods without using their `index`
|
|
// and `collection` arguments for `isDeep` and `callback`
|
|
if (typeof isDeep != 'boolean' && isDeep != null) {
|
|
thisArg = callback;
|
|
callback = isDeep;
|
|
isDeep = false;
|
|
}
|
|
return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
|
|
}
|
|
|
|
/**
|
|
* Creates a deep clone of `value`. If a callback is provided it will be
|
|
* executed to produce the cloned values. If the callback returns `undefined`
|
|
* cloning will be handled by the method instead. The callback is bound to
|
|
* `thisArg` and invoked with one argument; (value).
|
|
*
|
|
* Note: This method is loosely based on the structured clone algorithm. Functions
|
|
* and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
|
|
* objects created by constructors other than `Object` are cloned to plain `Object` objects.
|
|
* See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to deep clone.
|
|
* @param {Function} [callback] The function to customize cloning values.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the deep cloned value.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* var deep = _.cloneDeep(characters);
|
|
* deep[0] === characters[0];
|
|
* // => false
|
|
*
|
|
* var view = {
|
|
* 'label': 'docs',
|
|
* 'node': element
|
|
* };
|
|
*
|
|
* var clone = _.cloneDeep(view, function(value) {
|
|
* return _.isElement(value) ? value.cloneNode(true) : undefined;
|
|
* });
|
|
*
|
|
* clone.node == view.node;
|
|
* // => false
|
|
*/
|
|
function cloneDeep(value, callback, thisArg) {
|
|
return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
|
|
}
|
|
|
|
/**
|
|
* Creates an object that inherits from the given `prototype` object. If a
|
|
* `properties` object is provided its own enumerable properties are assigned
|
|
* to the created object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} prototype The object to inherit from.
|
|
* @param {Object} [properties] The properties to assign to the object.
|
|
* @returns {Object} Returns the new object.
|
|
* @example
|
|
*
|
|
* function Shape() {
|
|
* this.x = 0;
|
|
* this.y = 0;
|
|
* }
|
|
*
|
|
* function Circle() {
|
|
* Shape.call(this);
|
|
* }
|
|
*
|
|
* Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle });
|
|
*
|
|
* var circle = new Circle;
|
|
* circle instanceof Circle;
|
|
* // => true
|
|
*
|
|
* circle instanceof Shape;
|
|
* // => true
|
|
*/
|
|
function create(prototype, properties) {
|
|
var result = baseCreate(prototype);
|
|
return properties ? assign(result, properties) : result;
|
|
}
|
|
|
|
/**
|
|
* Assigns own enumerable properties of source object(s) to the destination
|
|
* object for all destination properties that resolve to `undefined`. Once a
|
|
* property is set, additional defaults of the same property will be ignored.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @category Objects
|
|
* @param {Object} object The destination object.
|
|
* @param {...Object} [source] The source objects.
|
|
* @param- {Object} [guard] Allows working with `_.reduce` without using its
|
|
* `key` and `object` arguments as sources.
|
|
* @returns {Object} Returns the destination object.
|
|
* @example
|
|
*
|
|
* var object = { 'name': 'barney' };
|
|
* _.defaults(object, { 'name': 'fred', 'employer': 'slate' });
|
|
* // => { 'name': 'barney', 'employer': 'slate' }
|
|
*/
|
|
var defaults = function(object, source, guard) {
|
|
var index, iterable = object, result = iterable;
|
|
if (!iterable) return result;
|
|
var args = arguments,
|
|
argsIndex = 0,
|
|
argsLength = typeof guard == 'number' ? 2 : args.length;
|
|
while (++argsIndex < argsLength) {
|
|
iterable = args[argsIndex];
|
|
if (iterable && objectTypes[typeof iterable]) {
|
|
var ownIndex = -1,
|
|
ownProps = objectTypes[typeof iterable] && keys(iterable),
|
|
length = ownProps ? ownProps.length : 0;
|
|
|
|
while (++ownIndex < length) {
|
|
index = ownProps[ownIndex];
|
|
if (typeof result[index] == 'undefined') result[index] = iterable[index];
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
};
|
|
|
|
/**
|
|
* This method is like `_.findIndex` except that it returns the key of the
|
|
* first element that passes the callback check, instead of the element itself.
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to search.
|
|
* @param {Function|Object|string} [callback=identity] The function called per
|
|
* iteration. If a property name or object is provided it will be used to
|
|
* create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {string|undefined} Returns the key of the found element, else `undefined`.
|
|
* @example
|
|
*
|
|
* var characters = {
|
|
* 'barney': { 'age': 36, 'blocked': false },
|
|
* 'fred': { 'age': 40, 'blocked': true },
|
|
* 'pebbles': { 'age': 1, 'blocked': false }
|
|
* };
|
|
*
|
|
* _.findKey(characters, function(chr) {
|
|
* return chr.age < 40;
|
|
* });
|
|
* // => 'barney' (property order is not guaranteed across environments)
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.findKey(characters, { 'age': 1 });
|
|
* // => 'pebbles'
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.findKey(characters, 'blocked');
|
|
* // => 'fred'
|
|
*/
|
|
function findKey(object, callback, thisArg) {
|
|
var result;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
forOwn(object, function(value, key, object) {
|
|
if (callback(value, key, object)) {
|
|
result = key;
|
|
return false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.findKey` except that it iterates over elements
|
|
* of a `collection` in the opposite order.
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to search.
|
|
* @param {Function|Object|string} [callback=identity] The function called per
|
|
* iteration. If a property name or object is provided it will be used to
|
|
* create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {string|undefined} Returns the key of the found element, else `undefined`.
|
|
* @example
|
|
*
|
|
* var characters = {
|
|
* 'barney': { 'age': 36, 'blocked': true },
|
|
* 'fred': { 'age': 40, 'blocked': false },
|
|
* 'pebbles': { 'age': 1, 'blocked': true }
|
|
* };
|
|
*
|
|
* _.findLastKey(characters, function(chr) {
|
|
* return chr.age < 40;
|
|
* });
|
|
* // => returns `pebbles`, assuming `_.findKey` returns `barney`
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.findLastKey(characters, { 'age': 40 });
|
|
* // => 'fred'
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.findLastKey(characters, 'blocked');
|
|
* // => 'pebbles'
|
|
*/
|
|
function findLastKey(object, callback, thisArg) {
|
|
var result;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
forOwnRight(object, function(value, key, object) {
|
|
if (callback(value, key, object)) {
|
|
result = key;
|
|
return false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Iterates over own and inherited enumerable properties of an object,
|
|
* executing the callback for each property. The callback is bound to `thisArg`
|
|
* and invoked with three arguments; (value, key, object). Callbacks may exit
|
|
* iteration early by explicitly returning `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @category Objects
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns `object`.
|
|
* @example
|
|
*
|
|
* function Shape() {
|
|
* this.x = 0;
|
|
* this.y = 0;
|
|
* }
|
|
*
|
|
* Shape.prototype.move = function(x, y) {
|
|
* this.x += x;
|
|
* this.y += y;
|
|
* };
|
|
*
|
|
* _.forIn(new Shape, function(value, key) {
|
|
* console.log(key);
|
|
* });
|
|
* // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments)
|
|
*/
|
|
var forIn = function(collection, callback, thisArg) {
|
|
var index, iterable = collection, result = iterable;
|
|
if (!iterable) return result;
|
|
if (!objectTypes[typeof iterable]) return result;
|
|
callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
|
|
for (index in iterable) {
|
|
if (callback(iterable[index], index, collection) === false) return result;
|
|
}
|
|
return result
|
|
};
|
|
|
|
/**
|
|
* This method is like `_.forIn` except that it iterates over elements
|
|
* of a `collection` in the opposite order.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns `object`.
|
|
* @example
|
|
*
|
|
* function Shape() {
|
|
* this.x = 0;
|
|
* this.y = 0;
|
|
* }
|
|
*
|
|
* Shape.prototype.move = function(x, y) {
|
|
* this.x += x;
|
|
* this.y += y;
|
|
* };
|
|
*
|
|
* _.forInRight(new Shape, function(value, key) {
|
|
* console.log(key);
|
|
* });
|
|
* // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move'
|
|
*/
|
|
function forInRight(object, callback, thisArg) {
|
|
var pairs = [];
|
|
|
|
forIn(object, function(value, key) {
|
|
pairs.push(key, value);
|
|
});
|
|
|
|
var length = pairs.length;
|
|
callback = baseCreateCallback(callback, thisArg, 3);
|
|
while (length--) {
|
|
if (callback(pairs[length--], pairs[length], object) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Iterates over own enumerable properties of an object, executing the callback
|
|
* for each property. The callback is bound to `thisArg` and invoked with three
|
|
* arguments; (value, key, object). Callbacks may exit iteration early by
|
|
* explicitly returning `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @category Objects
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns `object`.
|
|
* @example
|
|
*
|
|
* _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
|
|
* console.log(key);
|
|
* });
|
|
* // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
|
|
*/
|
|
var forOwn = function(collection, callback, thisArg) {
|
|
var index, iterable = collection, result = iterable;
|
|
if (!iterable) return result;
|
|
if (!objectTypes[typeof iterable]) return result;
|
|
callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
|
|
var ownIndex = -1,
|
|
ownProps = objectTypes[typeof iterable] && keys(iterable),
|
|
length = ownProps ? ownProps.length : 0;
|
|
|
|
while (++ownIndex < length) {
|
|
index = ownProps[ownIndex];
|
|
if (callback(iterable[index], index, collection) === false) return result;
|
|
}
|
|
return result
|
|
};
|
|
|
|
/**
|
|
* This method is like `_.forOwn` except that it iterates over elements
|
|
* of a `collection` in the opposite order.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns `object`.
|
|
* @example
|
|
*
|
|
* _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
|
|
* console.log(key);
|
|
* });
|
|
* // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length'
|
|
*/
|
|
function forOwnRight(object, callback, thisArg) {
|
|
var props = keys(object),
|
|
length = props.length;
|
|
|
|
callback = baseCreateCallback(callback, thisArg, 3);
|
|
while (length--) {
|
|
var key = props[length];
|
|
if (callback(object[key], key, object) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Creates a sorted array of property names of all enumerable properties,
|
|
* own and inherited, of `object` that have function values.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias methods
|
|
* @category Objects
|
|
* @param {Object} object The object to inspect.
|
|
* @returns {Array} Returns an array of property names that have function values.
|
|
* @example
|
|
*
|
|
* _.functions(_);
|
|
* // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
|
|
*/
|
|
function functions(object) {
|
|
var result = [];
|
|
forIn(object, function(value, key) {
|
|
if (isFunction(value)) {
|
|
result.push(key);
|
|
}
|
|
});
|
|
return result.sort();
|
|
}
|
|
|
|
/**
|
|
* Checks if the specified object `property` exists and is a direct property,
|
|
* instead of an inherited property.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to check.
|
|
* @param {string} property The property to check for.
|
|
* @returns {boolean} Returns `true` if key is a direct property, else `false`.
|
|
* @example
|
|
*
|
|
* _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
|
|
* // => true
|
|
*/
|
|
function has(object, property) {
|
|
return object ? hasOwnProperty.call(object, property) : false;
|
|
}
|
|
|
|
/**
|
|
* Creates an object composed of the inverted keys and values of the given object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to invert.
|
|
* @returns {Object} Returns the created inverted object.
|
|
* @example
|
|
*
|
|
* _.invert({ 'first': 'fred', 'second': 'barney' });
|
|
* // => { 'fred': 'first', 'barney': 'second' }
|
|
*/
|
|
function invert(object) {
|
|
var index = -1,
|
|
props = keys(object),
|
|
length = props.length,
|
|
result = {};
|
|
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
result[object[key]] = key;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a boolean value.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`.
|
|
* @example
|
|
*
|
|
* _.isBoolean(null);
|
|
* // => false
|
|
*/
|
|
function isBoolean(value) {
|
|
return value === true || value === false ||
|
|
value && typeof value == 'object' && toString.call(value) == boolClass || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a date.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a date, else `false`.
|
|
* @example
|
|
*
|
|
* _.isDate(new Date);
|
|
* // => true
|
|
*/
|
|
function isDate(value) {
|
|
return value && typeof value == 'object' && toString.call(value) == dateClass || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a DOM element.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`.
|
|
* @example
|
|
*
|
|
* _.isElement(document.body);
|
|
* // => true
|
|
*/
|
|
function isElement(value) {
|
|
return value && value.nodeType === 1 || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
|
|
* length of `0` and objects with no own enumerable properties are considered
|
|
* "empty".
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Array|Object|string} value The value to inspect.
|
|
* @returns {boolean} Returns `true` if the `value` is empty, else `false`.
|
|
* @example
|
|
*
|
|
* _.isEmpty([1, 2, 3]);
|
|
* // => false
|
|
*
|
|
* _.isEmpty({});
|
|
* // => true
|
|
*
|
|
* _.isEmpty('');
|
|
* // => true
|
|
*/
|
|
function isEmpty(value) {
|
|
var result = true;
|
|
if (!value) {
|
|
return result;
|
|
}
|
|
var className = toString.call(value),
|
|
length = value.length;
|
|
|
|
if ((className == arrayClass || className == stringClass || className == argsClass ) ||
|
|
(className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
|
|
return !length;
|
|
}
|
|
forOwn(value, function() {
|
|
return (result = false);
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Performs a deep comparison between two values to determine if they are
|
|
* equivalent to each other. If a callback is provided it will be executed
|
|
* to compare values. If the callback returns `undefined` comparisons will
|
|
* be handled by the method instead. The callback is bound to `thisArg` and
|
|
* invoked with two arguments; (a, b).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} a The value to compare.
|
|
* @param {*} b The other value to compare.
|
|
* @param {Function} [callback] The function to customize comparing values.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
|
* @example
|
|
*
|
|
* var object = { 'name': 'fred' };
|
|
* var copy = { 'name': 'fred' };
|
|
*
|
|
* object == copy;
|
|
* // => false
|
|
*
|
|
* _.isEqual(object, copy);
|
|
* // => true
|
|
*
|
|
* var words = ['hello', 'goodbye'];
|
|
* var otherWords = ['hi', 'goodbye'];
|
|
*
|
|
* _.isEqual(words, otherWords, function(a, b) {
|
|
* var reGreet = /^(?:hello|hi)$/i,
|
|
* aGreet = _.isString(a) && reGreet.test(a),
|
|
* bGreet = _.isString(b) && reGreet.test(b);
|
|
*
|
|
* return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
|
|
* });
|
|
* // => true
|
|
*/
|
|
function isEqual(a, b, callback, thisArg) {
|
|
return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2));
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is, or can be coerced to, a finite number.
|
|
*
|
|
* Note: This is not the same as native `isFinite` which will return true for
|
|
* booleans and empty strings. See http://es5.github.io/#x15.1.2.5.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is finite, else `false`.
|
|
* @example
|
|
*
|
|
* _.isFinite(-101);
|
|
* // => true
|
|
*
|
|
* _.isFinite('10');
|
|
* // => true
|
|
*
|
|
* _.isFinite(true);
|
|
* // => false
|
|
*
|
|
* _.isFinite('');
|
|
* // => false
|
|
*
|
|
* _.isFinite(Infinity);
|
|
* // => false
|
|
*/
|
|
function isFinite(value) {
|
|
return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a function, else `false`.
|
|
* @example
|
|
*
|
|
* _.isFunction(_);
|
|
* // => true
|
|
*/
|
|
function isFunction(value) {
|
|
return typeof value == 'function';
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is the language type of Object.
|
|
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is an object, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObject({});
|
|
* // => true
|
|
*
|
|
* _.isObject([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObject(1);
|
|
* // => false
|
|
*/
|
|
function isObject(value) {
|
|
// check if the value is the ECMAScript language type of Object
|
|
// http://es5.github.io/#x8
|
|
// and avoid a V8 bug
|
|
// http://code.google.com/p/v8/issues/detail?id=2291
|
|
return !!(value && objectTypes[typeof value]);
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is `NaN`.
|
|
*
|
|
* Note: This is not the same as native `isNaN` which will return `true` for
|
|
* `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`.
|
|
* @example
|
|
*
|
|
* _.isNaN(NaN);
|
|
* // => true
|
|
*
|
|
* _.isNaN(new Number(NaN));
|
|
* // => true
|
|
*
|
|
* isNaN(undefined);
|
|
* // => true
|
|
*
|
|
* _.isNaN(undefined);
|
|
* // => false
|
|
*/
|
|
function isNaN(value) {
|
|
// `NaN` as a primitive is the only value that is not equal to itself
|
|
// (perform the [[Class]] check first to avoid errors with some host objects in IE)
|
|
return isNumber(value) && value != +value;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is `null`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is `null`, else `false`.
|
|
* @example
|
|
*
|
|
* _.isNull(null);
|
|
* // => true
|
|
*
|
|
* _.isNull(undefined);
|
|
* // => false
|
|
*/
|
|
function isNull(value) {
|
|
return value === null;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a number.
|
|
*
|
|
* Note: `NaN` is considered a number. See http://es5.github.io/#x8.5.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a number, else `false`.
|
|
* @example
|
|
*
|
|
* _.isNumber(8.4 * 5);
|
|
* // => true
|
|
*/
|
|
function isNumber(value) {
|
|
return typeof value == 'number' ||
|
|
value && typeof value == 'object' && toString.call(value) == numberClass || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is an object created by the `Object` constructor.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
|
|
* @example
|
|
*
|
|
* function Shape() {
|
|
* this.x = 0;
|
|
* this.y = 0;
|
|
* }
|
|
*
|
|
* _.isPlainObject(new Shape);
|
|
* // => false
|
|
*
|
|
* _.isPlainObject([1, 2, 3]);
|
|
* // => false
|
|
*
|
|
* _.isPlainObject({ 'x': 0, 'y': 0 });
|
|
* // => true
|
|
*/
|
|
var isPlainObject = function(value) {
|
|
if (!(value && toString.call(value) == objectClass)) {
|
|
return false;
|
|
}
|
|
var valueOf = value.valueOf,
|
|
objProto = typeof valueOf == 'function' && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
|
|
|
|
return objProto
|
|
? (value == objProto || getPrototypeOf(value) == objProto)
|
|
: shimIsPlainObject(value);
|
|
};
|
|
|
|
/**
|
|
* Checks if `value` is a regular expression.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`.
|
|
* @example
|
|
*
|
|
* _.isRegExp(/fred/);
|
|
* // => true
|
|
*/
|
|
function isRegExp(value) {
|
|
return value && typeof value == 'object' && toString.call(value) == regexpClass || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a string.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is a string, else `false`.
|
|
* @example
|
|
*
|
|
* _.isString('fred');
|
|
* // => true
|
|
*/
|
|
function isString(value) {
|
|
return typeof value == 'string' ||
|
|
value && typeof value == 'object' && toString.call(value) == stringClass || false;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is `undefined`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`.
|
|
* @example
|
|
*
|
|
* _.isUndefined(void 0);
|
|
* // => true
|
|
*/
|
|
function isUndefined(value) {
|
|
return typeof value == 'undefined';
|
|
}
|
|
|
|
/**
|
|
* Recursively merges own enumerable properties of the source object(s), that
|
|
* don't resolve to `undefined` into the destination object. Subsequent sources
|
|
* will overwrite property assignments of previous sources. If a callback is
|
|
* provided it will be executed to produce the merged values of the destination
|
|
* and source properties. If the callback returns `undefined` merging will
|
|
* be handled by the method instead. The callback is bound to `thisArg` and
|
|
* invoked with two arguments; (objectValue, sourceValue).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The destination object.
|
|
* @param {...Object} [source] The source objects.
|
|
* @param {Function} [callback] The function to customize merging properties.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns the destination object.
|
|
* @example
|
|
*
|
|
* var names = {
|
|
* 'characters': [
|
|
* { 'name': 'barney' },
|
|
* { 'name': 'fred' }
|
|
* ]
|
|
* };
|
|
*
|
|
* var ages = {
|
|
* 'characters': [
|
|
* { 'age': 36 },
|
|
* { 'age': 40 }
|
|
* ]
|
|
* };
|
|
*
|
|
* _.merge(names, ages);
|
|
* // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] }
|
|
*
|
|
* var food = {
|
|
* 'fruits': ['apple'],
|
|
* 'vegetables': ['beet']
|
|
* };
|
|
*
|
|
* var otherFood = {
|
|
* 'fruits': ['banana'],
|
|
* 'vegetables': ['carrot']
|
|
* };
|
|
*
|
|
* _.merge(food, otherFood, function(a, b) {
|
|
* return _.isArray(a) ? a.concat(b) : undefined;
|
|
* });
|
|
* // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
|
|
*/
|
|
function merge(object) {
|
|
var args = arguments,
|
|
length = 2;
|
|
|
|
if (!isObject(object)) {
|
|
return object;
|
|
}
|
|
|
|
// allows working with `_.reduce` and `_.reduceRight` without using
|
|
// their `index` and `collection` arguments
|
|
if (typeof args[2] != 'number') {
|
|
length = args.length;
|
|
}
|
|
if (length > 3 && typeof args[length - 2] == 'function') {
|
|
var callback = baseCreateCallback(args[--length - 1], args[length--], 2);
|
|
} else if (length > 2 && typeof args[length - 1] == 'function') {
|
|
callback = args[--length];
|
|
}
|
|
var sources = slice(arguments, 1, length),
|
|
index = -1,
|
|
stackA = getArray(),
|
|
stackB = getArray();
|
|
|
|
while (++index < length) {
|
|
baseMerge(object, sources[index], callback, stackA, stackB);
|
|
}
|
|
releaseArray(stackA);
|
|
releaseArray(stackB);
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Creates a shallow clone of `object` excluding the specified properties.
|
|
* Property names may be specified as individual arguments or as arrays of
|
|
* property names. If a callback is provided it will be executed for each
|
|
* property of `object` omitting the properties the callback returns truey
|
|
* for. The callback is bound to `thisArg` and invoked with three arguments;
|
|
* (value, key, object).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The source object.
|
|
* @param {Function|...string|string[]} [callback] The properties to omit or the
|
|
* function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns an object without the omitted properties.
|
|
* @example
|
|
*
|
|
* _.omit({ 'name': 'fred', 'age': 40 }, 'age');
|
|
* // => { 'name': 'fred' }
|
|
*
|
|
* _.omit({ 'name': 'fred', 'age': 40 }, function(value) {
|
|
* return typeof value == 'number';
|
|
* });
|
|
* // => { 'name': 'fred' }
|
|
*/
|
|
function omit(object, callback, thisArg) {
|
|
var result = {};
|
|
if (typeof callback != 'function') {
|
|
var props = [];
|
|
forIn(object, function(value, key) {
|
|
props.push(key);
|
|
});
|
|
props = baseDifference(props, baseFlatten(arguments, true, false, 1));
|
|
|
|
var index = -1,
|
|
length = props.length;
|
|
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
result[key] = object[key];
|
|
}
|
|
} else {
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
forIn(object, function(value, key, object) {
|
|
if (!callback(value, key, object)) {
|
|
result[key] = value;
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates a two dimensional array of an object's key-value pairs,
|
|
* i.e. `[[key1, value1], [key2, value2]]`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to inspect.
|
|
* @returns {Array} Returns new array of key-value pairs.
|
|
* @example
|
|
*
|
|
* _.pairs({ 'barney': 36, 'fred': 40 });
|
|
* // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments)
|
|
*/
|
|
function pairs(object) {
|
|
var index = -1,
|
|
props = keys(object),
|
|
length = props.length,
|
|
result = Array(length);
|
|
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
result[index] = [key, object[key]];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates a shallow clone of `object` composed of the specified properties.
|
|
* Property names may be specified as individual arguments or as arrays of
|
|
* property names. If a callback is provided it will be executed for each
|
|
* property of `object` picking the properties the callback returns truey
|
|
* for. The callback is bound to `thisArg` and invoked with three arguments;
|
|
* (value, key, object).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The source object.
|
|
* @param {Function|...string|string[]} [callback] The function called per
|
|
* iteration or property names to pick, specified as individual property
|
|
* names or arrays of property names.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns an object composed of the picked properties.
|
|
* @example
|
|
*
|
|
* _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name');
|
|
* // => { 'name': 'fred' }
|
|
*
|
|
* _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) {
|
|
* return key.charAt(0) != '_';
|
|
* });
|
|
* // => { 'name': 'fred' }
|
|
*/
|
|
function pick(object, callback, thisArg) {
|
|
var result = {};
|
|
if (typeof callback != 'function') {
|
|
var index = -1,
|
|
props = baseFlatten(arguments, true, false, 1),
|
|
length = isObject(object) ? props.length : 0;
|
|
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
if (key in object) {
|
|
result[key] = object[key];
|
|
}
|
|
}
|
|
} else {
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
forIn(object, function(value, key, object) {
|
|
if (callback(value, key, object)) {
|
|
result[key] = value;
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* An alternative to `_.reduce` this method transforms `object` to a new
|
|
* `accumulator` object which is the result of running each of its elements
|
|
* through a callback, with each callback execution potentially mutating
|
|
* the `accumulator` object. The callback is bound to `thisArg` and invoked
|
|
* with four arguments; (accumulator, value, key, object). Callbacks may exit
|
|
* iteration early by explicitly returning `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Array|Object} object The object to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [accumulator] The custom accumulator value.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the accumulated value.
|
|
* @example
|
|
*
|
|
* var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {
|
|
* num *= num;
|
|
* if (num % 2) {
|
|
* return result.push(num) < 3;
|
|
* }
|
|
* });
|
|
* // => [1, 9, 25]
|
|
*
|
|
* var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
|
|
* result[key] = num * 3;
|
|
* });
|
|
* // => { 'a': 3, 'b': 6, 'c': 9 }
|
|
*/
|
|
function transform(object, callback, accumulator, thisArg) {
|
|
var isArr = isArray(object);
|
|
if (accumulator == null) {
|
|
if (isArr) {
|
|
accumulator = [];
|
|
} else {
|
|
var ctor = object && object.constructor,
|
|
proto = ctor && ctor.prototype;
|
|
|
|
accumulator = baseCreate(proto);
|
|
}
|
|
}
|
|
if (callback) {
|
|
callback = lodash.createCallback(callback, thisArg, 4);
|
|
(isArr ? forEach : forOwn)(object, function(value, index, object) {
|
|
return callback(accumulator, value, index, object);
|
|
});
|
|
}
|
|
return accumulator;
|
|
}
|
|
|
|
/**
|
|
* Creates an array composed of the own enumerable property values of `object`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Objects
|
|
* @param {Object} object The object to inspect.
|
|
* @returns {Array} Returns an array of property values.
|
|
* @example
|
|
*
|
|
* _.values({ 'one': 1, 'two': 2, 'three': 3 });
|
|
* // => [1, 2, 3] (property order is not guaranteed across environments)
|
|
*/
|
|
function values(object) {
|
|
var index = -1,
|
|
props = keys(object),
|
|
length = props.length,
|
|
result = Array(length);
|
|
|
|
while (++index < length) {
|
|
result[index] = object[props[index]];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Creates an array of elements from the specified indexes, or keys, of the
|
|
* `collection`. Indexes may be specified as individual arguments or as arrays
|
|
* of indexes.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {...(number|number[]|string|string[])} [index] The indexes of `collection`
|
|
* to retrieve, specified as individual indexes or arrays of indexes.
|
|
* @returns {Array} Returns a new array of elements corresponding to the
|
|
* provided indexes.
|
|
* @example
|
|
*
|
|
* _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
|
|
* // => ['a', 'c', 'e']
|
|
*
|
|
* _.at(['fred', 'barney', 'pebbles'], 0, 2);
|
|
* // => ['fred', 'pebbles']
|
|
*/
|
|
function at(collection) {
|
|
var args = arguments,
|
|
index = -1,
|
|
props = baseFlatten(args, true, false, 1),
|
|
length = (args[2] && args[2][args[1]] === collection) ? 1 : props.length,
|
|
result = Array(length);
|
|
|
|
while(++index < length) {
|
|
result[index] = collection[props[index]];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Checks if a given value is present in a collection using strict equality
|
|
* for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the
|
|
* offset from the end of the collection.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias include
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {*} target The value to check for.
|
|
* @param {number} [fromIndex=0] The index to search from.
|
|
* @returns {boolean} Returns `true` if the `target` element is found, else `false`.
|
|
* @example
|
|
*
|
|
* _.contains([1, 2, 3], 1);
|
|
* // => true
|
|
*
|
|
* _.contains([1, 2, 3], 1, 2);
|
|
* // => false
|
|
*
|
|
* _.contains({ 'name': 'fred', 'age': 40 }, 'fred');
|
|
* // => true
|
|
*
|
|
* _.contains('pebbles', 'eb');
|
|
* // => true
|
|
*/
|
|
function contains(collection, target, fromIndex) {
|
|
var index = -1,
|
|
indexOf = getIndexOf(),
|
|
length = collection ? collection.length : 0,
|
|
result = false;
|
|
|
|
fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
|
|
if (isArray(collection)) {
|
|
result = indexOf(collection, target, fromIndex) > -1;
|
|
} else if (typeof length == 'number') {
|
|
result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1;
|
|
} else {
|
|
forOwn(collection, function(value) {
|
|
if (++index >= fromIndex) {
|
|
return !(result = value === target);
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates an object composed of keys generated from the results of running
|
|
* each element of `collection` through the callback. The corresponding value
|
|
* of each key is the number of times the key was returned by the callback.
|
|
* The callback is bound to `thisArg` and invoked with three arguments;
|
|
* (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns the composed aggregate object.
|
|
* @example
|
|
*
|
|
* _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
|
|
* // => { '4': 1, '6': 2 }
|
|
*
|
|
* _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
|
|
* // => { '4': 1, '6': 2 }
|
|
*
|
|
* _.countBy(['one', 'two', 'three'], 'length');
|
|
* // => { '3': 2, '5': 1 }
|
|
*/
|
|
var countBy = createAggregator(function(result, value, key) {
|
|
(hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
|
|
});
|
|
|
|
/**
|
|
* Checks if the given callback returns truey value for **all** elements of
|
|
* a collection. The callback is bound to `thisArg` and invoked with three
|
|
* arguments; (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias all
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {boolean} Returns `true` if all elements passed the callback check,
|
|
* else `false`.
|
|
* @example
|
|
*
|
|
* _.every([true, 1, null, 'yes']);
|
|
* // => false
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.every(characters, 'age');
|
|
* // => true
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.every(characters, { 'age': 36 });
|
|
* // => false
|
|
*/
|
|
function every(collection, callback, thisArg) {
|
|
var result = true;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
if (typeof length == 'number') {
|
|
while (++index < length) {
|
|
if (!(result = !!callback(collection[index], index, collection))) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
forOwn(collection, function(value, index, collection) {
|
|
return (result = !!callback(value, index, collection));
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Iterates over elements of a collection, returning an array of all elements
|
|
* the callback returns truey for. The callback is bound to `thisArg` and
|
|
* invoked with three arguments; (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias select
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a new array of elements that passed the callback check.
|
|
* @example
|
|
*
|
|
* var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
|
|
* // => [2, 4, 6]
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'blocked': false },
|
|
* { 'name': 'fred', 'age': 40, 'blocked': true }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.filter(characters, 'blocked');
|
|
* // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.filter(characters, { 'age': 36 });
|
|
* // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
|
|
*/
|
|
function filter(collection, callback, thisArg) {
|
|
var result = [];
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
if (typeof length == 'number') {
|
|
while (++index < length) {
|
|
var value = collection[index];
|
|
if (callback(value, index, collection)) {
|
|
result.push(value);
|
|
}
|
|
}
|
|
} else {
|
|
forOwn(collection, function(value, index, collection) {
|
|
if (callback(value, index, collection)) {
|
|
result.push(value);
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Iterates over elements of a collection, returning the first element that
|
|
* the callback returns truey for. The callback is bound to `thisArg` and
|
|
* invoked with three arguments; (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias detect, findWhere
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the found element, else `undefined`.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'blocked': false },
|
|
* { 'name': 'fred', 'age': 40, 'blocked': true },
|
|
* { 'name': 'pebbles', 'age': 1, 'blocked': false }
|
|
* ];
|
|
*
|
|
* _.find(characters, function(chr) {
|
|
* return chr.age < 40;
|
|
* });
|
|
* // => { 'name': 'barney', 'age': 36, 'blocked': false }
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.find(characters, { 'age': 1 });
|
|
* // => { 'name': 'pebbles', 'age': 1, 'blocked': false }
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.find(characters, 'blocked');
|
|
* // => { 'name': 'fred', 'age': 40, 'blocked': true }
|
|
*/
|
|
function find(collection, callback, thisArg) {
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
if (typeof length == 'number') {
|
|
while (++index < length) {
|
|
var value = collection[index];
|
|
if (callback(value, index, collection)) {
|
|
return value;
|
|
}
|
|
}
|
|
} else {
|
|
var result;
|
|
forOwn(collection, function(value, index, collection) {
|
|
if (callback(value, index, collection)) {
|
|
result = value;
|
|
return false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.find` except that it iterates over elements
|
|
* of a `collection` from right to left.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the found element, else `undefined`.
|
|
* @example
|
|
*
|
|
* _.findLast([1, 2, 3, 4], function(num) {
|
|
* return num % 2 == 1;
|
|
* });
|
|
* // => 3
|
|
*/
|
|
function findLast(collection, callback, thisArg) {
|
|
var result;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
forEachRight(collection, function(value, index, collection) {
|
|
if (callback(value, index, collection)) {
|
|
result = value;
|
|
return false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Iterates over elements of a collection, executing the callback for each
|
|
* element. The callback is bound to `thisArg` and invoked with three arguments;
|
|
* (value, index|key, collection). Callbacks may exit iteration early by
|
|
* explicitly returning `false`.
|
|
*
|
|
* Note: As with other "Collections" methods, objects with a `length` property
|
|
* are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
|
|
* may be used for object iteration.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias each
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array|Object|string} Returns `collection`.
|
|
* @example
|
|
*
|
|
* _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');
|
|
* // => logs each number and returns '1,2,3'
|
|
*
|
|
* _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
|
|
* // => logs each number and returns the object (property order is not guaranteed across environments)
|
|
*/
|
|
function forEach(collection, callback, thisArg) {
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
|
|
if (typeof length == 'number') {
|
|
while (++index < length) {
|
|
if (callback(collection[index], index, collection) === false) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
forOwn(collection, callback);
|
|
}
|
|
return collection;
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.forEach` except that it iterates over elements
|
|
* of a `collection` from right to left.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias eachRight
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array|Object|string} Returns `collection`.
|
|
* @example
|
|
*
|
|
* _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(',');
|
|
* // => logs each number from right to left and returns '3,2,1'
|
|
*/
|
|
function forEachRight(collection, callback, thisArg) {
|
|
var length = collection ? collection.length : 0;
|
|
callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
|
|
if (typeof length == 'number') {
|
|
while (length--) {
|
|
if (callback(collection[length], length, collection) === false) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
var props = keys(collection);
|
|
length = props.length;
|
|
forOwn(collection, function(value, key, collection) {
|
|
key = props ? props[--length] : --length;
|
|
return callback(collection[key], key, collection);
|
|
});
|
|
}
|
|
return collection;
|
|
}
|
|
|
|
/**
|
|
* Creates an object composed of keys generated from the results of running
|
|
* each element of a collection through the callback. The corresponding value
|
|
* of each key is an array of the elements responsible for generating the key.
|
|
* The callback is bound to `thisArg` and invoked with three arguments;
|
|
* (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns the composed aggregate object.
|
|
* @example
|
|
*
|
|
* _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
|
|
* // => { '4': [4.2], '6': [6.1, 6.4] }
|
|
*
|
|
* _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
|
|
* // => { '4': [4.2], '6': [6.1, 6.4] }
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.groupBy(['one', 'two', 'three'], 'length');
|
|
* // => { '3': ['one', 'two'], '5': ['three'] }
|
|
*/
|
|
var groupBy = createAggregator(function(result, value, key) {
|
|
(hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
|
|
});
|
|
|
|
/**
|
|
* Creates an object composed of keys generated from the results of running
|
|
* each element of the collection through the given callback. The corresponding
|
|
* value of each key is the last element responsible for generating the key.
|
|
* The callback is bound to `thisArg` and invoked with three arguments;
|
|
* (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Object} Returns the composed aggregate object.
|
|
* @example
|
|
*
|
|
* var keys = [
|
|
* { 'dir': 'left', 'code': 97 },
|
|
* { 'dir': 'right', 'code': 100 }
|
|
* ];
|
|
*
|
|
* _.indexBy(keys, 'dir');
|
|
* // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
|
|
*
|
|
* _.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
|
|
* // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
|
|
*
|
|
* _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String);
|
|
* // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
|
|
*/
|
|
var indexBy = createAggregator(function(result, value, key) {
|
|
result[key] = value;
|
|
});
|
|
|
|
/**
|
|
* Invokes the method named by `methodName` on each element in the `collection`
|
|
* returning an array of the results of each invoked method. Additional arguments
|
|
* will be provided to each invoked method. If `methodName` is a function it
|
|
* will be invoked for, and `this` bound to, each element in the `collection`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|string} methodName The name of the method to invoke or
|
|
* the function invoked per iteration.
|
|
* @param {...*} [arg] Arguments to invoke the method with.
|
|
* @returns {Array} Returns a new array of the results of each invoked method.
|
|
* @example
|
|
*
|
|
* _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
|
|
* // => [[1, 5, 7], [1, 2, 3]]
|
|
*
|
|
* _.invoke([123, 456], String.prototype.split, '');
|
|
* // => [['1', '2', '3'], ['4', '5', '6']]
|
|
*/
|
|
function invoke(collection, methodName) {
|
|
var args = slice(arguments, 2),
|
|
index = -1,
|
|
isFunc = typeof methodName == 'function',
|
|
length = collection ? collection.length : 0,
|
|
result = Array(typeof length == 'number' ? length : 0);
|
|
|
|
forEach(collection, function(value) {
|
|
result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates an array of values by running each element in the collection
|
|
* through the callback. The callback is bound to `thisArg` and invoked with
|
|
* three arguments; (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias collect
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a new array of the results of each `callback` execution.
|
|
* @example
|
|
*
|
|
* _.map([1, 2, 3], function(num) { return num * 3; });
|
|
* // => [3, 6, 9]
|
|
*
|
|
* _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
|
|
* // => [3, 6, 9] (property order is not guaranteed across environments)
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.map(characters, 'name');
|
|
* // => ['barney', 'fred']
|
|
*/
|
|
function map(collection, callback, thisArg) {
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
if (typeof length == 'number') {
|
|
var result = Array(length);
|
|
while (++index < length) {
|
|
result[index] = callback(collection[index], index, collection);
|
|
}
|
|
} else {
|
|
result = [];
|
|
forOwn(collection, function(value, key, collection) {
|
|
result[++index] = callback(value, key, collection);
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the maximum value of a collection. If the collection is empty or
|
|
* falsey `-Infinity` is returned. If a callback is provided it will be executed
|
|
* for each value in the collection to generate the criterion by which the value
|
|
* is ranked. The callback is bound to `thisArg` and invoked with three
|
|
* arguments; (value, index, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the maximum value.
|
|
* @example
|
|
*
|
|
* _.max([4, 2, 8, 6]);
|
|
* // => 8
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* _.max(characters, function(chr) { return chr.age; });
|
|
* // => { 'name': 'fred', 'age': 40 };
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.max(characters, 'age');
|
|
* // => { 'name': 'fred', 'age': 40 };
|
|
*/
|
|
function max(collection, callback, thisArg) {
|
|
var computed = -Infinity,
|
|
result = computed;
|
|
|
|
// allows working with functions like `_.map` without using
|
|
// their `index` argument as a callback
|
|
if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
|
|
callback = null;
|
|
}
|
|
if (callback == null && isArray(collection)) {
|
|
var index = -1,
|
|
length = collection.length;
|
|
|
|
while (++index < length) {
|
|
var value = collection[index];
|
|
if (value > result) {
|
|
result = value;
|
|
}
|
|
}
|
|
} else {
|
|
callback = (callback == null && isString(collection))
|
|
? charAtCallback
|
|
: lodash.createCallback(callback, thisArg, 3);
|
|
|
|
forEach(collection, function(value, index, collection) {
|
|
var current = callback(value, index, collection);
|
|
if (current > computed) {
|
|
computed = current;
|
|
result = value;
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the minimum value of a collection. If the collection is empty or
|
|
* falsey `Infinity` is returned. If a callback is provided it will be executed
|
|
* for each value in the collection to generate the criterion by which the value
|
|
* is ranked. The callback is bound to `thisArg` and invoked with three
|
|
* arguments; (value, index, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the minimum value.
|
|
* @example
|
|
*
|
|
* _.min([4, 2, 8, 6]);
|
|
* // => 2
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* _.min(characters, function(chr) { return chr.age; });
|
|
* // => { 'name': 'barney', 'age': 36 };
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.min(characters, 'age');
|
|
* // => { 'name': 'barney', 'age': 36 };
|
|
*/
|
|
function min(collection, callback, thisArg) {
|
|
var computed = Infinity,
|
|
result = computed;
|
|
|
|
// allows working with functions like `_.map` without using
|
|
// their `index` argument as a callback
|
|
if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) {
|
|
callback = null;
|
|
}
|
|
if (callback == null && isArray(collection)) {
|
|
var index = -1,
|
|
length = collection.length;
|
|
|
|
while (++index < length) {
|
|
var value = collection[index];
|
|
if (value < result) {
|
|
result = value;
|
|
}
|
|
}
|
|
} else {
|
|
callback = (callback == null && isString(collection))
|
|
? charAtCallback
|
|
: lodash.createCallback(callback, thisArg, 3);
|
|
|
|
forEach(collection, function(value, index, collection) {
|
|
var current = callback(value, index, collection);
|
|
if (current < computed) {
|
|
computed = current;
|
|
result = value;
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the value of a specified property from all elements in the collection.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {string} property The property to pluck.
|
|
* @returns {Array} Returns a new array of property values.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* _.pluck(characters, 'name');
|
|
* // => ['barney', 'fred']
|
|
*/
|
|
function pluck(collection, property) {
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
if (typeof length == 'number') {
|
|
var result = Array(length);
|
|
while (++index < length) {
|
|
result[index] = collection[index][property];
|
|
}
|
|
}
|
|
return result || map(collection, property);
|
|
}
|
|
|
|
/**
|
|
* Reduces a collection to a value which is the accumulated result of running
|
|
* each element in the collection through the callback, where each successive
|
|
* callback execution consumes the return value of the previous execution. If
|
|
* `accumulator` is not provided the first element of the collection will be
|
|
* used as the initial `accumulator` value. The callback is bound to `thisArg`
|
|
* and invoked with four arguments; (accumulator, value, index|key, collection).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias foldl, inject
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [accumulator] Initial value of the accumulator.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the accumulated value.
|
|
* @example
|
|
*
|
|
* var sum = _.reduce([1, 2, 3], function(sum, num) {
|
|
* return sum + num;
|
|
* });
|
|
* // => 6
|
|
*
|
|
* var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
|
|
* result[key] = num * 3;
|
|
* return result;
|
|
* }, {});
|
|
* // => { 'a': 3, 'b': 6, 'c': 9 }
|
|
*/
|
|
function reduce(collection, callback, accumulator, thisArg) {
|
|
if (!collection) return accumulator;
|
|
var noaccum = arguments.length < 3;
|
|
callback = lodash.createCallback(callback, thisArg, 4);
|
|
|
|
var index = -1,
|
|
length = collection.length;
|
|
|
|
if (typeof length == 'number') {
|
|
if (noaccum) {
|
|
accumulator = collection[++index];
|
|
}
|
|
while (++index < length) {
|
|
accumulator = callback(accumulator, collection[index], index, collection);
|
|
}
|
|
} else {
|
|
forOwn(collection, function(value, index, collection) {
|
|
accumulator = noaccum
|
|
? (noaccum = false, value)
|
|
: callback(accumulator, value, index, collection)
|
|
});
|
|
}
|
|
return accumulator;
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.reduce` except that it iterates over elements
|
|
* of a `collection` from right to left.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias foldr
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function} [callback=identity] The function called per iteration.
|
|
* @param {*} [accumulator] Initial value of the accumulator.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the accumulated value.
|
|
* @example
|
|
*
|
|
* var list = [[0, 1], [2, 3], [4, 5]];
|
|
* var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
|
|
* // => [4, 5, 2, 3, 0, 1]
|
|
*/
|
|
function reduceRight(collection, callback, accumulator, thisArg) {
|
|
var noaccum = arguments.length < 3;
|
|
callback = lodash.createCallback(callback, thisArg, 4);
|
|
forEachRight(collection, function(value, index, collection) {
|
|
accumulator = noaccum
|
|
? (noaccum = false, value)
|
|
: callback(accumulator, value, index, collection);
|
|
});
|
|
return accumulator;
|
|
}
|
|
|
|
/**
|
|
* The opposite of `_.filter` this method returns the elements of a
|
|
* collection that the callback does **not** return truey for.
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a new array of elements that failed the callback check.
|
|
* @example
|
|
*
|
|
* var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
|
|
* // => [1, 3, 5]
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'blocked': false },
|
|
* { 'name': 'fred', 'age': 40, 'blocked': true }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.reject(characters, 'blocked');
|
|
* // => [{ 'name': 'barney', 'age': 36, 'blocked': false }]
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.reject(characters, { 'age': 36 });
|
|
* // => [{ 'name': 'fred', 'age': 40, 'blocked': true }]
|
|
*/
|
|
function reject(collection, callback, thisArg) {
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
return filter(collection, function(value, index, collection) {
|
|
return !callback(value, index, collection);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Retrieves a random element or `n` random elements from a collection.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to sample.
|
|
* @param {number} [n] The number of elements to sample.
|
|
* @param- {Object} [guard] Allows working with functions like `_.map`
|
|
* without using their `index` arguments as `n`.
|
|
* @returns {Array} Returns the random sample(s) of `collection`.
|
|
* @example
|
|
*
|
|
* _.sample([1, 2, 3, 4]);
|
|
* // => 2
|
|
*
|
|
* _.sample([1, 2, 3, 4], 2);
|
|
* // => [3, 1]
|
|
*/
|
|
function sample(collection, n, guard) {
|
|
if (collection && typeof collection.length != 'number') {
|
|
collection = values(collection);
|
|
}
|
|
if (n == null || guard) {
|
|
return collection ? collection[baseRandom(0, collection.length - 1)] : undefined;
|
|
}
|
|
var result = shuffle(collection);
|
|
result.length = nativeMin(nativeMax(0, n), result.length);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates an array of shuffled values, using a version of the Fisher-Yates
|
|
* shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to shuffle.
|
|
* @returns {Array} Returns a new shuffled collection.
|
|
* @example
|
|
*
|
|
* _.shuffle([1, 2, 3, 4, 5, 6]);
|
|
* // => [4, 1, 6, 3, 5, 2]
|
|
*/
|
|
function shuffle(collection) {
|
|
var index = -1,
|
|
length = collection ? collection.length : 0,
|
|
result = Array(typeof length == 'number' ? length : 0);
|
|
|
|
forEach(collection, function(value) {
|
|
var rand = baseRandom(0, ++index);
|
|
result[index] = result[rand];
|
|
result[rand] = value;
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the size of the `collection` by returning `collection.length` for arrays
|
|
* and array-like objects or the number of own enumerable properties for objects.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to inspect.
|
|
* @returns {number} Returns `collection.length` or number of own enumerable properties.
|
|
* @example
|
|
*
|
|
* _.size([1, 2]);
|
|
* // => 2
|
|
*
|
|
* _.size({ 'one': 1, 'two': 2, 'three': 3 });
|
|
* // => 3
|
|
*
|
|
* _.size('pebbles');
|
|
* // => 5
|
|
*/
|
|
function size(collection) {
|
|
var length = collection ? collection.length : 0;
|
|
return typeof length == 'number' ? length : keys(collection).length;
|
|
}
|
|
|
|
/**
|
|
* Checks if the callback returns a truey value for **any** element of a
|
|
* collection. The function returns as soon as it finds a passing value and
|
|
* does not iterate over the entire collection. The callback is bound to
|
|
* `thisArg` and invoked with three arguments; (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias any
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {boolean} Returns `true` if any element passed the callback check,
|
|
* else `false`.
|
|
* @example
|
|
*
|
|
* _.some([null, 0, 'yes', false], Boolean);
|
|
* // => true
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'blocked': false },
|
|
* { 'name': 'fred', 'age': 40, 'blocked': true }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.some(characters, 'blocked');
|
|
* // => true
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.some(characters, { 'age': 1 });
|
|
* // => false
|
|
*/
|
|
function some(collection, callback, thisArg) {
|
|
var result;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
|
|
var index = -1,
|
|
length = collection ? collection.length : 0;
|
|
|
|
if (typeof length == 'number') {
|
|
while (++index < length) {
|
|
if ((result = callback(collection[index], index, collection))) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
forOwn(collection, function(value, index, collection) {
|
|
return !(result = callback(value, index, collection));
|
|
});
|
|
}
|
|
return !!result;
|
|
}
|
|
|
|
/**
|
|
* Creates an array of elements, sorted in ascending order by the results of
|
|
* running each element in a collection through the callback. This method
|
|
* performs a stable sort, that is, it will preserve the original sort order
|
|
* of equal elements. The callback is bound to `thisArg` and invoked with
|
|
* three arguments; (value, index|key, collection).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a new array of sorted elements.
|
|
* @example
|
|
*
|
|
* _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
|
|
* // => [3, 1, 2]
|
|
*
|
|
* _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
|
|
* // => [3, 1, 2]
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.sortBy(['banana', 'strawberry', 'apple'], 'length');
|
|
* // => ['apple', 'banana', 'strawberry']
|
|
*/
|
|
function sortBy(collection, callback, thisArg) {
|
|
var index = -1,
|
|
length = collection ? collection.length : 0,
|
|
result = Array(typeof length == 'number' ? length : 0);
|
|
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
forEach(collection, function(value, key, collection) {
|
|
var object = result[++index] = getObject();
|
|
object.criteria = callback(value, key, collection);
|
|
object.index = index;
|
|
object.value = value;
|
|
});
|
|
|
|
length = result.length;
|
|
result.sort(compareAscending);
|
|
while (length--) {
|
|
var object = result[length];
|
|
result[length] = object.value;
|
|
releaseObject(object);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Converts the `collection` to an array.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to convert.
|
|
* @returns {Array} Returns the new converted array.
|
|
* @example
|
|
*
|
|
* (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
|
|
* // => [2, 3, 4]
|
|
*/
|
|
function toArray(collection) {
|
|
if (collection && typeof collection.length == 'number') {
|
|
return slice(collection);
|
|
}
|
|
return values(collection);
|
|
}
|
|
|
|
/**
|
|
* Performs a deep comparison of each element in a `collection` to the given
|
|
* `properties` object, returning an array of all elements that have equivalent
|
|
* property values.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Function
|
|
* @category Collections
|
|
* @param {Array|Object|string} collection The collection to iterate over.
|
|
* @param {Object} properties The object of property values to filter by.
|
|
* @returns {Array} Returns a new array of elements that have the given properties.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] },
|
|
* { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
|
|
* ];
|
|
*
|
|
* _.where(characters, { 'age': 36 });
|
|
* // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }]
|
|
*
|
|
* _.where(characters, { 'pets': ['dino'] });
|
|
* // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }]
|
|
*/
|
|
var where = filter;
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Creates an array with all falsey values removed. The values `false`, `null`,
|
|
* `0`, `""`, `undefined`, and `NaN` are all falsey.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to compact.
|
|
* @returns {Array} Returns a new array of filtered values.
|
|
* @example
|
|
*
|
|
* _.compact([0, 1, false, 2, '', 3]);
|
|
* // => [1, 2, 3]
|
|
*/
|
|
function compact(array) {
|
|
var index = -1,
|
|
length = array ? array.length : 0,
|
|
result = [];
|
|
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (value) {
|
|
result.push(value);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates an array excluding all values of the provided arrays using strict
|
|
* equality for comparisons, i.e. `===`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to process.
|
|
* @param {...Array} [values] The arrays of values to exclude.
|
|
* @returns {Array} Returns a new array of filtered values.
|
|
* @example
|
|
*
|
|
* _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
|
|
* // => [1, 3, 4]
|
|
*/
|
|
function difference(array) {
|
|
return baseDifference(array, baseFlatten(arguments, true, true, 1));
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.find` except that it returns the index of the first
|
|
* element that passes the callback check, instead of the element itself.
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to search.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {number} Returns the index of the found element, else `-1`.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'blocked': false },
|
|
* { 'name': 'fred', 'age': 40, 'blocked': true },
|
|
* { 'name': 'pebbles', 'age': 1, 'blocked': false }
|
|
* ];
|
|
*
|
|
* _.findIndex(characters, function(chr) {
|
|
* return chr.age < 20;
|
|
* });
|
|
* // => 2
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.findIndex(characters, { 'age': 36 });
|
|
* // => 0
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.findIndex(characters, 'blocked');
|
|
* // => 1
|
|
*/
|
|
function findIndex(array, callback, thisArg) {
|
|
var index = -1,
|
|
length = array ? array.length : 0;
|
|
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (++index < length) {
|
|
if (callback(array[index], index, array)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.findIndex` except that it iterates over elements
|
|
* of a `collection` from right to left.
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to search.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {number} Returns the index of the found element, else `-1`.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36, 'blocked': true },
|
|
* { 'name': 'fred', 'age': 40, 'blocked': false },
|
|
* { 'name': 'pebbles', 'age': 1, 'blocked': true }
|
|
* ];
|
|
*
|
|
* _.findLastIndex(characters, function(chr) {
|
|
* return chr.age > 30;
|
|
* });
|
|
* // => 1
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.findLastIndex(characters, { 'age': 36 });
|
|
* // => 0
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.findLastIndex(characters, 'blocked');
|
|
* // => 2
|
|
*/
|
|
function findLastIndex(array, callback, thisArg) {
|
|
var length = array ? array.length : 0;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (length--) {
|
|
if (callback(array[length], length, array)) {
|
|
return length;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Gets the first element or first `n` elements of an array. If a callback
|
|
* is provided elements at the beginning of the array are returned as long
|
|
* as the callback returns truey. The callback is bound to `thisArg` and
|
|
* invoked with three arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias head, take
|
|
* @category Arrays
|
|
* @param {Array} array The array to query.
|
|
* @param {Function|Object|number|string} [callback] The function called
|
|
* per element or the number of elements to return. If a property name or
|
|
* object is provided it will be used to create a "_.pluck" or "_.where"
|
|
* style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the first element(s) of `array`.
|
|
* @example
|
|
*
|
|
* _.first([1, 2, 3]);
|
|
* // => 1
|
|
*
|
|
* _.first([1, 2, 3], 2);
|
|
* // => [1, 2]
|
|
*
|
|
* _.first([1, 2, 3], function(num) {
|
|
* return num < 3;
|
|
* });
|
|
* // => [1, 2]
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
|
|
* { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
|
|
* { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.first(characters, 'blocked');
|
|
* // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }]
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.pluck(_.first(characters, { 'employer': 'slate' }), 'name');
|
|
* // => ['barney', 'fred']
|
|
*/
|
|
function first(array, callback, thisArg) {
|
|
var n = 0,
|
|
length = array ? array.length : 0;
|
|
|
|
if (typeof callback != 'number' && callback != null) {
|
|
var index = -1;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (++index < length && callback(array[index], index, array)) {
|
|
n++;
|
|
}
|
|
} else {
|
|
n = callback;
|
|
if (n == null || thisArg) {
|
|
return array ? array[0] : undefined;
|
|
}
|
|
}
|
|
return slice(array, 0, nativeMin(nativeMax(0, n), length));
|
|
}
|
|
|
|
/**
|
|
* Flattens a nested array (the nesting can be to any depth). If `isShallow`
|
|
* is truey, the array will only be flattened a single level. If a callback
|
|
* is provided each element of the array is passed through the callback before
|
|
* flattening. The callback is bound to `thisArg` and invoked with three
|
|
* arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to flatten.
|
|
* @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a new flattened array.
|
|
* @example
|
|
*
|
|
* _.flatten([1, [2], [3, [[4]]]]);
|
|
* // => [1, 2, 3, 4];
|
|
*
|
|
* _.flatten([1, [2], [3, [[4]]]], true);
|
|
* // => [1, 2, 3, [[4]]];
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] },
|
|
* { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.flatten(characters, 'pets');
|
|
* // => ['hoppy', 'baby puss', 'dino']
|
|
*/
|
|
function flatten(array, isShallow, callback, thisArg) {
|
|
// juggle arguments
|
|
if (typeof isShallow != 'boolean' && isShallow != null) {
|
|
thisArg = callback;
|
|
callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow;
|
|
isShallow = false;
|
|
}
|
|
if (callback != null) {
|
|
array = map(array, callback, thisArg);
|
|
}
|
|
return baseFlatten(array, isShallow);
|
|
}
|
|
|
|
/**
|
|
* Gets the index at which the first occurrence of `value` is found using
|
|
* strict equality for comparisons, i.e. `===`. If the array is already sorted
|
|
* providing `true` for `fromIndex` will run a faster binary search.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to search.
|
|
* @param {*} value The value to search for.
|
|
* @param {boolean|number} [fromIndex=0] The index to search from or `true`
|
|
* to perform a binary search on a sorted array.
|
|
* @returns {number} Returns the index of the matched value or `-1`.
|
|
* @example
|
|
*
|
|
* _.indexOf([1, 2, 3, 1, 2, 3], 2);
|
|
* // => 1
|
|
*
|
|
* _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
|
|
* // => 4
|
|
*
|
|
* _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
|
|
* // => 2
|
|
*/
|
|
function indexOf(array, value, fromIndex) {
|
|
if (typeof fromIndex == 'number') {
|
|
var length = array ? array.length : 0;
|
|
fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0);
|
|
} else if (fromIndex) {
|
|
var index = sortedIndex(array, value);
|
|
return array[index] === value ? index : -1;
|
|
}
|
|
return baseIndexOf(array, value, fromIndex);
|
|
}
|
|
|
|
/**
|
|
* Gets all but the last element or last `n` elements of an array. If a
|
|
* callback is provided elements at the end of the array are excluded from
|
|
* the result as long as the callback returns truey. The callback is bound
|
|
* to `thisArg` and invoked with three arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to query.
|
|
* @param {Function|Object|number|string} [callback=1] The function called
|
|
* per element or the number of elements to exclude. If a property name or
|
|
* object is provided it will be used to create a "_.pluck" or "_.where"
|
|
* style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a slice of `array`.
|
|
* @example
|
|
*
|
|
* _.initial([1, 2, 3]);
|
|
* // => [1, 2]
|
|
*
|
|
* _.initial([1, 2, 3], 2);
|
|
* // => [1]
|
|
*
|
|
* _.initial([1, 2, 3], function(num) {
|
|
* return num > 1;
|
|
* });
|
|
* // => [1]
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
|
|
* { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
|
|
* { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.initial(characters, 'blocked');
|
|
* // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }]
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.pluck(_.initial(characters, { 'employer': 'na' }), 'name');
|
|
* // => ['barney', 'fred']
|
|
*/
|
|
function initial(array, callback, thisArg) {
|
|
var n = 0,
|
|
length = array ? array.length : 0;
|
|
|
|
if (typeof callback != 'number' && callback != null) {
|
|
var index = length;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (index-- && callback(array[index], index, array)) {
|
|
n++;
|
|
}
|
|
} else {
|
|
n = (callback == null || thisArg) ? 1 : callback || n;
|
|
}
|
|
return slice(array, 0, nativeMin(nativeMax(0, length - n), length));
|
|
}
|
|
|
|
/**
|
|
* Creates an array of unique values present in all provided arrays using
|
|
* strict equality for comparisons, i.e. `===`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {...Array} [array] The arrays to inspect.
|
|
* @returns {Array} Returns an array of composite values.
|
|
* @example
|
|
*
|
|
* _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
|
|
* // => [1, 2]
|
|
*/
|
|
function intersection(array) {
|
|
var args = arguments,
|
|
argsLength = args.length,
|
|
argsIndex = -1,
|
|
caches = getArray(),
|
|
index = -1,
|
|
indexOf = getIndexOf(),
|
|
length = array ? array.length : 0,
|
|
result = [],
|
|
seen = getArray();
|
|
|
|
while (++argsIndex < argsLength) {
|
|
var value = args[argsIndex];
|
|
caches[argsIndex] = indexOf === baseIndexOf &&
|
|
(value ? value.length : 0) >= largeArraySize &&
|
|
createCache(argsIndex ? args[argsIndex] : seen);
|
|
}
|
|
outer:
|
|
while (++index < length) {
|
|
var cache = caches[0];
|
|
value = array[index];
|
|
|
|
if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) {
|
|
argsIndex = argsLength;
|
|
(cache || seen).push(value);
|
|
while (--argsIndex) {
|
|
cache = caches[argsIndex];
|
|
if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) {
|
|
continue outer;
|
|
}
|
|
}
|
|
result.push(value);
|
|
}
|
|
}
|
|
while (argsLength--) {
|
|
cache = caches[argsLength];
|
|
if (cache) {
|
|
releaseObject(cache);
|
|
}
|
|
}
|
|
releaseArray(caches);
|
|
releaseArray(seen);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the last element or last `n` elements of an array. If a callback is
|
|
* provided elements at the end of the array are returned as long as the
|
|
* callback returns truey. The callback is bound to `thisArg` and invoked
|
|
* with three arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to query.
|
|
* @param {Function|Object|number|string} [callback] The function called
|
|
* per element or the number of elements to return. If a property name or
|
|
* object is provided it will be used to create a "_.pluck" or "_.where"
|
|
* style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {*} Returns the last element(s) of `array`.
|
|
* @example
|
|
*
|
|
* _.last([1, 2, 3]);
|
|
* // => 3
|
|
*
|
|
* _.last([1, 2, 3], 2);
|
|
* // => [2, 3]
|
|
*
|
|
* _.last([1, 2, 3], function(num) {
|
|
* return num > 1;
|
|
* });
|
|
* // => [2, 3]
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'blocked': false, 'employer': 'slate' },
|
|
* { 'name': 'fred', 'blocked': true, 'employer': 'slate' },
|
|
* { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.pluck(_.last(characters, 'blocked'), 'name');
|
|
* // => ['fred', 'pebbles']
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.last(characters, { 'employer': 'na' });
|
|
* // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
|
|
*/
|
|
function last(array, callback, thisArg) {
|
|
var n = 0,
|
|
length = array ? array.length : 0;
|
|
|
|
if (typeof callback != 'number' && callback != null) {
|
|
var index = length;
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (index-- && callback(array[index], index, array)) {
|
|
n++;
|
|
}
|
|
} else {
|
|
n = callback;
|
|
if (n == null || thisArg) {
|
|
return array ? array[length - 1] : undefined;
|
|
}
|
|
}
|
|
return slice(array, nativeMax(0, length - n));
|
|
}
|
|
|
|
/**
|
|
* Gets the index at which the last occurrence of `value` is found using strict
|
|
* equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
|
|
* as the offset from the end of the collection.
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to search.
|
|
* @param {*} value The value to search for.
|
|
* @param {number} [fromIndex=array.length-1] The index to search from.
|
|
* @returns {number} Returns the index of the matched value or `-1`.
|
|
* @example
|
|
*
|
|
* _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
|
|
* // => 4
|
|
*
|
|
* _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
|
|
* // => 1
|
|
*/
|
|
function lastIndexOf(array, value, fromIndex) {
|
|
var index = array ? array.length : 0;
|
|
if (typeof fromIndex == 'number') {
|
|
index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
|
|
}
|
|
while (index--) {
|
|
if (array[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Removes all provided values from the given array using strict equality for
|
|
* comparisons, i.e. `===`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to modify.
|
|
* @param {...*} [value] The values to remove.
|
|
* @returns {Array} Returns `array`.
|
|
* @example
|
|
*
|
|
* var array = [1, 2, 3, 1, 2, 3];
|
|
* _.pull(array, 2, 3);
|
|
* console.log(array);
|
|
* // => [1, 1]
|
|
*/
|
|
function pull(array) {
|
|
var args = arguments,
|
|
argsIndex = 0,
|
|
argsLength = args.length,
|
|
length = array ? array.length : 0;
|
|
|
|
while (++argsIndex < argsLength) {
|
|
var index = -1,
|
|
value = args[argsIndex];
|
|
while (++index < length) {
|
|
if (array[index] === value) {
|
|
splice.call(array, index--, 1);
|
|
length--;
|
|
}
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Creates an array of numbers (positive and/or negative) progressing from
|
|
* `start` up to but not including `end`. If `start` is less than `stop` a
|
|
* zero-length range is created unless a negative `step` is specified.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {number} [start=0] The start of the range.
|
|
* @param {number} end The end of the range.
|
|
* @param {number} [step=1] The value to increment or decrement by.
|
|
* @returns {Array} Returns a new range array.
|
|
* @example
|
|
*
|
|
* _.range(4);
|
|
* // => [0, 1, 2, 3]
|
|
*
|
|
* _.range(1, 5);
|
|
* // => [1, 2, 3, 4]
|
|
*
|
|
* _.range(0, 20, 5);
|
|
* // => [0, 5, 10, 15]
|
|
*
|
|
* _.range(0, -4, -1);
|
|
* // => [0, -1, -2, -3]
|
|
*
|
|
* _.range(1, 4, 0);
|
|
* // => [1, 1, 1]
|
|
*
|
|
* _.range(0);
|
|
* // => []
|
|
*/
|
|
function range(start, end, step) {
|
|
start = +start || 0;
|
|
step = typeof step == 'number' ? step : (+step || 1);
|
|
|
|
if (end == null) {
|
|
end = start;
|
|
start = 0;
|
|
}
|
|
// use `Array(length)` so engines like Chakra and V8 avoid slower modes
|
|
// http://youtu.be/XAqIpGU8ZZk#t=17m25s
|
|
var index = -1,
|
|
length = nativeMax(0, ceil((end - start) / (step || 1))),
|
|
result = Array(length);
|
|
|
|
while (++index < length) {
|
|
result[index] = start;
|
|
start += step;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Removes all elements from an array that the callback returns truey for
|
|
* and returns an array of removed elements. The callback is bound to `thisArg`
|
|
* and invoked with three arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to modify.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a new array of removed elements.
|
|
* @example
|
|
*
|
|
* var array = [1, 2, 3, 4, 5, 6];
|
|
* var evens = _.remove(array, function(num) { return num % 2 == 0; });
|
|
*
|
|
* console.log(array);
|
|
* // => [1, 3, 5]
|
|
*
|
|
* console.log(evens);
|
|
* // => [2, 4, 6]
|
|
*/
|
|
function remove(array, callback, thisArg) {
|
|
var index = -1,
|
|
length = array ? array.length : 0,
|
|
result = [];
|
|
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (callback(value, index, array)) {
|
|
result.push(value);
|
|
splice.call(array, index--, 1);
|
|
length--;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The opposite of `_.initial` this method gets all but the first element or
|
|
* first `n` elements of an array. If a callback function is provided elements
|
|
* at the beginning of the array are excluded from the result as long as the
|
|
* callback returns truey. The callback is bound to `thisArg` and invoked
|
|
* with three arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias drop, tail
|
|
* @category Arrays
|
|
* @param {Array} array The array to query.
|
|
* @param {Function|Object|number|string} [callback=1] The function called
|
|
* per element or the number of elements to exclude. If a property name or
|
|
* object is provided it will be used to create a "_.pluck" or "_.where"
|
|
* style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a slice of `array`.
|
|
* @example
|
|
*
|
|
* _.rest([1, 2, 3]);
|
|
* // => [2, 3]
|
|
*
|
|
* _.rest([1, 2, 3], 2);
|
|
* // => [3]
|
|
*
|
|
* _.rest([1, 2, 3], function(num) {
|
|
* return num < 3;
|
|
* });
|
|
* // => [3]
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'blocked': true, 'employer': 'slate' },
|
|
* { 'name': 'fred', 'blocked': false, 'employer': 'slate' },
|
|
* { 'name': 'pebbles', 'blocked': true, 'employer': 'na' }
|
|
* ];
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.pluck(_.rest(characters, 'blocked'), 'name');
|
|
* // => ['fred', 'pebbles']
|
|
*
|
|
* // using "_.where" callback shorthand
|
|
* _.rest(characters, { 'employer': 'slate' });
|
|
* // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }]
|
|
*/
|
|
function rest(array, callback, thisArg) {
|
|
if (typeof callback != 'number' && callback != null) {
|
|
var n = 0,
|
|
index = -1,
|
|
length = array ? array.length : 0;
|
|
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
while (++index < length && callback(array[index], index, array)) {
|
|
n++;
|
|
}
|
|
} else {
|
|
n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);
|
|
}
|
|
return slice(array, n);
|
|
}
|
|
|
|
/**
|
|
* Uses a binary search to determine the smallest index at which a value
|
|
* should be inserted into a given sorted array in order to maintain the sort
|
|
* order of the array. If a callback is provided it will be executed for
|
|
* `value` and each element of `array` to compute their sort ranking. The
|
|
* callback is bound to `thisArg` and invoked with one argument; (value).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to inspect.
|
|
* @param {*} value The value to evaluate.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {number} Returns the index at which `value` should be inserted
|
|
* into `array`.
|
|
* @example
|
|
*
|
|
* _.sortedIndex([20, 30, 50], 40);
|
|
* // => 2
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
|
|
* // => 2
|
|
*
|
|
* var dict = {
|
|
* 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
|
|
* };
|
|
*
|
|
* _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
|
|
* return dict.wordToNumber[word];
|
|
* });
|
|
* // => 2
|
|
*
|
|
* _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
|
|
* return this.wordToNumber[word];
|
|
* }, dict);
|
|
* // => 2
|
|
*/
|
|
function sortedIndex(array, value, callback, thisArg) {
|
|
var low = 0,
|
|
high = array ? array.length : low;
|
|
|
|
// explicitly reference `identity` for better inlining in Firefox
|
|
callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity;
|
|
value = callback(value);
|
|
|
|
while (low < high) {
|
|
var mid = (low + high) >>> 1;
|
|
(callback(array[mid]) < value)
|
|
? low = mid + 1
|
|
: high = mid;
|
|
}
|
|
return low;
|
|
}
|
|
|
|
/**
|
|
* Creates an array of unique values, in order, of the provided arrays using
|
|
* strict equality for comparisons, i.e. `===`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {...Array} [array] The arrays to inspect.
|
|
* @returns {Array} Returns an array of composite values.
|
|
* @example
|
|
*
|
|
* _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
|
|
* // => [1, 2, 3, 101, 10]
|
|
*/
|
|
function union(array) {
|
|
return baseUniq(baseFlatten(arguments, true, true));
|
|
}
|
|
|
|
/**
|
|
* Creates a duplicate-value-free version of an array using strict equality
|
|
* for comparisons, i.e. `===`. If the array is sorted, providing
|
|
* `true` for `isSorted` will use a faster algorithm. If a callback is provided
|
|
* each element of `array` is passed through the callback before uniqueness
|
|
* is computed. The callback is bound to `thisArg` and invoked with three
|
|
* arguments; (value, index, array).
|
|
*
|
|
* If a property name is provided for `callback` the created "_.pluck" style
|
|
* callback will return the property value of the given element.
|
|
*
|
|
* If an object is provided for `callback` the created "_.where" style callback
|
|
* will return `true` for elements that have the properties of the given object,
|
|
* else `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias unique
|
|
* @category Arrays
|
|
* @param {Array} array The array to process.
|
|
* @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
|
|
* @param {Function|Object|string} [callback=identity] The function called
|
|
* per iteration. If a property name or object is provided it will be used
|
|
* to create a "_.pluck" or "_.where" style callback, respectively.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns a duplicate-value-free array.
|
|
* @example
|
|
*
|
|
* _.uniq([1, 2, 1, 3, 1]);
|
|
* // => [1, 2, 3]
|
|
*
|
|
* _.uniq([1, 1, 2, 2, 3], true);
|
|
* // => [1, 2, 3]
|
|
*
|
|
* _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); });
|
|
* // => ['A', 'b', 'C']
|
|
*
|
|
* _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
|
|
* // => [1, 2.5, 3]
|
|
*
|
|
* // using "_.pluck" callback shorthand
|
|
* _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
|
|
* // => [{ 'x': 1 }, { 'x': 2 }]
|
|
*/
|
|
function uniq(array, isSorted, callback, thisArg) {
|
|
// juggle arguments
|
|
if (typeof isSorted != 'boolean' && isSorted != null) {
|
|
thisArg = callback;
|
|
callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted;
|
|
isSorted = false;
|
|
}
|
|
if (callback != null) {
|
|
callback = lodash.createCallback(callback, thisArg, 3);
|
|
}
|
|
return baseUniq(array, isSorted, callback);
|
|
}
|
|
|
|
/**
|
|
* Creates an array excluding all provided values using strict equality for
|
|
* comparisons, i.e. `===`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Arrays
|
|
* @param {Array} array The array to filter.
|
|
* @param {...*} [value] The values to exclude.
|
|
* @returns {Array} Returns a new array of filtered values.
|
|
* @example
|
|
*
|
|
* _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
|
|
* // => [2, 3, 4]
|
|
*/
|
|
function without(array) {
|
|
return baseDifference(array, slice(arguments, 1));
|
|
}
|
|
|
|
/**
|
|
* Creates an array of grouped elements, the first of which contains the first
|
|
* elements of the given arrays, the second of which contains the second
|
|
* elements of the given arrays, and so on.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias unzip
|
|
* @category Arrays
|
|
* @param {...Array} [array] Arrays to process.
|
|
* @returns {Array} Returns a new array of grouped elements.
|
|
* @example
|
|
*
|
|
* _.zip(['fred', 'barney'], [30, 40], [true, false]);
|
|
* // => [['fred', 30, true], ['barney', 40, false]]
|
|
*/
|
|
function zip() {
|
|
var array = arguments.length > 1 ? arguments : arguments[0],
|
|
index = -1,
|
|
length = array ? max(pluck(array, 'length')) : 0,
|
|
result = Array(length < 0 ? 0 : length);
|
|
|
|
while (++index < length) {
|
|
result[index] = pluck(array, index);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates an object composed from arrays of `keys` and `values`. Provide
|
|
* either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`
|
|
* or two arrays, one of `keys` and one of corresponding `values`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @alias object
|
|
* @category Arrays
|
|
* @param {Array} keys The array of keys.
|
|
* @param {Array} [values=[]] The array of values.
|
|
* @returns {Object} Returns an object composed of the given keys and
|
|
* corresponding values.
|
|
* @example
|
|
*
|
|
* _.zipObject(['fred', 'barney'], [30, 40]);
|
|
* // => { 'fred': 30, 'barney': 40 }
|
|
*/
|
|
function zipObject(keys, values) {
|
|
var index = -1,
|
|
length = keys ? keys.length : 0,
|
|
result = {};
|
|
|
|
while (++index < length) {
|
|
var key = keys[index];
|
|
if (values) {
|
|
result[key] = values[index];
|
|
} else if (key) {
|
|
result[key[0]] = key[1];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Creates a function that executes `func`, with the `this` binding and
|
|
* arguments of the created function, only after being called `n` times.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {number} n The number of times the function must be called before
|
|
* `func` is executed.
|
|
* @param {Function} func The function to restrict.
|
|
* @returns {Function} Returns the new restricted function.
|
|
* @example
|
|
*
|
|
* var saves = ['profile', 'settings'];
|
|
*
|
|
* var done = _.after(saves.length, function() {
|
|
* console.log('Done saving!');
|
|
* });
|
|
*
|
|
* _.forEach(saves, function(type) {
|
|
* asyncSave({ 'type': type, 'complete': done });
|
|
* });
|
|
* // => logs 'Done saving!', after all saves have completed
|
|
*/
|
|
function after(n, func) {
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
return function() {
|
|
if (--n < 1) {
|
|
return func.apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a function that, when called, invokes `func` with the `this`
|
|
* binding of `thisArg` and prepends any additional `bind` arguments to those
|
|
* provided to the bound function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to bind.
|
|
* @param {*} [thisArg] The `this` binding of `func`.
|
|
* @param {...*} [arg] Arguments to be partially applied.
|
|
* @returns {Function} Returns the new bound function.
|
|
* @example
|
|
*
|
|
* var func = function(greeting) {
|
|
* return greeting + ' ' + this.name;
|
|
* };
|
|
*
|
|
* func = _.bind(func, { 'name': 'fred' }, 'hi');
|
|
* func();
|
|
* // => 'hi fred'
|
|
*/
|
|
function bind(func, thisArg) {
|
|
return arguments.length > 2
|
|
? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
|
|
: createWrapper(func, 1, null, null, thisArg);
|
|
}
|
|
|
|
/**
|
|
* Binds methods of an object to the object itself, overwriting the existing
|
|
* method. Method names may be specified as individual arguments or as arrays
|
|
* of method names. If no method names are provided all the function properties
|
|
* of `object` will be bound.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Object} object The object to bind and assign the bound methods to.
|
|
* @param {...string} [methodName] The object method names to
|
|
* bind, specified as individual method names or arrays of method names.
|
|
* @returns {Object} Returns `object`.
|
|
* @example
|
|
*
|
|
* var view = {
|
|
* 'label': 'docs',
|
|
* 'onClick': function() { console.log('clicked ' + this.label); }
|
|
* };
|
|
*
|
|
* _.bindAll(view);
|
|
* jQuery('#docs').on('click', view.onClick);
|
|
* // => logs 'clicked docs', when the button is clicked
|
|
*/
|
|
function bindAll(object) {
|
|
var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object),
|
|
index = -1,
|
|
length = funcs.length;
|
|
|
|
while (++index < length) {
|
|
var key = funcs[index];
|
|
object[key] = createWrapper(object[key], 1, null, null, object);
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that, when called, invokes the method at `object[key]`
|
|
* and prepends any additional `bindKey` arguments to those provided to the bound
|
|
* function. This method differs from `_.bind` by allowing bound functions to
|
|
* reference methods that will be redefined or don't yet exist.
|
|
* See http://michaux.ca/articles/lazy-function-definition-pattern.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Object} object The object the method belongs to.
|
|
* @param {string} key The key of the method.
|
|
* @param {...*} [arg] Arguments to be partially applied.
|
|
* @returns {Function} Returns the new bound function.
|
|
* @example
|
|
*
|
|
* var object = {
|
|
* 'name': 'fred',
|
|
* 'greet': function(greeting) {
|
|
* return greeting + ' ' + this.name;
|
|
* }
|
|
* };
|
|
*
|
|
* var func = _.bindKey(object, 'greet', 'hi');
|
|
* func();
|
|
* // => 'hi fred'
|
|
*
|
|
* object.greet = function(greeting) {
|
|
* return greeting + 'ya ' + this.name + '!';
|
|
* };
|
|
*
|
|
* func();
|
|
* // => 'hiya fred!'
|
|
*/
|
|
function bindKey(object, key) {
|
|
return arguments.length > 2
|
|
? createWrapper(key, 19, slice(arguments, 2), null, object)
|
|
: createWrapper(key, 3, null, null, object);
|
|
}
|
|
|
|
/**
|
|
* Creates a function that is the composition of the provided functions,
|
|
* where each function consumes the return value of the function that follows.
|
|
* For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
|
|
* Each function is executed with the `this` binding of the composed function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {...Function} [func] Functions to compose.
|
|
* @returns {Function} Returns the new composed function.
|
|
* @example
|
|
*
|
|
* var realNameMap = {
|
|
* 'pebbles': 'penelope'
|
|
* };
|
|
*
|
|
* var format = function(name) {
|
|
* name = realNameMap[name.toLowerCase()] || name;
|
|
* return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
|
|
* };
|
|
*
|
|
* var greet = function(formatted) {
|
|
* return 'Hiya ' + formatted + '!';
|
|
* };
|
|
*
|
|
* var welcome = _.compose(greet, format);
|
|
* welcome('pebbles');
|
|
* // => 'Hiya Penelope!'
|
|
*/
|
|
function compose() {
|
|
var funcs = arguments,
|
|
length = funcs.length;
|
|
|
|
while (length--) {
|
|
if (!isFunction(funcs[length])) {
|
|
throw new TypeError;
|
|
}
|
|
}
|
|
return function() {
|
|
var args = arguments,
|
|
length = funcs.length;
|
|
|
|
while (length--) {
|
|
args = [funcs[length].apply(this, args)];
|
|
}
|
|
return args[0];
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Produces a callback bound to an optional `thisArg`. If `func` is a property
|
|
* name the created callback will return the property value for a given element.
|
|
* If `func` is an object the created callback will return `true` for elements
|
|
* that contain the equivalent object properties, otherwise it will return `false`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {*} [func=identity] The value to convert to a callback.
|
|
* @param {*} [thisArg] The `this` binding of the created callback.
|
|
* @param {number} [argCount] The number of arguments the callback accepts.
|
|
* @returns {Function} Returns a callback function.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* // wrap to create custom callback shorthands
|
|
* _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
|
|
* var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
|
|
* return !match ? func(callback, thisArg) : function(object) {
|
|
* return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
|
|
* };
|
|
* });
|
|
*
|
|
* _.filter(characters, 'age__gt38');
|
|
* // => [{ 'name': 'fred', 'age': 40 }]
|
|
*/
|
|
function createCallback(func, thisArg, argCount) {
|
|
var type = typeof func;
|
|
if (func == null || type == 'function') {
|
|
return baseCreateCallback(func, thisArg, argCount);
|
|
}
|
|
// handle "_.pluck" style callback shorthands
|
|
if (type != 'object') {
|
|
return function(object) {
|
|
return object[func];
|
|
};
|
|
}
|
|
var props = keys(func),
|
|
key = props[0],
|
|
a = func[key];
|
|
|
|
// handle "_.where" style callback shorthands
|
|
if (props.length == 1 && a === a && !isObject(a)) {
|
|
// fast path the common case of providing an object with a single
|
|
// property containing a primitive value
|
|
return function(object) {
|
|
var b = object[key];
|
|
return a === b && (a !== 0 || (1 / a == 1 / b));
|
|
};
|
|
}
|
|
return function(object) {
|
|
var length = props.length,
|
|
result = false;
|
|
|
|
while (length--) {
|
|
if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a function which accepts one or more arguments of `func` that when
|
|
* invoked either executes `func` returning its result, if all `func` arguments
|
|
* have been provided, or returns a function that accepts one or more of the
|
|
* remaining `func` arguments, and so on. The arity of `func` can be specified
|
|
* if `func.length` is not sufficient.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to curry.
|
|
* @param {number} [arity=func.length] The arity of `func`.
|
|
* @returns {Function} Returns the new curried function.
|
|
* @example
|
|
*
|
|
* var curried = _.curry(function(a, b, c) {
|
|
* console.log(a + b + c);
|
|
* });
|
|
*
|
|
* curried(1)(2)(3);
|
|
* // => 6
|
|
*
|
|
* curried(1, 2)(3);
|
|
* // => 6
|
|
*
|
|
* curried(1, 2, 3);
|
|
* // => 6
|
|
*/
|
|
function curry(func, arity) {
|
|
arity = typeof arity == 'number' ? arity : (+arity || func.length);
|
|
return createWrapper(func, 4, null, null, null, arity);
|
|
}
|
|
|
|
/**
|
|
* Creates a function that will delay the execution of `func` until after
|
|
* `wait` milliseconds have elapsed since the last time it was invoked.
|
|
* Provide an options object to indicate that `func` should be invoked on
|
|
* the leading and/or trailing edge of the `wait` timeout. Subsequent calls
|
|
* to the debounced function will return the result of the last `func` call.
|
|
*
|
|
* Note: If `leading` and `trailing` options are `true` `func` will be called
|
|
* on the trailing edge of the timeout only if the the debounced function is
|
|
* invoked more than once during the `wait` timeout.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to debounce.
|
|
* @param {number} wait The number of milliseconds to delay.
|
|
* @param {Object} [options] The options object.
|
|
* @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout.
|
|
* @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called.
|
|
* @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
|
|
* @returns {Function} Returns the new debounced function.
|
|
* @example
|
|
*
|
|
* // avoid costly calculations while the window size is in flux
|
|
* var lazyLayout = _.debounce(calculateLayout, 150);
|
|
* jQuery(window).on('resize', lazyLayout);
|
|
*
|
|
* // execute `sendMail` when the click event is fired, debouncing subsequent calls
|
|
* jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
|
|
* 'leading': true,
|
|
* 'trailing': false
|
|
* });
|
|
*
|
|
* // ensure `batchLog` is executed once after 1 second of debounced calls
|
|
* var source = new EventSource('/stream');
|
|
* source.addEventListener('message', _.debounce(batchLog, 250, {
|
|
* 'maxWait': 1000
|
|
* }, false);
|
|
*/
|
|
function debounce(func, wait, options) {
|
|
var args,
|
|
maxTimeoutId,
|
|
result,
|
|
stamp,
|
|
thisArg,
|
|
timeoutId,
|
|
trailingCall,
|
|
lastCalled = 0,
|
|
maxWait = false,
|
|
trailing = true;
|
|
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
wait = nativeMax(0, wait) || 0;
|
|
if (options === true) {
|
|
var leading = true;
|
|
trailing = false;
|
|
} else if (isObject(options)) {
|
|
leading = options.leading;
|
|
maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0);
|
|
trailing = 'trailing' in options ? options.trailing : trailing;
|
|
}
|
|
var delayed = function() {
|
|
var remaining = wait - (now() - stamp);
|
|
if (remaining <= 0) {
|
|
if (maxTimeoutId) {
|
|
clearTimeout(maxTimeoutId);
|
|
}
|
|
var isCalled = trailingCall;
|
|
maxTimeoutId = timeoutId = trailingCall = undefined;
|
|
if (isCalled) {
|
|
lastCalled = now();
|
|
result = func.apply(thisArg, args);
|
|
if (!timeoutId && !maxTimeoutId) {
|
|
args = thisArg = null;
|
|
}
|
|
}
|
|
} else {
|
|
timeoutId = setTimeout(delayed, remaining);
|
|
}
|
|
};
|
|
|
|
var maxDelayed = function() {
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
maxTimeoutId = timeoutId = trailingCall = undefined;
|
|
if (trailing || (maxWait !== wait)) {
|
|
lastCalled = now();
|
|
result = func.apply(thisArg, args);
|
|
if (!timeoutId && !maxTimeoutId) {
|
|
args = thisArg = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
return function() {
|
|
args = arguments;
|
|
stamp = now();
|
|
thisArg = this;
|
|
trailingCall = trailing && (timeoutId || !leading);
|
|
|
|
if (maxWait === false) {
|
|
var leadingCall = leading && !timeoutId;
|
|
} else {
|
|
if (!maxTimeoutId && !leading) {
|
|
lastCalled = stamp;
|
|
}
|
|
var remaining = maxWait - (stamp - lastCalled),
|
|
isCalled = remaining <= 0;
|
|
|
|
if (isCalled) {
|
|
if (maxTimeoutId) {
|
|
maxTimeoutId = clearTimeout(maxTimeoutId);
|
|
}
|
|
lastCalled = stamp;
|
|
result = func.apply(thisArg, args);
|
|
}
|
|
else if (!maxTimeoutId) {
|
|
maxTimeoutId = setTimeout(maxDelayed, remaining);
|
|
}
|
|
}
|
|
if (isCalled && timeoutId) {
|
|
timeoutId = clearTimeout(timeoutId);
|
|
}
|
|
else if (!timeoutId && wait !== maxWait) {
|
|
timeoutId = setTimeout(delayed, wait);
|
|
}
|
|
if (leadingCall) {
|
|
isCalled = true;
|
|
result = func.apply(thisArg, args);
|
|
}
|
|
if (isCalled && !timeoutId && !maxTimeoutId) {
|
|
args = thisArg = null;
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Defers executing the `func` function until the current call stack has cleared.
|
|
* Additional arguments will be provided to `func` when it is invoked.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to defer.
|
|
* @param {...*} [arg] Arguments to invoke the function with.
|
|
* @returns {number} Returns the timer id.
|
|
* @example
|
|
*
|
|
* _.defer(function() { console.log('deferred'); });
|
|
* // returns from the function before 'deferred' is logged
|
|
*/
|
|
function defer(func) {
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
var args = slice(arguments, 1);
|
|
return setTimeout(function() { func.apply(undefined, args); }, 1);
|
|
}
|
|
// use `setImmediate` if available in Node.js
|
|
if (setImmediate) {
|
|
defer = function(func) {
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
return setImmediate.apply(context, arguments);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Executes the `func` function after `wait` milliseconds. Additional arguments
|
|
* will be provided to `func` when it is invoked.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to delay.
|
|
* @param {number} wait The number of milliseconds to delay execution.
|
|
* @param {...*} [arg] Arguments to invoke the function with.
|
|
* @returns {number} Returns the timer id.
|
|
* @example
|
|
*
|
|
* var log = _.bind(console.log, console);
|
|
* _.delay(log, 1000, 'logged later');
|
|
* // => 'logged later' (Appears after one second.)
|
|
*/
|
|
function delay(func, wait) {
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
var args = slice(arguments, 2);
|
|
return setTimeout(function() { func.apply(undefined, args); }, wait);
|
|
}
|
|
|
|
/**
|
|
* Creates a function that memoizes the result of `func`. If `resolver` is
|
|
* provided it will be used to determine the cache key for storing the result
|
|
* based on the arguments provided to the memoized function. By default, the
|
|
* first argument provided to the memoized function is used as the cache key.
|
|
* The `func` is executed with the `this` binding of the memoized function.
|
|
* The result cache is exposed as the `cache` property on the memoized function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to have its output memoized.
|
|
* @param {Function} [resolver] A function used to resolve the cache key.
|
|
* @returns {Function} Returns the new memoizing function.
|
|
* @example
|
|
*
|
|
* var fibonacci = _.memoize(function(n) {
|
|
* return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
|
|
* });
|
|
*
|
|
* fibonacci(9)
|
|
* // => 34
|
|
*
|
|
* var data = {
|
|
* 'fred': { 'name': 'fred', 'age': 40 },
|
|
* 'pebbles': { 'name': 'pebbles', 'age': 1 }
|
|
* };
|
|
*
|
|
* // modifying the result cache
|
|
* var get = _.memoize(function(name) { return data[name]; }, _.identity);
|
|
* get('pebbles');
|
|
* // => { 'name': 'pebbles', 'age': 1 }
|
|
*
|
|
* get.cache.pebbles.name = 'penelope';
|
|
* get('pebbles');
|
|
* // => { 'name': 'penelope', 'age': 1 }
|
|
*/
|
|
function memoize(func, resolver) {
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
var memoized = function() {
|
|
var cache = memoized.cache,
|
|
key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0];
|
|
|
|
return hasOwnProperty.call(cache, key)
|
|
? cache[key]
|
|
: (cache[key] = func.apply(this, arguments));
|
|
}
|
|
memoized.cache = {};
|
|
return memoized;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that is restricted to execute `func` once. Repeat calls to
|
|
* the function will return the value of the first call. The `func` is executed
|
|
* with the `this` binding of the created function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to restrict.
|
|
* @returns {Function} Returns the new restricted function.
|
|
* @example
|
|
*
|
|
* var initialize = _.once(createApplication);
|
|
* initialize();
|
|
* initialize();
|
|
* // `initialize` executes `createApplication` once
|
|
*/
|
|
function once(func) {
|
|
var ran,
|
|
result;
|
|
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
return function() {
|
|
if (ran) {
|
|
return result;
|
|
}
|
|
ran = true;
|
|
result = func.apply(this, arguments);
|
|
|
|
// clear the `func` variable so the function may be garbage collected
|
|
func = null;
|
|
return result;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a function that, when called, invokes `func` with any additional
|
|
* `partial` arguments prepended to those provided to the new function. This
|
|
* method is similar to `_.bind` except it does **not** alter the `this` binding.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to partially apply arguments to.
|
|
* @param {...*} [arg] Arguments to be partially applied.
|
|
* @returns {Function} Returns the new partially applied function.
|
|
* @example
|
|
*
|
|
* var greet = function(greeting, name) { return greeting + ' ' + name; };
|
|
* var hi = _.partial(greet, 'hi');
|
|
* hi('fred');
|
|
* // => 'hi fred'
|
|
*/
|
|
function partial(func) {
|
|
return createWrapper(func, 16, slice(arguments, 1));
|
|
}
|
|
|
|
/**
|
|
* This method is like `_.partial` except that `partial` arguments are
|
|
* appended to those provided to the new function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to partially apply arguments to.
|
|
* @param {...*} [arg] Arguments to be partially applied.
|
|
* @returns {Function} Returns the new partially applied function.
|
|
* @example
|
|
*
|
|
* var defaultsDeep = _.partialRight(_.merge, _.defaults);
|
|
*
|
|
* var options = {
|
|
* 'variable': 'data',
|
|
* 'imports': { 'jq': $ }
|
|
* };
|
|
*
|
|
* defaultsDeep(options, _.templateSettings);
|
|
*
|
|
* options.variable
|
|
* // => 'data'
|
|
*
|
|
* options.imports
|
|
* // => { '_': _, 'jq': $ }
|
|
*/
|
|
function partialRight(func) {
|
|
return createWrapper(func, 32, null, slice(arguments, 1));
|
|
}
|
|
|
|
/**
|
|
* Creates a function that, when executed, will only call the `func` function
|
|
* at most once per every `wait` milliseconds. Provide an options object to
|
|
* indicate that `func` should be invoked on the leading and/or trailing edge
|
|
* of the `wait` timeout. Subsequent calls to the throttled function will
|
|
* return the result of the last `func` call.
|
|
*
|
|
* Note: If `leading` and `trailing` options are `true` `func` will be called
|
|
* on the trailing edge of the timeout only if the the throttled function is
|
|
* invoked more than once during the `wait` timeout.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {Function} func The function to throttle.
|
|
* @param {number} wait The number of milliseconds to throttle executions to.
|
|
* @param {Object} [options] The options object.
|
|
* @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout.
|
|
* @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout.
|
|
* @returns {Function} Returns the new throttled function.
|
|
* @example
|
|
*
|
|
* // avoid excessively updating the position while scrolling
|
|
* var throttled = _.throttle(updatePosition, 100);
|
|
* jQuery(window).on('scroll', throttled);
|
|
*
|
|
* // execute `renewToken` when the click event is fired, but not more than once every 5 minutes
|
|
* jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
|
|
* 'trailing': false
|
|
* }));
|
|
*/
|
|
function throttle(func, wait, options) {
|
|
var leading = true,
|
|
trailing = true;
|
|
|
|
if (!isFunction(func)) {
|
|
throw new TypeError;
|
|
}
|
|
if (options === false) {
|
|
leading = false;
|
|
} else if (isObject(options)) {
|
|
leading = 'leading' in options ? options.leading : leading;
|
|
trailing = 'trailing' in options ? options.trailing : trailing;
|
|
}
|
|
debounceOptions.leading = leading;
|
|
debounceOptions.maxWait = wait;
|
|
debounceOptions.trailing = trailing;
|
|
|
|
return debounce(func, wait, debounceOptions);
|
|
}
|
|
|
|
/**
|
|
* Creates a function that provides `value` to the wrapper function as its
|
|
* first argument. Additional arguments provided to the function are appended
|
|
* to those provided to the wrapper function. The wrapper is executed with
|
|
* the `this` binding of the created function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Functions
|
|
* @param {*} value The value to wrap.
|
|
* @param {Function} wrapper The wrapper function.
|
|
* @returns {Function} Returns the new function.
|
|
* @example
|
|
*
|
|
* var p = _.wrap(_.escape, function(func, text) {
|
|
* return '<p>' + func(text) + '</p>';
|
|
* });
|
|
*
|
|
* p('Fred, Wilma, & Pebbles');
|
|
* // => '<p>Fred, Wilma, & Pebbles</p>'
|
|
*/
|
|
function wrap(value, wrapper) {
|
|
return createWrapper(wrapper, 16, [value]);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
|
|
* corresponding HTML entities.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {string} string The string to escape.
|
|
* @returns {string} Returns the escaped string.
|
|
* @example
|
|
*
|
|
* _.escape('Fred, Wilma, & Pebbles');
|
|
* // => 'Fred, Wilma, & Pebbles'
|
|
*/
|
|
function escape(string) {
|
|
return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
|
|
}
|
|
|
|
/**
|
|
* This method returns the first argument provided to it.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {*} value Any value.
|
|
* @returns {*} Returns `value`.
|
|
* @example
|
|
*
|
|
* var object = { 'name': 'fred' };
|
|
* _.identity(object) === object;
|
|
* // => true
|
|
*/
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Adds function properties of a source object to the `lodash` function and
|
|
* chainable wrapper.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {Object} object The object of function properties to add to `lodash`.
|
|
* @param {Object} object The object of function properties to add to `lodash`.
|
|
* @example
|
|
*
|
|
* _.mixin({
|
|
* 'capitalize': function(string) {
|
|
* return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
|
|
* }
|
|
* });
|
|
*
|
|
* _.capitalize('fred');
|
|
* // => 'Fred'
|
|
*
|
|
* _('fred').capitalize();
|
|
* // => 'Fred'
|
|
*/
|
|
function mixin(object, source) {
|
|
var ctor = object,
|
|
isFunc = !source || isFunction(ctor);
|
|
|
|
if (!source) {
|
|
ctor = lodashWrapper;
|
|
source = object;
|
|
object = lodash;
|
|
}
|
|
forEach(functions(source), function(methodName) {
|
|
var func = object[methodName] = source[methodName];
|
|
if (isFunc) {
|
|
ctor.prototype[methodName] = function() {
|
|
var value = this.__wrapped__,
|
|
args = [value];
|
|
|
|
push.apply(args, arguments);
|
|
var result = func.apply(object, args);
|
|
if (value && typeof value == 'object' && value === result) {
|
|
return this;
|
|
}
|
|
result = new ctor(result);
|
|
result.__chain__ = this.__chain__;
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Reverts the '_' variable to its previous value and returns a reference to
|
|
* the `lodash` function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @returns {Function} Returns the `lodash` function.
|
|
* @example
|
|
*
|
|
* var lodash = _.noConflict();
|
|
*/
|
|
function noConflict() {
|
|
context._ = oldDash;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* A no-operation function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @example
|
|
*
|
|
* var object = { 'name': 'fred' };
|
|
* _.noop(object) === undefined;
|
|
* // => true
|
|
*/
|
|
function noop() {
|
|
// no operation performed
|
|
}
|
|
|
|
/**
|
|
* Converts the given value into an integer of the specified radix.
|
|
* If `radix` is `undefined` or `0` a `radix` of `10` is used unless the
|
|
* `value` is a hexadecimal, in which case a `radix` of `16` is used.
|
|
*
|
|
* Note: This method avoids differences in native ES3 and ES5 `parseInt`
|
|
* implementations. See http://es5.github.io/#E.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {string} value The value to parse.
|
|
* @param {number} [radix] The radix used to interpret the value to parse.
|
|
* @returns {number} Returns the new integer value.
|
|
* @example
|
|
*
|
|
* _.parseInt('08');
|
|
* // => 8
|
|
*/
|
|
var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {
|
|
// Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt`
|
|
return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);
|
|
};
|
|
|
|
/**
|
|
* Produces a random number between `min` and `max` (inclusive). If only one
|
|
* argument is provided a number between `0` and the given number will be
|
|
* returned. If `floating` is truey or either `min` or `max` are floats a
|
|
* floating-point number will be returned instead of an integer.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {number} [min=0] The minimum possible value.
|
|
* @param {number} [max=1] The maximum possible value.
|
|
* @param {boolean} [floating=false] Specify returning a floating-point number.
|
|
* @returns {number} Returns a random number.
|
|
* @example
|
|
*
|
|
* _.random(0, 5);
|
|
* // => an integer between 0 and 5
|
|
*
|
|
* _.random(5);
|
|
* // => also an integer between 0 and 5
|
|
*
|
|
* _.random(5, true);
|
|
* // => a floating-point number between 0 and 5
|
|
*
|
|
* _.random(1.2, 5.2);
|
|
* // => a floating-point number between 1.2 and 5.2
|
|
*/
|
|
function random(min, max, floating) {
|
|
var noMin = min == null,
|
|
noMax = max == null;
|
|
|
|
if (floating == null) {
|
|
if (typeof min == 'boolean' && noMax) {
|
|
floating = min;
|
|
min = 1;
|
|
}
|
|
else if (!noMax && typeof max == 'boolean') {
|
|
floating = max;
|
|
noMax = true;
|
|
}
|
|
}
|
|
if (noMin && noMax) {
|
|
max = 1;
|
|
}
|
|
min = +min || 0;
|
|
if (noMax) {
|
|
max = min;
|
|
min = 0;
|
|
} else {
|
|
max = +max || 0;
|
|
}
|
|
if (floating || min % 1 || max % 1) {
|
|
var rand = nativeRandom();
|
|
return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max);
|
|
}
|
|
return baseRandom(min, max);
|
|
}
|
|
|
|
/**
|
|
* Resolves the value of `property` on `object`. If `property` is a function
|
|
* it will be invoked with the `this` binding of `object` and its result returned,
|
|
* else the property value is returned. If `object` is falsey then `undefined`
|
|
* is returned.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {Object} object The object to inspect.
|
|
* @param {string} property The property to get the value of.
|
|
* @returns {*} Returns the resolved value.
|
|
* @example
|
|
*
|
|
* var object = {
|
|
* 'cheese': 'crumpets',
|
|
* 'stuff': function() {
|
|
* return 'nonsense';
|
|
* }
|
|
* };
|
|
*
|
|
* _.result(object, 'cheese');
|
|
* // => 'crumpets'
|
|
*
|
|
* _.result(object, 'stuff');
|
|
* // => 'nonsense'
|
|
*/
|
|
function result(object, property) {
|
|
if (object) {
|
|
var value = object[property];
|
|
return isFunction(value) ? object[property]() : value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A micro-templating method that handles arbitrary delimiters, preserves
|
|
* whitespace, and correctly escapes quotes within interpolated code.
|
|
*
|
|
* Note: In the development build, `_.template` utilizes sourceURLs for easier
|
|
* debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
|
|
*
|
|
* For more information on precompiling templates see:
|
|
* http://lodash.com/custom-builds
|
|
*
|
|
* For more information on Chrome extension sandboxes see:
|
|
* http://developer.chrome.com/stable/extensions/sandboxingEval.html
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {string} text The template text.
|
|
* @param {Object} data The data object used to populate the text.
|
|
* @param {Object} [options] The options object.
|
|
* @param {RegExp} [options.escape] The "escape" delimiter.
|
|
* @param {RegExp} [options.evaluate] The "evaluate" delimiter.
|
|
* @param {Object} [options.imports] An object to import into the template as local variables.
|
|
* @param {RegExp} [options.interpolate] The "interpolate" delimiter.
|
|
* @param {string} [sourceURL] The sourceURL of the template's compiled source.
|
|
* @param {string} [variable] The data object variable name.
|
|
* @returns {Function|string} Returns a compiled function when no `data` object
|
|
* is given, else it returns the interpolated text.
|
|
* @example
|
|
*
|
|
* // using the "interpolate" delimiter to create a compiled template
|
|
* var compiled = _.template('hello <%= name %>');
|
|
* compiled({ 'name': 'fred' });
|
|
* // => 'hello fred'
|
|
*
|
|
* // using the "escape" delimiter to escape HTML in data property values
|
|
* _.template('<b><%- value %></b>', { 'value': '<script>' });
|
|
* // => '<b><script></b>'
|
|
*
|
|
* // using the "evaluate" delimiter to generate HTML
|
|
* var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
|
|
* _.template(list, { 'people': ['fred', 'barney'] });
|
|
* // => '<li>fred</li><li>barney</li>'
|
|
*
|
|
* // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
|
|
* _.template('hello ${ name }', { 'name': 'pebbles' });
|
|
* // => 'hello pebbles'
|
|
*
|
|
* // using the internal `print` function in "evaluate" delimiters
|
|
* _.template('<% print("hello " + name); %>!', { 'name': 'barney' });
|
|
* // => 'hello barney!'
|
|
*
|
|
* // using a custom template delimiters
|
|
* _.templateSettings = {
|
|
* 'interpolate': /{{([\s\S]+?)}}/g
|
|
* };
|
|
*
|
|
* _.template('hello {{ name }}!', { 'name': 'mustache' });
|
|
* // => 'hello mustache!'
|
|
*
|
|
* // using the `imports` option to import jQuery
|
|
* var list = '<% $.each(people, function(name) { %><li><%- name %></li><% }); %>';
|
|
* _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { '$': jQuery } });
|
|
* // => '<li>fred</li><li>barney</li>'
|
|
*
|
|
* // using the `sourceURL` option to specify a custom sourceURL for the template
|
|
* var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
|
|
* compiled(data);
|
|
* // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
|
|
*
|
|
* // using the `variable` option to ensure a with-statement isn't used in the compiled template
|
|
* var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
|
|
* compiled.source;
|
|
* // => function(data) {
|
|
* var __t, __p = '', __e = _.escape;
|
|
* __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
|
|
* return __p;
|
|
* }
|
|
*
|
|
* // using the `source` property to inline compiled templates for meaningful
|
|
* // line numbers in error messages and a stack trace
|
|
* fs.writeFileSync(path.join(cwd, 'jst.js'), '\
|
|
* var JST = {\
|
|
* "main": ' + _.template(mainText).source + '\
|
|
* };\
|
|
* ');
|
|
*/
|
|
function template(text, data, options) {
|
|
// based on John Resig's `tmpl` implementation
|
|
// http://ejohn.org/blog/javascript-micro-templating/
|
|
// and Laura Doktorova's doT.js
|
|
// https://github.com/olado/doT
|
|
var settings = lodash.templateSettings;
|
|
text = String(text || '');
|
|
|
|
// avoid missing dependencies when `iteratorTemplate` is not defined
|
|
options = defaults({}, options, settings);
|
|
|
|
var imports = defaults({}, options.imports, settings.imports),
|
|
importsKeys = keys(imports),
|
|
importsValues = values(imports);
|
|
|
|
var isEvaluating,
|
|
index = 0,
|
|
interpolate = options.interpolate || reNoMatch,
|
|
source = "__p += '";
|
|
|
|
// compile the regexp to match each delimiter
|
|
var reDelimiters = RegExp(
|
|
(options.escape || reNoMatch).source + '|' +
|
|
interpolate.source + '|' +
|
|
(interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
|
|
(options.evaluate || reNoMatch).source + '|$'
|
|
, 'g');
|
|
|
|
text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
|
|
interpolateValue || (interpolateValue = esTemplateValue);
|
|
|
|
// escape characters that cannot be included in string literals
|
|
source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);
|
|
|
|
// replace delimiters with snippets
|
|
if (escapeValue) {
|
|
source += "' +\n__e(" + escapeValue + ") +\n'";
|
|
}
|
|
if (evaluateValue) {
|
|
isEvaluating = true;
|
|
source += "';\n" + evaluateValue + ";\n__p += '";
|
|
}
|
|
if (interpolateValue) {
|
|
source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
|
|
}
|
|
index = offset + match.length;
|
|
|
|
// the JS engine embedded in Adobe products requires returning the `match`
|
|
// string in order to produce the correct `offset` value
|
|
return match;
|
|
});
|
|
|
|
source += "';\n";
|
|
|
|
// if `variable` is not specified, wrap a with-statement around the generated
|
|
// code to add the data object to the top of the scope chain
|
|
var variable = options.variable,
|
|
hasVariable = variable;
|
|
|
|
if (!hasVariable) {
|
|
variable = 'obj';
|
|
source = 'with (' + variable + ') {\n' + source + '\n}\n';
|
|
}
|
|
// cleanup code by stripping empty strings
|
|
source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
|
|
.replace(reEmptyStringMiddle, '$1')
|
|
.replace(reEmptyStringTrailing, '$1;');
|
|
|
|
// frame code as the function body
|
|
source = 'function(' + variable + ') {\n' +
|
|
(hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
|
|
"var __t, __p = '', __e = _.escape" +
|
|
(isEvaluating
|
|
? ', __j = Array.prototype.join;\n' +
|
|
"function print() { __p += __j.call(arguments, '') }\n"
|
|
: ';\n'
|
|
) +
|
|
source +
|
|
'return __p\n}';
|
|
|
|
// Use a sourceURL for easier debugging.
|
|
// http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
|
|
var sourceURL = '\n/*\n//# sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\n*/';
|
|
|
|
try {
|
|
var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);
|
|
} catch(e) {
|
|
e.source = source;
|
|
throw e;
|
|
}
|
|
if (data) {
|
|
return result(data);
|
|
}
|
|
// provide the compiled function's source by its `toString` method, in
|
|
// supported environments, or the `source` property as a convenience for
|
|
// inlining compiled templates during the build process
|
|
result.source = source;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Executes the callback `n` times, returning an array of the results
|
|
* of each callback execution. The callback is bound to `thisArg` and invoked
|
|
* with one argument; (index).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {number} n The number of times to execute the callback.
|
|
* @param {Function} callback The function called per iteration.
|
|
* @param {*} [thisArg] The `this` binding of `callback`.
|
|
* @returns {Array} Returns an array of the results of each `callback` execution.
|
|
* @example
|
|
*
|
|
* var diceRolls = _.times(3, _.partial(_.random, 1, 6));
|
|
* // => [3, 6, 4]
|
|
*
|
|
* _.times(3, function(n) { mage.castSpell(n); });
|
|
* // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively
|
|
*
|
|
* _.times(3, function(n) { this.cast(n); }, mage);
|
|
* // => also calls `mage.castSpell(n)` three times
|
|
*/
|
|
function times(n, callback, thisArg) {
|
|
n = (n = +n) > -1 ? n : 0;
|
|
var index = -1,
|
|
result = Array(n);
|
|
|
|
callback = baseCreateCallback(callback, thisArg, 1);
|
|
while (++index < n) {
|
|
result[index] = callback(index);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The inverse of `_.escape` this method converts the HTML entities
|
|
* `&`, `<`, `>`, `"`, and `'` in `string` to their
|
|
* corresponding characters.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {string} string The string to unescape.
|
|
* @returns {string} Returns the unescaped string.
|
|
* @example
|
|
*
|
|
* _.unescape('Fred, Barney & Pebbles');
|
|
* // => 'Fred, Barney & Pebbles'
|
|
*/
|
|
function unescape(string) {
|
|
return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar);
|
|
}
|
|
|
|
/**
|
|
* Generates a unique ID. If `prefix` is provided the ID will be appended to it.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utilities
|
|
* @param {string} [prefix] The value to prefix the ID with.
|
|
* @returns {string} Returns the unique ID.
|
|
* @example
|
|
*
|
|
* _.uniqueId('contact_');
|
|
* // => 'contact_104'
|
|
*
|
|
* _.uniqueId();
|
|
* // => '105'
|
|
*/
|
|
function uniqueId(prefix) {
|
|
var id = ++idCounter;
|
|
return String(prefix == null ? '' : prefix) + id;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Creates a `lodash` object that wraps the given value with explicit
|
|
* method chaining enabled.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Chaining
|
|
* @param {*} value The value to wrap.
|
|
* @returns {Object} Returns the wrapper object.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 },
|
|
* { 'name': 'pebbles', 'age': 1 }
|
|
* ];
|
|
*
|
|
* var youngest = _.chain(characters)
|
|
* .sortBy('age')
|
|
* .map(function(chr) { return chr.name + ' is ' + chr.age; })
|
|
* .first()
|
|
* .value();
|
|
* // => 'pebbles is 1'
|
|
*/
|
|
function chain(value) {
|
|
value = new lodashWrapper(value);
|
|
value.__chain__ = true;
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Invokes `interceptor` with the `value` as the first argument and then
|
|
* returns `value`. The purpose of this method is to "tap into" a method
|
|
* chain in order to perform operations on intermediate results within
|
|
* the chain.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Chaining
|
|
* @param {*} value The value to provide to `interceptor`.
|
|
* @param {Function} interceptor The function to invoke.
|
|
* @returns {*} Returns `value`.
|
|
* @example
|
|
*
|
|
* _([1, 2, 3, 4])
|
|
* .tap(function(array) { array.pop(); })
|
|
* .reverse()
|
|
* .value();
|
|
* // => [3, 2, 1]
|
|
*/
|
|
function tap(value, interceptor) {
|
|
interceptor(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Enables explicit method chaining on the wrapper object.
|
|
*
|
|
* @name chain
|
|
* @memberOf _
|
|
* @category Chaining
|
|
* @returns {*} Returns the wrapper object.
|
|
* @example
|
|
*
|
|
* var characters = [
|
|
* { 'name': 'barney', 'age': 36 },
|
|
* { 'name': 'fred', 'age': 40 }
|
|
* ];
|
|
*
|
|
* // without explicit chaining
|
|
* _(characters).first();
|
|
* // => { 'name': 'barney', 'age': 36 }
|
|
*
|
|
* // with explicit chaining
|
|
* _(characters).chain()
|
|
* .first()
|
|
* .pick('age')
|
|
* .value()
|
|
* // => { 'age': 36 }
|
|
*/
|
|
function wrapperChain() {
|
|
this.__chain__ = true;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Produces the `toString` result of the wrapped value.
|
|
*
|
|
* @name toString
|
|
* @memberOf _
|
|
* @category Chaining
|
|
* @returns {string} Returns the string result.
|
|
* @example
|
|
*
|
|
* _([1, 2, 3]).toString();
|
|
* // => '1,2,3'
|
|
*/
|
|
function wrapperToString() {
|
|
return String(this.__wrapped__);
|
|
}
|
|
|
|
/**
|
|
* Extracts the wrapped value.
|
|
*
|
|
* @name valueOf
|
|
* @memberOf _
|
|
* @alias value
|
|
* @category Chaining
|
|
* @returns {*} Returns the wrapped value.
|
|
* @example
|
|
*
|
|
* _([1, 2, 3]).valueOf();
|
|
* // => [1, 2, 3]
|
|
*/
|
|
function wrapperValueOf() {
|
|
return this.__wrapped__;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
// add functions that return wrapped values when chaining
|
|
lodash.after = after;
|
|
lodash.assign = assign;
|
|
lodash.at = at;
|
|
lodash.bind = bind;
|
|
lodash.bindAll = bindAll;
|
|
lodash.bindKey = bindKey;
|
|
lodash.chain = chain;
|
|
lodash.compact = compact;
|
|
lodash.compose = compose;
|
|
lodash.countBy = countBy;
|
|
lodash.create = create;
|
|
lodash.createCallback = createCallback;
|
|
lodash.curry = curry;
|
|
lodash.debounce = debounce;
|
|
lodash.defaults = defaults;
|
|
lodash.defer = defer;
|
|
lodash.delay = delay;
|
|
lodash.difference = difference;
|
|
lodash.filter = filter;
|
|
lodash.flatten = flatten;
|
|
lodash.forEach = forEach;
|
|
lodash.forEachRight = forEachRight;
|
|
lodash.forIn = forIn;
|
|
lodash.forInRight = forInRight;
|
|
lodash.forOwn = forOwn;
|
|
lodash.forOwnRight = forOwnRight;
|
|
lodash.functions = functions;
|
|
lodash.groupBy = groupBy;
|
|
lodash.indexBy = indexBy;
|
|
lodash.initial = initial;
|
|
lodash.intersection = intersection;
|
|
lodash.invert = invert;
|
|
lodash.invoke = invoke;
|
|
lodash.keys = keys;
|
|
lodash.map = map;
|
|
lodash.max = max;
|
|
lodash.memoize = memoize;
|
|
lodash.merge = merge;
|
|
lodash.min = min;
|
|
lodash.omit = omit;
|
|
lodash.once = once;
|
|
lodash.pairs = pairs;
|
|
lodash.partial = partial;
|
|
lodash.partialRight = partialRight;
|
|
lodash.pick = pick;
|
|
lodash.pluck = pluck;
|
|
lodash.pull = pull;
|
|
lodash.range = range;
|
|
lodash.reject = reject;
|
|
lodash.remove = remove;
|
|
lodash.rest = rest;
|
|
lodash.shuffle = shuffle;
|
|
lodash.sortBy = sortBy;
|
|
lodash.tap = tap;
|
|
lodash.throttle = throttle;
|
|
lodash.times = times;
|
|
lodash.toArray = toArray;
|
|
lodash.transform = transform;
|
|
lodash.union = union;
|
|
lodash.uniq = uniq;
|
|
lodash.values = values;
|
|
lodash.where = where;
|
|
lodash.without = without;
|
|
lodash.wrap = wrap;
|
|
lodash.zip = zip;
|
|
lodash.zipObject = zipObject;
|
|
|
|
// add aliases
|
|
lodash.collect = map;
|
|
lodash.drop = rest;
|
|
lodash.each = forEach;
|
|
lodash.eachRight = forEachRight;
|
|
lodash.extend = assign;
|
|
lodash.methods = functions;
|
|
lodash.object = zipObject;
|
|
lodash.select = filter;
|
|
lodash.tail = rest;
|
|
lodash.unique = uniq;
|
|
lodash.unzip = zip;
|
|
|
|
// add functions to `lodash.prototype`
|
|
mixin(lodash);
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
// add functions that return unwrapped values when chaining
|
|
lodash.clone = clone;
|
|
lodash.cloneDeep = cloneDeep;
|
|
lodash.contains = contains;
|
|
lodash.escape = escape;
|
|
lodash.every = every;
|
|
lodash.find = find;
|
|
lodash.findIndex = findIndex;
|
|
lodash.findKey = findKey;
|
|
lodash.findLast = findLast;
|
|
lodash.findLastIndex = findLastIndex;
|
|
lodash.findLastKey = findLastKey;
|
|
lodash.has = has;
|
|
lodash.identity = identity;
|
|
lodash.indexOf = indexOf;
|
|
lodash.isArguments = isArguments;
|
|
lodash.isArray = isArray;
|
|
lodash.isBoolean = isBoolean;
|
|
lodash.isDate = isDate;
|
|
lodash.isElement = isElement;
|
|
lodash.isEmpty = isEmpty;
|
|
lodash.isEqual = isEqual;
|
|
lodash.isFinite = isFinite;
|
|
lodash.isFunction = isFunction;
|
|
lodash.isNaN = isNaN;
|
|
lodash.isNull = isNull;
|
|
lodash.isNumber = isNumber;
|
|
lodash.isObject = isObject;
|
|
lodash.isPlainObject = isPlainObject;
|
|
lodash.isRegExp = isRegExp;
|
|
lodash.isString = isString;
|
|
lodash.isUndefined = isUndefined;
|
|
lodash.lastIndexOf = lastIndexOf;
|
|
lodash.mixin = mixin;
|
|
lodash.noConflict = noConflict;
|
|
lodash.noop = noop;
|
|
lodash.parseInt = parseInt;
|
|
lodash.random = random;
|
|
lodash.reduce = reduce;
|
|
lodash.reduceRight = reduceRight;
|
|
lodash.result = result;
|
|
lodash.runInContext = runInContext;
|
|
lodash.size = size;
|
|
lodash.some = some;
|
|
lodash.sortedIndex = sortedIndex;
|
|
lodash.template = template;
|
|
lodash.unescape = unescape;
|
|
lodash.uniqueId = uniqueId;
|
|
|
|
// add aliases
|
|
lodash.all = every;
|
|
lodash.any = some;
|
|
lodash.detect = find;
|
|
lodash.findWhere = find;
|
|
lodash.foldl = reduce;
|
|
lodash.foldr = reduceRight;
|
|
lodash.include = contains;
|
|
lodash.inject = reduce;
|
|
|
|
forOwn(lodash, function(func, methodName) {
|
|
if (!lodash.prototype[methodName]) {
|
|
lodash.prototype[methodName] = function() {
|
|
var args = [this.__wrapped__],
|
|
chainAll = this.__chain__;
|
|
|
|
push.apply(args, arguments);
|
|
var result = func.apply(lodash, args);
|
|
return chainAll
|
|
? new lodashWrapper(result, chainAll)
|
|
: result;
|
|
};
|
|
}
|
|
});
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
// add functions capable of returning wrapped and unwrapped values when chaining
|
|
lodash.first = first;
|
|
lodash.last = last;
|
|
lodash.sample = sample;
|
|
|
|
// add aliases
|
|
lodash.take = first;
|
|
lodash.head = first;
|
|
|
|
forOwn(lodash, function(func, methodName) {
|
|
var callbackable = methodName !== 'sample';
|
|
if (!lodash.prototype[methodName]) {
|
|
lodash.prototype[methodName]= function(n, guard) {
|
|
var chainAll = this.__chain__,
|
|
result = func(this.__wrapped__, n, guard);
|
|
|
|
return !chainAll && (n == null || (guard && !(callbackable && typeof n == 'function')))
|
|
? result
|
|
: new lodashWrapper(result, chainAll);
|
|
};
|
|
}
|
|
});
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* The semantic version number.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type string
|
|
*/
|
|
lodash.VERSION = '2.3.0';
|
|
|
|
// add "Chaining" functions to the wrapper
|
|
lodash.prototype.chain = wrapperChain;
|
|
lodash.prototype.toString = wrapperToString;
|
|
lodash.prototype.value = wrapperValueOf;
|
|
lodash.prototype.valueOf = wrapperValueOf;
|
|
|
|
// add `Array` functions that return unwrapped values
|
|
forEach(['join', 'pop', 'shift'], function(methodName) {
|
|
var func = arrayRef[methodName];
|
|
lodash.prototype[methodName] = function() {
|
|
var chainAll = this.__chain__,
|
|
result = func.apply(this.__wrapped__, arguments);
|
|
|
|
return chainAll
|
|
? new lodashWrapper(result, chainAll)
|
|
: result;
|
|
};
|
|
});
|
|
|
|
// add `Array` functions that return the wrapped value
|
|
forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
|
|
var func = arrayRef[methodName];
|
|
lodash.prototype[methodName] = function() {
|
|
func.apply(this.__wrapped__, arguments);
|
|
return this;
|
|
};
|
|
});
|
|
|
|
// add `Array` functions that return new wrapped values
|
|
forEach(['concat', 'slice', 'splice'], function(methodName) {
|
|
var func = arrayRef[methodName];
|
|
lodash.prototype[methodName] = function() {
|
|
return new lodashWrapper(func.apply(this.__wrapped__, arguments), this.__chain__);
|
|
};
|
|
});
|
|
|
|
return lodash;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
// expose Lo-Dash
|
|
var _ = runInContext();
|
|
|
|
// some AMD build optimizers like r.js check for condition patterns like the following:
|
|
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
|
|
// Expose Lo-Dash to the global object even when an AMD loader is present in
|
|
// case Lo-Dash was injected by a third-party script and not intended to be
|
|
// loaded as a module. The global assignment can be reverted in the Lo-Dash
|
|
// module by its `noConflict()` method.
|
|
root._ = _;
|
|
|
|
// define as an anonymous module so, through path mapping, it can be
|
|
// referenced as the "underscore" module
|
|
define(function() {
|
|
return _;
|
|
});
|
|
}
|
|
// check for `exports` after `define` in case a build optimizer adds an `exports` object
|
|
else if (freeExports && freeModule) {
|
|
// in Node.js or RingoJS
|
|
if (moduleExports) {
|
|
(freeModule.exports = _)._ = _;
|
|
}
|
|
// in Narwhal or Rhino -require
|
|
else {
|
|
freeExports._ = _;
|
|
}
|
|
}
|
|
else {
|
|
// in a browser or Rhino
|
|
root._ = _;
|
|
}
|
|
}.call(this));
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
/**
|
|
* Wrapper for the elasticsearch.js client, which will register the client constructor
|
|
* as a factory within angular that can be easily injected with Angular's awesome DI.
|
|
*
|
|
* It will also instruct the client to use Angular's $http service for it's ajax requests
|
|
*/
|
|
var AngularConnector = require('./lib/connectors/angular');
|
|
var Transport = require('./lib/transport');
|
|
var Client = require('./lib/client');
|
|
|
|
/* global angular */
|
|
angular.module('elasticsearch.client', [])
|
|
.factory('esFactory', ['$http', '$q', function ($http, $q) {
|
|
|
|
AngularConnector.prototype.$http = $http;
|
|
|
|
// store the original request function
|
|
Transport.prototype._request = Transport.prototype.request;
|
|
|
|
// overwrite the request function to return a promise
|
|
// and support the callback
|
|
Transport.prototype.request = function (params, cb) {
|
|
var deferred = $q.defer();
|
|
this._request(params, function (err, body, status) {
|
|
if (typeof cb === 'function') {
|
|
cb(err, body, status);
|
|
}
|
|
|
|
if (err) {
|
|
deferred.reject(err);
|
|
} else {
|
|
deferred.resolve({ body: body, status: status });
|
|
}
|
|
});
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
return function (config) {
|
|
config = config || {};
|
|
config.connectionClass = AngularConnector;
|
|
return new Client(config);
|
|
};
|
|
}]);
|
|
|
|
},{"./lib/client":16,"./lib/connectors/angular":21,"./lib/transport":31}],15:[function(require,module,exports){
|
|
/* jshint maxlen: false */
|
|
|
|
var ca = require('./client_action');
|
|
var errors = require('./errors');
|
|
|
|
var api = module.exports = {};
|
|
|
|
api._namespaces = ['cluster', 'indices'];
|
|
|
|
/**
|
|
* Perform a [bulk](http://elasticsearch.org/guide/reference/api/bulk/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.consistency - Explicit write consistency setting for the operation
|
|
* @param {Boolean} params.refresh - Refresh the index after performing the operation
|
|
* @param {String} [params.replication=sync] - Explicitely set the replication type
|
|
* @param {String} params.type - Default document type for items which don't provide one
|
|
* @param {String} params.index - Default index for items which don't provide one
|
|
*/
|
|
api.bulk = ca({
|
|
methods: [
|
|
'POST',
|
|
'PUT'
|
|
],
|
|
params: {
|
|
consistency: {
|
|
type: 'enum',
|
|
options: [
|
|
'one',
|
|
'quorum',
|
|
'all'
|
|
]
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
replication: {
|
|
type: 'enum',
|
|
'default': 'sync',
|
|
options: [
|
|
'sync',
|
|
'async'
|
|
]
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_bulk',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_bulk',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_bulk'
|
|
}
|
|
],
|
|
bulkBody: true
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [clearScroll](http://www.elasticsearch.org/guide/reference/api/search/scroll/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.scrollId - A comma-separated list of scroll IDs to clear
|
|
*/
|
|
api.clearScroll = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/_search/scroll/<%=scrollId%>',
|
|
req: {
|
|
scrollId: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
api.cluster = function ClusterNS(client) {
|
|
if (this instanceof ClusterNS) {
|
|
this.client = client;
|
|
} else {
|
|
return new ClusterNS(client);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Perform a [cluster.getSettings](http://elasticsearch.org/guide/reference/api/admin-cluster-update-settings/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
*/
|
|
api.cluster.prototype.getSettings = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/_cluster/settings'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.health](http://elasticsearch.org/guide/reference/api/admin-cluster-health/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.level=cluster] - Specify the level of detail for returned information
|
|
* @param {Boolean} params.local - Return local information, do not retrieve the state from master node (default: false)
|
|
* @param {Date or Number} params.masterTimeout - Explicit operation timeout for connection to master node
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Number} params.waitForActiveShards - Wait until the specified number of shards is active
|
|
* @param {String} params.waitForNodes - Wait until the specified number of nodes is available
|
|
* @param {Number} params.waitForRelocatingShards - Wait until the specified number of relocating shards is finished
|
|
* @param {String} params.waitForStatus - Wait until cluster is in a specific state
|
|
* @param {String} params.index - Limit the information returned to a specific index
|
|
*/
|
|
api.cluster.prototype.health = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
level: {
|
|
type: 'enum',
|
|
'default': 'cluster',
|
|
options: [
|
|
'cluster',
|
|
'indices',
|
|
'shards'
|
|
]
|
|
},
|
|
local: {
|
|
type: 'boolean'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
waitForActiveShards: {
|
|
type: 'number',
|
|
name: 'wait_for_active_shards'
|
|
},
|
|
waitForNodes: {
|
|
type: 'string',
|
|
name: 'wait_for_nodes'
|
|
},
|
|
waitForRelocatingShards: {
|
|
type: 'number',
|
|
name: 'wait_for_relocating_shards'
|
|
},
|
|
waitForStatus: {
|
|
type: 'enum',
|
|
'default': null,
|
|
options: [
|
|
'green',
|
|
'yellow',
|
|
'red'
|
|
],
|
|
name: 'wait_for_status'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_cluster/health/<%=index%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_cluster/health'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.nodeHotThreads](http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-hot-threads/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.interval - The interval for the second sampling of threads
|
|
* @param {Number} params.snapshots - Number of samples of thread stacktrace (default: 10)
|
|
* @param {Number} params.threads - Specify the number of threads to provide information for (default: 3)
|
|
* @param {String} params.type - The type to sample (default: cpu)
|
|
* @param {String or String[] or Boolean} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
|
|
*/
|
|
api.cluster.prototype.nodeHotThreads = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
interval: {
|
|
type: 'time'
|
|
},
|
|
snapshots: {
|
|
type: 'number'
|
|
},
|
|
threads: {
|
|
type: 'number'
|
|
},
|
|
type: {
|
|
type: 'enum',
|
|
options: [
|
|
'cpu',
|
|
'wait',
|
|
'block'
|
|
]
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_nodes/<%=nodeId%>/hotthreads',
|
|
req: {
|
|
nodeId: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_nodes/hotthreads'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.nodeInfo](http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-info/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.all - Return all available information
|
|
* @param {Boolean} params.clear - Reset the default settings
|
|
* @param {Boolean} params.http - Return information about HTTP
|
|
* @param {Boolean} params.jvm - Return information about the JVM
|
|
* @param {Boolean} params.network - Return information about network
|
|
* @param {Boolean} params.os - Return information about the operating system
|
|
* @param {Boolean} params.plugin - Return information about plugins
|
|
* @param {Boolean} params.process - Return information about the Elasticsearch process
|
|
* @param {Boolean} params.settings - Return information about node settings
|
|
* @param {Boolean} params.threadPool - Return information about the thread pool
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Boolean} params.transport - Return information about transport
|
|
* @param {String or String[] or Boolean} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
|
|
*/
|
|
api.cluster.prototype.nodeInfo = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
all: {
|
|
type: 'boolean'
|
|
},
|
|
clear: {
|
|
type: 'boolean'
|
|
},
|
|
http: {
|
|
type: 'boolean'
|
|
},
|
|
jvm: {
|
|
type: 'boolean'
|
|
},
|
|
network: {
|
|
type: 'boolean'
|
|
},
|
|
os: {
|
|
type: 'boolean'
|
|
},
|
|
plugin: {
|
|
type: 'boolean'
|
|
},
|
|
process: {
|
|
type: 'boolean'
|
|
},
|
|
settings: {
|
|
type: 'boolean'
|
|
},
|
|
threadPool: {
|
|
type: 'boolean',
|
|
name: 'thread_pool'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
transport: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_nodes/<%=nodeId%>',
|
|
req: {
|
|
nodeId: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_nodes'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.nodeShutdown](http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-shutdown/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.delay - Set the delay for the operation (default: 1s)
|
|
* @param {Boolean} params.exit - Exit the JVM as well (default: true)
|
|
* @param {String or String[] or Boolean} params.nodeId - A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes
|
|
*/
|
|
api.cluster.prototype.nodeShutdown = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
delay: {
|
|
type: 'time'
|
|
},
|
|
exit: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_cluster/nodes/<%=nodeId%>/_shutdown',
|
|
req: {
|
|
nodeId: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_shutdown'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.nodeStats](http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-stats/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.all - Return all available information
|
|
* @param {Boolean} params.clear - Reset the default level of detail
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return detailed information for, when returning the `indices` metric family (supports wildcards)
|
|
* @param {Boolean} params.fs - Return information about the filesystem
|
|
* @param {Boolean} params.http - Return information about HTTP
|
|
* @param {Boolean} params.indices - Return information about indices
|
|
* @param {Boolean} params.jvm - Return information about the JVM
|
|
* @param {Boolean} params.network - Return information about network
|
|
* @param {Boolean} params.os - Return information about the operating system
|
|
* @param {Boolean} params.process - Return information about the Elasticsearch process
|
|
* @param {Boolean} params.threadPool - Return information about the thread pool
|
|
* @param {Boolean} params.transport - Return information about transport
|
|
* @param {String} params.metricFamily - Limit the information returned to a certain metric family
|
|
* @param {String} params.metric - Limit the information returned for `indices` family to a specific metric
|
|
* @param {String or String[] or Boolean} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
|
|
*/
|
|
api.cluster.prototype.nodeStats = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
all: {
|
|
type: 'boolean'
|
|
},
|
|
clear: {
|
|
type: 'boolean'
|
|
},
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
fs: {
|
|
type: 'boolean'
|
|
},
|
|
http: {
|
|
type: 'boolean'
|
|
},
|
|
indices: {
|
|
type: 'boolean'
|
|
},
|
|
jvm: {
|
|
type: 'boolean'
|
|
},
|
|
network: {
|
|
type: 'boolean'
|
|
},
|
|
os: {
|
|
type: 'boolean'
|
|
},
|
|
process: {
|
|
type: 'boolean'
|
|
},
|
|
threadPool: {
|
|
type: 'boolean',
|
|
name: 'thread_pool'
|
|
},
|
|
transport: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_nodes/<%=nodeId%>/stats',
|
|
req: {
|
|
nodeId: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_nodes/stats'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.putSettings](http://elasticsearch.org/guide/reference/api/admin-cluster-update-settings/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
*/
|
|
api.cluster.prototype.putSettings = ca({
|
|
methods: [
|
|
'PUT'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/_cluster/settings'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.reroute](http://elasticsearch.org/guide/reference/api/admin-cluster-reroute/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.dryRun - Simulate the operation only and return the resulting state
|
|
* @param {Boolean} params.filterMetadata - Don't return cluster state metadata (default: false)
|
|
*/
|
|
api.cluster.prototype.reroute = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
dryRun: {
|
|
type: 'boolean',
|
|
name: 'dry_run'
|
|
},
|
|
filterMetadata: {
|
|
type: 'boolean',
|
|
name: 'filter_metadata'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_cluster/reroute'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [cluster.state](http://elasticsearch.org/guide/reference/api/admin-cluster-state/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.filterBlocks - Do not return information about blocks
|
|
* @param {Boolean} params.filterIndexTemplates - Do not return information about index templates
|
|
* @param {String or String[] or Boolean} params.filterIndices - Limit returned metadata information to specific indices
|
|
* @param {Boolean} params.filterMetadata - Do not return information about indices metadata
|
|
* @param {Boolean} params.filterNodes - Do not return information about nodes
|
|
* @param {Boolean} params.filterRoutingTable - Do not return information about shard allocation (`routing_table` and `routing_nodes`)
|
|
* @param {Boolean} params.local - Return local information, do not retrieve the state from master node (default: false)
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
*/
|
|
api.cluster.prototype.state = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
filterBlocks: {
|
|
type: 'boolean',
|
|
name: 'filter_blocks'
|
|
},
|
|
filterIndexTemplates: {
|
|
type: 'boolean',
|
|
name: 'filter_index_templates'
|
|
},
|
|
filterIndices: {
|
|
type: 'list',
|
|
name: 'filter_indices'
|
|
},
|
|
filterMetadata: {
|
|
type: 'boolean',
|
|
name: 'filter_metadata'
|
|
},
|
|
filterNodes: {
|
|
type: 'boolean',
|
|
name: 'filter_nodes'
|
|
},
|
|
filterRoutingTable: {
|
|
type: 'boolean',
|
|
name: 'filter_routing_table'
|
|
},
|
|
local: {
|
|
type: 'boolean'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_cluster/state'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [count](http://elasticsearch.org/guide/reference/api/count/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {Number} params.minScore - Include only documents with a specific `_score` value in the result
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String} params.source - The URL-encoded query definition (instead of using the request body)
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of indices to restrict the results
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of types to restrict the results
|
|
*/
|
|
api.count = ca({
|
|
methods: [
|
|
'POST',
|
|
'GET'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
minScore: {
|
|
type: 'number',
|
|
name: 'min_score'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
source: {
|
|
type: 'string'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_count',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_count',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_count'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [create](http://elasticsearch.org/guide/reference/api/index_/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.consistency - Explicit write consistency setting for the operation
|
|
* @param {String} params.id - Document ID
|
|
* @param {String} params.parent - ID of the parent document
|
|
* @param {String} params.percolate - Percolator queries to execute while indexing the document
|
|
* @param {Boolean} params.refresh - Refresh the index after performing the operation
|
|
* @param {String} [params.replication=sync] - Specific replication type
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.timestamp - Explicit timestamp for the document
|
|
* @param {Duration} params.ttl - Expiration time for the document
|
|
* @param {Number} params.version - Explicit version number for concurrency control
|
|
* @param {String} params.versionType - Specific version type
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document
|
|
*/
|
|
api.create = ca({
|
|
methods: [
|
|
'POST',
|
|
'PUT'
|
|
],
|
|
params: {
|
|
consistency: {
|
|
type: 'enum',
|
|
options: [
|
|
'one',
|
|
'quorum',
|
|
'all'
|
|
]
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
percolate: {
|
|
type: 'string'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
replication: {
|
|
type: 'enum',
|
|
'default': 'sync',
|
|
options: [
|
|
'sync',
|
|
'async'
|
|
]
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
timestamp: {
|
|
type: 'time'
|
|
},
|
|
ttl: {
|
|
type: 'duration'
|
|
},
|
|
version: {
|
|
type: 'number'
|
|
},
|
|
versionType: {
|
|
type: 'enum',
|
|
options: [
|
|
'internal',
|
|
'external'
|
|
],
|
|
name: 'version_type'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [delete](http://elasticsearch.org/guide/reference/api/delete/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.consistency - Specific write consistency setting for the operation
|
|
* @param {String} params.parent - ID of parent document
|
|
* @param {Boolean} params.refresh - Refresh the index after performing the operation
|
|
* @param {String} [params.replication=sync] - Specific replication type
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Number} params.version - Explicit version number for concurrency control
|
|
* @param {String} params.versionType - Specific version type
|
|
* @param {String} params.id - The document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document
|
|
*/
|
|
api['delete'] = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
consistency: {
|
|
type: 'enum',
|
|
options: [
|
|
'one',
|
|
'quorum',
|
|
'all'
|
|
]
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
replication: {
|
|
type: 'enum',
|
|
'default': 'sync',
|
|
options: [
|
|
'sync',
|
|
'async'
|
|
]
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
version: {
|
|
type: 'number'
|
|
},
|
|
versionType: {
|
|
type: 'enum',
|
|
options: [
|
|
'internal',
|
|
'external'
|
|
],
|
|
name: 'version_type'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [deleteByQuery](http://www.elasticsearch.org/guide/reference/api/delete-by-query/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.analyzer - The analyzer to use for the query string
|
|
* @param {String} params.consistency - Specific write consistency setting for the operation
|
|
* @param {String} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
|
|
* @param {String} params.df - The field to use as default where no field prefix is given in the query string
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String} [params.replication=sync] - Specific replication type
|
|
* @param {String} params.q - Query in the Lucene query string syntax
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String} params.source - The URL-encoded query definition (instead of using the request body)
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of types to restrict the operation
|
|
*/
|
|
api.deleteByQuery = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
analyzer: {
|
|
type: 'string'
|
|
},
|
|
consistency: {
|
|
type: 'enum',
|
|
options: [
|
|
'one',
|
|
'quorum',
|
|
'all'
|
|
]
|
|
},
|
|
defaultOperator: {
|
|
type: 'enum',
|
|
'default': 'OR',
|
|
options: [
|
|
'AND',
|
|
'OR'
|
|
],
|
|
name: 'default_operator'
|
|
},
|
|
df: {
|
|
type: 'string'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
replication: {
|
|
type: 'enum',
|
|
'default': 'sync',
|
|
options: [
|
|
'sync',
|
|
'async'
|
|
]
|
|
},
|
|
q: {
|
|
type: 'string'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
source: {
|
|
type: 'string'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_query',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_query',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [exists](http://elasticsearch.org/guide/reference/api/get/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.parent - The ID of the parent document
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {Boolean} params.realtime - Specify whether to perform the operation in realtime or search mode
|
|
* @param {Boolean} params.refresh - Refresh the shard containing the document before performing the operation
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String} params.id - The document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} [params.type=_all] - The type of the document (use `_all` to fetch the first document matching the ID across all types)
|
|
*/
|
|
api.exists = ca({
|
|
methods: [
|
|
'HEAD'
|
|
],
|
|
params: {
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
realtime: {
|
|
type: 'boolean'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>',
|
|
opt: {
|
|
type: {
|
|
type: 'string',
|
|
'default': '_all'
|
|
}
|
|
},
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
],
|
|
castExists: true
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [explain](http://elasticsearch.org/guide/reference/api/explain/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
|
|
* @param {String} params.analyzer - The analyzer for the query string query
|
|
* @param {String} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
|
|
* @param {String} params.df - The default field for query string query (default: _all)
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return in the response
|
|
* @param {Boolean} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
|
|
* @param {Boolean} params.lowercaseExpandedTerms - Specify whether query terms should be lowercased
|
|
* @param {String} params.parent - The ID of the parent document
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {String} params.q - Query in the Lucene query string syntax
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String or String[] or Boolean} params.source - True or false to return the _source field or not, or a list of fields to return
|
|
* @param {String or String[] or Boolean} params.sourceExclude - A list of fields to exclude from the returned _source field
|
|
* @param {String or String[] or Boolean} params.sourceInclude - A list of fields to extract and return from the _source field
|
|
* @param {String} params.id - The document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document
|
|
*/
|
|
api.explain = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
analyzeWildcard: {
|
|
type: 'boolean',
|
|
name: 'analyze_wildcard'
|
|
},
|
|
analyzer: {
|
|
type: 'string'
|
|
},
|
|
defaultOperator: {
|
|
type: 'enum',
|
|
'default': 'OR',
|
|
options: [
|
|
'AND',
|
|
'OR'
|
|
],
|
|
name: 'default_operator'
|
|
},
|
|
df: {
|
|
type: 'string'
|
|
},
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
lenient: {
|
|
type: 'boolean'
|
|
},
|
|
lowercaseExpandedTerms: {
|
|
type: 'boolean',
|
|
name: 'lowercase_expanded_terms'
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
q: {
|
|
type: 'string'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
source: {
|
|
type: 'list',
|
|
name: '_source'
|
|
},
|
|
sourceExclude: {
|
|
type: 'list',
|
|
name: '_source_exclude'
|
|
},
|
|
sourceInclude: {
|
|
type: 'list',
|
|
name: '_source_include'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [get](http://elasticsearch.org/guide/reference/api/get/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return in the response
|
|
* @param {String} params.parent - The ID of the parent document
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {Boolean} params.realtime - Specify whether to perform the operation in realtime or search mode
|
|
* @param {Boolean} params.refresh - Refresh the shard containing the document before performing the operation
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String or String[] or Boolean} params.source - True or false to return the _source field or not, or a list of fields to return
|
|
* @param {String or String[] or Boolean} params.sourceExclude - A list of fields to exclude from the returned _source field
|
|
* @param {String or String[] or Boolean} params.sourceInclude - A list of fields to extract and return from the _source field
|
|
* @param {String} params.id - The document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} [params.type=_all] - The type of the document (use `_all` to fetch the first document matching the ID across all types)
|
|
*/
|
|
api.get = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
realtime: {
|
|
type: 'boolean'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
source: {
|
|
type: 'list',
|
|
name: '_source'
|
|
},
|
|
sourceExclude: {
|
|
type: 'list',
|
|
name: '_source_exclude'
|
|
},
|
|
sourceInclude: {
|
|
type: 'list',
|
|
name: '_source_include'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>',
|
|
opt: {
|
|
type: {
|
|
type: 'string',
|
|
'default': '_all'
|
|
}
|
|
},
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [getSource](http://elasticsearch.org/guide/reference/api/get/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.exclude - A list of fields to exclude from the returned _source field
|
|
* @param {String or String[] or Boolean} params.include - A list of fields to extract and return from the _source field
|
|
* @param {String} params.parent - The ID of the parent document
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {Boolean} params.realtime - Specify whether to perform the operation in realtime or search mode
|
|
* @param {Boolean} params.refresh - Refresh the shard containing the document before performing the operation
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String} params.id - The document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} [params.type=_all] - The type of the document; use `_all` to fetch the first document matching the ID across all types
|
|
*/
|
|
api.getSource = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
exclude: {
|
|
type: 'list'
|
|
},
|
|
include: {
|
|
type: 'list'
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
realtime: {
|
|
type: 'boolean'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
|
|
opt: {
|
|
type: {
|
|
type: 'string',
|
|
'default': '_all'
|
|
}
|
|
},
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [index](http://elasticsearch.org/guide/reference/api/index_/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.consistency - Explicit write consistency setting for the operation
|
|
* @param {String} [params.opType=index] - Explicit operation type
|
|
* @param {String} params.parent - ID of the parent document
|
|
* @param {String} params.percolate - Percolator queries to execute while indexing the document
|
|
* @param {Boolean} params.refresh - Refresh the index after performing the operation
|
|
* @param {String} [params.replication=sync] - Specific replication type
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.timestamp - Explicit timestamp for the document
|
|
* @param {Duration} params.ttl - Expiration time for the document
|
|
* @param {Number} params.version - Explicit version number for concurrency control
|
|
* @param {String} params.versionType - Specific version type
|
|
* @param {String} params.id - Document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document
|
|
*/
|
|
api.index = ca({
|
|
methods: [
|
|
'POST',
|
|
'PUT'
|
|
],
|
|
params: {
|
|
consistency: {
|
|
type: 'enum',
|
|
options: [
|
|
'one',
|
|
'quorum',
|
|
'all'
|
|
]
|
|
},
|
|
opType: {
|
|
type: 'enum',
|
|
'default': 'index',
|
|
options: [
|
|
'index',
|
|
'create'
|
|
],
|
|
name: 'op_type'
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
percolate: {
|
|
type: 'string'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
replication: {
|
|
type: 'enum',
|
|
'default': 'sync',
|
|
options: [
|
|
'sync',
|
|
'async'
|
|
]
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
timestamp: {
|
|
type: 'time'
|
|
},
|
|
ttl: {
|
|
type: 'duration'
|
|
},
|
|
version: {
|
|
type: 'number'
|
|
},
|
|
versionType: {
|
|
type: 'enum',
|
|
options: [
|
|
'internal',
|
|
'external'
|
|
],
|
|
name: 'version_type'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
api.indices = function IndicesNS(client) {
|
|
if (this instanceof IndicesNS) {
|
|
this.client = client;
|
|
} else {
|
|
return new IndicesNS(client);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Perform a [indices.analyze](http://www.elasticsearch.org/guide/reference/api/admin-indices-analyze/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.analyzer - The name of the analyzer to use
|
|
* @param {String} params.field - Use the analyzer configured for this field (instead of passing the analyzer name)
|
|
* @param {String or String[] or Boolean} params.filters - A comma-separated list of filters to use for the analysis
|
|
* @param {String} params.index - The name of the index to scope the operation
|
|
* @param {Boolean} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
|
|
* @param {String} params.text - The text on which the analysis should be performed (when request body is not used)
|
|
* @param {String} params.tokenizer - The name of the tokenizer to use for the analysis
|
|
* @param {String} [params.format=detailed] - Format of the output
|
|
*/
|
|
api.indices.prototype.analyze = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
analyzer: {
|
|
type: 'string'
|
|
},
|
|
field: {
|
|
type: 'string'
|
|
},
|
|
filters: {
|
|
type: 'list'
|
|
},
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
preferLocal: {
|
|
type: 'boolean',
|
|
name: 'prefer_local'
|
|
},
|
|
text: {
|
|
type: 'string'
|
|
},
|
|
tokenizer: {
|
|
type: 'string'
|
|
},
|
|
format: {
|
|
type: 'enum',
|
|
'default': 'detailed',
|
|
options: [
|
|
'detailed',
|
|
'text'
|
|
]
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_analyze',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_analyze'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.clearCache](http://www.elasticsearch.org/guide/reference/api/admin-indices-clearcache/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.fieldData - Clear field data
|
|
* @param {Boolean} params.fielddata - Clear field data
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
|
|
* @param {Boolean} params.filter - Clear filter caches
|
|
* @param {Boolean} params.filterCache - Clear filter caches
|
|
* @param {Boolean} params.filterKeys - A comma-separated list of keys to clear when using the `filter_cache` parameter (default: all)
|
|
* @param {Boolean} params.id - Clear ID caches for parent/child
|
|
* @param {Boolean} params.idCache - Clear ID caches for parent/child
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index name to limit the operation
|
|
* @param {Boolean} params.recycler - Clear the recycler cache
|
|
*/
|
|
api.indices.prototype.clearCache = ca({
|
|
methods: [
|
|
'POST',
|
|
'GET'
|
|
],
|
|
params: {
|
|
fieldData: {
|
|
type: 'boolean',
|
|
name: 'field_data'
|
|
},
|
|
fielddata: {
|
|
type: 'boolean'
|
|
},
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
filter: {
|
|
type: 'boolean'
|
|
},
|
|
filterCache: {
|
|
type: 'boolean',
|
|
name: 'filter_cache'
|
|
},
|
|
filterKeys: {
|
|
type: 'boolean',
|
|
name: 'filter_keys'
|
|
},
|
|
id: {
|
|
type: 'boolean'
|
|
},
|
|
idCache: {
|
|
type: 'boolean',
|
|
name: 'id_cache'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
recycler: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_cache/clear',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_cache/clear'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.close](http://www.elasticsearch.org/guide/reference/api/admin-indices-open-close/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.index - The name of the index
|
|
*/
|
|
api.indices.prototype.close = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_close',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.create](http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.index - The name of the index
|
|
*/
|
|
api.indices.prototype.create = ca({
|
|
methods: [
|
|
'PUT',
|
|
'POST'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.delete](http://www.elasticsearch.org/guide/reference/api/admin-indices-delete-index/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of indices to delete; use `_all` or empty string to delete all indices
|
|
*/
|
|
api.indices.prototype['delete'] = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.deleteAlias](http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit timestamp for the document
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.index - The name of the index with an alias
|
|
* @param {String} params.name - The name of the alias to be deleted
|
|
*/
|
|
api.indices.prototype.deleteAlias = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_alias/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.deleteMapping](http://www.elasticsearch.org/guide/reference/api/admin-indices-delete-mapping/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` for all indices
|
|
* @param {String} params.type - The name of the document type to delete
|
|
*/
|
|
api.indices.prototype.deleteMapping = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.deleteTemplate](http://www.elasticsearch.org/guide/reference/api/admin-indices-templates/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.name - The name of the template
|
|
*/
|
|
api.indices.prototype.deleteTemplate = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_template/<%=name%>',
|
|
req: {
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.deleteWarmer](http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to register warmer for; use `_all` or empty string to perform the operation on all indices
|
|
* @param {String} params.name - The name of the warmer (supports wildcards); leave empty to delete all warmers
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to register warmer for; use `_all` or empty string to perform the operation on all types
|
|
*/
|
|
api.indices.prototype.deleteWarmer = ca({
|
|
methods: [
|
|
'DELETE'
|
|
],
|
|
params: {
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_warmer/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_warmer/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_warmer',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.exists](http://www.elasticsearch.org/guide/reference/api/admin-indices-indices-exists/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of indices to check
|
|
*/
|
|
api.indices.prototype.exists = ca({
|
|
methods: [
|
|
'HEAD'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
],
|
|
castExists: true
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.existsAlias](http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to filter aliases
|
|
* @param {String or String[] or Boolean} params.name - A comma-separated list of alias names to return
|
|
*/
|
|
api.indices.prototype.existsAlias = ca({
|
|
methods: [
|
|
'HEAD'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_alias/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_alias/<%=name%>',
|
|
req: {
|
|
name: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
],
|
|
castExists: true
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.existsType](http://www.elasticsearch.org/guide/reference/api/admin-indices-types-exists/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to check
|
|
*/
|
|
api.indices.prototype.existsType = ca({
|
|
methods: [
|
|
'HEAD'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
],
|
|
castExists: true
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.flush](http://www.elasticsearch.org/guide/reference/api/admin-indices-flush/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.force - TODO: ?
|
|
* @param {Boolean} params.full - TODO: ?
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {Boolean} params.refresh - Refresh the index after performing the operation
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
|
|
*/
|
|
api.indices.prototype.flush = ca({
|
|
methods: [
|
|
'POST',
|
|
'GET'
|
|
],
|
|
params: {
|
|
force: {
|
|
type: 'boolean'
|
|
},
|
|
full: {
|
|
type: 'boolean'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_flush',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_flush'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getAlias](http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to filter aliases
|
|
* @param {String or String[] or Boolean} params.name - A comma-separated list of alias names to return
|
|
*/
|
|
api.indices.prototype.getAlias = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_alias/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_alias/<%=name%>',
|
|
req: {
|
|
name: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getAliases](http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to filter aliases
|
|
*/
|
|
api.indices.prototype.getAliases = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_aliases',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_aliases'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getFieldMapping](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-get-field-mapping.html) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.includeDefaults - Whether the default mapping values should be returned as well
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types
|
|
* @param {String or String[] or Boolean} params.field - A comma-separated list of fields
|
|
*/
|
|
api.indices.prototype.getFieldMapping = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
includeDefaults: {
|
|
type: 'boolean',
|
|
name: 'include_defaults'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_mapping/field/<%=field%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
},
|
|
field: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_mapping/field/<%=field%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
field: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_mapping/field/<%=field%>',
|
|
req: {
|
|
field: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getMapping](http://www.elasticsearch.org/guide/reference/api/admin-indices-get-mapping/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types
|
|
*/
|
|
api.indices.prototype.getMapping = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_mapping',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_mapping',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_mapping'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getSettings](http://www.elasticsearch.org/guide/reference/api/admin-indices-get-settings/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.indices.prototype.getSettings = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_settings',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_settings'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getTemplate](http://www.elasticsearch.org/guide/reference/api/admin-indices-templates/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.name - The name of the template
|
|
*/
|
|
api.indices.prototype.getTemplate = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/_template/<%=name%>',
|
|
req: {
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_template'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.getWarmer](http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices
|
|
* @param {String} params.name - The name of the warmer (supports wildcards); leave empty to get all warmers
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
|
|
*/
|
|
api.indices.prototype.getWarmer = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_warmer/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_warmer/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_warmer',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.open](http://www.elasticsearch.org/guide/reference/api/admin-indices-open-close/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.index - The name of the index
|
|
*/
|
|
api.indices.prototype.open = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_open',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.optimize](http://www.elasticsearch.org/guide/reference/api/admin-indices-optimize/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {Number} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
|
|
* @param {Boolean} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
|
|
* @param {*} params.operationThreading - TODO: ?
|
|
* @param {Boolean} params.refresh - Specify whether the index should be refreshed after performing the operation (default: true)
|
|
* @param {Boolean} params.waitForMerge - Specify whether the request should block until the merge process is finished (default: true)
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.indices.prototype.optimize = ca({
|
|
methods: [
|
|
'POST',
|
|
'GET'
|
|
],
|
|
params: {
|
|
flush: {
|
|
type: 'boolean'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
maxNumSegments: {
|
|
type: 'number',
|
|
name: 'max_num_segments'
|
|
},
|
|
onlyExpungeDeletes: {
|
|
type: 'boolean',
|
|
name: 'only_expunge_deletes'
|
|
},
|
|
operationThreading: {
|
|
name: 'operation_threading'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
waitForMerge: {
|
|
type: 'boolean',
|
|
name: 'wait_for_merge'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_optimize',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_optimize'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.putAlias](http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Explicit timestamp for the document
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.index - The name of the index with an alias
|
|
* @param {String} params.name - The name of the alias to be created or updated
|
|
*/
|
|
api.indices.prototype.putAlias = ca({
|
|
methods: [
|
|
'PUT'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_alias/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_alias/<%=name%>',
|
|
req: {
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_alias',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_alias'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.putMapping](http://www.elasticsearch.org/guide/reference/api/admin-indices-put-mapping/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.ignoreConflicts - Specify whether to ignore conflicts while updating the mapping (default: false)
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` to perform the operation on all indices
|
|
* @param {String} params.type - The name of the document type
|
|
*/
|
|
api.indices.prototype.putMapping = ca({
|
|
methods: [
|
|
'PUT',
|
|
'POST'
|
|
],
|
|
params: {
|
|
ignoreConflicts: {
|
|
type: 'boolean',
|
|
name: 'ignore_conflicts'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_mapping',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.putSettings](http://www.elasticsearch.org/guide/reference/api/admin-indices-update-settings/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.indices.prototype.putSettings = ca({
|
|
methods: [
|
|
'PUT'
|
|
],
|
|
params: {
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_settings',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_settings'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.putTemplate](http://www.elasticsearch.org/guide/reference/api/admin-indices-templates/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Number} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String} params.name - The name of the template
|
|
*/
|
|
api.indices.prototype.putTemplate = ca({
|
|
methods: [
|
|
'PUT',
|
|
'POST'
|
|
],
|
|
params: {
|
|
order: {
|
|
type: 'number'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_template/<%=name%>',
|
|
req: {
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.putWarmer](http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to register the warmer for; use `_all` or empty string to perform the operation on all indices
|
|
* @param {String} params.name - The name of the warmer
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types
|
|
*/
|
|
api.indices.prototype.putWarmer = ca({
|
|
methods: [
|
|
'PUT'
|
|
],
|
|
params: {
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_warmer/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_warmer/<%=name%>',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
name: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.refresh](http://www.elasticsearch.org/guide/reference/api/admin-indices-refresh/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {*} params.operationThreading - TODO: ?
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.indices.prototype.refresh = ca({
|
|
methods: [
|
|
'POST',
|
|
'GET'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
operationThreading: {
|
|
name: 'operation_threading'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_refresh',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_refresh'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.segments](http://elasticsearch.org/guide/reference/api/admin-indices-segments/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {*} params.operationThreading - TODO: ?
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.indices.prototype.segments = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
operationThreading: {
|
|
name: 'operation_threading'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_segments',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_segments'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.snapshotIndex](http://www.elasticsearch.org/guide/reference/api/admin-indices-gateway-snapshot/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
|
|
*/
|
|
api.indices.prototype.snapshotIndex = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_gateway/snapshot',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_gateway/snapshot'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.stats](http://elasticsearch.org/guide/reference/api/admin-indices-stats/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.all - Return all available information
|
|
* @param {Boolean} params.clear - Reset the default level of detail
|
|
* @param {Boolean} params.completion - Return information about completion suggester stats
|
|
* @param {String or String[] or Boolean} params.completionFields - A comma-separated list of fields for `completion` metric (supports wildcards)
|
|
* @param {Boolean} params.docs - Return information about indexed and deleted documents
|
|
* @param {Boolean} params.fielddata - Return information about field data
|
|
* @param {String or String[] or Boolean} params.fielddataFields - A comma-separated list of fields for `fielddata` metric (supports wildcards)
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return detailed information for, when returning the `search` statistics
|
|
* @param {Boolean} params.filterCache - Return information about filter cache
|
|
* @param {Boolean} params.flush - Return information about flush operations
|
|
* @param {Boolean} params.get - Return information about get operations
|
|
* @param {Boolean} params.groups - A comma-separated list of search groups for `search` statistics
|
|
* @param {Boolean} params.idCache - Return information about ID cache
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {Boolean} params.indexing - Return information about indexing operations
|
|
* @param {Boolean} params.merge - Return information about merge operations
|
|
* @param {Boolean} params.refresh - Return information about refresh operations
|
|
* @param {Boolean} params.search - Return information about search operations; use the `groups` parameter to include information for specific search groups
|
|
* @param {Boolean} params.store - Return information about the size of the index
|
|
* @param {Boolean} params.warmer - Return information about warmers
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
* @param {String or String[] or Boolean} params.indexingTypes - A comma-separated list of document types to include in the `indexing` statistics
|
|
* @param {String} params.metricFamily - Limit the information returned to a specific metric
|
|
* @param {String or String[] or Boolean} params.searchGroups - A comma-separated list of search groups to include in the `search` statistics
|
|
*/
|
|
api.indices.prototype.stats = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
all: {
|
|
type: 'boolean'
|
|
},
|
|
clear: {
|
|
type: 'boolean'
|
|
},
|
|
completion: {
|
|
type: 'boolean'
|
|
},
|
|
completionFields: {
|
|
type: 'list',
|
|
name: 'completion_fields'
|
|
},
|
|
docs: {
|
|
type: 'boolean'
|
|
},
|
|
fielddata: {
|
|
type: 'boolean'
|
|
},
|
|
fielddataFields: {
|
|
type: 'list',
|
|
name: 'fielddata_fields'
|
|
},
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
filterCache: {
|
|
type: 'boolean',
|
|
name: 'filter_cache'
|
|
},
|
|
flush: {
|
|
type: 'boolean'
|
|
},
|
|
get: {
|
|
type: 'boolean'
|
|
},
|
|
groups: {
|
|
type: 'boolean'
|
|
},
|
|
idCache: {
|
|
type: 'boolean',
|
|
name: 'id_cache'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
indexing: {
|
|
type: 'boolean'
|
|
},
|
|
merge: {
|
|
type: 'boolean'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
search: {
|
|
type: 'boolean'
|
|
},
|
|
store: {
|
|
type: 'boolean'
|
|
},
|
|
warmer: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_stats',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_stats'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.status](http://elasticsearch.org/guide/reference/api/admin-indices-status/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {*} params.operationThreading - TODO: ?
|
|
* @param {Boolean} params.recovery - Return information about shard recovery
|
|
* @param {Boolean} params.snapshot - TODO: ?
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.indices.prototype.status = ca({
|
|
methods: [
|
|
'GET'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
operationThreading: {
|
|
name: 'operation_threading'
|
|
},
|
|
recovery: {
|
|
type: 'boolean'
|
|
},
|
|
snapshot: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_status',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_status'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.updateAliases](http://www.elasticsearch.org/guide/reference/api/admin-indices-aliases/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Date or Number} params.timeout - Request timeout
|
|
* @param {Date or Number} params.masterTimeout - Specify timeout for connection to master
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to filter aliases
|
|
*/
|
|
api.indices.prototype.updateAliases = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
masterTimeout: {
|
|
type: 'time',
|
|
name: 'master_timeout'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_aliases'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [indices.validateQuery](http://www.elasticsearch.org/guide/reference/api/validate/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.explain - Return detailed information about the error
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {*} params.operationThreading - TODO: ?
|
|
* @param {String} params.source - The URL-encoded query definition (instead of using the request body)
|
|
* @param {String} params.q - Query in the Lucene query string syntax
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
|
|
*/
|
|
api.indices.prototype.validateQuery = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
explain: {
|
|
type: 'boolean'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
operationThreading: {
|
|
name: 'operation_threading'
|
|
},
|
|
source: {
|
|
type: 'string'
|
|
},
|
|
q: {
|
|
type: 'string'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_validate/query',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_validate/query',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_validate/query'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [info](http://elasticsearch.org/guide/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
*/
|
|
api.info = ca({
|
|
methods: [
|
|
'GET',
|
|
'HEAD'
|
|
],
|
|
params: {},
|
|
urls: [
|
|
{
|
|
fmt: '/'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [mget](http://elasticsearch.org/guide/reference/api/multi-get/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return in the response
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {Boolean} params.realtime - Specify whether to perform the operation in realtime or search mode
|
|
* @param {Boolean} params.refresh - Refresh the shard containing the document before performing the operation
|
|
* @param {String or String[] or Boolean} params.source - True or false to return the _source field or not, or a list of fields to return
|
|
* @param {String or String[] or Boolean} params.sourceExclude - A list of fields to exclude from the returned _source field
|
|
* @param {String or String[] or Boolean} params.sourceInclude - A list of fields to extract and return from the _source field
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document
|
|
*/
|
|
api.mget = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
realtime: {
|
|
type: 'boolean'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
source: {
|
|
type: 'list',
|
|
name: '_source'
|
|
},
|
|
sourceExclude: {
|
|
type: 'list',
|
|
name: '_source_exclude'
|
|
},
|
|
sourceInclude: {
|
|
type: 'list',
|
|
name: '_source_include'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_mget',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_mget',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_mget'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [mlt](http://elasticsearch.org/guide/reference/api/more-like-this/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Number} params.boostTerms - The boost factor
|
|
* @param {Number} params.maxDocFreq - The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored
|
|
* @param {Number} params.maxQueryTerms - The maximum query terms to be included in the generated query
|
|
* @param {Number} params.maxWordLen - The minimum length of the word: longer words will be ignored
|
|
* @param {Number} params.minDocFreq - The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored
|
|
* @param {Number} params.minTermFreq - The term frequency as percent: terms with lower occurence in the source document will be ignored
|
|
* @param {Number} params.minWordLen - The minimum length of the word: shorter words will be ignored
|
|
* @param {String or String[] or Boolean} params.mltFields - Specific fields to perform the query against
|
|
* @param {Number} params.percentTermsToMatch - How many terms have to match in order to consider the document a match (default: 0.3)
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {Number} params.searchFrom - The offset from which to return results
|
|
* @param {String or String[] or Boolean} params.searchIndices - A comma-separated list of indices to perform the query against (default: the index containing the document)
|
|
* @param {String} params.searchQueryHint - The search query hint
|
|
* @param {String} params.searchScroll - A scroll search request definition
|
|
* @param {Number} params.searchSize - The number of documents to return (default: 10)
|
|
* @param {String} params.searchSource - A specific search request definition (instead of using the request body)
|
|
* @param {String} params.searchType - Specific search type (eg. `dfs_then_fetch`, `count`, etc)
|
|
* @param {String or String[] or Boolean} params.searchTypes - A comma-separated list of types to perform the query against (default: the same type as the document)
|
|
* @param {String or String[] or Boolean} params.stopWords - A list of stop words to be ignored
|
|
* @param {String} params.id - The document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
|
|
*/
|
|
api.mlt = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
boostTerms: {
|
|
type: 'number',
|
|
name: 'boost_terms'
|
|
},
|
|
maxDocFreq: {
|
|
type: 'number',
|
|
name: 'max_doc_freq'
|
|
},
|
|
maxQueryTerms: {
|
|
type: 'number',
|
|
name: 'max_query_terms'
|
|
},
|
|
maxWordLen: {
|
|
type: 'number',
|
|
name: 'max_word_len'
|
|
},
|
|
minDocFreq: {
|
|
type: 'number',
|
|
name: 'min_doc_freq'
|
|
},
|
|
minTermFreq: {
|
|
type: 'number',
|
|
name: 'min_term_freq'
|
|
},
|
|
minWordLen: {
|
|
type: 'number',
|
|
name: 'min_word_len'
|
|
},
|
|
mltFields: {
|
|
type: 'list',
|
|
name: 'mlt_fields'
|
|
},
|
|
percentTermsToMatch: {
|
|
type: 'number',
|
|
name: 'percent_terms_to_match'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
searchFrom: {
|
|
type: 'number',
|
|
name: 'search_from'
|
|
},
|
|
searchIndices: {
|
|
type: 'list',
|
|
name: 'search_indices'
|
|
},
|
|
searchQueryHint: {
|
|
type: 'string',
|
|
name: 'search_query_hint'
|
|
},
|
|
searchScroll: {
|
|
type: 'string',
|
|
name: 'search_scroll'
|
|
},
|
|
searchSize: {
|
|
type: 'number',
|
|
name: 'search_size'
|
|
},
|
|
searchSource: {
|
|
type: 'string',
|
|
name: 'search_source'
|
|
},
|
|
searchType: {
|
|
type: 'string',
|
|
name: 'search_type'
|
|
},
|
|
searchTypes: {
|
|
type: 'list',
|
|
name: 'search_types'
|
|
},
|
|
stopWords: {
|
|
type: 'list',
|
|
name: 'stop_words'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>/_mlt',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [msearch](http://www.elasticsearch.org/guide/reference/api/multi-search/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.searchType - Search operation type
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to use as default
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to use as default
|
|
*/
|
|
api.msearch = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
searchType: {
|
|
type: 'enum',
|
|
options: [
|
|
'query_then_fetch',
|
|
'query_and_fetch',
|
|
'dfs_query_then_fetch',
|
|
'dfs_query_and_fetch',
|
|
'count',
|
|
'scan'
|
|
],
|
|
name: 'search_type'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_msearch',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
},
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_msearch',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_msearch'
|
|
}
|
|
],
|
|
bulkBody: true
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [percolate](http://elasticsearch.org/guide/reference/api/percolate/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Boolean} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
|
|
* @param {String} params.index - The name of the index with a registered percolator query
|
|
* @param {String} params.type - The document type
|
|
*/
|
|
api.percolate = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
preferLocal: {
|
|
type: 'boolean',
|
|
name: 'prefer_local'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_percolate',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [scroll](http://www.elasticsearch.org/guide/reference/api/search/scroll/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {Duration} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
|
|
* @param {String} params.scrollId - The scroll ID
|
|
*/
|
|
api.scroll = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
scroll: {
|
|
type: 'duration'
|
|
},
|
|
scrollId: {
|
|
type: 'string',
|
|
name: 'scroll_id'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/_search/scroll/<%=scrollId%>',
|
|
req: {
|
|
scrollId: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_search/scroll'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [search](http://www.elasticsearch.org/guide/reference/api/search/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.analyzer - The analyzer to use for the query string
|
|
* @param {Boolean} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
|
|
* @param {String} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
|
|
* @param {String} params.df - The field to use as default where no field prefix is given in the query string
|
|
* @param {Boolean} params.explain - Specify whether to return detailed information about score computation as part of a hit
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return as part of a hit
|
|
* @param {Number} params.from - Starting offset (default: 0)
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String or String[] or Boolean} params.indicesBoost - Comma-separated list of index boosts
|
|
* @param {Boolean} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
|
|
* @param {Boolean} params.lowercaseExpandedTerms - Specify whether query terms should be lowercased
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {String} params.q - Query in the Lucene query string syntax
|
|
* @param {String or String[] or Boolean} params.routing - A comma-separated list of specific routing values
|
|
* @param {Duration} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
|
|
* @param {String} params.searchType - Search operation type
|
|
* @param {Number} params.size - Number of hits to return (default: 10)
|
|
* @param {String or String[] or Boolean} params.sort - A comma-separated list of <field>:<direction> pairs
|
|
* @param {String or String[] or Boolean} params.source - True or false to return the _source field or not, or a list of fields to return
|
|
* @param {String or String[] or Boolean} params.sourceExclude - A list of fields to exclude from the returned _source field
|
|
* @param {String or String[] or Boolean} params.sourceInclude - A list of fields to extract and return from the _source field
|
|
* @param {String or String[] or Boolean} params.stats - Specific 'tag' of the request for logging and statistical purposes
|
|
* @param {String} params.suggestField - Specify which field to use for suggestions
|
|
* @param {String} [params.suggestMode=missing] - Specify suggest mode
|
|
* @param {Number} params.suggestSize - How many suggestions to return in response
|
|
* @param {Text} params.suggestText - The source text for which the suggestions should be returned
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Boolean} params.version - Specify whether to return document version as part of a hit
|
|
* @param {String or String[] or Boolean} [params.index=_all] - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
|
|
* @param {String or String[] or Boolean} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
|
|
*/
|
|
api.search = ca({
|
|
methods: [
|
|
'GET',
|
|
'POST'
|
|
],
|
|
params: {
|
|
analyzer: {
|
|
type: 'string'
|
|
},
|
|
analyzeWildcard: {
|
|
type: 'boolean',
|
|
name: 'analyze_wildcard'
|
|
},
|
|
defaultOperator: {
|
|
type: 'enum',
|
|
'default': 'OR',
|
|
options: [
|
|
'AND',
|
|
'OR'
|
|
],
|
|
name: 'default_operator'
|
|
},
|
|
df: {
|
|
type: 'string'
|
|
},
|
|
explain: {
|
|
type: 'boolean'
|
|
},
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
from: {
|
|
type: 'number'
|
|
},
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
indicesBoost: {
|
|
type: 'list',
|
|
name: 'indices_boost'
|
|
},
|
|
lenient: {
|
|
type: 'boolean'
|
|
},
|
|
lowercaseExpandedTerms: {
|
|
type: 'boolean',
|
|
name: 'lowercase_expanded_terms'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
q: {
|
|
type: 'string'
|
|
},
|
|
routing: {
|
|
type: 'list'
|
|
},
|
|
scroll: {
|
|
type: 'duration'
|
|
},
|
|
searchType: {
|
|
type: 'enum',
|
|
options: [
|
|
'query_then_fetch',
|
|
'query_and_fetch',
|
|
'dfs_query_then_fetch',
|
|
'dfs_query_and_fetch',
|
|
'count',
|
|
'scan'
|
|
],
|
|
name: 'search_type'
|
|
},
|
|
size: {
|
|
type: 'number'
|
|
},
|
|
sort: {
|
|
type: 'list'
|
|
},
|
|
source: {
|
|
type: 'list',
|
|
name: '_source'
|
|
},
|
|
sourceExclude: {
|
|
type: 'list',
|
|
name: '_source_exclude'
|
|
},
|
|
sourceInclude: {
|
|
type: 'list',
|
|
name: '_source_include'
|
|
},
|
|
stats: {
|
|
type: 'list'
|
|
},
|
|
suggestField: {
|
|
type: 'string',
|
|
name: 'suggest_field'
|
|
},
|
|
suggestMode: {
|
|
type: 'enum',
|
|
'default': 'missing',
|
|
options: [
|
|
'missing',
|
|
'popular',
|
|
'always'
|
|
],
|
|
name: 'suggest_mode'
|
|
},
|
|
suggestSize: {
|
|
type: 'number',
|
|
name: 'suggest_size'
|
|
},
|
|
suggestText: {
|
|
type: 'text',
|
|
name: 'suggest_text'
|
|
},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
version: {
|
|
type: 'boolean'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/_search',
|
|
opt: {
|
|
index: {
|
|
type: 'list',
|
|
'default': '_all'
|
|
}
|
|
},
|
|
req: {
|
|
type: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/<%=index%>/_search',
|
|
opt: {
|
|
index: {
|
|
type: 'list',
|
|
'default': '_all'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [suggest](http://elasticsearch.org/guide/reference/api/search/suggest/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} [params.ignoreIndices=none] - When performed on multiple indices, allows to ignore `missing` ones
|
|
* @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random)
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {String} params.source - The URL-encoded request definition (instead of using request body)
|
|
* @param {String or String[] or Boolean} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
|
|
*/
|
|
api.suggest = ca({
|
|
methods: [
|
|
'POST',
|
|
'GET'
|
|
],
|
|
params: {
|
|
ignoreIndices: {
|
|
type: 'enum',
|
|
'default': 'none',
|
|
options: [
|
|
'none',
|
|
'missing'
|
|
],
|
|
name: 'ignore_indices'
|
|
},
|
|
preference: {
|
|
type: 'string'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
source: {
|
|
type: 'string'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/_suggest',
|
|
req: {
|
|
index: {
|
|
type: 'list'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
fmt: '/_suggest'
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
/**
|
|
* Perform a [update](http://elasticsearch.org/guide/reference/api/update/) request
|
|
*
|
|
* @param {Object} params - An object with parameters used to carry out this action
|
|
* @param {String} params.consistency - Explicit write consistency setting for the operation
|
|
* @param {String or String[] or Boolean} params.fields - A comma-separated list of fields to return in the response
|
|
* @param {String} params.lang - The script language (default: mvel)
|
|
* @param {String} params.parent - ID of the parent document
|
|
* @param {String} params.percolate - Perform percolation during the operation; use specific registered query name, attribute, or wildcard
|
|
* @param {Boolean} params.refresh - Refresh the index after performing the operation
|
|
* @param {String} [params.replication=sync] - Specific replication type
|
|
* @param {Number} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
|
|
* @param {String} params.routing - Specific routing value
|
|
* @param {*} params.script - The URL-encoded script definition (instead of using request body)
|
|
* @param {Date or Number} params.timeout - Explicit operation timeout
|
|
* @param {Date or Number} params.timestamp - Explicit timestamp for the document
|
|
* @param {Duration} params.ttl - Expiration time for the document
|
|
* @param {Number} params.version - Explicit version number for concurrency control
|
|
* @param {String} params.versionType - Specific version type
|
|
* @param {String} params.id - Document ID
|
|
* @param {String} params.index - The name of the index
|
|
* @param {String} params.type - The type of the document
|
|
*/
|
|
api.update = ca({
|
|
methods: [
|
|
'POST'
|
|
],
|
|
params: {
|
|
consistency: {
|
|
type: 'enum',
|
|
options: [
|
|
'one',
|
|
'quorum',
|
|
'all'
|
|
]
|
|
},
|
|
fields: {
|
|
type: 'list'
|
|
},
|
|
lang: {
|
|
type: 'string'
|
|
},
|
|
parent: {
|
|
type: 'string'
|
|
},
|
|
percolate: {
|
|
type: 'string'
|
|
},
|
|
refresh: {
|
|
type: 'boolean'
|
|
},
|
|
replication: {
|
|
type: 'enum',
|
|
'default': 'sync',
|
|
options: [
|
|
'sync',
|
|
'async'
|
|
]
|
|
},
|
|
retryOnConflict: {
|
|
type: 'number',
|
|
name: 'retry_on_conflict'
|
|
},
|
|
routing: {
|
|
type: 'string'
|
|
},
|
|
script: {},
|
|
timeout: {
|
|
type: 'time'
|
|
},
|
|
timestamp: {
|
|
type: 'time'
|
|
},
|
|
ttl: {
|
|
type: 'duration'
|
|
},
|
|
version: {
|
|
type: 'number'
|
|
},
|
|
versionType: {
|
|
type: 'enum',
|
|
options: [
|
|
'internal',
|
|
'external'
|
|
],
|
|
name: 'version_type'
|
|
}
|
|
},
|
|
urls: [
|
|
{
|
|
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
|
|
req: {
|
|
index: {
|
|
type: 'string'
|
|
},
|
|
type: {
|
|
type: 'string'
|
|
},
|
|
id: {
|
|
type: 'string'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
|
|
},{"./client_action":17,"./errors":22}],16:[function(require,module,exports){
|
|
/**
|
|
* A client that makes requests to Elasticsearch via a {{#crossLink "Transport"}}Transport{{/crossLink}}
|
|
*
|
|
* Initializing a client might look something like:
|
|
*
|
|
* ```
|
|
* var client = new es.Client({
|
|
* hosts: [
|
|
* 'es1.net:9200',
|
|
* {
|
|
* host: 'es2.net',
|
|
* port: 9200
|
|
* }
|
|
* ],
|
|
* sniffOnStart: true,
|
|
* log: {
|
|
* type: 'file',
|
|
* level: 'warning'
|
|
* }
|
|
* });
|
|
* ```
|
|
*
|
|
* @class Client
|
|
* @constructor
|
|
* @param {Object} [config={}] - Configuration for the transport
|
|
* @param {Object} [config.transport] - Transport settings passed to {{#crossLink "Transport"}}Transport Constructor{{/crossLink}}
|
|
* @param {String|Array<String>} [config.log] - Log output settings {{#crossLink "Log"}}Log Constructor{{/crossLink}}
|
|
* @param {Object} [config.trace=false] - Create a log output to stdio that only tracks trace logs
|
|
*/
|
|
|
|
module.exports = Client;
|
|
|
|
var _ = require('./utils');
|
|
var ClientConfig = require('./client_config');
|
|
var api = require('./api.js');
|
|
|
|
function Client(config) {
|
|
this.client = this;
|
|
|
|
// setup the config.. this config will be passed EVERYWHERE so for good measure it is locked down
|
|
Object.defineProperty(this, 'config', {
|
|
configurable: false,
|
|
enumerable: false,
|
|
writable: false,
|
|
value: !config || _.isPlainObject(config) ? new ClientConfig(config) : config,
|
|
});
|
|
this.config.client = this;
|
|
|
|
// instansiate the api's namespaces
|
|
for (var i = 0; i < this._namespaces.length; i++) {
|
|
this[this._namespaces[i]] = new this[this._namespaces[i]](this);
|
|
}
|
|
}
|
|
|
|
Client.prototype = _.clone(api);
|
|
|
|
/**
|
|
* Ping some node to ensure that the cluster is available in some respect
|
|
*
|
|
* @param {Object} params - Currently just a placeholder, no params used at this time
|
|
* @param {Function} cb - callback
|
|
*/
|
|
Client.prototype.ping = function (params, cb) {
|
|
if (typeof params === 'function') {
|
|
cb = params;
|
|
params = {};
|
|
}
|
|
|
|
this.config.transport.request({
|
|
method: 'HEAD',
|
|
path: '/',
|
|
timeout: 100,
|
|
}, cb);
|
|
};
|
|
|
|
Client.prototype.close = function () {
|
|
this.config.close();
|
|
};
|
|
|
|
},{"./api.js":15,"./client_config":18,"./utils":33}],17:[function(require,module,exports){
|
|
/**
|
|
* Constructs a function that can be called to make a request to ES
|
|
* @type {[type]}
|
|
*/
|
|
module.exports = function ClientAction(spec, client) {
|
|
return function (params, cb) {
|
|
return exec((client || this.client).config.transport, spec, params, cb);
|
|
};
|
|
};
|
|
|
|
var errors = require('./errors');
|
|
var _ = require('./utils');
|
|
var urlParamRE = /\{(\w+)\}/g;
|
|
|
|
var castType = {
|
|
enum: function (param, val, name) {
|
|
if (_.contains(param.options, val)) {
|
|
return val;
|
|
} else {
|
|
throw new TypeError('Invalid ' + name + ': expected one of ' + param.options.join(','));
|
|
}
|
|
},
|
|
duration: function (param, val, name) {
|
|
if (_.isNumeric(val) || _.isInterval(val)) {
|
|
return val;
|
|
} else {
|
|
throw new TypeError(
|
|
'Invalid ' + name + ': expected a number or interval ' +
|
|
'(an integer followed by one of Mwdhmsy).'
|
|
);
|
|
}
|
|
},
|
|
list: function (param, val, name) {
|
|
switch (typeof val) {
|
|
case 'string':
|
|
return val;
|
|
case 'object':
|
|
if (_.isArray(val)) {
|
|
return val.join(',');
|
|
} else {
|
|
throw new TypeError('Invalid ' + name + ': expected be a comma seperated list, array, or boolean.');
|
|
}
|
|
break;
|
|
default:
|
|
return !!val;
|
|
}
|
|
},
|
|
boolean: function (param, val, name) {
|
|
val = _.isString(val) ? val.toLowerCase() : val;
|
|
return (val === 'no' || val === 'off') ? false : !!val;
|
|
},
|
|
number: function (param, val, name) {
|
|
if (_.isNumeric(val)) {
|
|
return val * 1;
|
|
} else {
|
|
throw new TypeError('Invalid ' + name + ': expected a number.');
|
|
}
|
|
},
|
|
string: function (param, val, name) {
|
|
if (typeof val !== 'object' && val) {
|
|
return '' + val;
|
|
} else {
|
|
throw new TypeError('Invalid ' + name + ': expected a string.');
|
|
}
|
|
},
|
|
time: function (param, val, name) {
|
|
if (typeof val === 'string' || _.isNumeric(val)) {
|
|
return val;
|
|
} else if (val instanceof Date) {
|
|
return val.getTime();
|
|
} else {
|
|
throw new TypeError('Invalid ' + name + ': expected some sort of time.');
|
|
}
|
|
}
|
|
};
|
|
|
|
function resolveUrl(url, params) {
|
|
var vars = {}, i, key;
|
|
|
|
if (url.req) {
|
|
// url has required params
|
|
if (!url.reqParamKeys) {
|
|
// create cached key list on demand
|
|
url.reqParamKeys = _.keys(url.req);
|
|
}
|
|
|
|
for (i = 0; i < url.reqParamKeys.length; i ++) {
|
|
key = url.reqParamKeys[i];
|
|
if (!params.hasOwnProperty(key)) {
|
|
// missing a required param
|
|
return false;
|
|
} else {
|
|
// copy param vals into vars
|
|
vars[key] = params[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (url.opt) {
|
|
// url has optional params
|
|
if (!url.optParamKeys) {
|
|
url.optParamKeys = _.keys(url.opt);
|
|
}
|
|
|
|
for (i = 0; i < url.optParamKeys.length; i ++) {
|
|
key = url.optParamKeys[i];
|
|
if (params[key]) {
|
|
if (castType[url.opt[key].type]) {
|
|
vars[key] = castType[url.opt[key].type](url.opt[key], params[key], key);
|
|
} else {
|
|
vars[key] = params[key];
|
|
}
|
|
} else {
|
|
vars[key] = url.opt[key]['default'];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!url.template) {
|
|
// compile the template on demand
|
|
url.template = _.template(url.fmt);
|
|
}
|
|
|
|
return url.template(_.transform(vars, function (note, val, name) {
|
|
// encode each value
|
|
note[name] = encodeURIComponent(val);
|
|
// remove it from the params so that it isn't sent to the final request
|
|
delete params[name];
|
|
}, {}));
|
|
}
|
|
|
|
function exec(transport, spec, params, cb) {
|
|
if (typeof params === 'function') {
|
|
cb = params;
|
|
params = {};
|
|
} else {
|
|
params = params || {};
|
|
cb = typeof cb === 'function' ? cb : _.noop;
|
|
}
|
|
|
|
var request = {};
|
|
var parts = {};
|
|
var query = {};
|
|
var i;
|
|
|
|
if (spec.needsBody && !params.body) {
|
|
return _.nextTick(cb, new TypeError('A request body is required.'));
|
|
}
|
|
|
|
params.body && (request.body = params.body);
|
|
params.ignore && (request.ignore = _.isArray(params.ignore) ? params.ignore : [params.ignore]);
|
|
if (params.timeout === void 0) {
|
|
request.timeout = 10000;
|
|
} else {
|
|
request.timeout = params.timeout;
|
|
}
|
|
|
|
// copy over some properties from the spec
|
|
spec.bulkBody && (request.bulkBody = true);
|
|
spec.castExists && (request.castExists = true);
|
|
|
|
if (spec.methods.length === 1) {
|
|
request.method = spec.methods[0];
|
|
} else {
|
|
// if set, uppercase the user's choice, other wise returns ""
|
|
request.method = _.toUpperString(params.method);
|
|
|
|
if (request.method) {
|
|
// use the one specified as long as it's a valid option
|
|
if (!_.contains(spec.methods, request.method)) {
|
|
return _.nextTick(cb, new TypeError('Invalid method: should be one of ' + spec.methods.join(', ')));
|
|
}
|
|
} else {
|
|
// pick a method
|
|
if (request.body) {
|
|
// first method that isn't "GET"
|
|
request.method = spec.methodWithBody || (
|
|
spec.methodWithBody = _.find(spec.methods, function (m) { return m !== 'GET'; })
|
|
);
|
|
} else {
|
|
// just use the first option
|
|
request.method = spec.methods[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (spec.url) {
|
|
// only one url option
|
|
request.path = resolveUrl(spec.url, params);
|
|
} else {
|
|
for (i = 0; i < spec.urls.length; i++) {
|
|
if (request.path = resolveUrl(spec.urls[i], params)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!request.path) {
|
|
// there must have been some mimimun requirements that were not met
|
|
return _.nextTick(
|
|
cb,
|
|
new TypeError(
|
|
'Unable to build a path with those params. Supply at least ' +
|
|
_.keys(spec.urls[spec.urls.length - 1].req).join(', ')
|
|
)
|
|
);
|
|
}
|
|
|
|
// build the query string
|
|
if (!spec.paramKeys) {
|
|
// build a key list on demand
|
|
spec.paramKeys = _.keys(spec.params);
|
|
}
|
|
var key, param, name;
|
|
for (i = 0; i < spec.paramKeys.length; i++) {
|
|
key = spec.paramKeys[i];
|
|
param = spec.params[key];
|
|
// param keys don't always match the param name, in those cases it's stored in the param def as "name"
|
|
name = param.name || key;
|
|
try {
|
|
if (params[key] != null) {
|
|
query[name] = castType[param.type] ? castType[param.type](param, params[key], key) : params[key];
|
|
if (param['default'] && query[name] === param['default']) {
|
|
delete query[name];
|
|
}
|
|
} else if (param.required) {
|
|
throw new TypeError('Missing required parameter ' + key);
|
|
}
|
|
} catch (e) {
|
|
return _.nextTick(cb, e);
|
|
}
|
|
}
|
|
|
|
request.query = query;
|
|
|
|
return transport.request(request, cb);
|
|
}
|
|
|
|
},{"./errors":22,"./utils":33}],18:[function(require,module,exports){
|
|
var process=require("__browserify_process");/**
|
|
* Manages the configuration of the client.
|
|
*
|
|
* @class ClientConfig
|
|
* @type {Function}
|
|
*/
|
|
module.exports = ClientConfig;
|
|
|
|
var url = require('url');
|
|
var _ = require('./utils');
|
|
var Host = require('./host');
|
|
var selectors = require('./selectors');
|
|
|
|
var connectors = {};
|
|
if (process.browser) {
|
|
connectors.Xhr = require('./connectors/xhr');
|
|
connectors.Angular = require('./connectors/angular');
|
|
connectors.jQuery = require('./connectors/jquery');
|
|
} else {
|
|
connectors.Http = require('./connectors/http');
|
|
}
|
|
|
|
_.each(connectors, function (conn, name) {
|
|
if (typeof conn !== 'function') {
|
|
delete connectors[name];
|
|
}
|
|
});
|
|
|
|
var serializers = {
|
|
Json: require('./serializers/json')
|
|
};
|
|
|
|
var extractHostPartsRE = /\[([^:]+):(\d+)]/;
|
|
var hostProtocolRE = /^([a-z]+:)?\/\//;
|
|
|
|
var defaultClasses = {
|
|
log: require('./log'),
|
|
serializer: serializers.Json,
|
|
connectionPool: require('./connection_pool'),
|
|
transport: require('./transport'),
|
|
};
|
|
|
|
var defaultConfig = {
|
|
loggers: [
|
|
{
|
|
level: 'warning'
|
|
}
|
|
],
|
|
hosts: [
|
|
{
|
|
host: 'localhost',
|
|
port: 9200,
|
|
protocol: 'http'
|
|
}
|
|
],
|
|
connectionClass: process.browser ? connectors.Xhr : connectors.Http,
|
|
selector: selectors.roundRobin,
|
|
sniffOnStart: false,
|
|
sniffAfterRequests: null,
|
|
sniffOnConnectionFail: false,
|
|
maxRetries: 3,
|
|
timeout: 10000,
|
|
deadTimeout: 60000,
|
|
maxSockets: 10,
|
|
nodesToHostCallback: function (nodes) {
|
|
var hosts = [];
|
|
_.each(nodes, function (node, id) {
|
|
var hostnameMatches = extractHostPartsRE.exec(node.host);
|
|
hosts.push({
|
|
host: hostnameMatches[1],
|
|
port: hostnameMatches[2],
|
|
_meta: {
|
|
id: id,
|
|
name: node.name,
|
|
servername: node.host,
|
|
version: node.version
|
|
}
|
|
});
|
|
});
|
|
return hosts;
|
|
}
|
|
};
|
|
|
|
// remove connector classes that were not included in the build
|
|
connectors = _.transform(connectors, function (note, connector, name) {
|
|
if (connector) {
|
|
note[name] = connector;
|
|
}
|
|
}, {});
|
|
|
|
function ClientConfig(config) {
|
|
_.extend(this, defaultConfig, config);
|
|
|
|
if (this.log) {
|
|
// treat log as an alias for loggers in the config.
|
|
this.loggers = this.log;
|
|
delete this.log;
|
|
}
|
|
|
|
// validate connectionClass
|
|
if (typeof this.connectionClass === 'string') {
|
|
this.connectionClass = connectors[_.studlyCase(this.connectionClass)];
|
|
}
|
|
if (typeof this.connectionClass !== 'function') {
|
|
throw new TypeError('Invalid connectionClass "' + this.connectionClass + '". ' +
|
|
'Expected a constructor or one of ' + _.keys(connectors).join(', '));
|
|
}
|
|
|
|
// validate selector
|
|
if (typeof this.selector === 'string') {
|
|
this.selector = selectors[_.camelCase(this.selector)];
|
|
}
|
|
if (typeof this.selector !== 'function') {
|
|
throw new TypeError('Invalid Selector "' + this.selector + '". ' +
|
|
'Expected a function or one of ' + _.keys(selectors).join(', '));
|
|
}
|
|
|
|
_.each(defaultClasses, function (DefaultClass, prop) {
|
|
this[prop] = typeof this[prop] === 'function' ? new this[prop](this) : new DefaultClass(this);
|
|
}, this);
|
|
|
|
// populate the connection pool
|
|
this.connectionPool.setNodes(this.prepareHosts(this.hosts));
|
|
|
|
// nodes are completely managed by the connection pool, remove traces of the config
|
|
// value to prevent confusion
|
|
delete this.hosts;
|
|
}
|
|
|
|
ClientConfig.prototype.prepareHosts = function (hosts) {
|
|
var host;
|
|
var i;
|
|
|
|
if (!_.isArray(hosts)) {
|
|
hosts = [hosts];
|
|
}
|
|
|
|
return _.map(hosts, function (host) {
|
|
return new Host(host);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Shutdown the connectionPool, log outputs, and clear timers
|
|
*/
|
|
ClientConfig.prototype.close = function () {
|
|
this.log.close();
|
|
this.connectionPool.close();
|
|
};
|
|
|
|
},{"./connection_pool":20,"./connectors/angular":21,"./connectors/http":1,"./connectors/jquery":1,"./connectors/xhr":1,"./host":23,"./log":24,"./selectors":27,"./serializers/json":30,"./transport":31,"./utils":33,"__browserify_process":12,"url":7}],19:[function(require,module,exports){
|
|
module.exports = ConnectionAbstract;
|
|
|
|
var _ = require('./utils');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
|
|
/**
|
|
* Abstract class used for Connection classes
|
|
* @class ConnectionAbstract
|
|
* @constructor
|
|
*/
|
|
function ConnectionAbstract(host, config) {
|
|
EventEmitter.call(this);
|
|
this.config = config;
|
|
this.host = host;
|
|
this.requestCount = 0;
|
|
|
|
if (!this.host) {
|
|
throw new Error('Missing host config');
|
|
}
|
|
|
|
_.makeBoundMethods(this);
|
|
}
|
|
_.inherits(ConnectionAbstract, EventEmitter);
|
|
|
|
/**
|
|
* Make a request using this connection. Must be overridden by Connection classes, which can add whatever keys to
|
|
* params that they like. These are just the basics.
|
|
*
|
|
* @param [params] {Object} - The parameters for the request
|
|
* @param params.path {String} - The path for which you are requesting
|
|
* @param params.method {String} - The HTTP method for the request (GET, HEAD, etc.)
|
|
* @param params.timeout {Integer} - The amount of time in milliseconds that this request should be allowed to run for.
|
|
* @param cb {Function} - A callback to be called once with `cb(err, responseBody, responseStatus)`
|
|
*/
|
|
ConnectionAbstract.prototype.request = function () {
|
|
throw new Error('Connection#request must be overwritten by the Connector');
|
|
};
|
|
|
|
ConnectionAbstract.prototype.ping = function (params, cb) {
|
|
if (typeof params === 'function') {
|
|
cb = params;
|
|
} else if (typeof cb !== 'function') {
|
|
throw new TypeError('Callback must be a function');
|
|
}
|
|
return this.request({
|
|
path: '/',
|
|
method: 'HEAD',
|
|
timeout: 100
|
|
}, cb);
|
|
};
|
|
|
|
ConnectionAbstract.prototype.setStatus = function (status) {
|
|
var origStatus = this.status;
|
|
|
|
this.status = status;
|
|
|
|
if (status === 'dead' || status === 'closed') {
|
|
if (this.__deadTimeout) {
|
|
clearTimeout(this.__deadTimeout);
|
|
}
|
|
if (status === 'dead') {
|
|
this.__deadTimeout = setTimeout(this.bound.resuscitate, this.config.deadTimeout);
|
|
}
|
|
}
|
|
|
|
this.emit('status changed', status, origStatus, this);
|
|
};
|
|
|
|
ConnectionAbstract.prototype.resuscitate = _.scheduled(function () {
|
|
var self = this;
|
|
|
|
if (self.status === 'dead') {
|
|
self.ping(function (err) {
|
|
if (!err) {
|
|
self.setStatus('alive');
|
|
} else {
|
|
self.emit('dead');
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
},{"./utils":33,"events":4}],20:[function(require,module,exports){
|
|
/**
|
|
* Manager of connections to a node(s), capable of ensuring that connections are clear and living
|
|
* before providing them to the application
|
|
*
|
|
* @class ConnectionPool
|
|
* @param {Client} client - The client this pool belongs to
|
|
*/
|
|
|
|
module.exports = ConnectionPool;
|
|
|
|
var _ = require('./utils');
|
|
var selectors = require('./selectors');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var errors = require('./errors');
|
|
var Host = require('./host');
|
|
|
|
function ConnectionPool(config) {
|
|
_.makeBoundMethods(this);
|
|
this.config = config;
|
|
this.index = {};
|
|
this.connections = {
|
|
alive: [],
|
|
dead: []
|
|
};
|
|
}
|
|
|
|
ConnectionPool.prototype.select = function (cb) {
|
|
if (this.connections.alive.length) {
|
|
if (this.config.selector.length > 1) {
|
|
this.config.selector(this.connections.alive, cb);
|
|
} else {
|
|
try {
|
|
_.nextTick(cb, null, this.config.selector(this.connections.alive));
|
|
} catch (e) {
|
|
this.config.log.error(e);
|
|
cb(e);
|
|
}
|
|
}
|
|
} else {
|
|
cb();
|
|
}
|
|
};
|
|
|
|
ConnectionPool.prototype.onStatusChanged = _.handler(function (status, oldStatus, connection) {
|
|
var from, to, index;
|
|
|
|
if (oldStatus === status) {
|
|
return true;
|
|
} else {
|
|
this.config.log.info('connection id:', connection.__id, 'is', status);
|
|
}
|
|
|
|
switch (status) {
|
|
case 'alive':
|
|
from = this.connections.dead;
|
|
to = this.connections.alive;
|
|
break;
|
|
case 'dead':
|
|
from = this.connections.alive;
|
|
to = this.connections.dead;
|
|
break;
|
|
case 'closed':
|
|
from = this.connections[oldStatus];
|
|
break;
|
|
}
|
|
|
|
if (from && from.indexOf) {
|
|
index = from.indexOf(connection);
|
|
if (~index) {
|
|
from.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
if (to && to.indexOf) {
|
|
index = to.indexOf(connection);
|
|
if (!~index) {
|
|
to.push(connection);
|
|
}
|
|
}
|
|
});
|
|
|
|
ConnectionPool.prototype._add = function (connection) {
|
|
if (!this.index[connection.__id]) {
|
|
this.index[connection.__id] = connection;
|
|
connection.on('status changed', this.bound.onStatusChanged);
|
|
connection.setStatus('alive');
|
|
}
|
|
};
|
|
|
|
ConnectionPool.prototype._remove = function (connection) {
|
|
if (this.index[connection.__id]) {
|
|
delete this.index[connection.__id];
|
|
connection.setStatus('closed');
|
|
connection.removeListener('status changed', this.bound.onStatusChanged);
|
|
}
|
|
};
|
|
|
|
ConnectionPool.prototype.setNodes = function (nodeConfigs) {
|
|
var connection;
|
|
var i;
|
|
var id;
|
|
var node;
|
|
var toRemove = _.clone(this.index);
|
|
|
|
for (i = 0; i < nodeConfigs.length; i++) {
|
|
node = nodeConfigs[i];
|
|
if (node instanceof Host) {
|
|
id = node.toString();
|
|
if (this.index[id]) {
|
|
delete toRemove[id];
|
|
} else {
|
|
connection = new this.config.connectionClass(node, this.config);
|
|
connection.__id = id;
|
|
this._add(connection);
|
|
}
|
|
}
|
|
}
|
|
|
|
_.each(toRemove, this._remove, this);
|
|
};
|
|
|
|
ConnectionPool.prototype.close = function () {
|
|
this.setNodes([]);
|
|
};
|
|
ConnectionPool.prototype.empty = ConnectionPool.prototype.close;
|
|
|
|
},{"./errors":22,"./host":23,"./selectors":27,"./utils":33,"events":4}],21:[function(require,module,exports){
|
|
/**
|
|
* Connection that registers a module with angular, using angular's $http service
|
|
* to communicate with ES.
|
|
*
|
|
* @class connections.Angular
|
|
*/
|
|
module.exports = AngularConnector;
|
|
|
|
var _ = require('../utils');
|
|
var ConnectionAbstract = require('../connection');
|
|
var ConnectionFault = require('../errors').ConnectionFault;
|
|
|
|
/* global angular */
|
|
|
|
function AngularConnector(host, config) {
|
|
ConnectionAbstract.call(this, host, config);
|
|
}
|
|
_.inherits(AngularConnector, ConnectionAbstract);
|
|
|
|
AngularConnector.prototype.request = function (params, cb) {
|
|
var timeoutId;
|
|
|
|
this.$http({
|
|
method: params.method,
|
|
url: this.host.makeUrl(params),
|
|
data: params.body,
|
|
cache: false,
|
|
timeout: params.timeout !== Infinity ? params.timeout : 0
|
|
}).then(function (response) {
|
|
cb(null, response.data, response.status);
|
|
}, function (err) {
|
|
cb(new ConnectionFault(err.message));
|
|
});
|
|
|
|
};
|
|
|
|
// must be overwritten before this connection can be used
|
|
AngularConnector.prototype.$http = null;
|
|
|
|
},{"../connection":19,"../errors":22,"../utils":33}],22:[function(require,module,exports){
|
|
var process=require("__browserify_process");var _ = require('./utils'),
|
|
errors = module.exports;
|
|
|
|
function ErrorAbstract(msg, constructor) {
|
|
this.message = msg;
|
|
|
|
Error.call(this, this.message);
|
|
if (process.browser) {
|
|
this.stack = '';
|
|
} else {
|
|
Error.captureStackTrace(this, constructor);
|
|
}
|
|
}
|
|
_.inherits(ErrorAbstract, Error);
|
|
|
|
/**
|
|
* Connection Error
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
errors.ConnectionFault = function ConnectionFault(msg) {
|
|
ErrorAbstract.call(this, msg || 'Connection Failure', errors.ConnectionFault);
|
|
};
|
|
_.inherits(errors.ConnectionFault, ErrorAbstract);
|
|
|
|
/**
|
|
* No Living Connections
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
errors.NoConnections = function NoConnections(msg) {
|
|
ErrorAbstract.call(this, msg || 'No Living connections', errors.NoConnections);
|
|
};
|
|
_.inherits(errors.NoConnections, ErrorAbstract);
|
|
|
|
/**
|
|
* Generic Error
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
errors.Generic = function Generic(msg) {
|
|
ErrorAbstract.call(this, msg || 'Generic Error', errors.Generic);
|
|
};
|
|
_.inherits(errors.Generic, ErrorAbstract);
|
|
|
|
/**
|
|
* Request Timeout Error
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
errors.RequestTimeout = function RequestTimeout(msg) {
|
|
ErrorAbstract.call(this, msg || 'Request Timeout', errors.RequestTimeout);
|
|
};
|
|
_.inherits(errors.RequestTimeout, ErrorAbstract);
|
|
|
|
|
|
/**
|
|
* Request Body could not be parsed
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
errors.Serialization = function Serialization(msg) {
|
|
ErrorAbstract.call(this, msg || 'Unable to parse/serialize body', errors.Serialization);
|
|
};
|
|
_.inherits(errors.Serialization, ErrorAbstract);
|
|
|
|
|
|
var statusCodes = {
|
|
|
|
/**
|
|
* Service Unavailable
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
503: 'Service Unavailable',
|
|
|
|
/**
|
|
* Internal Server Error
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
500: 'Internal Server Error',
|
|
|
|
/**
|
|
* Precondition Failed
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
412: 'Precondition Failed',
|
|
|
|
/**
|
|
* Conflict
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
409: 'Conflict',
|
|
|
|
/**
|
|
* Forbidden
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
403: 'Forbidden',
|
|
|
|
/**
|
|
* Not Found
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
404: 'Not Found',
|
|
|
|
/**
|
|
* Bad Request
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
400: 'Bad Request',
|
|
|
|
/**
|
|
* Moved Permanently
|
|
* @param {String} [msg] - An error message that will probably end up in a log.
|
|
*/
|
|
301: 'Moved Permanently'
|
|
};
|
|
|
|
_.each(statusCodes, function (name, status) {
|
|
var className = _.studlyCase(name);
|
|
|
|
function StatusCodeError(msg) {
|
|
ErrorAbstract.call(this, msg || name, errors[className]);
|
|
}
|
|
|
|
_.inherits(StatusCodeError, ErrorAbstract);
|
|
errors[className] = StatusCodeError;
|
|
errors[status] = StatusCodeError;
|
|
});
|
|
|
|
},{"./utils":33,"__browserify_process":12}],23:[function(require,module,exports){
|
|
/**
|
|
* Class to wrap URLS, formatting them and maintaining their seperate details
|
|
* @type {[type]}
|
|
*/
|
|
module.exports = Host;
|
|
|
|
var url = require('url');
|
|
var qs = require('querystring');
|
|
var _ = require('./utils');
|
|
|
|
var startsWithProtocolRE = /^([a-z]+:)?\/\//;
|
|
|
|
// simple reference used when formatting as a url
|
|
var defaultPort = {
|
|
http: 80,
|
|
https: 443
|
|
};
|
|
|
|
function Host(config) {
|
|
if (this instanceof Host) {
|
|
if (typeof config === 'string') {
|
|
return Host.fromString(config);
|
|
} else {
|
|
_.extend(this, config || {});
|
|
}
|
|
} else {
|
|
return new Host(config);
|
|
}
|
|
}
|
|
|
|
Host.fromString = function (urlString) {
|
|
if (!startsWithProtocolRE.test(urlString)) {
|
|
urlString = 'http://' + urlString;
|
|
}
|
|
var u = url.parse(urlString, true, true);
|
|
return new Host({
|
|
protocol: u.protocol ? u.protocol.substring(0, u.protocol.length - 1) : 'http',
|
|
host: u.hostname || 'localhost',
|
|
port: u.port || 9200,
|
|
auth: u.auth || '',
|
|
path: u.pathname,
|
|
query: u.query,
|
|
});
|
|
};
|
|
|
|
Host.prototype = {
|
|
protocol: 'http',
|
|
host: 'localhost',
|
|
port: 9200,
|
|
auth: '',
|
|
path: '',
|
|
query: false
|
|
};
|
|
|
|
Host.prototype.makeUrl = function (params) {
|
|
params = params || {};
|
|
// build the port
|
|
var port = '';
|
|
if (this.port !== defaultPort[this.protocol]) {
|
|
// add an actual port
|
|
port = ':' + this.port;
|
|
}
|
|
|
|
// build the path
|
|
var path = '';
|
|
// add the path prefix if set
|
|
if (this.path) {
|
|
path += this.path;
|
|
}
|
|
// then the path from the params
|
|
if (params.path) {
|
|
path += params.path;
|
|
}
|
|
// if we still have a path, and it doesn't start with '/' add it.
|
|
if (path && path.charAt(0) !== '/') {
|
|
path = '/' + path;
|
|
}
|
|
|
|
// build the query string
|
|
var query = '';
|
|
if (params.query) {
|
|
// if the user passed in a query, merge it with the defaults from the host
|
|
query = qs.stringify(
|
|
_.defaults(typeof params.query === 'string' ? qs.parse(params.query) : params.query, this.query)
|
|
);
|
|
} else if (this.query) {
|
|
// just stringify the hosts query
|
|
query = qs.stringify(this.query);
|
|
}
|
|
|
|
return this.protocol + '://' + this.host + port + path + (query ? '?' + query : '');
|
|
};
|
|
|
|
},{"./utils":33,"querystring":6,"url":7}],24:[function(require,module,exports){
|
|
var process=require("__browserify_process");var _ = require('./utils');
|
|
var url = require('url');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
if (process.browser) {
|
|
var loggers = {
|
|
Console: require('./loggers/console')
|
|
};
|
|
} else {
|
|
var loggers = {
|
|
File: require('./loggers/file'),
|
|
Stream: require('./loggers/file'),
|
|
Stdio: require('./loggers/stdio')
|
|
};
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Log bridge, which is an [EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter)
|
|
* that sends events to one or more outputs/loggers. Setup these loggers by
|
|
* specifying their config as the first argument, or by passing it to addOutput().
|
|
*
|
|
* @class Log
|
|
* @uses Loggers.Stdio
|
|
* @constructor
|
|
* @param {string|Object|ArrayOfStrings|ArrayOfObjects} output - Either the level
|
|
* to setup a single logger, a full config object for alogger, or an array of
|
|
* config objects to use for creating log outputs.
|
|
* @param {string} output.level - One of the keys in Log.levels (error, warning, etc.)
|
|
* @param {string} output.type - The name of the logger to use for this output
|
|
*/
|
|
function Log(config) {
|
|
this.config = config || {};
|
|
|
|
var i;
|
|
var output = config.loggers ? config.loggers : 'warning';
|
|
|
|
if (_.isString(output) || _.isFinite(output)) {
|
|
output = [
|
|
{
|
|
level: output
|
|
}
|
|
];
|
|
} else if (_.isPlainObject(output)) {
|
|
output = [output];
|
|
} else if (_.isArray(output)) {
|
|
for (i = 0; i < output.length; i++) {
|
|
if (_.isString(output[i])) {
|
|
output[i] = {
|
|
level: output[i]
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!_.isArrayOfPlainObjects(output)) {
|
|
throw new TypeError('Invalid Logging output config');
|
|
}
|
|
|
|
for (i = 0; i < output.length; i++) {
|
|
this.addOutput(output[i]);
|
|
}
|
|
|
|
}
|
|
_.inherits(Log, EventEmitter);
|
|
|
|
|
|
Log.prototype.close = function () {
|
|
this.emit('closing');
|
|
if (this.listenerCount()) {
|
|
console.error('Something is still listening for log events, but the logger is closing.');
|
|
this.clearAllListeners();
|
|
}
|
|
};
|
|
|
|
Log.prototype.listenerCount = function (event) {
|
|
// compatability for node < 0.10
|
|
if (EventEmitter.listenerCount) {
|
|
return EventEmitter.listenerCount(this, event);
|
|
} else {
|
|
return this.listeners(event).length;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Levels observed by the loggers, ordered by rank
|
|
*
|
|
* @property levels
|
|
* @type Array
|
|
* @static
|
|
*/
|
|
Log.levels = [
|
|
/**
|
|
* Event fired for error level log entries
|
|
* @event error
|
|
* @param {Error} error - The error object to log
|
|
*/
|
|
'error',
|
|
/**
|
|
* Event fired for "warning" level log entries, which usually represent things
|
|
* like correctly formatted error responses from ES (400, ...) and recoverable
|
|
* errors (one node unresponsive)
|
|
*
|
|
* @event warning
|
|
* @param {String} message - A message to be logged
|
|
*/
|
|
'warning',
|
|
/**
|
|
* Event fired for "info" level log entries, which usually describe what a
|
|
* client is doing (sniffing etc)
|
|
*
|
|
* @event info
|
|
* @param {String} message - A message to be logged
|
|
*/
|
|
'info',
|
|
/**
|
|
* Event fired for "debug" level log entries, which will describe requests sent,
|
|
* including their url (no data, response codes, or exec times)
|
|
*
|
|
* @event debug
|
|
* @param {String} message - A message to be logged
|
|
*/
|
|
'debug',
|
|
/**
|
|
* Event fired for "trace" level log entries, which provide detailed information
|
|
* about each request made from a client, including reponse codes, execution times,
|
|
* and a full curl command that can be copied and pasted into a terminal
|
|
*
|
|
* @event trace
|
|
* @param {String} method method, , body, responseStatus, responseBody
|
|
* @param {String} url - The url the request was made to
|
|
* @param {String} body - The body of the request
|
|
* @param {Integer} responseStatus - The status code returned from the response
|
|
* @param {String} responseBody - The body of the response
|
|
*/
|
|
'trace'
|
|
];
|
|
|
|
/**
|
|
* Converts a log config value (string or array) to an array of level names which
|
|
* it represents
|
|
*
|
|
* @method parseLevels
|
|
* @static
|
|
* @private
|
|
* @param {String|ArrayOfStrings} input - Cound be a string to specify the max
|
|
* level, or an array of exact levels
|
|
* @return {Array} -
|
|
*/
|
|
Log.parseLevels = function (input) {
|
|
if (_.isString(input)) {
|
|
return Log.levels.slice(0, _.indexOf(Log.levels, input) + 1);
|
|
}
|
|
else if (_.isArray(input)) {
|
|
return _.intersection(input, Log.levels);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Combine the array-like param into a simple string
|
|
*
|
|
* @method join
|
|
* @static
|
|
* @private
|
|
* @param {*} arrayish - An array like object that can be itterated by _.each
|
|
* @return {String} - The final string.
|
|
*/
|
|
Log.join = function (arrayish) {
|
|
return _.map(arrayish, function (item) {
|
|
if (_.isPlainObject(item)) {
|
|
return _.inspect(item) + '\n';
|
|
} else {
|
|
return item.toString();
|
|
}
|
|
}).join(' ');
|
|
};
|
|
|
|
/**
|
|
* Create a new logger, based on the config.
|
|
*
|
|
* @method addOutput
|
|
* @param {object} config - An object with config options for the logger.
|
|
* @param {String} [config.type=stdio] - The name of an output/logger. Options
|
|
* can be found in the `src/loggers` directory.
|
|
* @param {String|ArrayOfStrings} [config.levels=warning] - The levels to output
|
|
* to this logger, when an array is specified no levels other than the ones
|
|
* specified will be listened to. When a string is specified, that and all lower
|
|
* levels will be logged.
|
|
* @return {Logger}
|
|
*/
|
|
Log.prototype.addOutput = function (config) {
|
|
var levels = Log.parseLevels(config.levels || config.level || 'warning');
|
|
|
|
_.defaults(config || {}, {
|
|
type: process.browser ? 'Console' : 'Stdio',
|
|
});
|
|
|
|
// force the levels config
|
|
delete config.level;
|
|
config.levels = levels;
|
|
|
|
var Logger = loggers[_.studlyCase(config.type)];
|
|
if (Logger) {
|
|
return new Logger(config, this);
|
|
} else {
|
|
throw new Error('Invalid logger type "' + config.type + '". Expected one of ' + _.keys(loggers).join(', '));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Log an error
|
|
*
|
|
* @method error
|
|
* @param {Error|String} error The Error to log
|
|
* @return {Boolean} - True if any outputs accepted the message
|
|
*/
|
|
Log.prototype.error = function (e) {
|
|
if (this.listenerCount('error')) {
|
|
return this.emit('error', e instanceof Error ? e : new Error(e));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Log a warning message
|
|
*
|
|
* @method warning
|
|
* @param {*} msg* - Any amount of messages that will be joined before logged
|
|
* @return {Boolean} - True if any outputs accepted the message
|
|
*/
|
|
Log.prototype.warning = function (/* ...msg */) {
|
|
if (this.listenerCount('warning')) {
|
|
return this.emit('warning', Log.join(arguments));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Log useful info about what's going on
|
|
*
|
|
* @method info
|
|
* @param {*} msg* - Any amount of messages that will be joined before logged
|
|
* @return {Boolean} - True if any outputs accepted the message
|
|
*/
|
|
Log.prototype.info = function (/* ...msg */) {
|
|
if (this.listenerCount('info')) {
|
|
return this.emit('info', Log.join(arguments));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Log a debug level message
|
|
*
|
|
* @method debug
|
|
* @param {*} msg* - Any amount of messages that will be joined before logged
|
|
* @return {Boolean} - True if any outputs accepted the message
|
|
*/
|
|
Log.prototype.debug = function (/* ...msg */) {
|
|
if (this.listenerCount('debug')) {
|
|
return this.emit('debug', Log.join(arguments) /*+ _.getStackTrace(Log.prototype.debug)*/);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Log a trace level message
|
|
*
|
|
* @method trace
|
|
* @param {String} method - HTTP request method
|
|
* @param {String|Object} requestUrl - URL requested. If the value is an object,
|
|
* it is expected to be the return value of Node's url.parse()
|
|
* @param {String} body - The request's body
|
|
* @param {String} responseBody - body returned from ES
|
|
* @param {String} responseStatus - HTTP status code
|
|
* @return {Boolean} - True if any outputs accepted the message
|
|
*/
|
|
Log.prototype.trace = function (method, requestUrl, body, responseBody, responseStatus) {
|
|
if (this.listenerCount('trace')) {
|
|
if (typeof requestUrl === 'string') {
|
|
requestUrl = url.parse(requestUrl, true, true);
|
|
}
|
|
requestUrl = _.defaults({
|
|
host: 'localhost:9200',
|
|
query: _.defaults({
|
|
pretty: true
|
|
}, requestUrl.query)
|
|
}, requestUrl);
|
|
delete requestUrl.auth;
|
|
|
|
if (!requestUrl.pathname && requestUrl.path) {
|
|
requestUrl.pathname = requestUrl.path.split('?').shift();
|
|
}
|
|
|
|
return this.emit('trace', method, url.format(requestUrl), body, responseBody, responseStatus);
|
|
}
|
|
};
|
|
|
|
module.exports = Log;
|
|
|
|
},{"./loggers/console":26,"./loggers/file":1,"./loggers/stdio":1,"./utils":33,"__browserify_process":12,"events":4,"url":7}],25:[function(require,module,exports){
|
|
var Log = require('./log'),
|
|
_ = require('./utils');
|
|
|
|
/**
|
|
* Abstract class providing common functionality to loggers
|
|
* @param {[type]} config [description]
|
|
* @param {[type]} bridge [description]
|
|
*/
|
|
function LoggerAbstract(config, bridge) {
|
|
|
|
this.bridge = bridge;
|
|
this.listeningLevels = [];
|
|
|
|
_.makeBoundMethods(this);
|
|
|
|
// when the bridge closes, remove our event listeners
|
|
this.bridge.on('closing', this.bound.cleanUpListeners);
|
|
|
|
this.setupListeners(config.levels);
|
|
}
|
|
|
|
function padNumToTen(n) {
|
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
}
|
|
|
|
/**
|
|
* Create a timestamp string used in the format function. Defers to Log.timestamp if it is defined,
|
|
* Also, feel free to override this at the logger level.
|
|
* @return {String} - Timestamp in ISO 8601 UTC
|
|
*/
|
|
LoggerAbstract.prototype.timestamp = function () {
|
|
var d = new Date();
|
|
return d.getUTCFullYear() + '-' +
|
|
padNumToTen(d.getUTCMonth() + 1) + '-' +
|
|
padNumToTen(d.getUTCDate()) + 'T' +
|
|
padNumToTen(d.getUTCHours()) + ':' +
|
|
padNumToTen(d.getUTCMinutes()) + ':' +
|
|
padNumToTen(d.getUTCSeconds()) + 'Z';
|
|
};
|
|
|
|
function indent(text, spaces) {
|
|
var space = _.repeat(' ', spaces || 2);
|
|
return text.split(/\r?\n/).map(function (line) {
|
|
return space + line;
|
|
}).join('\n');
|
|
}
|
|
|
|
LoggerAbstract.prototype.format = function (label, message) {
|
|
return label + ': ' + this.timestamp() + '\n' + indent(message) + '\n\n';
|
|
};
|
|
|
|
LoggerAbstract.prototype.write = function () {
|
|
throw new Error('This should be overwritten by the logger');
|
|
};
|
|
|
|
/**
|
|
* Clear the current event listeners and then re-listen for events based on the level specified
|
|
*
|
|
* @method setupListeners
|
|
* @private
|
|
* @param {Integer} level - The max log level that this logger should listen to
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.setupListeners = function (levels) {
|
|
this.cleanUpListeners();
|
|
|
|
this.listeningLevels = levels;
|
|
|
|
_.each(this.listeningLevels, function (level) {
|
|
var fnName = 'on' + _.ucfirst(level);
|
|
if (this.bound[fnName]) {
|
|
this.bridge.on(level, this.bound[fnName]);
|
|
} else {
|
|
throw new Error(fnName + ' is not a function');
|
|
}
|
|
}, this);
|
|
};
|
|
|
|
/**
|
|
* Clear the current event listeners
|
|
*
|
|
* @method cleanUpListeners
|
|
* @private
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.cleanUpListeners = _.handler(function () {
|
|
_.each(this.listeningLevels, function (level) {
|
|
this.bridge.removeListener(level, this.bound['on' + _.ucfirst(level)]);
|
|
}, this);
|
|
});
|
|
|
|
/**
|
|
* Handler for the bridges "error" event
|
|
*
|
|
* @method onError
|
|
* @private
|
|
* @param {Error} e - The Error object to log
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.onError = _.handler(function (e) {
|
|
this.write((e.name === 'Error' ? 'ERROR' : e.name), e.stack);
|
|
});
|
|
|
|
/**
|
|
* Handler for the bridges "warning" event
|
|
*
|
|
* @method onWarning
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.onWarning = _.handler(function (msg) {
|
|
this.write('WARNING', msg);
|
|
});
|
|
|
|
/**
|
|
* Handler for the bridges "info" event
|
|
*
|
|
* @method onInfo
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.onInfo = _.handler(function (msg) {
|
|
this.write('INFO', msg);
|
|
});
|
|
|
|
/**
|
|
* Handler for the bridges "debug" event
|
|
*
|
|
* @method onDebug
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.onDebug = _.handler(function (msg) {
|
|
this.write('DEBUG', msg);
|
|
});
|
|
|
|
/**
|
|
* Handler for the bridges "trace" event
|
|
*
|
|
* @method onTrace
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
LoggerAbstract.prototype.onTrace = _.handler(function (method, url, body, responseBody, responseStatus) {
|
|
var message = 'curl "' + url.replace(/"/g, '\\"') + '" -X' + method.toUpperCase();
|
|
if (body) {
|
|
message += ' -d "' + body.replace(/"/g, '\\"') + '"';
|
|
}
|
|
message += '\n<- ' + responseStatus + '\n' + responseBody;
|
|
this.write('TRACE', message);
|
|
});
|
|
|
|
|
|
module.exports = LoggerAbstract;
|
|
|
|
},{"./log":24,"./utils":33}],26:[function(require,module,exports){
|
|
/**
|
|
* Special version of the Stream logger, which logs errors and warnings to stderr and all other
|
|
* levels to stdout.
|
|
*
|
|
* @class Loggers.Console
|
|
* @extends LoggerAbstract
|
|
* @constructor
|
|
* @param {Object} config - The configuration for the Logger
|
|
* @param {string} config.level - The highest log level for this logger to output.
|
|
* @param {Log} bridge - The object that triggers logging events, which we will record
|
|
*/
|
|
|
|
module.exports = Console;
|
|
|
|
var LoggerAbstract = require('../logger');
|
|
var _ = require('../utils');
|
|
|
|
function Console(config, bridge) {
|
|
LoggerAbstract.call(this, config, bridge);
|
|
|
|
// config/state
|
|
this.color = _.has(config, 'color') ? !!config.color : true;
|
|
}
|
|
_.inherits(Console, LoggerAbstract);
|
|
|
|
/**
|
|
* Override the LoggerAbstract's setup listeners to do a little extra setup
|
|
*
|
|
* @param {Array} levels - The levels that we should be listeneing for
|
|
*/
|
|
Console.prototype.setupListeners = function (levels) {
|
|
// since some of our functions are bound a bit differently (to the console)
|
|
// create some of the bound properties manually
|
|
this.bound.onWarning = this.onWarning;
|
|
this.bound.onInfo = this.onInfo;
|
|
this.bound.onDebug = this.onDebug;
|
|
|
|
// call the super method
|
|
LoggerAbstract.prototype.setupListeners.call(this, levels);
|
|
};
|
|
|
|
/**
|
|
* Handler for the bridges "error" event
|
|
*
|
|
* @method onError
|
|
* @private
|
|
* @param {Error} e - The Error object to log
|
|
* @return {undefined}
|
|
*/
|
|
Console.prototype.onError = _.handler(function (e) {
|
|
if (console.error && console.trace) {
|
|
console.error(e.name === 'Error' ? 'ERROR' : e.name, e.stack || e.message);
|
|
} else {
|
|
console.log(e.name === 'Error' ? 'ERROR' : e.name, e.stack || e.message);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Handler for the bridges "warning" event
|
|
*
|
|
* @method onWarning
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
Console.prototype.onWarning = function (msg) {
|
|
console[console.warn ? 'warn' : 'log']('WARNING', msg);
|
|
};
|
|
|
|
/**
|
|
* Handler for the bridges "info" event
|
|
*
|
|
* @method onInfo
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
Console.prototype.onInfo = function (msg) {
|
|
console[console.warn ? 'info' : 'log']('INFO', msg);
|
|
};
|
|
|
|
/**
|
|
* Handler for the bridges "debug" event
|
|
*
|
|
* @method onDebug
|
|
* @private
|
|
* @param {String} msg - The message to be logged
|
|
* @return {undefined}
|
|
*/
|
|
Console.prototype.onDebug = function (msg) {
|
|
console[console.debug ? 'debug' : 'log']('DEBUG', msg);
|
|
};
|
|
/**
|
|
* Handler for the bridges "trace" event
|
|
*
|
|
* @method onTrace
|
|
* @private
|
|
* @return {undefined}
|
|
*/
|
|
Console.prototype.onTrace = _.handler(function (method, url, body, responseBody, responseStatus) {
|
|
var message = 'curl "' + url.replace(/"/g, '\\"') + '" -X' + method.toUpperCase();
|
|
if (body) {
|
|
message += ' -d "' + body.replace(/"/g, '\\"') + '"';
|
|
}
|
|
message += '\n<- ' + responseStatus + '\n' + responseBody;
|
|
console.log('TRACE:\n' + message + '\n\n');
|
|
});
|
|
|
|
},{"../logger":25,"../utils":33}],27:[function(require,module,exports){
|
|
module.exports = {
|
|
random: require('./random'),
|
|
roundRobin: require('./round_robin')
|
|
};
|
|
|
|
},{"./random":28,"./round_robin":29}],28:[function(require,module,exports){
|
|
module.exports = RandomSelect;
|
|
|
|
function RandomSelect(connections) {
|
|
return connections[Math.floor(Math.random() * connections.length)];
|
|
}
|
|
|
|
},{}],29:[function(require,module,exports){
|
|
/**
|
|
* Selects a connection the simplest way possible, Round Robin
|
|
*
|
|
* @class selector.roundRobin
|
|
* @constructor
|
|
* @type {Function}
|
|
*/
|
|
module.exports = RoundRobinSelect;
|
|
|
|
function RoundRobinSelect(connections) {
|
|
connections.unshift(connections.pop());
|
|
return connections[0];
|
|
}
|
|
|
|
},{}],30:[function(require,module,exports){
|
|
/**
|
|
* Simple JSON serializer
|
|
* @type {[type]}
|
|
*/
|
|
module.exports = Json;
|
|
|
|
var _ = require('../utils');
|
|
|
|
function Json(client) {
|
|
this.client = client;
|
|
}
|
|
|
|
Json.prototype.serialize = function (val, replacer, spaces) {
|
|
if (val == null) {
|
|
return null;
|
|
}
|
|
else if (typeof val === 'string') {
|
|
return val;
|
|
} else {
|
|
return JSON.stringify(val, replacer, spaces);
|
|
}
|
|
};
|
|
|
|
Json.prototype.unserialize = function (str) {
|
|
if (typeof str === 'string') {
|
|
try {
|
|
return JSON.parse(str);
|
|
} catch (e) {
|
|
this.client.log.error(new Error('unable to parse', str));
|
|
return null;
|
|
}
|
|
} else {
|
|
return str;
|
|
}
|
|
};
|
|
|
|
Json.prototype.bulkBody = function (val) {
|
|
var body = '', i;
|
|
|
|
if (_.isArray(val)) {
|
|
for (i = 0; i < val.length; i++) {
|
|
body += this.serialize(val[i]) + '\n';
|
|
}
|
|
} else if (typeof val === 'string') {
|
|
// make sure the string ends in a new line
|
|
body = val + (val[val.length - 1] === '\n' ? '' : '\n');
|
|
} else {
|
|
throw new TypeError('Bulk body should either be an Array of commands/string, or a String');
|
|
}
|
|
|
|
return body;
|
|
};
|
|
|
|
},{"../utils":33}],31:[function(require,module,exports){
|
|
/**
|
|
* Class that manages making request, called by all of the API methods.
|
|
* @type {[type]}
|
|
*/
|
|
module.exports = Transport;
|
|
|
|
var _ = require('./utils');
|
|
var TransportRequest = require('./transport_request');
|
|
var errors = require('./errors');
|
|
|
|
function Transport(config) {
|
|
this.config = config;
|
|
}
|
|
|
|
/**
|
|
* Perform a request with the client's transport
|
|
*
|
|
* @method request
|
|
* @todo async body writing
|
|
* @todo abort
|
|
* @todo access to custom headers, modifying of request in general
|
|
* @param {object} params
|
|
* @param {String} params.url - The url for the request
|
|
* @param {String} params.method - The HTTP method for the request
|
|
* @param {String} params.body - The body of the HTTP request
|
|
* @param {Function} cb - A function to call back with (error, responseBody, responseStatus)
|
|
*/
|
|
Transport.prototype.request = function (params, cb) {
|
|
return new TransportRequest(this.config, params, cb);
|
|
};
|
|
|
|
/**
|
|
* Ask an ES node for a list of all the nodes, add/remove nodes from the connection
|
|
* pool as appropriate
|
|
*
|
|
* @param {Function} cb - Function to call back once complete
|
|
*/
|
|
Transport.prototype.sniff = function (cb) {
|
|
var config = this.config;
|
|
|
|
// make cb a function if it isn't
|
|
cb = typeof cb === 'function' ? cb : _.noop;
|
|
|
|
this.request({
|
|
path: '/_cluster/nodes',
|
|
method: 'GET'
|
|
}, function (err, resp) {
|
|
if (!err && resp && resp.nodes) {
|
|
var nodes = config.nodesToHostCallback(resp.nodes);
|
|
config.connectionPool.setNodes(nodes);
|
|
}
|
|
cb(err, resp);
|
|
});
|
|
};
|
|
|
|
},{"./errors":22,"./transport_request":32,"./utils":33}],32:[function(require,module,exports){
|
|
var process=require("__browserify_process");/**
|
|
* Constructs a function that can be called to make a request to ES
|
|
* @type {[type]}
|
|
*/
|
|
module.exports = TransportRequest;
|
|
|
|
var _ = require('./utils');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var errors = require('./errors');
|
|
|
|
function TransportRequest(config, params, cb) {
|
|
// setup event emitter
|
|
EventEmitter.call(this);
|
|
// copy cetain methods into the bound object
|
|
_.makeBoundMethods(this);
|
|
|
|
this._params = params;
|
|
this._log = config.log;
|
|
this._serializer = config.serializer;
|
|
this._connectionPool = config.connectionPool;
|
|
this._remainingRetries = config.maxRetries;
|
|
|
|
// in cb isn't a function make it one
|
|
if (typeof cb === 'function') {
|
|
this.once('done', cb);
|
|
}
|
|
|
|
this._startRequest();
|
|
}
|
|
_.inherits(TransportRequest, EventEmitter);
|
|
|
|
TransportRequest.prototype._startRequest = function () {
|
|
var params = this._params;
|
|
|
|
this._log.debug('starting request', params);
|
|
|
|
if (params.body && params.method === 'GET') {
|
|
process.nextTick(_.bindKey(this, 'respond', new TypeError('Body can not be sent with method "GET"')));
|
|
return;
|
|
}
|
|
|
|
// serialize the body
|
|
if (params.body) {
|
|
params.body = this._serializer[params.bulkBody ? 'bulkBody' : 'serialize'](params.body);
|
|
}
|
|
|
|
params.req = {
|
|
timeout: params.timeout,
|
|
path: params.path,
|
|
query: params.query,
|
|
method: params.method,
|
|
body: params.body,
|
|
};
|
|
|
|
this._connectionPool.select(this.bound._sendReqWithCon);
|
|
};
|
|
|
|
TransportRequest.prototype._sendReqWithCon = _.handler(function (err, con) {
|
|
if (err) {
|
|
this._respond(err);
|
|
} else if (con) {
|
|
this._connection = con;
|
|
this._log.info('Selected', con.status, 'Connection, making request');
|
|
this._request = con.request(this._params.req, this.bound._checkRespForFail);
|
|
} else {
|
|
this._log.warning('No living connections');
|
|
this._respond(new errors.NoConnections());
|
|
}
|
|
});
|
|
|
|
TransportRequest.prototype._checkRespForFail = _.handler(function (err, body, status) {
|
|
if (err && this._remainingRetries) {
|
|
this._remainingRetries--;
|
|
this._log.error(err.message, '-- retrying');
|
|
this._connectionPool.select(this.bound._sendReqWithCon);
|
|
} else {
|
|
this._log.info('Request complete');
|
|
this._respond(err, body, status);
|
|
}
|
|
});
|
|
|
|
TransportRequest.prototype._respond = _.handler(function (err, body, status) {
|
|
if (this._response) {
|
|
throw new Error('Request responded twice');
|
|
}
|
|
|
|
var parsedBody;
|
|
var serializer = this._serializer;
|
|
|
|
// get ignore and ensure that it's an array
|
|
var ignore = this._params.ignore;
|
|
if (ignore && !_.isArray(ignore)) {
|
|
ignore = [ignore];
|
|
}
|
|
|
|
if (!err && body) {
|
|
parsedBody = serializer.unserialize(body);
|
|
if (parsedBody == null) {
|
|
err = new errors.Serialization();
|
|
}
|
|
}
|
|
|
|
if (!err) {
|
|
if ((status < 200 || status >= 300) && !_.contains(ignore, status)) {
|
|
if (errors[status]) {
|
|
err = new errors[status](parsedBody && parsedBody.error);
|
|
} else {
|
|
err = new errors.Generic('unknown error');
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this._params.castExists) {
|
|
if (err && err instanceof errors.NotFound) {
|
|
parsedBody = false;
|
|
err = void 0;
|
|
} else {
|
|
parsedBody = !err;
|
|
}
|
|
}
|
|
|
|
this._error = err;
|
|
this._response = {
|
|
body: parsedBody,
|
|
status: status
|
|
};
|
|
|
|
this.emit('done', this._error, this._response.body, this._response.status);
|
|
});
|
|
|
|
TransportRequest.prototype.abort = function () {
|
|
this.aborted = true;
|
|
if (this.__request) {
|
|
this.__request.abort();
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
TransportRequest.prototype.then = function (callback, errback) {
|
|
if (this._error) {
|
|
errback(this._error);
|
|
} else if (this._response) {
|
|
callback(this._response);
|
|
} else {
|
|
this.once('done', _.bindKey(this, 'then', callback, errback));
|
|
}
|
|
};
|
|
|
|
},{"./errors":22,"./utils":33,"__browserify_process":12,"events":4}],33:[function(require,module,exports){
|
|
var process=require("__browserify_process");var path = require('path'),
|
|
_ = require('lodash'),
|
|
nodeUtils = require('util');
|
|
|
|
/**
|
|
* Custom utils library, basically a modified version of [lodash](http://lodash.com/docs) +
|
|
* [node.utils](http://nodejs.org/api/util.html#util_util) that doesn't use mixins to prevent
|
|
* confusion when requiring lodash itself.
|
|
*
|
|
* @class utils
|
|
* @static
|
|
*/
|
|
var utils = _.extend({}, _, nodeUtils);
|
|
_ = utils;
|
|
|
|
utils.inspect = function (thing, opts) {
|
|
return nodeUtils.inspect(thing, _.defaults(opts || {}, {
|
|
showHidden: true,
|
|
depth: null,
|
|
color: true
|
|
}));
|
|
};
|
|
|
|
|
|
/**
|
|
* Link to [path.join](http://nodejs.org/api/path.html#path_path_join_path1_path2)
|
|
*
|
|
* @method utils.joinPath
|
|
* @type {function}
|
|
*/
|
|
utils.joinPath = path.join;
|
|
|
|
/**
|
|
* Recursively re-key an object, applying "transform" to each key
|
|
* @param {Object} obj - The object to re-key
|
|
* @param {Function} transform - The transformation function to apply to each key
|
|
* @param {Boolean} [recursive=true] - Should this act recursively?
|
|
* @param {Object} out - used primarily for recursion, allows you to specify the object which new keys will be written to
|
|
* @return {Object}
|
|
*/
|
|
utils.reKey = function (obj, transform, recursive) {
|
|
// defaults
|
|
if (recursive === void 0) { recursive = true; }
|
|
if (typeof transform !== 'function') { throw new TypeError('invalid transform function'); }
|
|
|
|
var out = {};
|
|
|
|
_.each(obj, function (prop, name) {
|
|
if (recursive && typeof prop === 'object') {
|
|
out[transform(name)] = utils.reKey(prop, transform, recursive);
|
|
} else {
|
|
out[transform(name)] = prop;
|
|
}
|
|
});
|
|
|
|
return out;
|
|
};
|
|
|
|
/**
|
|
* Recursively merge two objects, walking into each object and concating arrays. If both to and from have a value at a
|
|
* key, but the values' types don't match to's value is left unmodified. Only Array and Object values are merged - that
|
|
* it to say values with a typeof "object"
|
|
*
|
|
* @param {Object} to - Object to merge into (no cloning, the original object
|
|
* is modified)
|
|
* @param {Object} from - Object to pull changed from
|
|
* @return {Object} - returns the modified to value
|
|
*/
|
|
utils.deepMerge = function (to, from) {
|
|
Object.keys(from).forEach(function (key) {
|
|
switch (typeof to[key]) {
|
|
case 'undefined':
|
|
to[key] = from[key];
|
|
break;
|
|
case 'object':
|
|
if (_.isArray(to[key]) && _.isArray(from[key])) {
|
|
to[key] = to[key].concat(from[key]);
|
|
}
|
|
else if (_.isPlainObject(to[key]) && _.isPlainObject(from[key])) {
|
|
utils.deepMerge(to[key], from[key]);
|
|
}
|
|
}
|
|
});
|
|
return to;
|
|
};
|
|
|
|
/**
|
|
* Test if a value is an array and it's contents are of a specific type
|
|
*
|
|
* @method isArrayOf<Strings|Object|Array|Finite|Function|RegExp>s
|
|
* @param {Array} arr - An array to check
|
|
* @return {Boolean}
|
|
*/
|
|
'String Object PlainObject Array Finite Function RegExp'.split(' ').forEach(function (type) {
|
|
var check = _.bindKey(_, 'is' + type);
|
|
|
|
utils['isArrayOf' + type + 's'] = function (arr) {
|
|
// quick shallow check of arrays
|
|
return _.isArray(arr) && _.every(arr.slice(0, 10), check);
|
|
};
|
|
});
|
|
|
|
|
|
/**
|
|
* Capitalize the first letter of a word
|
|
*
|
|
* @todo Tests
|
|
* @method ucfirst
|
|
* @param {string} word - The word to transform
|
|
* @return {string}
|
|
*/
|
|
utils.ucfirst = function (word) {
|
|
return word[0].toUpperCase() + word.substring(1).toLowerCase();
|
|
};
|
|
|
|
/**
|
|
* Base algo for studlyCase and camelCase
|
|
* @param {boolean} firstWordCap - Should the first character of the first word be capitalized
|
|
* @return {Function}
|
|
*/
|
|
function adjustWordCase(firstWordCap, otherWordsCap, sep) {
|
|
return function (string) {
|
|
var inWord = false;
|
|
var i = 0;
|
|
var words = [];
|
|
var word = '';
|
|
var code, c, upper, lower;
|
|
|
|
for (; i < string.length; i++) {
|
|
code = string.charCodeAt(i);
|
|
c = string.charAt(i);
|
|
lower = code >= 97 && code <= 122;
|
|
upper = code >= 65 && code <= 90;
|
|
|
|
if (upper || !lower) {
|
|
// new word
|
|
if (word.length) {
|
|
words.push(word);
|
|
}
|
|
word = '';
|
|
}
|
|
|
|
if (upper || lower) {
|
|
if (lower && word.length) {
|
|
word += c;
|
|
} else {
|
|
if ((!words.length && firstWordCap) || (words.length && otherWordsCap)) {
|
|
word = c.toUpperCase();
|
|
}
|
|
else {
|
|
word = c.toLowerCase();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (word.length) {
|
|
words.push(word);
|
|
}
|
|
// add the leading underscore back to strings the had it originally
|
|
if (words.lenth && string.charAt(0) === '_') {
|
|
words[0] = '_' + words[0];
|
|
}
|
|
return words.join(sep);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Transform a string into StudlyCase
|
|
*
|
|
* @todo Tests
|
|
* @method studlyCase
|
|
* @param {String} string
|
|
* @return {String}
|
|
*/
|
|
utils.studlyCase = adjustWordCase(true, true, '');
|
|
|
|
/**
|
|
* Transform a string into camelCase
|
|
*
|
|
* @todo Tests
|
|
* @method camelCase
|
|
* @param {String} string
|
|
* @return {String}
|
|
*/
|
|
utils.camelCase = adjustWordCase(false, true, '');
|
|
|
|
/**
|
|
* Transform a string into snakeCase
|
|
*
|
|
* @todo Tests
|
|
* @method snakeCase
|
|
* @param {String} string
|
|
* @return {String}
|
|
*/
|
|
utils.snakeCase = adjustWordCase(false, false, '_');
|
|
|
|
/**
|
|
* Lower-case a string, and return an empty string if any is not a string
|
|
*
|
|
* @todo Tests
|
|
* @param any {*} - Something or nothing
|
|
* @returns {string}
|
|
*/
|
|
utils.toLowerString = function (any) {
|
|
if (any) {
|
|
if (typeof any !== 'string') {
|
|
any = any.toString();
|
|
}
|
|
} else {
|
|
any = '';
|
|
}
|
|
return any.toLowerCase();
|
|
};
|
|
|
|
/**
|
|
* Upper-case the string, return an empty string if any is not a string
|
|
*
|
|
* @todo Tests
|
|
* @param any {*} - Something or nothing
|
|
* @returns {string}
|
|
*/
|
|
utils.toUpperString = function (any) {
|
|
if (any) {
|
|
if (typeof any !== 'string') {
|
|
any = any.toString();
|
|
}
|
|
} else {
|
|
any = '';
|
|
}
|
|
return any.toUpperCase();
|
|
};
|
|
|
|
/**
|
|
* Test if a value is "numeric" meaning that it can be transformed into something besides NaN
|
|
*
|
|
* @todo Tests
|
|
* @method isNumeric
|
|
* @param {*} val
|
|
* @return {Boolean}
|
|
*/
|
|
utils.isNumeric = function (val) {
|
|
return !isNaN(val === null ? NaN : val * 1);
|
|
};
|
|
|
|
// regexp to test for intervals
|
|
var intervalRE = /^(\d+(?:\.\d+)?)([Mwdhmsy])$/;
|
|
|
|
/**
|
|
* Test if a string represents an interval (eg. 1m, 2Y)
|
|
*
|
|
* @todo Test
|
|
* @method isInterval
|
|
* @param {String} val
|
|
* @return {Boolean}
|
|
*/
|
|
utils.isInterval = function (val) {
|
|
return !!(val.match && val.match(intervalRE));
|
|
};
|
|
|
|
/**
|
|
* Repeat a string n times
|
|
*
|
|
* @todo Test
|
|
* @todo TestPerformance
|
|
* @method repeat
|
|
* @param {String} what - The string to repeat
|
|
* @param {Number} times - Times the string should be repeated
|
|
* @return {String}
|
|
*/
|
|
utils.repeat = function (what, times) {
|
|
return (new Array(times + 1)).join(what);
|
|
};
|
|
|
|
/**
|
|
* Override node's util.inherits function to also supply a callSuper function on the child class that can be called
|
|
* with the instance and the arguments passed to the child's constructor. This should only be called from within the
|
|
* constructor of the child class and should be removed from the code once the constructor is "done".
|
|
*
|
|
* @param constructor {Function} - the constructor that should subClass superConstructor
|
|
* @param superConstructor {Function} - The parent constructor
|
|
*/
|
|
utils.inherits = function (constructor, superConstructor) {
|
|
nodeUtils.inherits(constructor, superConstructor);
|
|
constructor.callSuper = function (inst, args) {
|
|
if (args) {
|
|
if (_.isArguments(args)) {
|
|
utils.applyArgs(superConstructor, inst, args);
|
|
} else {
|
|
utils.applyArgs(superConstructor, inst, arguments, 1);
|
|
}
|
|
} else {
|
|
superConstructor.call(inst);
|
|
}
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Remove leading/trailing spaces from a string
|
|
*
|
|
* @param str {String} - Any string
|
|
* @returns {String}
|
|
*/
|
|
utils.trim = function (str) {
|
|
return typeof str === 'string' ? str.replace(/^\s+|\s+$/g, '') : '';
|
|
};
|
|
|
|
utils.collectMatches = function (text, regExp) {
|
|
var matches = [], match;
|
|
while (match = regExp.exec(text)) {
|
|
matches.push(match);
|
|
if (regExp.global !== true) {
|
|
// would loop forever if not true
|
|
break;
|
|
}
|
|
}
|
|
return matches;
|
|
};
|
|
|
|
/**
|
|
* Call a function, applying the arguments object to it in an optimized way, rather than always turning it into an array
|
|
*
|
|
* @param func {Function} - The function to execute
|
|
* @param context {*} - The context the function will be executed with
|
|
* @param args {Arguments} - The arguments to send to func
|
|
* @param [sliceIndex=0] {Integer} - The index that args should be sliced at, before feeding args to func
|
|
* @returns {*} - the return value of func
|
|
*/
|
|
utils.applyArgs = function (func, context, args, sliceIndex) {
|
|
sliceIndex = sliceIndex || 0;
|
|
switch (args.length - sliceIndex) {
|
|
case 0:
|
|
return func.call(context);
|
|
case 1:
|
|
return func.call(context, args[0 + sliceIndex]);
|
|
case 2:
|
|
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex]);
|
|
case 3:
|
|
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex], args[2 + sliceIndex]);
|
|
case 4:
|
|
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex], args[2 + sliceIndex], args[3 + sliceIndex]);
|
|
case 5:
|
|
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex],
|
|
args[2 + sliceIndex], args[3 + sliceIndex], args[4 + sliceIndex]);
|
|
default:
|
|
return func.apply(context, Array.prototype.slice.call(args, sliceIndex));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Schedule a function to be called on the next tick, and supply it with these arguments
|
|
* when it is called.
|
|
* @return {[type]} [description]
|
|
*/
|
|
_.nextTick = function (cb) {
|
|
// bind the function and schedule it
|
|
process.nextTick(_.bindKey(_, 'applyArgs', cb, null, arguments, 1));
|
|
};
|
|
|
|
/**
|
|
* Marks a method as a handler. Currently this just makes a property on the method
|
|
* flagging it to be bound to the object at object creation when "makeBoundMethods" is called
|
|
*
|
|
* ```
|
|
* ClassName.prototype.methodName = _.handler(function () {
|
|
* // this will always be bound when called via classInstance.bound.methodName
|
|
* this === classInstance
|
|
* });
|
|
* ```
|
|
*
|
|
* @alias _.scheduled
|
|
* @param {Function} func - The method that is being defined
|
|
* @return {Function}
|
|
*/
|
|
_.handler = function (func) {
|
|
func._provideBound = true;
|
|
return func;
|
|
};
|
|
_.scheduled = _.handler;
|
|
|
|
/**
|
|
* Creates an "bound" property on an object, which all or a subset of methods from
|
|
* the object which are bound to the original object.
|
|
*
|
|
* ```
|
|
* var obj = {
|
|
* onEvent: function () {}
|
|
* };
|
|
*
|
|
* _.makeBoundMethods(obj);
|
|
*
|
|
* obj.bound.onEvent() // is bound to obj, and can safely be used as an event handler.
|
|
* ```
|
|
*
|
|
* @param {Object} obj - The object to bind the methods to
|
|
* @param {Array} [methods] - The methods to bind, false values === bind all flagged with _provideBound
|
|
*/
|
|
_.makeBoundMethods = function (obj, methods) {
|
|
obj.bound = {};
|
|
if (!methods) {
|
|
methods = [];
|
|
for (var prop in obj) {
|
|
// dearest maintainer, we want to look through the prototype
|
|
if (typeof obj[prop] === 'function' && obj[prop]._provideBound === true) {
|
|
obj.bound[prop] = _.bind(obj[prop], obj);
|
|
}
|
|
}
|
|
} else {
|
|
_.each(methods, function (method) {
|
|
obj.bound[method] = _.bindKey(obj, method);
|
|
});
|
|
}
|
|
};
|
|
|
|
_.noop = function () {};
|
|
|
|
// _.getStackTrace = function (callee) {
|
|
// var e = {};
|
|
// if (typeof Error.captureStackTrace === 'function') {
|
|
// Error.captureStackTrace(e, callee || _.getStackTrace);
|
|
// } else {
|
|
// e.stack = (new Error()).stack;
|
|
// console.log(e.stack);
|
|
// }
|
|
// return '\n' + e.stack.split('\n').slice(1).join('\n');
|
|
// };
|
|
|
|
module.exports = utils;
|
|
|
|
},{"__browserify_process":12,"lodash":13,"path":5,"util":8}]},{},[14])
|
|
(14)
|
|
});
|
|
; |