@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -1,205 +0,0 @@
-import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-import { setToArray } from '../../utils/lang/sets';
-/**
- * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
- */
-var SplitsCacheInLocal = /** @class */ (function (_super) {
-    __extends(SplitsCacheInLocal, _super);
-    function SplitsCacheInLocal(settings, keys) {
-        var _this = _super.call(this) || this;
-        _this.keys = keys;
-        _this.log = settings.log;
-        _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-        return _this;
-    }
-    SplitsCacheInLocal.prototype._decrementCount = function (key) {
-        var count = toNumber(localStorage.getItem(key)) - 1;
-        // @ts-expect-error
-        if (count > 0)
-            localStorage.setItem(key, count);
-        else
-            localStorage.removeItem(key);
-    };
-    SplitsCacheInLocal.prototype._decrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this._decrementCount(ttKey);
-            if (usesSegments(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this._decrementCount(segmentsCountKey);
-            }
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
-    };
-    SplitsCacheInLocal.prototype._incrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            // @ts-expect-error
-            localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-            if (usesSegments(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                // @ts-expect-error
-                localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-            }
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
-    };
-    /**
-     * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
-     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
-     */
-    SplitsCacheInLocal.prototype.clear = function () {
-        // collect item keys
-        var len = localStorage.length;
-        var accum = [];
-        for (var cur = 0; cur < len; cur++) {
-            var key = localStorage.key(cur);
-            if (key != null && this.keys.isSplitsCacheKey(key))
-                accum.push(key);
-        }
-        // remove items
-        accum.forEach(function (key) {
-            localStorage.removeItem(key);
-        });
-        this.hasSync = false;
-    };
-    SplitsCacheInLocal.prototype.addSplit = function (split) {
-        try {
-            var name_1 = split.name;
-            var splitKey = this.keys.buildSplitKey(name_1);
-            var splitFromLocalStorage = localStorage.getItem(splitKey);
-            var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-            if (previousSplit) {
-                this._decrementCounts(previousSplit);
-                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            }
-            localStorage.setItem(splitKey, JSON.stringify(split));
-            this._incrementCounts(split);
-            this.addToFlagSets(split);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        try {
-            var split = this.getSplit(name);
-            if (!split)
-                return false;
-            localStorage.removeItem(this.keys.buildSplitKey(name));
-            this._decrementCounts(split);
-            this.removeFromFlagSets(split.name, split.sets);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    SplitsCacheInLocal.prototype.getSplit = function (name) {
-        var item = localStorage.getItem(this.keys.buildSplitKey(name));
-        return item && JSON.parse(item);
-    };
-    SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
-            // update "last updated" timestamp with current time
-            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-            this.hasSync = true;
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    SplitsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = localStorage.getItem(this.keys.buildSplitsTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return isNaNNumber(value) ? n : value;
-        }
-        return n;
-    };
-    SplitsCacheInLocal.prototype.getSplitNames = function () {
-        var len = localStorage.length;
-        var accum = [];
-        var cur = 0;
-        while (cur < len) {
-            var key = localStorage.key(cur);
-            if (key != null && this.keys.isSplitKey(key))
-                accum.push(this.keys.extractKey(key));
-            cur++;
-        }
-        return accum;
-    };
-    SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
-        var ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
-        return isFiniteNumber(ttCount) && ttCount > 0;
-    };
-    SplitsCacheInLocal.prototype.usesSegments = function () {
-        // If cache hasn't been synchronized with the cloud, assume we need them.
-        if (!this.hasSync)
-            return true;
-        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        return isFiniteNumber(splitsWithSegmentsCount) ?
-            splitsWithSegmentsCount > 0 :
-            true;
-    };
-    SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        return flagSets.map(function (flagSet) {
-            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-        });
-    };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            var flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-            flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-        });
-    };
-    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
-        var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-        if (!flagSetFromLocalStorage)
-            return;
-        var flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            localStorage.removeItem(flagSetKey);
-            return;
-        }
-        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    };
-    return SplitsCacheInLocal;
-}(AbstractSplitsCacheSync));
-export { SplitsCacheInLocal };

package/esm/storages/inLocalStorage/constants.js

@@ -1,2 +0,0 @@
-export var LOG_PREFIX = 'storage:localstorage: ';
-export var DEFINED = '1';

package/esm/storages/inLocalStorage/index.js

