--- /dev/null
+'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);
+ };
+};
projects / dotfiles / .git / blobdiff