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

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -1,77 +0,0 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
-import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
-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 { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { setCache } from '../dataLoader';
-import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
-/**
- * InMemory storage factory for standalone client-side SplitFactory
- *
- * @param params - parameters required by EventsCacheSync
- */
-export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
-    var storages = {};
-    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
-    var rbSegments = new RBSegmentsCacheInMemory();
-    var segments = new MySegmentsCacheInMemory();
-    var largeSegments = new MySegmentsCacheInMemory();
-    var storage = {
-        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(),
-        destroy: function () { },
-        // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function (matchingKey) {
-            if (!storages[matchingKey]) {
-                var segments_1 = new MySegmentsCacheInMemory();
-                var largeSegments_1 = new MySegmentsCacheInMemory();
-                if (preloadedData) {
-                    setCache(log, preloadedData, { segments: segments_1, largeSegments: largeSegments_1 }, matchingKey);
-                }
-                storages[matchingKey] = {
-                    splits: this.splits,
-                    rbSegments: this.rbSegments,
-                    segments: segments_1,
-                    largeSegments: largeSegments_1,
-                    impressions: this.impressions,
-                    impressionCounts: this.impressionCounts,
-                    events: this.events,
-                    telemetry: this.telemetry,
-                    uniqueKeys: this.uniqueKeys,
-                    destroy: function () { }
-                };
-            }
-            return storages[matchingKey];
-        },
-    };
-    // @TODO revisit storage logic in localhost mode
-    // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
-    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;
-    }
-    var matchingKey = getMatching(params.settings.core.key);
-    storages[matchingKey] = storage;
-    if (preloadedData) {
-        setCache(log, preloadedData, storage, matchingKey);
-        if (splits.getChangeNumber() > -1)
-            onReadyFromCacheCb();
-    }
-    return storage;
-}
-InMemoryStorageCSFactory.type = STORAGE_MEMORY;

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -1,43 +0,0 @@
-import { __extends } from "tslib";
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-/**
- * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
- * Supported by all JS runtimes.
- */
-var MySegmentsCacheInMemory = /** @class */ (function (_super) {
-    __extends(MySegmentsCacheInMemory, _super);
-    function MySegmentsCacheInMemory() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.segmentCache = {};
-        return _this;
-    }
-    MySegmentsCacheInMemory.prototype.addSegment = function (name) {
-        if (this.segmentCache[name])
-            return false;
-        this.segmentCache[name] = true;
-        return true;
-    };
-    MySegmentsCacheInMemory.prototype.removeSegment = function (name) {
-        if (!this.segmentCache[name])
-            return false;
-        delete this.segmentCache[name];
-        return true;
-    };
-    MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
-        return this.segmentCache[name] === true;
-    };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.cn = changeNumber;
-    };
-    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.cn || -1;
-    };
-    MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
-        return Object.keys(this.segmentCache);
-    };
-    MySegmentsCacheInMemory.prototype.getKeysCount = function () {
-        return 1;
-    };
-    return MySegmentsCacheInMemory;
-}(AbstractMySegmentsCacheSync));
-export { MySegmentsCacheInMemory };

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -1,62 +0,0 @@
-import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
-var RBSegmentsCacheInMemory = /** @class */ (function () {
-    function RBSegmentsCacheInMemory() {
-        this.cache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-    }
-    RBSegmentsCacheInMemory.prototype.clear = function () {
-        this.cache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-    };
-    RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        this.changeNumber = changeNumber;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
-    };
-    RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
-        var name = rbSegment.name;
-        var previous = this.get(name);
-        if (previous && usesSegments(previous))
-            this.segmentsCount--;
-        this.cache[name] = rbSegment;
-        if (usesSegments(rbSegment))
-            this.segmentsCount++;
-        return true;
-    };
-    RBSegmentsCacheInMemory.prototype.remove = function (name) {
-        var rbSegment = this.get(name);
-        if (!rbSegment)
-            return false;
-        delete this.cache[name];
-        if (usesSegments(rbSegment))
-            this.segmentsCount--;
-        return true;
-    };
-    RBSegmentsCacheInMemory.prototype.getNames = function () {
-        return Object.keys(this.cache);
-    };
-    RBSegmentsCacheInMemory.prototype.get = function (name) {
-        return this.cache[name] || null;
-    };
-    RBSegmentsCacheInMemory.prototype.getAll = function () {
-        var _this = this;
-        return this.getNames().map(function (key) { return _this.get(key); });
-    };
-    RBSegmentsCacheInMemory.prototype.contains = function (names) {
-        var namesArray = setToArray(names);
-        var namesInStorage = this.getNames();
-        return namesArray.every(function (name) { return namesInStorage.indexOf(name) !== -1; });
-    };
-    RBSegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.changeNumber;
-    };
-    RBSegmentsCacheInMemory.prototype.usesSegments = function () {
-        return this.segmentsCount > 0;
-    };
-    return RBSegmentsCacheInMemory;
-}());
-export { RBSegmentsCacheInMemory };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,58 +0,0 @@
-import { isIntegerNumber } from '../../utils/lang';
-/**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
- */
-var SegmentsCacheInMemory = /** @class */ (function () {
-    function SegmentsCacheInMemory() {
-        this.segmentCache = {};
-        this.segmentChangeNumber = {};
-    }
-    SegmentsCacheInMemory.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
-        var keySet = this.segmentCache[name] || new Set();
-        addedKeys.forEach(function (k) { return keySet.add(k); });
-        removedKeys.forEach(function (k) { return keySet.delete(k); });
-        this.segmentCache[name] = keySet;
-        this.segmentChangeNumber[name] = changeNumber;
-        return addedKeys.length > 0 || removedKeys.length > 0;
-    };
-    SegmentsCacheInMemory.prototype.isInSegment = function (name, key) {
-        var segmentValues = this.segmentCache[name];
-        if (segmentValues) {
-            return segmentValues.has(key);
-        }
-        return false;
-    };
-    SegmentsCacheInMemory.prototype.clear = function () {
-        this.segmentCache = {};
-        this.segmentChangeNumber = {};
-    };
-    SegmentsCacheInMemory.prototype._registerSegment = function (name) {
-        if (!this.segmentCache[name]) {
-            this.segmentCache[name] = new Set();
-        }
-        return true;
-    };
-    SegmentsCacheInMemory.prototype.registerSegments = function (names) {
-        for (var i = 0; i < names.length; i++) {
-            this._registerSegment(names[i]);
-        }
-        return true;
-    };
-    SegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
-        return Object.keys(this.segmentCache);
-    };
-    SegmentsCacheInMemory.prototype.getKeysCount = function () {
-        var _this = this;
-        return Object.keys(this.segmentCache).reduce(function (acum, segmentName) {
-            return acum + _this.segmentCache[segmentName].size;
-        }, 0);
-    };
-    SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
-        var value = this.segmentChangeNumber[name];
-        return isIntegerNumber(value) ? value : undefined;
-    };
-    // No-op. Not used in server-side
-    SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };
-    return SegmentsCacheInMemory;
-}());
-export { SegmentsCacheInMemory };

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,118 +0,0 @@
-import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-import { isFiniteNumber } from '../../utils/lang';
-/**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- */
-var SplitsCacheInMemory = /** @class */ (function (_super) {
-    __extends(SplitsCacheInMemory, _super);
-    function SplitsCacheInMemory(splitFiltersValidation) {
-        var _this = _super.call(this) || this;
-        _this.splitsCache = {};
-        _this.ttCache = {};
-        _this.changeNumber = -1;
-        _this.segmentsCount = 0;
-        _this.flagSetsCache = {};
-        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-        return _this;
-    }
-    SplitsCacheInMemory.prototype.clear = function () {
-        this.splitsCache = {};
-        this.ttCache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-        this.flagSetsCache = {};
-    };
-    SplitsCacheInMemory.prototype.addSplit = function (split) {
-        var name = split.name;
-        var previousSplit = this.getSplit(name);
-        if (previousSplit) { // We had this Split already
-            var previousTtName = previousSplit.trafficTypeName;
-            this.ttCache[previousTtName]--;
-            if (!this.ttCache[previousTtName])
-                delete this.ttCache[previousTtName];
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Subtract from segments count for the previous version of this Split
-            if (usesSegments(previousSplit))
-                this.segmentsCount--;
-        }
-        // Store the Split.
-        this.splitsCache[name] = split;
-        // Update TT cache
-        var ttName = split.trafficTypeName;
-        this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-        this.addToFlagSets(split);
-        // Add to segments count for the new version of the Split
-        if (usesSegments(split))
-            this.segmentsCount++;
-        return true;
-    };
-    SplitsCacheInMemory.prototype.removeSplit = function (name) {
-        var split = this.getSplit(name);
-        if (!split)
-            return false;
-        // Delete the Split
-        delete this.splitsCache[name];
-        var ttName = split.trafficTypeName;
-        this.ttCache[ttName]--; // Update tt cache
-        if (!this.ttCache[ttName])
-            delete this.ttCache[ttName];
-        this.removeFromFlagSets(split.name, split.sets);
-        // Update the segments count.
-        if (usesSegments(split))
-            this.segmentsCount--;
-        return true;
-    };
-    SplitsCacheInMemory.prototype.getSplit = function (name) {
-        return this.splitsCache[name] || null;
-    };
-    SplitsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.changeNumber = changeNumber;
-        return true;
-    };
-    SplitsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.changeNumber;
-    };
-    SplitsCacheInMemory.prototype.getSplitNames = function () {
-        return Object.keys(this.splitsCache);
-    };
-    SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
-        return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
-    };
-    SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
-    };
-    SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new Set(); });
-    };
-    SplitsCacheInMemory.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;
-            if (!_this.flagSetsCache[featureFlagSet])
-                _this.flagSetsCache[featureFlagSet] = new Set([]);
-            _this.flagSetsCache[featureFlagSet].add(featureFlag.name);
-        });
-    };
-    SplitsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInMemory.prototype.removeNames = function (flagSetName, featureFlagName) {
-        if (!this.flagSetsCache[flagSetName])
-            return;
-        this.flagSetsCache[flagSetName].delete(featureFlagName);
-        if (this.flagSetsCache[flagSetName].size === 0)
-            delete this.flagSetsCache[flagSetName];
-    };
-    return SplitsCacheInMemory;
-}(AbstractSplitsCacheSync));
-export { SplitsCacheInMemory };

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,202 +0,0 @@
-import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
-import { findLatencyIndex } from '../findLatencyIndex';
-var MAX_STREAMING_EVENTS = 20;
-var MAX_TAGS = 10;
-export var MAX_LATENCY_BUCKET_COUNT = 23;
-export function newBuckets() {
-    // MAX_LATENCY_BUCKET_COUNT (length) is 23
-    // Not using Array.fill for old browsers compatibility
-    return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-}
-var ACCEPTANCE_RANGE = 0.001;
-/**
- * Record telemetry if mode is not localhost.
- * All factory instances track telemetry on server-side, and 0.1% on client-side.
- */
-export function shouldRecordTelemetry(_a) {
-    var settings = _a.settings;
-    return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
-}
-var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
-        this.splits = splits;
-        this.segments = segments;
-        this.largeSegments = largeSegments;
-        // isEmpty flag
-        this.e = true;
-        this.notReadyUsage = 0;
-        /** Usage stats */
-        this.impressionStats = [0, 0, 0];
-        this.eventStats = [0, 0];
-        this.lastSync = {};
-        this.httpErrors = {};
-        this.httpLatencies = {};
-        this.authRejections = 0;
-        this.tokenRefreshes = 0;
-        this.streamingEvents = [];
-        this.tags = [];
-        this.exceptions = {};
-        this.latencies = {};
-        this.updatesFromSSE = {};
-    }
-    TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
-    TelemetryCacheInMemory.prototype.clear = function () { };
-    TelemetryCacheInMemory.prototype.pop = function () {
-        this.e = true;
-        return {
-            lS: this.getLastSynchronization(),
-            mL: this.popLatencies(),
-            mE: this.popExceptions(),
-            hE: this.popHttpErrors(),
-            hL: this.popHttpLatencies(),
-            tR: this.popTokenRefreshes(),
-            aR: this.popAuthRejections(),
-            iQ: this.getImpressionStats(QUEUED),
-            iDe: this.getImpressionStats(DEDUPED),
-            iDr: this.getImpressionStats(DROPPED),
-            spC: this.splits && this.splits.getSplitNames().length,
-            seC: this.segments && this.segments.getRegisteredSegments().length,
-            skC: this.segments && this.segments.getKeysCount(),
-            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
-            sL: this.getSessionLength(),
-            eQ: this.getEventStats(QUEUED),
-            eD: this.getEventStats(DROPPED),
-            sE: this.popStreamingEvents(),
-            t: this.popTags(),
-            ufs: this.popUpdatesFromSSE(),
-        };
-    };
-    TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
-        return this.timeUntilReady;
-    };
-    TelemetryCacheInMemory.prototype.recordTimeUntilReady = function (ms) {
-        this.timeUntilReady = ms;
-    };
-    TelemetryCacheInMemory.prototype.getTimeUntilReadyFromCache = function () {
-        return this.timeUntilReadyFromCache;
-    };
-    TelemetryCacheInMemory.prototype.recordTimeUntilReadyFromCache = function (ms) {
-        this.timeUntilReadyFromCache = ms;
-    };
-    TelemetryCacheInMemory.prototype.getNonReadyUsage = function () {
-        return this.notReadyUsage;
-    };
-    TelemetryCacheInMemory.prototype.recordNonReadyUsage = function () {
-        this.notReadyUsage++;
-    };
-    TelemetryCacheInMemory.prototype.getImpressionStats = function (type) {
-        return this.impressionStats[type];
-    };
-    TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {
-        this.impressionStats[type] += count;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.getEventStats = function (type) {
-        return this.eventStats[type];
-    };
-    TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {
-        this.eventStats[type] += count;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.getLastSynchronization = function () {
-        return this.lastSync;
-    };
-    TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {
-        this.lastSync[resource] = timeMs;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popHttpErrors = function () {
-        var result = this.httpErrors;
-        this.httpErrors = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {
-        var statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
-        statusErrors[status] = (statusErrors[status] || 0) + 1;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popHttpLatencies = function () {
-        var result = this.httpLatencies;
-        this.httpLatencies = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {
-        var latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
-        latencyBuckets[findLatencyIndex(latencyMs)]++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popAuthRejections = function () {
-        var result = this.authRejections;
-        this.authRejections = 0;
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
-        this.authRejections++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
-        var result = this.tokenRefreshes;
-        this.tokenRefreshes = 0;
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {
-        this.tokenRefreshes++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popStreamingEvents = function () {
-        return this.streamingEvents.splice(0);
-    };
-    TelemetryCacheInMemory.prototype.recordStreamingEvents = function (streamingEvent) {
-        if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
-            this.streamingEvents.push(streamingEvent);
-        }
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popTags = function () {
-        return this.tags.splice(0);
-    };
-    TelemetryCacheInMemory.prototype.addTag = function (tag) {
-        if (this.tags.length < MAX_TAGS) {
-            this.tags.push(tag);
-        }
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.getSessionLength = function () {
-        return this.sessionLength;
-    };
-    TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {
-        this.sessionLength = ms;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popExceptions = function () {
-        var result = this.exceptions;
-        this.exceptions = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordException = function (method) {
-        this.exceptions[method] = (this.exceptions[method] || 0) + 1;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popLatencies = function () {
-        var result = this.latencies;
-        this.latencies = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {
-        var latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
-        latencyBuckets[findLatencyIndex(latencyMs)]++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
-        var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
-        this.e = false;
-    };
-    return TelemetryCacheInMemory;
-}());
-export { TelemetryCacheInMemory };

package/esm/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -1,68 +0,0 @@
-import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
-import { setToArray } from '../../utils/lang/sets';
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export function fromUniqueKeysCollector(uniqueKeys) {
-    var payload = [];
-    var featureNames = Object.keys(uniqueKeys);
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var userKeys = setToArray(uniqueKeys[featureName]);
-        var uniqueKeysPayload = {
-            f: featureName,
-            ks: userKeys
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-var UniqueKeysCacheInMemory = /** @class */ (function () {
-    function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
-        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
-        this.uniqueTrackerSize = 0;
-        this.uniqueKeysTracker = {};
-        this.maxStorage = uniqueKeysQueueSize;
-    }
-    UniqueKeysCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
-        this.onFullQueue = cb;
-    };
-    /**
-     * Store unique keys per feature.
-     */
-    UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
-        if (!this.uniqueKeysTracker[featureName])
-            this.uniqueKeysTracker[featureName] = new Set();
-        var tracker = this.uniqueKeysTracker[featureName];
-        if (!tracker.has(userKey)) {
-            tracker.add(userKey);
-            this.uniqueTrackerSize++;
-        }
-        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
-            this.onFullQueue();
-        }
-    };
-    /**
-     * Clear the data stored on the cache.
-     */
-    UniqueKeysCacheInMemory.prototype.clear = function () {
-        this.uniqueTrackerSize = 0;
-        this.uniqueKeysTracker = {};
-    };
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    UniqueKeysCacheInMemory.prototype.pop = function () {
-        var data = this.uniqueKeysTracker;
-        this.clear();
-        return fromUniqueKeysCollector(data);
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
-        return Object.keys(this.uniqueKeysTracker).length === 0;
-    };
-    return UniqueKeysCacheInMemory;
-}());
-export { UniqueKeysCacheInMemory };