wishthis/node_modules/class-utils/index.js
2022-01-21 09:28:41 +01:00

370 lines
8 KiB
JavaScript

'use strict';
var util = require('util');
var union = require('arr-union');
var define = require('define-property');
var staticExtend = require('static-extend');
var isObj = require('isobject');
/**
* Expose class utils
*/
var cu = module.exports;
/**
* Expose class utils: `cu`
*/
cu.isObject = function isObject(val) {
return isObj(val) || typeof val === 'function';
};
/**
* Returns true if an array has any of the given elements, or an
* object has any of the give keys.
*
* ```js
* cu.has(['a', 'b', 'c'], 'c');
* //=> true
*
* cu.has(['a', 'b', 'c'], ['c', 'z']);
* //=> true
*
* cu.has({a: 'b', c: 'd'}, ['c', 'z']);
* //=> true
* ```
* @param {Object} `obj`
* @param {String|Array} `val`
* @return {Boolean}
* @api public
*/
cu.has = function has(obj, val) {
val = cu.arrayify(val);
var len = val.length;
if (cu.isObject(obj)) {
for (var key in obj) {
if (val.indexOf(key) > -1) {
return true;
}
}
var keys = cu.nativeKeys(obj);
return cu.has(keys, val);
}
if (Array.isArray(obj)) {
var arr = obj;
while (len--) {
if (arr.indexOf(val[len]) > -1) {
return true;
}
}
return false;
}
throw new TypeError('expected an array or object.');
};
/**
* Returns true if an array or object has all of the given values.
*
* ```js
* cu.hasAll(['a', 'b', 'c'], 'c');
* //=> true
*
* cu.hasAll(['a', 'b', 'c'], ['c', 'z']);
* //=> false
*
* cu.hasAll({a: 'b', c: 'd'}, ['c', 'z']);
* //=> false
* ```
* @param {Object|Array} `val`
* @param {String|Array} `values`
* @return {Boolean}
* @api public
*/
cu.hasAll = function hasAll(val, values) {
values = cu.arrayify(values);
var len = values.length;
while (len--) {
if (!cu.has(val, values[len])) {
return false;
}
}
return true;
};
/**
* Cast the given value to an array.
*
* ```js
* cu.arrayify('foo');
* //=> ['foo']
*
* cu.arrayify(['foo']);
* //=> ['foo']
* ```
*
* @param {String|Array} `val`
* @return {Array}
* @api public
*/
cu.arrayify = function arrayify(val) {
return val ? (Array.isArray(val) ? val : [val]) : [];
};
/**
* Noop
*/
cu.noop = function noop() {
return;
};
/**
* Returns the first argument passed to the function.
*/
cu.identity = function identity(val) {
return val;
};
/**
* Returns true if a value has a `contructor`
*
* ```js
* cu.hasConstructor({});
* //=> true
*
* cu.hasConstructor(Object.create(null));
* //=> false
* ```
* @param {Object} `value`
* @return {Boolean}
* @api public
*/
cu.hasConstructor = function hasConstructor(val) {
return cu.isObject(val) && typeof val.constructor !== 'undefined';
};
/**
* Get the native `ownPropertyNames` from the constructor of the
* given `object`. An empty array is returned if the object does
* not have a constructor.
*
* ```js
* cu.nativeKeys({a: 'b', b: 'c', c: 'd'})
* //=> ['a', 'b', 'c']
*
* cu.nativeKeys(function(){})
* //=> ['length', 'caller']
* ```
*
* @param {Object} `obj` Object that has a `constructor`.
* @return {Array} Array of keys.
* @api public
*/
cu.nativeKeys = function nativeKeys(val) {
if (!cu.hasConstructor(val)) return [];
var keys = Object.getOwnPropertyNames(val);
if ('caller' in val) keys.push('caller');
return keys;
};
/**
* Returns property descriptor `key` if it's an "own" property
* of the given object.
*
* ```js
* function App() {}
* Object.defineProperty(App.prototype, 'count', {
* get: function() {
* return Object.keys(this).length;
* }
* });
* cu.getDescriptor(App.prototype, 'count');
* // returns:
* // {
* // get: [Function],
* // set: undefined,
* // enumerable: false,
* // configurable: false
* // }
* ```
*
* @param {Object} `obj`
* @param {String} `key`
* @return {Object} Returns descriptor `key`
* @api public
*/
cu.getDescriptor = function getDescriptor(obj, key) {
if (!cu.isObject(obj)) {
throw new TypeError('expected an object.');
}
if (typeof key !== 'string') {
throw new TypeError('expected key to be a string.');
}
return Object.getOwnPropertyDescriptor(obj, key);
};
/**
* Copy a descriptor from one object to another.
*
* ```js
* function App() {}
* Object.defineProperty(App.prototype, 'count', {
* get: function() {
* return Object.keys(this).length;
* }
* });
* var obj = {};
* cu.copyDescriptor(obj, App.prototype, 'count');
* ```
* @param {Object} `receiver`
* @param {Object} `provider`
* @param {String} `name`
* @return {Object}
* @api public
*/
cu.copyDescriptor = function copyDescriptor(receiver, provider, name) {
if (!cu.isObject(receiver)) {
throw new TypeError('expected receiving object to be an object.');
}
if (!cu.isObject(provider)) {
throw new TypeError('expected providing object to be an object.');
}
if (typeof name !== 'string') {
throw new TypeError('expected name to be a string.');
}
var val = cu.getDescriptor(provider, name);
if (val) Object.defineProperty(receiver, name, val);
};
/**
* Copy static properties, prototype properties, and descriptors
* from one object to another.
*
* @param {Object} `receiver`
* @param {Object} `provider`
* @param {String|Array} `omit` One or more properties to omit
* @return {Object}
* @api public
*/
cu.copy = function copy(receiver, provider, omit) {
if (!cu.isObject(receiver)) {
throw new TypeError('expected receiving object to be an object.');
}
if (!cu.isObject(provider)) {
throw new TypeError('expected providing object to be an object.');
}
var props = Object.getOwnPropertyNames(provider);
var keys = Object.keys(provider);
var len = props.length,
key;
omit = cu.arrayify(omit);
while (len--) {
key = props[len];
if (cu.has(keys, key)) {
define(receiver, key, provider[key]);
} else if (!(key in receiver) && !cu.has(omit, key)) {
cu.copyDescriptor(receiver, provider, key);
}
}
};
/**
* Inherit the static properties, prototype properties, and descriptors
* from of an object.
*
* @param {Object} `receiver`
* @param {Object} `provider`
* @param {String|Array} `omit` One or more properties to omit
* @return {Object}
* @api public
*/
cu.inherit = function inherit(receiver, provider, omit) {
if (!cu.isObject(receiver)) {
throw new TypeError('expected receiving object to be an object.');
}
if (!cu.isObject(provider)) {
throw new TypeError('expected providing object to be an object.');
}
var keys = [];
for (var key in provider) {
keys.push(key);
receiver[key] = provider[key];
}
keys = keys.concat(cu.arrayify(omit));
var a = provider.prototype || provider;
var b = receiver.prototype || receiver;
cu.copy(b, a, keys);
};
/**
* Returns a function for extending the static properties,
* prototype properties, and descriptors from the `Parent`
* constructor onto `Child` constructors.
*
* ```js
* var extend = cu.extend(Parent);
* Parent.extend(Child);
*
* // optional methods
* Parent.extend(Child, {
* foo: function() {},
* bar: function() {}
* });
* ```
* @param {Function} `Parent` Parent ctor
* @param {Function} `extend` Optional extend function to handle custom extensions. Useful when updating methods that require a specific prototype.
* @param {Function} `Child` Child ctor
* @param {Object} `proto` Optionally pass additional prototype properties to inherit.
* @return {Object}
* @api public
*/
cu.extend = function() {
// keep it lazy, instead of assigning to `cu.extend`
return staticExtend.apply(null, arguments);
};
/**
* Bubble up events emitted from static methods on the Parent ctor.
*
* @param {Object} `Parent`
* @param {Array} `events` Event names to bubble up
* @api public
*/
cu.bubble = function(Parent, events) {
events = events || [];
Parent.bubble = function(Child, arr) {
if (Array.isArray(arr)) {
events = union([], events, arr);
}
var len = events.length;
var idx = -1;
while (++idx < len) {
var name = events[idx];
Parent.on(name, Child.emit.bind(Child, name));
}
cu.bubble(Child, events);
};
};