@@ -1,69 +0,0 @@
-import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
-import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
-import { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
-import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
-import { LOG_PREFIX } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
-/**
- * InLocal storage factory for standalone client-side SplitFactory
- */
-export function InLocalStorage(options) {
-    if (options === void 0) { options = {}; }
-    var prefix = validatePrefix(options.prefix);
-    function InLocalStorageCSFactory(params) {
-        // Fallback to InMemoryStorage if LocalStorage API is not available
-        if (!isLocalStorageAvailable()) {
-            params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
-            return InMemoryStorageCSFactory(params);
-        }
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
-        var matchingKey = getMatching(settings.core.key);
-        var keys = new KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal(settings, keys);
-        var rbSegments = new RBSegmentsCacheInLocal(settings, keys);
-        var segments = new MySegmentsCacheInLocal(log, keys);
-        var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
-        return {
-            splits: splits,
-            rbSegments: rbSegments,
-            segments: segments,
-            largeSegments: largeSegments,
-            impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-            impressionCounts: new ImpressionCountsCacheInMemory(),
-            events: new EventsCacheInMemory(eventsQueueSize),
-            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-            uniqueKeys: new UniqueKeysCacheInMemoryCS(),
-            validateCache: function () {
-                return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
-            },
-            destroy: function () { },
-            // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
-            shared: function (matchingKey) {
-                return {
-                    splits: this.splits,
-                    rbSegments: this.rbSegments,
-                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
-                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
-                    impressions: this.impressions,
-                    impressionCounts: this.impressionCounts,
-                    events: this.events,
-                    telemetry: this.telemetry,
-                    uniqueKeys: this.uniqueKeys,
-                    destroy: function () { }
-                };
-            },
-        };
-    }
-    InLocalStorageCSFactory.type = STORAGE_LOCALSTORAGE;
-    return InLocalStorageCSFactory;
-}

package/esm/storages/inLocalStorage/validateCache.js

@@ -1,76 +0,0 @@
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { getStorageHash } from '../KeyBuilder';
-import { LOG_PREFIX } from './constants';
-var DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
-var MILLIS_IN_A_DAY = 86400000;
-/**
- * Validates if cache should be cleared and sets the cache `hash` if needed.
- *
- * @returns `true` if cache should be cleared, `false` otherwise
- */
-function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
-    var log = settings.log;
-    // Check expiration
-    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
-    if (!isNaNNumber(lastUpdatedTimestamp)) {
-        var cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
-        var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
-        if (lastUpdatedTimestamp < expirationTimestamp) {
-            log.info(LOG_PREFIX + 'Cache expired more than ' + cacheExpirationInDays + ' days ago. Cleaning up cache');
-            return true;
-        }
-    }
-    // Check hash
-    var storageHashKey = keys.buildHashKey();
-    var storageHash = localStorage.getItem(storageHashKey);
-    var currentStorageHash = getStorageHash(settings);
-    if (storageHash !== currentStorageHash) {
-        try {
-            localStorage.setItem(storageHashKey, currentStorageHash);
-        }
-        catch (e) {
-            log.error(LOG_PREFIX + e);
-        }
-        if (isThereCache) {
-            log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
-            return true;
-        }
-        return false; // No cache to clear
-    }
-    // Clear on init
-    if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
-        if (isNaNNumber(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
-            log.info(LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
-            return true;
-        }
-    }
-}
-/**
- * Clean cache if:
- * - it has expired, i.e., its `lastUpdated` timestamp is older than the given `expirationTimestamp`
- * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
- * - `clearOnInit` was set and cache was not cleared in the last 24 hours
- *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
- */
-export function validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments) {
-    var currentTimestamp = Date.now();
-    var isThereCache = splits.getChangeNumber() > -1;
-    if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
-        splits.clear();
-        rbSegments.clear();
-        segments.clear();
-        largeSegments.clear();
-        // Update last clear timestamp
-        try {
-            localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
-        }
-        catch (e) {
-            settings.log.error(LOG_PREFIX + e);
-        }
-        return false;
-    }
-    // Check if ready from cache
-    return isThereCache;
-}

package/esm/storages/inMemory/AttributesCacheInMemory.js

