@splitsoftware/splitio-commons 3.1.1-rc.10 → 3.1.1-rc.12

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -1,200 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitChangesUpdaterFactory = exports.computeMutation = exports.parseSegments = void 0;
-var timeout_1 = require("../../../utils/promise/timeout");
-var constants_1 = require("../../../readiness/constants");
-var constants_2 = require("../../../logger/constants");
-var lang_1 = require("../../../utils/lang");
-var constants_3 = require("../../../utils/constants");
-var sets_1 = require("../../../utils/lang/sets");
-var constants_4 = require("../../streaming/constants");
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments) {
-    var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-    return registeredSegments.then(function (segmentNames) {
-        return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
-    });
-}
-/**
- * Collect segments from a raw FF or RBS definition.
- * Exported for testing purposes.
- */
-function parseSegments(ruleEntity, matcherType) {
-    if (matcherType === void 0) { matcherType = constants_3.IN_SEGMENT; }
-    var _a = ruleEntity, conditions = _a.conditions, excluded = _a.excluded;
-    var segments = new Set();
-    if (excluded && excluded.segments) {
-        excluded.segments.forEach(function (_a) {
-            var type = _a.type, name = _a.name;
-            if ((type === constants_3.STANDARD_SEGMENT && matcherType === constants_3.IN_SEGMENT) || (type === constants_3.RULE_BASED_SEGMENT && matcherType === constants_3.IN_RULE_BASED_SEGMENT)) {
-                segments.add(name);
-            }
-        });
-    }
-    if (conditions) {
-        for (var i = 0; i < conditions.length; i++) {
-            var matchers = conditions[i].matcherGroup.matchers;
-            matchers.forEach(function (matcher) {
-                if (matcher.matcherType === matcherType)
-                    segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-            });
-        }
-    }
-    return segments;
-}
-exports.parseSegments = parseSegments;
-/**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
- *
- * @param featureFlag - feature flag to be evaluated
- * @param filters - splitFiltersValidation bySet | byName
- */
-function matchFilters(featureFlag, filters) {
-    var _a = filters.groupedFilters, setsFilter = _a.bySet, namesFilter = _a.byName, prefixFilter = _a.byPrefix;
-    if (setsFilter.length > 0)
-        return featureFlag.sets && featureFlag.sets.some(function (featureFlagSet) { return setsFilter.indexOf(featureFlagSet) > -1; });
-    var namesFilterConfigured = namesFilter.length > 0;
-    var prefixFilterConfigured = prefixFilter.length > 0;
-    if (!namesFilterConfigured && !prefixFilterConfigured)
-        return true;
-    var matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-    var matchPrefix = prefixFilterConfigured && prefixFilter.some(function (prefix) { return (0, lang_1.startsWith)(featureFlag.name, prefix); });
-    return matchNames || matchPrefix;
-}
-/**
- * Given the list of splits from /splitChanges endpoint, it returns the mutations,
- * i.e., an object with added splits, removed splits and used segments.
- * Exported for testing purposes.
- */
-function computeMutation(rules, segments, filters) {
-    return rules.reduce(function (accum, ruleEntity) {
-        if (ruleEntity.status !== 'ARCHIVED' && (!filters || matchFilters(ruleEntity, filters))) {
-            accum.added.push(ruleEntity);
-            parseSegments(ruleEntity).forEach(function (segmentName) {
-                segments.add(segmentName);
-            });
-        }
-        else {
-            accum.removed.push(ruleEntity);
-        }
-        accum.names.push(ruleEntity.name);
-        return accum;
-    }, { added: [], removed: [], names: [] });
-}
-exports.computeMutation = computeMutation;
-/**
- * factory of SplitChanges updater, a task that:
- *  - fetches split changes using `splitChangesFetcher`
- *  - updates `splitsCache`
- *  - uses `splitsEventEmitter` to emit events related to split data updates
- *
- * @param log -  Logger instance
- * @param splitChangesFetcher -  Fetcher of `/splitChanges`
- * @param splits -  Splits storage, with sync or async methods
- * @param segments -  Segments storage, with sync or async methods
- * @param splitsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
- * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
- * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
- */
-function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
-    if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
-    if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments;
-    var startingUp = true;
-    /** timeout decorator for `splitChangesFetcher` promise  */
-    function _promiseDecorator(promise) {
-        if (startingUp && requestTimeoutBeforeReady)
-            promise = (0, timeout_1.timeout)(requestTimeoutBeforeReady, promise);
-        return promise;
-    }
-    /**
-     * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
-     * Returned promise will not be rejected.
-     *
-     * @param noCache - true to revalidate data to fetch
-     * @param till - query param to bypass CDN requests
-     */
-    return function splitChangesUpdater(noCache, till, instantUpdate) {
-        /**
-         * @param since - current changeNumber at splitsCache
-         * @param retry - current number of retry attempts
-         */
-        function _splitChangesUpdater(sinces, retry) {
-            if (retry === void 0) { retry = 0; }
-            var since = sinces[0], rbSince = sinces[1];
-            log.debug(constants_2.SYNC_SPLITS_FETCH, sinces);
-            return Promise.resolve(instantUpdate ?
-                instantUpdate.type === constants_4.SPLIT_UPDATE ?
-                    // IFFU edge case: a change to a flag that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
-                    Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, constants_3.IN_RULE_BASED_SEGMENT))).then(function (contains) {
-                        return contains ?
-                            { ff: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
-                            splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
-                    }) :
-                    { rbs: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
-                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
-                .then(function (splitChanges) {
-                var usedSegments = new Set();
-                var updatedFlags = [];
-                var ffUpdate = false;
-                if (splitChanges.ff) {
-                    var _a = computeMutation(splitChanges.ff.d || [], usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
-                    updatedFlags = names;
-                    log.debug(constants_2.SYNC_SPLITS_UPDATE, [added.length, removed.length]);
-                    ffUpdate = splits.update(added, removed, splitChanges.ff.t);
-                }
-                var rbsUpdate = false;
-                if (splitChanges.rbs) {
-                    var _b = computeMutation(splitChanges.rbs.d || [], usedSegments), added = _b.added, removed = _b.removed;
-                    log.debug(constants_2.SYNC_RBS_UPDATE, [added.length, removed.length]);
-                    rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
-                }
-                return Promise.all([ffUpdate, rbsUpdate,
-                    // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
-                    segments.registerSegments((0, sets_1.setToArray)(usedSegments))
-                ]).then(function (_a) {
-                    var ffChanged = _a[0], rbsChanged = _a[1];
-                    if (storage.save)
-                        storage.save();
-                    startingUp = false;
-                    if (splitsEventEmitter) {
-                        // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
-                            .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                            .then(function (emitSplitsArrivedEvent) {
-                            // emit SDK events
-                            if (emitSplitsArrivedEvent) {
-                                var metadata = {
-                                    type: updatedFlags.length > 0 ? constants_1.FLAGS_UPDATE : constants_1.SEGMENTS_UPDATE,
-                                    names: updatedFlags.length > 0 ? updatedFlags : []
-                                };
-                                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, metadata);
-                            }
-                            return true;
-                        });
-                    }
-                    return true;
-                });
-            })
-                .catch(function (error) {
-                if (startingUp && retriesOnFailureBeforeReady > retry) {
-                    retry += 1;
-                    log.warn(constants_2.SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-                    return _splitChangesUpdater(sinces, retry);
-                }
-                else {
-                    startingUp = false;
-                    log.warn(constants_2.SYNC_SPLITS_FETCH_FAILS, [error]);
-                }
-                return false;
-            });
-        }
-        // `getChangeNumber` never rejects or throws error
-        return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
-    };
-}
-exports.splitChangesUpdaterFactory = splitChangesUpdaterFactory;

