gs_nuxt/node_modules/node-cache/lib/node_cache.js

/*
 * node-cache 4.2.1 ( 2019-07-24 )
 * https://github.com/mpneuried/nodecache
 *
 * Released under the MIT license
 * https://github.com/mpneuried/nodecache/blob/master/LICENSE
 *
 * Maintained by  (  )
*/
(function() {
  // lodash requires
  var EventEmitter, NodeCache, _assignIn, _isArray, _isFunction, _isNumber, _isObject, _isString, _size, _template, clone,
    boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } },
    indexOf = [].indexOf;

  _assignIn = require("lodash/assignIn");

  _isArray = require("lodash/isArray");

  _isString = require("lodash/isString");

  _isFunction = require("lodash/isFunction");

  _isNumber = require("lodash/isNumber");

  _isObject = require("lodash/isObject");

  _size = require("lodash/size");

  _template = require("lodash/template");

  clone = require("clone");

  EventEmitter = require('events').EventEmitter;

  // generate superclass
  module.exports = NodeCache = (function() {
    class NodeCache extends EventEmitter {
      constructor(options = {}) {
        super();
        // ## get

        // get a cached key and change the stats

        // **Parameters:**

        // * `key` ( String | Number ): cache key
        // * `[cb]` ( Function ): Callback function
        // * `[errorOnMissing=false]` ( Boolean ) return a error to the `cb` or throw it if no `cb` is used. Otherwise the get will return `undefined` on a miss.

        // **Example:**

        //     myCache.get "myKey", ( err, val )->
        //       console.log( err, val )
        //       return

        this.get = this.get.bind(this);
        // ## mget

        // get multiple cached keys at once and change the stats

        // **Parameters:**

        // * `keys` ( String|Number[] ): an array of keys
        // * `[cb]` ( Function ): Callback function

        // **Example:**

        //     myCache.mget [ "foo", "bar" ], ( err, val )->
        //       console.log( err, val )
        //       return

        this.mget = this.mget.bind(this);
        // ## set

        // set a cached key and change the stats

        // **Parameters:**

        // * `key` ( String | Number ): cache key
        // * `value` ( Any ): A element to cache. If the option `option.forceString` is `true` the module trys to translate it to a serialized JSON
        // * `[ ttl ]` ( Number | String ): ( optional ) The time to live in seconds.
        // * `[cb]` ( Function ): Callback function

        // **Example:**

        //     myCache.set "myKey", "my_String Value", ( err, success )->
        //       console.log( err, success )

        //     myCache.set "myKey", "my_String Value", "10", ( err, success )->
        //       console.log( err, success )

        this.set = this.set.bind(this);
        // ## del

        // remove keys

        // **Parameters:**

        // * `keys` ( String | Number | String|Number[] ): cache key to delete or a array of cache keys
        // * `[cb]` ( Function ): Callback function

        // **Return**

        // ( Number ): Number of deleted keys

        // **Example:**

        //     myCache.del( "myKey" )

        //     myCache.del( "myKey", ( err, delCount )->
        //       console.log( err, delCount )
        //       return
        this.del = this.del.bind(this);
        // ## ttl

        // reset or redefine the ttl of a key. `ttl` = 0 means infinite lifetime.
        // If `ttl` is not passed the default ttl is used.
        // If `ttl` < 0 the key will be deleted.

        // **Parameters:**

        // * `key` ( String | Number ): cache key to reset the ttl value
        // * `ttl` ( Number ): ( optional -> options.stdTTL || 0 ) The time to live in seconds
        // * `[cb]` ( Function ): Callback function

        // **Return**

        // ( Boolen ): key found and ttl set

        // **Example:**

        //     myCache.ttl( "myKey" ) // will set ttl to default ttl

        //     myCache.ttl( "myKey", 1000, ( err, keyFound )->
        //       console.log( err, success )

        this.ttl = this.ttl.bind(this);
        // ## getTtl

        // receive the ttl of a key.

        // **Parameters:**

        // * `key` ( String | Number ): cache key to check the ttl value
        // * `[cb]` ( Function ): Callback function

        // **Return**

        // ( Number|undefined ): The timestamp in ms when the key will expire, 0 if it will never expire or undefined if it not exists

        // **Example:**

        //     ts = myCache.getTtl( "myKey" )

        //     myCache.getTtl( "myKey",( err, ttl )->
        //       console.log( err, ttl )
        //       return

        this.getTtl = this.getTtl.bind(this);
        // ## keys

        // list all keys within this cache

        // **Parameters:**

        // * `[cb]` ( Function ): Callback function

        // **Return**

        // ( Array ): An array of all keys

        // **Example:**

        //     _keys = myCache.keys()

        //     # [ "foo", "bar", "fizz", "buzz", "anotherKeys" ]

        this.keys = this.keys.bind(this);
        // ## getStats

        // get the stats

        // **Parameters:**

        // -

        // **Return**

        // ( Object ): Stats data

        // **Example:**

        //     myCache.getStats()
        //     # {
        //     # hits: 0,
        //     # misses: 0,
        //     # keys: 0,
        //     # ksize: 0,
        //     # vsize: 0
        //     # }

        this.getStats = this.getStats.bind(this);
        // ## flushAll

        // flush the whole data and reset the stats

        // **Example:**

        //     myCache.flushAll()

        //     myCache.getStats()
        //     # {
        //     # hits: 0,
        //     # misses: 0,
        //     # keys: 0,
        //     # ksize: 0,
        //     # vsize: 0
        //     # }

        this.flushAll = this.flushAll.bind(this);
        // ## close

        // This will clear the interval timeout which is set on checkperiod option.

        // **Example:**

        //     myCache.close()

        this.close = this.close.bind(this);
        // ## _checkData

        // internal housekeeping method.
        // Check all the cached data and delete the invalid values
        this._checkData = this._checkData.bind(this);
        // ## _check

        // internal method the check the value. If it's not valid any more delete it
        this._check = this._check.bind(this);
        // ## _isInvalidKey

        // internal method to check if the type of a key is either `number` or `string`
        this._isInvalidKey = this._isInvalidKey.bind(this);
        // ## _wrap

        // internal method to wrap a value in an object with some metadata
        this._wrap = this._wrap.bind(this);
        // ## _getValLength

        // internal method to calculate the value length
        this._getValLength = this._getValLength.bind(this);
        // ## _error

        // internal method to handle an error message
        this._error = this._error.bind(this);
        // ## _initErrors

        // internal method to generate error message templates
        this._initErrors = this._initErrors.bind(this);
        this.options = options;
        this._initErrors();
        // container for cached data
        this.data = {};
        // module options
        this.options = _assignIn({
          // convert all elements to string
          forceString: false,
          // used standard size for calculating value size
          objectValueSize: 80,
          promiseValueSize: 80,
          arrayValueSize: 40,
          // standard time to live in seconds. 0 = infinity;
          stdTTL: 0,
          // time in seconds to check all data and delete expired keys
          checkperiod: 600,
          // en/disable cloning of variables. If `true` you'll get a copy of the cached variable. If `false` you'll save and get just the reference
          useClones: true,
          // en/disable throwing errors when trying to `.get` missing or expired values.
          errorOnMissing: false,
          // whether values should be deleted automatically at expiration
          deleteOnExpire: true
        }, this.options);
        // statistics container
        this.stats = {
          hits: 0,
          misses: 0,
          keys: 0,
          ksize: 0,
          vsize: 0
        };
        // pre allocate valid keytypes array
        this.validKeyTypes = ["string", "number"];
        // initalize checking period
        this._checkData();
        return;
      }

      get(key, cb, errorOnMissing) {
        var _err, _ret, err;
        boundMethodCheck(this, NodeCache);
        // handle passing in errorOnMissing without cb
        if (typeof cb === "boolean" && arguments.length === 2) {
          errorOnMissing = cb;
          cb = void 0;
        }
        // handle invalid key types
        if ((err = this._isInvalidKey(key)) != null) {
          if (cb != null) {
            cb(err);
            return;
          } else {
            throw err;
          }
        }
        // get data and incremet stats
        if ((this.data[key] != null) && this._check(key, this.data[key])) {
          this.stats.hits++;
          _ret = this._unwrap(this.data[key]);
          if (cb != null) {
            // return data
            cb(null, _ret);
          }
          return _ret;
        } else {
          // if not found return a error
          this.stats.misses++;
          if (this.options.errorOnMissing || errorOnMissing) {
            _err = this._error("ENOTFOUND", {
              key: key
            }, cb);
            if (_err != null) {
              throw _err;
            }
            return;
          } else {
            if (cb != null) {
              cb(null, void 0);
            }
          }
          return void 0;
        }
      }

      mget(keys, cb) {
        var _err, err, i, key, len, oRet;
        boundMethodCheck(this, NodeCache);
        // convert a string to an array of one key
        if (!_isArray(keys)) {
          _err = this._error("EKEYSTYPE");
          if (cb != null) {
            cb(_err);
          }
          return _err;
        }
        // define return
        oRet = {};
        for (i = 0, len = keys.length; i < len; i++) {
          key = keys[i];
          // handle invalid key types
          if ((err = this._isInvalidKey(key)) != null) {
            if (cb != null) {
              cb(err);
              return;
            } else {
              throw err;
            }
          }
          // get data and increment stats
          if ((this.data[key] != null) && this._check(key, this.data[key])) {
            this.stats.hits++;
            oRet[key] = this._unwrap(this.data[key]);
          } else {
            // if not found return a error
            this.stats.misses++;
          }
        }
        if (cb != null) {
          // return all found keys
          cb(null, oRet);
        }
        return oRet;
      }

      set(key, value, ttl, cb) {
        var err, existent;
        boundMethodCheck(this, NodeCache);
        // force the data to string
        if (this.options.forceString && !_isString(value)) {
          value = JSON.stringify(value);
        }
        // remap the arguments if `ttl` is not passed
        if (arguments.length === 3 && _isFunction(ttl)) {
          cb = ttl;
          ttl = this.options.stdTTL;
        }
        // handle invalid key types
        if ((err = this._isInvalidKey(key)) != null) {
          if (cb != null) {
            cb(err);
            return;
          } else {
            throw err;
          }
        }
        // internal helper variables
        existent = false;
        // remove existing data from stats
        if (this.data[key]) {
          existent = true;
          this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
        }
        // set the value
        this.data[key] = this._wrap(value, ttl);
        this.stats.vsize += this._getValLength(value);
        // only add the keys and key-size if the key is new
        if (!existent) {
          this.stats.ksize += this._getKeyLength(key);
          this.stats.keys++;
        }
        this.emit("set", key, value);
        if (cb != null) {
          // return true
          cb(null, true);
        }
        return true;
      }

      del(keys, cb) {
        var delCount, err, i, key, len, oldVal;
        boundMethodCheck(this, NodeCache);
        // convert keys to an array of itself
        if (!_isArray(keys)) {
          keys = [keys];
        }
        delCount = 0;
        for (i = 0, len = keys.length; i < len; i++) {
          key = keys[i];
          // handle invalid key types
          if ((err = this._isInvalidKey(key)) != null) {
            if (cb != null) {
              cb(err);
              return;
            } else {
              throw err;
            }
          }
          // only delete if existent
          if (this.data[key] != null) {
            // calc the stats
            this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
            this.stats.ksize -= this._getKeyLength(key);
            this.stats.keys--;
            delCount++;
            // delete the value
            oldVal = this.data[key];
            delete this.data[key];
            // return true
            this.emit("del", key, oldVal.v);
          } else {
            // if the key has not been found return an error
            this.stats.misses++;
          }
        }
        if (cb != null) {
          cb(null, delCount);
        }
        return delCount;
      }

      ttl() {
        var arg, args, cb, err, i, key, len, ttl;
        boundMethodCheck(this, NodeCache);
        // change args if only key and callback are passed
        [key, ...args] = arguments;
        for (i = 0, len = args.length; i < len; i++) {
          arg = args[i];
          switch (typeof arg) {
            case "number":
              ttl = arg;
              break;
            case "function":
              cb = arg;
          }
        }
        ttl || (ttl = this.options.stdTTL);
        if (!key) {
          if (cb != null) {
            cb(null, false);
          }
          return false;
        }
        // handle invalid key types
        if ((err = this._isInvalidKey(key)) != null) {
          if (cb != null) {
            cb(err);
            return;
          } else {
            throw err;
          }
        }
        // check for existant data and update the ttl value
        if ((this.data[key] != null) && this._check(key, this.data[key])) {
          // if ttl < 0 delete the key. otherwise reset the value
          if (ttl >= 0) {
            this.data[key] = this._wrap(this.data[key].v, ttl, false);
          } else {
            this.del(key);
          }
          if (cb != null) {
            cb(null, true);
          }
          return true;
        } else {
          if (cb != null) {
            // return false if key has not been found
            cb(null, false);
          }
          return false;
        }
      }

      getTtl(key, cb) {
        var _ttl, err;
        boundMethodCheck(this, NodeCache);
        if (!key) {
          if (cb != null) {
            cb(null, void 0);
          }
          return void 0;
        }
        // handle invalid key types
        if ((err = this._isInvalidKey(key)) != null) {
          if (cb != null) {
            cb(err);
            return;
          } else {
            throw err;
          }
        }
        // check for existant data and update the ttl value
        if ((this.data[key] != null) && this._check(key, this.data[key])) {
          _ttl = this.data[key].t;
          if (cb != null) {
            cb(null, _ttl);
          }
          return _ttl;
        } else {
          if (cb != null) {
            // return undefined if key has not been found
            cb(null, void 0);
          }
          return void 0;
        }
      }

      keys(cb) {
        var _keys;
        boundMethodCheck(this, NodeCache);
        _keys = Object.keys(this.data);
        if (cb != null) {
          cb(null, _keys);
        }
        return _keys;
      }

      getStats() {
        boundMethodCheck(this, NodeCache);
        return this.stats;
      }

      flushAll(_startPeriod = true) {
        boundMethodCheck(this, NodeCache);
        // parameter just for testing

        // set data empty
        this.data = {};
        // reset stats
        this.stats = {
          hits: 0,
          misses: 0,
          keys: 0,
          ksize: 0,
          vsize: 0
        };
        // reset check period
        this._killCheckPeriod();
        this._checkData(_startPeriod);
        this.emit("flush");
      }

      close() {
        boundMethodCheck(this, NodeCache);
        this._killCheckPeriod();
      }

      _checkData(startPeriod = true) {
        var key, ref, value;
        boundMethodCheck(this, NodeCache);
        ref = this.data;
        // run the housekeeping method
        for (key in ref) {
          value = ref[key];
          this._check(key, value);
        }
        if (startPeriod && this.options.checkperiod > 0) {
          this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod);
          if (this.checkTimeout.unref != null) {
            this.checkTimeout.unref();
          }
        }
      }

      // ## _killCheckPeriod

      // stop the checkdata period. Only needed to abort the script in testing mode.
      _killCheckPeriod() {
        if (this.checkTimeout != null) {
          return clearTimeout(this.checkTimeout);
        }
      }

      _check(key, data) {
        var _retval;
        boundMethodCheck(this, NodeCache);
        _retval = true;
        // data is invalid if the ttl is too old and is not 0
        // console.log data.t < Date.now(), data.t, Date.now()
        if (data.t !== 0 && data.t < Date.now()) {
          if (this.options.deleteOnExpire) {
            _retval = false;
            this.del(key);
          }
          this.emit("expired", key, this._unwrap(data));
        }
        return _retval;
      }

      _isInvalidKey(key) {
        var ref;
        boundMethodCheck(this, NodeCache);
        if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) {
          return this._error("EKEYTYPE", {
            type: typeof key
          });
        }
      }

      _wrap(value, ttl, asClone = true) {
        var livetime, now, oReturn, ttlMultiplicator;
        boundMethodCheck(this, NodeCache);
        if (!this.options.useClones) {
          asClone = false;
        }
        // define the time to live
        now = Date.now();
        livetime = 0;
        ttlMultiplicator = 1000;
        // use given ttl
        if (ttl === 0) {
          livetime = 0;
        } else if (ttl) {
          livetime = now + (ttl * ttlMultiplicator);
        } else {
          // use standard ttl
          if (this.options.stdTTL === 0) {
            livetime = this.options.stdTTL;
          } else {
            livetime = now + (this.options.stdTTL * ttlMultiplicator);
          }
        }
        // return the wrapped value
        return oReturn = {
          t: livetime,
          v: asClone ? clone(value) : value
        };
      }

      // ## _unwrap

      // internal method to extract get the value out of the wrapped value
      _unwrap(value, asClone = true) {
        if (!this.options.useClones) {
          asClone = false;
        }
        if (value.v != null) {
          if (asClone) {
            return clone(value.v);
          } else {
            return value.v;
          }
        }
        return null;
      }

      // ## _getKeyLength

      // internal method the calculate the key length
      _getKeyLength(key) {
        return key.length;
      }

      _getValLength(value) {
        boundMethodCheck(this, NodeCache);
        if (_isString(value)) {
          // if the value is a String get the real length
          return value.length;
        } else if (this.options.forceString) {
          // force string if it's defined and not passed
          return JSON.stringify(value).length;
        } else if (_isArray(value)) {
          // if the data is an Array multiply each element with a defined default length
          return this.options.arrayValueSize * value.length;
        } else if (_isNumber(value)) {
          return 8;
        } else if (typeof (value != null ? value.then : void 0) === "function") {
          // if the data is a Promise, use defined default
          // (can't calculate actual/resolved value size synchronously)
          return this.options.promiseValueSize;
        } else if (_isObject(value)) {
          // if the data is an Object multiply each element with a defined default length
          return this.options.objectValueSize * _size(value);
        } else {
          // default fallback
          return 0;
        }
      }

      _error(type, data = {}, cb) {
        var error;
        boundMethodCheck(this, NodeCache);
        // generate the error object
        error = new Error();
        error.name = type;
        error.errorcode = type;
        error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : "-";
        error.data = data;
        if (cb && _isFunction(cb)) {
          // return the error
          cb(error, null);
        } else {
          // if no callback is defined return the error object
          return error;
        }
      }

      _initErrors() {
        var _errMsg, _errT, ref;
        boundMethodCheck(this, NodeCache);
        this.ERRORS = {};
        ref = this._ERRORS;
        for (_errT in ref) {
          _errMsg = ref[_errT];
          this.ERRORS[_errT] = _template(_errMsg);
        }
      }

    };

    NodeCache.prototype._ERRORS = {
      "ENOTFOUND": "Key `<%= key %>` not found",
      "EKEYTYPE": "The key argument has to be of type `string` or `number`. Found: `<%= type %>`",
      "EKEYSTYPE": "The keys argument has to be an array."
    };

    return NodeCache;

  }).call(this);

}).call(this);