@@ -1,67 +0,0 @@
-import { objectAssign } from '../../utils/lang/objectAssign';
-var AttributesCacheInMemory = /** @class */ (function () {
-    function AttributesCacheInMemory() {
-        this.attributesCache = {};
-    }
-    /**
-     * Create or update the value for the given attribute
-     *
-     * @param attributeName - attribute name
-     * @param attributeValue - attribute value
-     * @returns the attribute was stored
-     */
-    AttributesCacheInMemory.prototype.setAttribute = function (attributeName, attributeValue) {
-        this.attributesCache[attributeName] = attributeValue;
-        return true;
-    };
-    /**
-     * Retrieves the value of a given attribute
-     *
-     * @param attributeName - attribute name
-     * @returns stored attribute value
-     */
-    AttributesCacheInMemory.prototype.getAttribute = function (attributeName) {
-        return this.attributesCache[attributeName];
-    };
-    /**
-     * Create or update all the given attributes
-     *
-     * @param attributes - attributes to create or update
-     * @returns attributes were stored
-     */
-    AttributesCacheInMemory.prototype.setAttributes = function (attributes) {
-        this.attributesCache = objectAssign(this.attributesCache, attributes);
-        return true;
-    };
-    /**
-     * Retrieve the full attributes map
-     *
-     * @returns stored attributes
-     */
-    AttributesCacheInMemory.prototype.getAll = function () {
-        return this.attributesCache;
-    };
-    /**
-     * Removes a given attribute from the map
-     *
-     * @param attributeName - attribute to remove
-     * @returns attribute removed
-     */
-    AttributesCacheInMemory.prototype.removeAttribute = function (attributeName) {
-        if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
-            delete this.attributesCache[attributeName];
-            return true;
-        }
-        return false;
-    };
-    /**
-     * Clears all attributes stored in the SDK
-     *
-     */
-    AttributesCacheInMemory.prototype.clear = function () {
-        this.attributesCache = {};
-        return true;
-    };
-    return AttributesCacheInMemory;
-}());
-export { AttributesCacheInMemory };

package/esm/storages/inMemory/EventsCacheInMemory.js

@@ -1,60 +0,0 @@
-var MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
-var EventsCacheInMemory = /** @class */ (function () {
-    /**
-     *
-     * @param eventsQueueSize - number of queued events to call onFullQueueCb.
-     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
-     */
-    function EventsCacheInMemory(eventsQueueSize) {
-        if (eventsQueueSize === void 0) { eventsQueueSize = 0; }
-        this.maxQueue = eventsQueueSize;
-        this.queue = [];
-        this.queueByteSize = 0;
-    }
-    EventsCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
-        this.onFullQueue = cb;
-    };
-    /**
-     * Add a new event object at the end of the queue.
-     */
-    EventsCacheInMemory.prototype.track = function (data, size) {
-        if (size === void 0) { size = 0; }
-        this.queueByteSize += size;
-        this.queue.push(data);
-        this._checkForFlush();
-        return true;
-    };
-    /**
-     * Clear the data stored on the cache.
-     */
-    EventsCacheInMemory.prototype.clear = function () {
-        this.queue = [];
-        this.queueByteSize = 0;
-    };
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    EventsCacheInMemory.prototype.pop = function (toMerge) {
-        var data = this.queue;
-        this.clear();
-        return toMerge ? toMerge.concat(data) : data;
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    EventsCacheInMemory.prototype.isEmpty = function () {
-        return this.queue.length === 0;
-    };
-    /**
-     * Check if the cache queue is full and we need to flush it.
-     */
-    EventsCacheInMemory.prototype._checkForFlush = function () {
-        if ((this.queueByteSize > MAX_QUEUE_BYTE_SIZE) ||
-            // 0 means no maximum value, in case we want to avoid this being triggered. Size limit is not affected by it.
-            (this.maxQueue > 0 && this.queue.length >= this.maxQueue)) {
-            this.onFullQueue && this.onFullQueue();
-        }
-    };
-    return EventsCacheInMemory;
-}());
-export { EventsCacheInMemory };

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -1,62 +0,0 @@
-import { truncateTimeFrame } from '../../utils/time';
-import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
-var ImpressionCountsCacheInMemory = /** @class */ (function () {
-    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {
-        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = DEFAULT_CACHE_SIZE; }
-        this.cache = {};
-        this.cacheSize = 0;
-        this.maxStorage = impressionCountsCacheSize;
-    }
-    /**
-    * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
-    */
-    ImpressionCountsCacheInMemory.prototype._makeKey = function (featureName, timeFrame) {
-        return featureName + "::" + truncateTimeFrame(timeFrame);
-    };
-    /**
-    * Increments the quantity of impressions with the passed featureName and timeFrame.
-    */
-    ImpressionCountsCacheInMemory.prototype.track = function (featureName, timeFrame, amount) {
-        var key = this._makeKey(featureName, timeFrame);
-        var currentAmount = this.cache[key];
-        this.cache[key] = currentAmount ? currentAmount + amount : amount;
-        if (this.onFullQueue) {
-            this.cacheSize = this.cacheSize + amount;
-            if (this.cacheSize >= this.maxStorage) {
-                this.onFullQueue();
-            }
-        }
-    };
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    ImpressionCountsCacheInMemory.prototype.pop = function (toMerge) {
-        var data = this.cache;
-        this.clear();
-        if (toMerge) {
-            Object.keys(data).forEach(function (key) {
-                if (toMerge[key])
-                    toMerge[key] += data[key];
-                else
-                    toMerge[key] = data[key];
-            });
-            return toMerge;
-        }
-        return data;
-    };
-    /**
-     * Clear the data stored on the cache.
-     */
-    ImpressionCountsCacheInMemory.prototype.clear = function () {
-        this.cache = {};
-        this.cacheSize = 0;
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    ImpressionCountsCacheInMemory.prototype.isEmpty = function () {
-        return Object.keys(this.cache).length === 0;
-    };
-    return ImpressionCountsCacheInMemory;
-}());
-export { ImpressionCountsCacheInMemory };

