ES5 object manipulation library for node and modern browsers. 

ES5 object manipulation library for node and modern browsers

jason-green

mailonline

mol-proto

  "homepage": "https://github.com/milojs/proto",

    "MOL Technical <MOL_Technical@assocnews.co.uk>"

  "description": "Prototypes aware object manipulation library for node and modern browsers",

 * These methods can be [chained](proto.js.html#Proto).

 * Functions that Array [implements natively](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype#Methods) are also included for convenience - they can be used with array-like objects and for chaining (native functions are always called).

 * These methods can be [chained](proto.js.html#Proto) too.

var nativeArrayMethodsNames = [ 'join', 'pop', 'push', 'concat',

    'reverse', 'shift', 'unshift', 'slice', 'splice',

    'sort', 'filter', 'forEach', 'some', 'every',

    'map', 'indexOf', 'lastIndexOf', 'reduce', 'reduceRight'];

var nativeArrayMethods = mapToObject.call(nativeArrayMethodsNames,

            return Array.prototype[methodName];

__.extend.call(arrayMethods, nativeArrayMethods);

 * Implementation of ES6 [Array __find__ method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) (native method is used if available).

 * Returns array element that passes callback test.

 * @param {Array} self array to search in

 * @param {Function} callback should return `true` for item to pass the test, passed `value`, `index` and `self` as parameters

 * @param {Object} thisArg optional context (`this`) of callback call

    || utils.makeFindMethod(arrayMethods.forEach, 'value');

    || utils.makeFindMethod(arrayMethods.some, 'value');

 * Implementation of ES6 [Array __findIndex__ method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex) (native method is used if available).

 * Returns the index of array element that passes callback test. Returns `-1` if not found.

arrayMethods.findIndex = Array.prototype.findIndex

    || utils.makeFindMethod(arrayMethods.forEach, 'index');

    || utils.makeFindMethod(arrayMethods.some, 'index');

 * Appends `arrayToAppend` to the end of array `self` in place (can be an instance of Array or array-like object).

 * Changes the value of `self` (it uses `Array.prototype.splice`) and returns `self`.

 * @param {Array} self An array that will be modified

 * @param {Array|Array-like} arrayToAppend An array that will be appended

    if (! arrayToAppend.length) return this;

        arrayToAppend = toArray.call(arrayToAppend);

    var args = [this.length, 0].concat(arrayToAppend);

    arrayMethods.splice.apply(this, args);

 * Prepends `arrayToPrepend` to the beginnig of array `self` in place (can be an instance of Array or array-like object).

 * @param {Array|Array-like} arrayToAppend An array that will be prepended

    if (! arrayToPrepend.length) return this;

        arrayToPrepend = toArray.call(arrayToPrepend);

    var args = [0, 0].concat(arrayToPrepend);

 * Removes item from array that is found using indexOf (i.e. '===')

 * Modifies original array and returns the reference to it.

    if (index >= 0) this.splice(index, 1);

 * Returns new array created from array-like object (e.g., `arguments` pseudo-array).

 * @param {Array-like} self Object with numeric property length

    return arrayMethods.slice.call(this);

 * Returns an object created from the array of `keys` and optional array of `values`.

 * @param {Array|any} values Optional array of values or the value to be assigned to each property.

        , valuesIsArray = Array.isArray(values);

    arrayMethods.forEach.call(this, function(key, index) {

        obj[key] = valuesIsArray ? values[index] : values;

 * Array elements become keys, value are taken from `callback`.

 * @param {Array} self An array which values will become keys of the result

 * @param {Function} callback Callback is passed `value`, `index` and `self` and should return value that will be included in the result.

 * @param {Object} thisArg An optional context of iteration (the valueof `this`), will be undefined if this parameter is not passed.

function mapToObject(callback, thisArg) {

    Array.prototype.forEach.call(this, function(value, index) {

        result[value] = callback.call(thisArg, value, index, this);

 * - [defineProperties](#defineProperties)

 * All these methods can be [chained](proto.js.html#Proto)

 * The sum of these constants can be used as last parameter of defineProperty and defineProperties to determine types of properties.

defineProperty.call(objectMethods, '_constants', constants);

 * Analogue of ES6 [Array __find__ method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find).

 * Returns the value of object property that passes callback test.

 * @param {Object} self object to search in

 * @param {Function} callback should return `true` for item to pass the test, passed `value`, `key` and `self` as parameters

 * @param {Boolean} onlyEnumerable An optional `true` to iterate enumerable properties only.

objectMethods.findValue = utils.makeFindMethod(eachKey, 'value');

objectMethods.findValue = utils.makeFindMethod(someKey, 'value');

 * Analogue of ES6 [Array __findIndex__ method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex).

 * Returns the key of object property that passes callback test. Returns `undefined` if not found (unlike `findIndex`, that returns -1 in this case).

objectMethods.findKey = utils.makeFindMethod(eachKey, 'key');

objectMethods.findKey = utils.makeFindMethod(someKey, 'key');

 * Extends object `self` with the properties of the object `obj` copying all own properties (not those inherited via prototype chain), including non-enumerable properties (unless `onlyEnumerable` is truthy).

 * Created properties will have the same descriptors as the propertis of `obj`.

 * Returns `self` to allow chaining with other functions.

 * Can be used with functions, to copy class methods, e.g.

 * @param {Object} self An object to be extended

 * @param {Object} obj An object which properties will be copied to self

 * @param {Boolean} onlyEnumerable Optional flag to prevent copying non-enumerable properties, `false` by default

    eachKey.call(obj, function(value, prop) {

        descriptors[prop] = Object.getOwnPropertyDescriptor(obj, prop);

    Object.defineProperties(this, descriptors);

 * Makes a shallow clone of object `obj` creating an instance of the same class; the properties will have the same descriptors.

 * This function should not be used to clone an array, because it is inefficient.

 * @param {Object} self An object to be cloned

    if (Array.isArray(this)) return this.slice();

    if (this instanceof Date) return new Date(this);

    if (this instanceof RegExp) return new RegExp(this);

    var clonedObject = Object.create(this.constructor.prototype);

 * Syntax sugar to shorten usage of `Object.defineProperty`.

 * The simplest usage (to add non-enumerable, non-configurable, non-writable property):

 * To define some other properties use sum of the flags `_.ENUMERABLE` (or `_.ENUM`), `_.CONFIGURABLE` (or `_.CONF`) and `_.WRITABLE` (or `_.WRIT`):

 * _.defineProperty(obj, 'key', value, _.ENUM + _.WRIT);

 * @param {Object} self An object to add a property to

 * @param {String} propertyName the name of the property that will be added

 * @param {Any} value the value of added property

 * @param {Integer} decriptorFlags bit mask of property descriptor properties composed from `_.ENUMERABLE` (or `_.ENUM`), `_.CONFIGURABLE` (or `_.CONF`) and `_.WRITABLE` (or `_.WRIT`)

function defineProperty(propertyName, value, decriptorFlags) {

    Object.defineProperty(this, propertyName,

        _getDescriptor(value, decriptorFlags));

function _getDescriptor(value, decriptorFlags) {

            enumerable: !! (decriptorFlags & constants.ENUMERABLE),

            configurable: !! (decriptorFlags & constants.CONFIGURABLE),

            writable: !! (decriptorFlags & constants.WRITABLE)

 * Syntax sugar to shorten usage of `Object.defineProperties`.

 * The simplest usage (to add non-enumerable, non-configurable, non-writable properties):

    makeProtoInstanceMethod: makeProtoInstanceMethod,

    makeProtoFunction: makeProtoFunction,

function makeProtoInstanceMethod(method) {

        this.self = method.apply(this.self, arguments);

        // when the method is executed, the value of "this" will be arguments[0],

        // other arguments starting from #1 will passed to method as parameters.

        return method.call.apply(method, arguments);

 * Returns `find` or `findIndex` method, depending on parameter

 * @param {Function} eachMethod - method to use for iteration (forEach for array or eachKey for object)

 * @param {String} findWhat 'value' - returns find method of Array (implemented in ES6) or findValue method of Object, anything else = returns findIndex/findKey methods.

function makeFindMethod(eachMethod, findWhat) {

function makeFindMethod(someMethod, findWhat) {

    var argIndex = findWhat == 'value' ? 0 : 1;

    return function findValueOrIndex(callback, thisArg, onlyEnumerable) {

            eachMethod.call(this, testItem, thisArg, onlyEnumerable);

            if (found === _error) throw caughtError;

        var found = someMethod.call(this, testItem, thisArg, onlyEnumerable);

        // if looking for index and not found, return -1

        if (argIndex && eachMethod == Array.prototype.forEach)

        else if (argIndex && someMethod == Array.prototype.some)

        function testItem(value, index, self) {

                test = callback.call(this, value, index, self);

            var test = callback.call(this, value, index, self);

                foundValueOrIndex = arguments[argIndex]

                throw arguments[argIndex];

  "description": "ES5 object manipulation library for node and modern browsers",

    "test": "NODE_ENV=test ./node_modules/.bin/mocha --recursive --reporter=spec"

    "url": "git://github.com/milojs/proto.git"

    "url": "https://github.com/milojs/proto/issues"

		{
		"name": "proto",
		"version": "0.1.13",
		"version": "0.1.14",
		"homepage": "https://github.com/milojs/proto",
		@@ -5,0 +5,0 @@ "authors": [

		@@ -85,3 +85,3 @@ 'use strict';
		*/
		objectMethods.findValue = utils.makeFindMethod(eachKey, 'value');
		objectMethods.findValue = utils.makeFindMethod(someKey, 'value');

		@@ -99,3 +99,3 @@
		*/
		objectMethods.findKey = utils.makeFindMethod(eachKey, 'key');
		objectMethods.findKey = utils.makeFindMethod(someKey, 'key');

		@@ -102,0 +102,0 @@

		@@ -36,29 +36,22 @@ 'use strict';
		*/
		function makeFindMethod(eachMethod, findWhat) {
		function makeFindMethod(someMethod, findWhat) {
		var argIndex = findWhat == 'value' ? 0 : 1;

		return function findValueOrIndex(callback, thisArg, onlyEnumerable) {
		var caughtError;
		try {
		eachMethod.call(this, testItem, thisArg, onlyEnumerable);
		} catch (found) {
		if (found === _error) throw caughtError;
		else return found;
		}
		var foundValueOrIndex;
		var found = someMethod.call(this, testItem, thisArg, onlyEnumerable);
		if (found)
		return foundValueOrIndex;
		// if looking for index and not found, return -1
		if (argIndex && eachMethod == Array.prototype.forEach)
		return -1;
		else if (argIndex && someMethod == Array.prototype.some)
		return -1;

		function testItem(value, index, self) {
		var test;
		try {
		test = callback.call(this, value, index, self);
		} catch(err) {
		caughtError = err;
		throw _error;
		var test = callback.call(this, value, index, self);
		if (test) {
		foundValueOrIndex = arguments[argIndex]
		return test;
		}
		if (test)
		throw arguments[argIndex];
		}
		}
		}

		{
		"name": "mol-proto",
		"version": "0.1.13",
		"version": "0.1.14",
		"description": "ES5 object manipulation library for node and modern browsers",
		@@ -5,0 +5,0 @@ "main": "lib/proto.js",

		@@ -62,3 +62,3 @@ 'use strict';
		arrayMethods.find = Array.prototype.find
		\|\| utils.makeFindMethod(arrayMethods.forEach, 'value');
		\|\| utils.makeFindMethod(arrayMethods.some, 'value');

		@@ -76,3 +76,3 @@
		arrayMethods.findIndex = Array.prototype.findIndex
		\|\| utils.makeFindMethod(arrayMethods.forEach, 'index');
		\|\| utils.makeFindMethod(arrayMethods.some, 'index');

		@@ -79,0 +79,0 @@

Worsened metrics