| '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); |
| }; |
| }; |