package/esm/storages/inMemory/ImpressionsCacheInMemory.js

@@ -1,48 +0,0 @@
-var ImpressionsCacheInMemory = /** @class */ (function () {
-    /**
-     *
-     * @param impressionsQueueSize - number of queued impressions to call onFullQueueCb.
-     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
-     */
-    function ImpressionsCacheInMemory(impressionsQueueSize) {
-        if (impressionsQueueSize === void 0) { impressionsQueueSize = 0; }
-        this.maxQueue = impressionsQueueSize;
-        this.queue = [];
-    }
-    ImpressionsCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
-        this.onFullQueue = cb;
-    };
-    /**
-     * Store impressions in sequential order
-     */
-    ImpressionsCacheInMemory.prototype.track = function (data) {
-        var _a;
-        (_a = this.queue).push.apply(_a, data);
-        // Check if the cache queue is full and we need to flush it.
-        if (this.maxQueue > 0 && this.queue.length >= this.maxQueue && this.onFullQueue) {
-            this.onFullQueue();
-        }
-    };
-    /**
-     * Clear the data stored on the cache.
-     */
-    ImpressionsCacheInMemory.prototype.clear = function () {
-        this.queue = [];
-    };
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    ImpressionsCacheInMemory.prototype.pop = function (toMerge) {
-        var data = this.queue;
-        this.clear();
-        return toMerge ? toMerge.concat(data) : data;
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    ImpressionsCacheInMemory.prototype.isEmpty = function () {
-        return this.queue.length === 0;
-    };
-    return ImpressionsCacheInMemory;
-}());
-export { ImpressionsCacheInMemory };

package/esm/storages/inMemory/InMemoryStorage.js

@@ -1,42 +0,0 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
-import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
-import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
-import { EventsCacheInMemory } from './EventsCacheInMemory';
-import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
-import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
-/**
- * InMemory storage factory for standalone server-side SplitFactory
- *
- * @param params - parameters required by EventsCacheSync
- */
-export function InMemoryStorageFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
-    var rbSegments = new RBSegmentsCacheInMemory();
-    var segments = new SegmentsCacheInMemory();
-    var storage = {
-        splits: splits,
-        rbSegments: rbSegments,
-        segments: segments,
-        impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-        impressionCounts: new ImpressionCountsCacheInMemory(),
-        events: new EventsCacheInMemory(eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-        uniqueKeys: new UniqueKeysCacheInMemory(),
-        destroy: function () { }
-    };
-    // @TODO revisit storage logic in localhost mode
-    // No tracking data in localhost mode to avoid memory leaks
-    if (params.settings.mode === LOCALHOST_MODE) {
-        var noopTrack = function () { return true; };
-        storage.impressions.track = noopTrack;
-        storage.events.track = noopTrack;
-        storage.impressionCounts.track = noopTrack;
-        storage.uniqueKeys.track = noopTrack;
-    }
-    return storage;
-}
-InMemoryStorageFactory.type = STORAGE_MEMORY;