angular-caching/bundles/angular-caching-inmemory-cache.umd.js

Lightweight library for data caching

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('rxjs/operators')) :
    typeof define === 'function' && define.amd ? define('angular-caching/inmemory-cache', ['exports', 'rxjs', 'rxjs/operators'], factory) :
    (global = global || self, factory((global['angular-caching'] = global['angular-caching'] || {}, global['angular-caching']['inmemory-cache'] = {}), global.rxjs, global.rxjs.operators));
}(this, (function (exports, rxjs, operators) { 'use strict';

    function InMemoryCache(params) {
        if (params === void 0) { params = {}; }
        var originalFunc;
        var cacheSize = params.cacheSize || 1;
        var chacheTTL = params.ttl;
        var cacheMap = new Map();
        var timersMap = new Map();
        return function (target, propertyKey, descriptor) {
            originalFunc = descriptor.value;
            descriptor.value = function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                if (!args.length && cacheSize > 1) {
                    throw new Error("If you don't provide arguments, cache size could not be bigger then 1");
                }
                var id = JSON.stringify(args);
                var currentCacheSize = cacheMap.size;
                var data = cacheMap.get(id);
                if (!data) {
                    data = originalFunc.apply(this, args);
                    if (data instanceof rxjs.Observable) {
                        data = data.pipe(operators.publishReplay(1), operators.refCount(), operators.take(1));
                    }
                    if (currentCacheSize >= cacheSize) {
                        if (timersMap.has(cacheMap.keys()[0])) {
                            clearTimeout(timersMap.get(cacheMap.keys()[0]));
                            timersMap.delete(cacheMap.keys()[0]);
                        }
                        cacheMap.delete(cacheMap.keys()[0]);
                    }
                    if (params.sync) {
                        cacheMap.set(id, data);
                    }
                    else {
                        Promise.resolve().then(function () {
                            cacheMap.set(id, data);
                        });
                    }
                    if (chacheTTL || chacheTTL === 0) {
                        var timerId = setTimeout(function () {
                            cacheMap.delete(id);
                            timersMap.delete(id);
                        }, chacheTTL);
                        timersMap.set(id, timerId);
                    }
                }
                return data;
            };
        };
    }

    exports.InMemoryCache = InMemoryCache;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=angular-caching-inmemory-cache.umd.js.map