1 files changed, 261 insertions, 0 deletions
diff --git a/node_modules/cache-base/index.js b/node_modules/cache-base/index.js
new file mode 100644
index 0000000..4128024
--- /dev/null
+++ b/node_modules/cache-base/index.js
@@ -0,0 +1,261 @@
+'use strict';
+
+var isObject = require('isobject');
+var Emitter = require('component-emitter');
+var visit = require('collection-visit');
+var toPath = require('to-object-path');
+var union = require('union-value');
+var del = require('unset-value');
+var get = require('get-value');
+var has = require('has-value');
+var set = require('set-value');
+
+/**
+ * Create a `Cache` constructor that when instantiated will
+ * store values on the given `prop`.
+ *
+ * ```js
+ * var Cache = require('cache-base').namespace('data');
+ * var cache = new Cache();
+ *
+ * cache.set('foo', 'bar');
+ * //=> {data: {foo: 'bar'}}
+ * ```
+ * @param {String} `prop` The property name to use for storing values.
+ * @return {Function} Returns a custom `Cache` constructor
+ * @api public
+ */
+
+function namespace(prop) {
+
+  /**
+   * Create a new `Cache`. Internally the `Cache` constructor is created using
+   * the `namespace` function, with `cache` defined as the storage object.
+   *
+   * ```js
+   * var app = new Cache();
+   * ```
+   * @param {Object} `cache` Optionally pass an object to initialize with.
+   * @constructor
+   * @api public
+   */
+
+  function Cache(cache) {
+    if (prop) {
+      this[prop] = {};
+    }
+    if (cache) {
+      this.set(cache);
+    }
+  }
+
+  /**
+   * Inherit Emitter
+   */
+
+  Emitter(Cache.prototype);
+
+  /**
+   * Assign `value` to `key`. Also emits `set` with
+   * the key and value.
+   *
+   * ```js
+   * app.on('set', function(key, val) {
+   *   // do something when `set` is emitted
+   * });
+   *
+   * app.set(key, value);
+   *
+   * // also takes an object or array
+   * app.set({name: 'Halle'});
+   * app.set([{foo: 'bar'}, {baz: 'quux'}]);
+   * console.log(app);
+   * //=> {name: 'Halle', foo: 'bar', baz: 'quux'}
+   * ```
+   *
+   * @name .set
+   * @emits `set` with `key` and `value` as arguments.
+   * @param {String} `key`
+   * @param {any} `value`
+   * @return {Object} Returns the instance for chaining.
+   * @api public
+   */
+
+  Cache.prototype.set = function(key, val) {
+    if (Array.isArray(key) && arguments.length === 2) {
+      key = toPath(key);
+    }
+    if (isObject(key) || Array.isArray(key)) {
+      this.visit('set', key);
+    } else {
+      set(prop ? this[prop] : this, key, val);
+      this.emit('set', key, val);
+    }
+    return this;
+  };
+
+  /**
+   * Union `array` to `key`. Also emits `set` with
+   * the key and value.
+   *
+   * ```js
+   * app.union('a.b', ['foo']);
+   * app.union('a.b', ['bar']);
+   * console.log(app.get('a'));
+   * //=> {b: ['foo', 'bar']}
+   * ```
+   * @name .union
+   * @param {String} `key`
+   * @param {any} `value`
+   * @return {Object} Returns the instance for chaining.
+   * @api public
+   */
+
+  Cache.prototype.union = function(key, val) {
+    if (Array.isArray(key) && arguments.length === 2) {
+      key = toPath(key);
+    }
+    var ctx = prop ? this[prop] : this;
+    union(ctx, key, arrayify(val));
+    this.emit('union', val);
+    return this;
+  };
+
+  /**
+   * Return the value of `key`. Dot notation may be used
+   * to get [nested property values][get-value].
+   *
+   * ```js
+   * app.set('a.b.c', 'd');
+   * app.get('a.b');
+   * //=> {c: 'd'}
+   *
+   * app.get(['a', 'b']);
+   * //=> {c: 'd'}
+   * ```
+   *
+   * @name .get
+   * @emits `get` with `key` and `value` as arguments.
+   * @param {String} `key` The name of the property to get. Dot-notation may be used.
+   * @return {any} Returns the value of `key`
+   * @api public
+   */
+
+  Cache.prototype.get = function(key) {
+    key = toPath(arguments);
+
+    var ctx = prop ? this[prop] : this;
+    var val = get(ctx, key);
+
+    this.emit('get', key, val);
+    return val;
+  };
+
+  /**
+   * Return true if app has a stored value for `key`,
+   * false only if value is `undefined`.
+   *
+   * ```js
+   * app.set('foo', 'bar');
+   * app.has('foo');
+   * //=> true
+   * ```
+   *
+   * @name .has
+   * @emits `has` with `key` and true or false as arguments.
+   * @param {String} `key`
+   * @return {Boolean}
+   * @api public
+   */
+
+  Cache.prototype.has = function(key) {
+    key = toPath(arguments);
+
+    var ctx = prop ? this[prop] : this;
+    var val = get(ctx, key);
+
+    var has = typeof val !== 'undefined';
+    this.emit('has', key, has);
+    return has;
+  };
+
+  /**
+   * Delete one or more properties from the instance.
+   *
+   * ```js
+   * app.del(); // delete all
+   * // or
+   * app.del('foo');
+   * // or
+   * app.del(['foo', 'bar']);
+   * ```
+   * @name .del
+   * @emits `del` with the `key` as the only argument.
+   * @param {String|Array} `key` Property name or array of property names.
+   * @return {Object} Returns the instance for chaining.
+   * @api public
+   */
+
+  Cache.prototype.del = function(key) {
+    if (Array.isArray(key)) {
+      this.visit('del', key);
+    } else {
+      del(prop ? this[prop] : this, key);
+      this.emit('del', key);
+    }
+    return this;
+  };
+
+  /**
+   * Reset the entire cache to an empty object.
+   *
+   * ```js
+   * app.clear();
+   * ```
+   * @api public
+   */
+
+  Cache.prototype.clear = function() {
+    if (prop) {
+      this[prop] = {};
+    }
+  };
+
+  /**
+   * Visit `method` over the properties in the given object, or map
+   * visit over the object-elements in an array.
+   *
+   * @name .visit
+   * @param {String} `method` The name of the `base` method to call.
+   * @param {Object|Array} `val` The object or array to iterate over.
+   * @return {Object} Returns the instance for chaining.
+   * @api public
+   */
+
+  Cache.prototype.visit = function(method, val) {
+    visit(this, method, val);
+    return this;
+  };
+
+  return Cache;
+}
+
+/**
+ * Cast val to an array
+ */
+
+function arrayify(val) {
+  return val ? (Array.isArray(val) ? val : [val]) : [];
+}
+
+/**
+ * Expose `Cache`
+ */
+
+module.exports = namespace();
+
+/**
+ * Expose `Cache.namespace`
+ */
+
+module.exports.namespace = namespace;