package/cjs/sync/streaming/AuthClient/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils/inputValidation/splits.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplits = void 0;
-var constants_1 = require("../../logger/constants");
-var lang_1 = require("../lang");
-var split_1 = require("./split");
-function validateSplits(log, maybeSplits, method, listName, item) {
-    if (listName === void 0) { listName = 'feature flag names'; }
-    if (item === void 0) { item = 'feature flag name'; }
-    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-        var validatedArray_1 = [];
-        // Remove invalid values
-        maybeSplits.forEach(function (maybeSplit) {
-            var splitName = (0, split_1.validateSplit)(log, maybeSplit, method, item);
-            if (splitName)
-                validatedArray_1.push(splitName);
-        });
-        // Strip off duplicated values if we have valid split names then return
-        if (validatedArray_1.length)
-            return (0, lang_1.uniq)(validatedArray_1);
-    }
-    log.error(constants_1.ERROR_EMPTY_ARRAY, [method, listName]);
-    return false;
-}
-exports.validateSplits = validateSplits;

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -1,48 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheAsync = /** @class */ (function () {
-    function AbstractSplitsCacheAsync() {
-    }
-    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
-            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
-        return Promise.resolve(true);
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     * The promise will never be rejected.
-     */
-    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-                var newSplit = objectAssign({}, split);
-                newSplit.killed = true;
-                newSplit.defaultTreatment = defaultTreatment;
-                newSplit.changeNumber = changeNumber;
-                return _this.addSplit(newSplit);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractSplitsCacheAsync;
-}());
-export { AbstractSplitsCacheAsync };

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,71 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheSync = /** @class */ (function () {
-    function AbstractSplitsCacheSync() {
-    }
-    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
-        this.setChangeNumber(changeNumber);
-        return updated;
-    };
-    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
-        var _this = this;
-        var splits = {};
-        names.forEach(function (name) {
-            splits[name] = _this.getSplit(name);
-        });
-        return splits;
-    };
-    AbstractSplitsCacheSync.prototype.getAll = function () {
-        var _this = this;
-        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     */
-    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var split = this.getSplit(name);
-        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-            var newSplit = objectAssign({}, split);
-            newSplit.killed = true;
-            newSplit.defaultTreatment = defaultTreatment;
-            newSplit.changeNumber = changeNumber;
-            return this.addSplit(newSplit);
-        }
-        return false;
-    };
-    return AbstractSplitsCacheSync;
-}());
-export { AbstractSplitsCacheSync };
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-export function usesSegments(ruleEntity) {
-    var conditions = ruleEntity.conditions || [];
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
-                return true;
-        }
-    }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
-    return false;
-}
-export function usesSegmentsSync(storage) {
-    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -1,191 +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';
-var SplitsCacheInLocal = /** @class */ (function (_super) {
-    __extends(SplitsCacheInLocal, _super);
-    function SplitsCacheInLocal(settings, keys, storage) {
-        var _this = _super.call(this) || this;
-        _this.keys = keys;
-        _this.log = settings.log;
-        _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-        _this.storage = storage;
-        return _this;
-    }
-    SplitsCacheInLocal.prototype._decrementCount = function (key) {
-        var count = toNumber(this.storage.getItem(key)) - 1;
-        if (count > 0)
-            this.storage.setItem(key, count + '');
-        else
-            this.storage.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);
-            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
-            if (usesSegments(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.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 () {
-        var _this = this;
-        // collect item keys
-        var len = this.storage.length;
-        var accum = [];
-        for (var cur = 0; cur < len; cur++) {
-            var key = this.storage.key(cur);
-            if (key != null && this.keys.isSplitsCacheKey(key))
-                accum.push(key);
-        }
-        // remove items
-        accum.forEach(function (key) {
-            _this.storage.removeItem(key);
-        });
-        this.hasSync = false;
-    };
-    SplitsCacheInLocal.prototype.addSplit = function (split) {
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        var splitFromStorage = this.storage.getItem(splitKey);
-        var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
-        if (previousSplit) {
-            this._decrementCounts(previousSplit);
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-        }
-        this.storage.setItem(splitKey, JSON.stringify(split));
-        this._incrementCounts(split);
-        this.addToFlagSets(split);
-        return true;
-    };
-    SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        var split = this.getSplit(name);
-        if (!split)
-            return false;
-        this.storage.removeItem(this.keys.buildSplitKey(name));
-        this._decrementCounts(split);
-        this.removeFromFlagSets(split.name, split.sets);
-        return true;
-    };
-    SplitsCacheInLocal.prototype.getSplit = function (name) {
-        var item = this.storage.getItem(this.keys.buildSplitKey(name));
-        return item && JSON.parse(item);
-    };
-    SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
-            // update "last updated" timestamp with current time
-            this.storage.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 = this.storage.getItem(this.keys.buildSplitsTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return isNaNNumber(value) ? n : value;
-        }
-        return n;
-    };
-    SplitsCacheInLocal.prototype.getSplitNames = function () {
-        var len = this.storage.length;
-        var accum = [];
-        var cur = 0;
-        while (cur < len) {
-            var key = this.storage.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(this.storage.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 = this.storage.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 flagSetFromStorage = _this.storage.getItem(flagSetKey);
-            return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-        });
-    };
-    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 flagSetFromStorage = _this.storage.getItem(flagSetKey);
-            var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-            if (flagSetCache.has(featureFlag.name))
-                return;
-            flagSetCache.add(featureFlag.name);
-            _this.storage.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 flagSetFromStorage = this.storage.getItem(flagSetKey);
-        if (!flagSetFromStorage)
-            return;
-        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            this.storage.removeItem(flagSetKey);
-            return;
-        }
-        this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    };
-    return SplitsCacheInLocal;
-}(AbstractSplitsCacheSync));
-export { SplitsCacheInLocal };

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 };