| 'use strict'; |
| |
| var typeOf = require('kind-of'); |
| var copyDescriptor = require('copy-descriptor'); |
| var define = require('define-property'); |
| |
| /** |
| * Copy static properties, prototype properties, and descriptors from one object to another. |
| * |
| * ```js |
| * function App() {} |
| * var proto = App.prototype; |
| * App.prototype.set = function() {}; |
| * App.prototype.get = function() {}; |
| * |
| * var obj = {}; |
| * copy(obj, proto); |
| * ``` |
| * @param {Object} `receiver` |
| * @param {Object} `provider` |
| * @param {String|Array} `omit` One or more properties to omit |
| * @return {Object} |
| * @api public |
| */ |
| |
| function copy(receiver, provider, omit) { |
| if (!isObject(receiver)) { |
| throw new TypeError('expected receiving object to be an object.'); |
| } |
| if (!isObject(provider)) { |
| throw new TypeError('expected providing object to be an object.'); |
| } |
| |
| var props = nativeKeys(provider); |
| var keys = Object.keys(provider); |
| var len = props.length; |
| omit = arrayify(omit); |
| |
| while (len--) { |
| var key = props[len]; |
| |
| if (has(keys, key)) { |
| define(receiver, key, provider[key]); |
| } else if (!(key in receiver) && !has(omit, key)) { |
| copyDescriptor(receiver, provider, key); |
| } |
| } |
| }; |
| |
| /** |
| * Return true if the given value is an object or function |
| */ |
| |
| function isObject(val) { |
| return typeOf(val) === 'object' || typeof val === 'function'; |
| } |
| |
| /** |
| * Returns true if an array has any of the given elements, or an |
| * object has any of the give keys. |
| * |
| * ```js |
| * has(['a', 'b', 'c'], 'c'); |
| * //=> true |
| * |
| * has(['a', 'b', 'c'], ['c', 'z']); |
| * //=> true |
| * |
| * has({a: 'b', c: 'd'}, ['c', 'z']); |
| * //=> true |
| * ``` |
| * @param {Object} `obj` |
| * @param {String|Array} `val` |
| * @return {Boolean} |
| */ |
| |
| function has(obj, val) { |
| val = arrayify(val); |
| var len = val.length; |
| |
| if (isObject(obj)) { |
| for (var key in obj) { |
| if (val.indexOf(key) > -1) { |
| return true; |
| } |
| } |
| |
| var keys = nativeKeys(obj); |
| return 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.'); |
| } |
| |
| /** |
| * Cast the given value to an array. |
| * |
| * ```js |
| * arrayify('foo'); |
| * //=> ['foo'] |
| * |
| * arrayify(['foo']); |
| * //=> ['foo'] |
| * ``` |
| * |
| * @param {String|Array} `val` |
| * @return {Array} |
| */ |
| |
| function arrayify(val) { |
| return val ? (Array.isArray(val) ? val : [val]) : []; |
| } |
| |
| /** |
| * Returns true if a value has a `contructor` |
| * |
| * ```js |
| * hasConstructor({}); |
| * //=> true |
| * |
| * hasConstructor(Object.create(null)); |
| * //=> false |
| * ``` |
| * @param {Object} `value` |
| * @return {Boolean} |
| */ |
| |
| function hasConstructor(val) { |
| return 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 |
| * nativeKeys({a: 'b', b: 'c', c: 'd'}) |
| * //=> ['a', 'b', 'c'] |
| * |
| * nativeKeys(function(){}) |
| * //=> ['length', 'caller'] |
| * ``` |
| * |
| * @param {Object} `obj` Object that has a `constructor`. |
| * @return {Array} Array of keys. |
| */ |
| |
| function nativeKeys(val) { |
| if (!hasConstructor(val)) return []; |
| return Object.getOwnPropertyNames(val); |
| } |
| |
| /** |
| * Expose `copy` |
| */ |
| |
| module.exports = copy; |
| |
| /** |
| * Expose `copy.has` for tests |
| */ |
| |
| module.exports.has = has; |