| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/jungly/node_modules/cache-base/ |
Upload File : |
'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;