@splitsoftware/splitio-commons 2.2.1-rc.0 → 2.2.1-rc.2

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,16 +1,12 @@
-import { IRBSegment, ISplit } from '../../../dtos/types';
-import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
+import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
-import { IRBSegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { ISplitsCacheSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { InstantUpdate } from '../../polling/updaters/splitChangesUpdater';
-import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 import { IUpdateWorker } from './types';
@@ -18,128 +14,102 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
-  const ff = SplitsUpdateWorker(storage.splits);
-  const rbs = SplitsUpdateWorker(storage.rbSegments);
+  let maxChangeNumber = 0;
+  let handleNewEvent = false;
+  let isHandlingEvent: boolean;
+  let cdnBypass: boolean;
+  let payload: ISplit | undefined;
+  const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
-  function SplitsUpdateWorker(cache: ISplitsCacheSync | IRBSegmentsCacheSync) {
-    let maxChangeNumber = -1;
-    let handleNewEvent = false;
-    let isHandlingEvent: boolean;
-    let cdnBypass: boolean;
-    let instantUpdate: InstantUpdate | undefined;
-    const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+  function __handleSplitUpdateCall() {
+    isHandlingEvent = true;
+    if (maxChangeNumber > splitsCache.getChangeNumber()) {
+      handleNewEvent = false;
+      const splitUpdateNotification = payload ? { payload, changeNumber: maxChangeNumber } : undefined;
+      // fetch splits revalidating data if cached
+      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification).then(() => {
+        if (!isHandlingEvent) return; // halt if `stop` has been called
+        if (handleNewEvent) {
+          __handleSplitUpdateCall();
+        } else {
+          if (splitUpdateNotification) telemetryTracker.trackUpdatesFromSSE(SPLITS);
+          // fetch new registered segments for server-side API. Not retrying on error
+          if (segmentsSyncTask) segmentsSyncTask.execute(true);
 
-    function __handleSplitUpdateCall() {
-      isHandlingEvent = true;
-      if (maxChangeNumber > cache.getChangeNumber()) {
-        handleNewEvent = false;
-        // fetch splits revalidating data if cached
-        splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
-          if (!isHandlingEvent) return; // halt if `stop` has been called
-          if (handleNewEvent) {
-            __handleSplitUpdateCall();
-          } else {
-            if (instantUpdate) telemetryTracker.trackUpdatesFromSSE(SPLITS);
-            // fetch new registered segments for server-side API. Not retrying on error
-            if (segmentsSyncTask) segmentsSyncTask.execute(true);
-
-            const attempts = backoff.attempts + 1;
+          const attempts = backoff.attempts + 1;
 
-            if (ff.isSync() && rbs.isSync()) {
-              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
-              isHandlingEvent = false;
-              return;
-            }
+          if (maxChangeNumber <= splitsCache.getChangeNumber()) {
+            log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+            isHandlingEvent = false;
+            return;
+          }
 
-            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-              backoff.scheduleCall();
-              return;
-            }
+          if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+            backoff.scheduleCall();
+            return;
+          }
 
-            if (cdnBypass) {
-              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
-              isHandlingEvent = false;
-            } else {
-              backoff.reset();
-              cdnBypass = true;
-              __handleSplitUpdateCall();
-            }
+          if (cdnBypass) {
+            log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
+            isHandlingEvent = false;
+          } else {
+            backoff.reset();
+            cdnBypass = true;
+            __handleSplitUpdateCall();
           }
-        });
-      } else {
-        isHandlingEvent = false;
-      }
+        }
+      });
+    } else {
+      isHandlingEvent = false;
     }
+  }
 
-    return {
-      /**
-       * Invoked by NotificationProcessor on SPLIT_UPDATE or RB_SEGMENT_UPDATE event
-       *
-       * @param changeNumber - change number of the notification
-       */
-      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: ISplit | IRBSegment) {
-        const currentChangeNumber = cache.getChangeNumber();
+  /**
+   * Invoked by NotificationProcessor on SPLIT_UPDATE event
+   *
+   * @param changeNumber - change number of the SPLIT_UPDATE notification
+   */
+  function put({ changeNumber, pcn }: ISplitUpdateData, _payload?: ISplit) {
+    const currentChangeNumber = splitsCache.getChangeNumber();
 
-        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+    if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-        maxChangeNumber = changeNumber;
-        handleNewEvent = true;
-        cdnBypass = false;
-        instantUpdate = undefined;
+    maxChangeNumber = changeNumber;
+    handleNewEvent = true;
+    cdnBypass = false;
+    payload = undefined;
 
-        if (payload && currentChangeNumber === pcn) {
-          instantUpdate = { payload, changeNumber, type };
-        }
+    if (_payload && currentChangeNumber === pcn) {
+      payload = _payload;
+    }
 
-        if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
-        backoff.reset();
-      },
-      stop() {
-        isHandlingEvent = false;
-        backoff.reset();
-      },
-      isSync() {
-        return maxChangeNumber <= cache.getChangeNumber();
-      }
-    };
+    if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+    backoff.reset();
   }
 
   return {
-    put(parsedData) {
-      if (parsedData.d && parsedData.c !== undefined) {
-        try {
-          const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
-          if (payload) {
-            (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
-            return;
-          }
-        } catch (e) {
-          log.warn(STREAMING_PARSING_SPLIT_UPDATE, [parsedData.type, e]);
-        }
-      }
-      (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData);
-    },
+    put,
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
-     * @param changeNumber - change number of the notification
+     * @param changeNumber - change number of the SPLIT_UPDATE notification
      * @param splitName - name of split to kill
      * @param defaultTreatment - default treatment value
      */
     killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-      if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
+      if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
         // trigger an SDK_UPDATE if Split was killed locally
         splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
       }
       // queues the SplitChanges fetch (only if changeNumber is newer)
-      ff.put({ changeNumber } as ISplitUpdateData);
+      put({ changeNumber } as ISplitUpdateData);
     },
 
     stop() {
-      ff.stop();
-      rbs.stop();
+      isHandlingEvent = false;
+      backoff.reset();
     }
   };
 }

package/src/sync/streaming/constants.ts

@@ -30,7 +30,6 @@ export const MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';
-export const RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export const CONTROL = 'CONTROL';

package/src/sync/streaming/parseUtils.ts

@@ -2,7 +2,7 @@ import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { hash } from '../../utils/murmur3/murmur3';
 import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
-import { IRBSegment, ISplit } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -82,7 +82,7 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 /**
  * Parse feature flags notifications for instant feature flag updates
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | IRBSegment | undefined {
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
   return compression > 0 ?
     parseKeyList(data, compression, false) :
     JSON.parse(decodeFromBase64(data));

package/src/sync/streaming/pushManager.ts

@@ -11,10 +11,10 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -56,7 +56,7 @@ export function pushManagerFactory(
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
   const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
   // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
@@ -219,8 +219,20 @@ export function pushManagerFactory(
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
   pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-  pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+  pushEmitter.on(SPLIT_UPDATE, (parsedData) => {
+    if (parsedData.d && parsedData.c !== undefined) {
+      try {
+        const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+        if (payload) {
+          splitsUpdateWorker.put(parsedData, payload);
+          return;
+        }
+      } catch (e) {
+        log.warn(STREAMING_PARSING_SPLIT_UPDATE, [e]);
+      }
+    }
+    splitsUpdateWorker.put(parsedData);
+  });
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
     switch (parsedData.u) {

package/src/sync/streaming/types.ts

@@ -16,19 +16,18 @@ export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
-export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
   T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
-  T extends SPLIT_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
+  T extends SPLIT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**

package/src/sync/syncManagerOnline.ts

@@ -155,14 +155,14 @@ export function syncManagerOnlineFactory(
             if (pushManager) {
               if (pollingManager.isRunning()) {
                 // if doing polling, we must start the periodic fetch of data
-                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               } else {
                 // if not polling, we must execute the sync task for the initial fetch
                 // of segments since `syncAll` was already executed when starting the main client
                 mySegmentsSyncTask.execute();
               }
             } else {
-              if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+              if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }
           } else {
             if (!readinessManager.isReady()) mySegmentsSyncTask.execute();

package/src/utils/constants/index.ts

@@ -104,9 +104,8 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAG_SPEC_VERSION = '1.3';
+export const FLAG_SPEC_VERSION = '1.2';
 
 // Matcher types
 export const IN_SEGMENT = 'IN_SEGMENT';
 export const IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';
-export const IN_RULE_BASED_SEGMENT = 'IN_RULE_BASED_SEGMENT';

package/src/utils/labels/index.ts

@@ -6,4 +6,3 @@ export const EXCEPTION = 'exception';
 export const SPLIT_ARCHIVED = 'archived';
 export const NOT_IN_SPLIT = 'not in split';
 export const UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
-export const PREREQUISITES_NOT_MET = 'prerequisites not met';

package/src/utils/lang/index.ts

@@ -111,7 +111,7 @@ export function groupBy<T extends Record<string, any>>(source: T[], prop: string
 /**
  * Checks if a given value is a boolean.
  */
-export function isBoolean(val: any): val is boolean {
+export function isBoolean(val: any): boolean {
   return val === true || val === false;
 }
 

package/types/splitio.d.ts

@@ -879,7 +879,7 @@ declare namespace SplitIO {
     /**
      * The list of treatments available for the feature flag.
      */
-    treatments: string[];
+    treatments: Array<string>;
     /**
      * Current change number of the feature flag.
      */
@@ -903,10 +903,6 @@ declare namespace SplitIO {
      * Whether the feature flag has impressions tracking disabled or not.
      */
     impressionsDisabled: boolean;
-    /**
-     * Prerequisites for the feature flag.
-     */
-    prerequisites: Array<{ flagName: string, treatments: string[] }>;
   };
   /**
    * A promise that resolves to a feature flag view or null if the feature flag is not found.

package/cjs/evaluator/matchers/prerequisites.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prerequisitesMatcherContext = void 0;
-var thenable_1 = require("../../utils/promise/thenable");
-function prerequisitesMatcherContext(prerequisites, storage, log) {
-    if (prerequisites === void 0) { prerequisites = []; }
-    return function prerequisitesMatcher(_a, splitEvaluator) {
-        var key = _a.key, attributes = _a.attributes;
-        function evaluatePrerequisite(prerequisite) {
-            var evaluation = splitEvaluator(log, key, prerequisite.n, attributes, storage);
-            return (0, thenable_1.thenable)(evaluation) ?
-                evaluation.then(function (evaluation) { return prerequisite.ts.indexOf(evaluation.treatment) !== -1; }) :
-                prerequisite.ts.indexOf(evaluation.treatment) !== -1;
-        }
-        return prerequisites.reduce(function (prerequisitesMet, prerequisite) {
-            return (0, thenable_1.thenable)(prerequisitesMet) ?
-                prerequisitesMet.then(function (prerequisitesMet) { return prerequisitesMet ? evaluatePrerequisite(prerequisite) : false; }) :
-                prerequisitesMet ? evaluatePrerequisite(prerequisite) : false;
-        }, true);
-    };
-}
-exports.prerequisitesMatcherContext = prerequisitesMatcherContext;

package/cjs/evaluator/matchers/rbsegment.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ruleBasedSegmentMatcherContext = void 0;
-var thenable_1 = require("../../utils/promise/thenable");
-var key_1 = require("../../utils/key");
-var parser_1 = require("../parser");
-function ruleBasedSegmentMatcherContext(segmentName, storage, log) {
-    return function ruleBasedSegmentMatcher(_a, splitEvaluator) {
-        var key = _a.key, attributes = _a.attributes;
-        function matchConditions(rbsegment) {
-            var conditions = rbsegment.conditions || [];
-            var evaluator = (0, parser_1.parser)(log, conditions, storage);
-            var evaluation = evaluator((0, key_1.keyParser)(key), undefined, undefined, undefined, attributes, splitEvaluator);
-            return (0, thenable_1.thenable)(evaluation) ?
-                evaluation.then(function (evaluation) { return evaluation ? true : false; }) :
-                evaluation ? true : false;
-        }
-        function isExcluded(rbSegment) {
-            var matchingKey = (0, key_1.getMatching)(key);
-            var excluded = rbSegment.excluded || {};
-            if (excluded.keys && excluded.keys.indexOf(matchingKey) !== -1)
-                return true;
-            var isInSegment = (excluded.segments || []).map(function (segmentName) {
-                return storage.segments.isInSegment(segmentName, matchingKey);
-            });
-            return isInSegment.length && (0, thenable_1.thenable)(isInSegment[0]) ?
-                Promise.all(isInSegment).then(function (results) { return results.some(function (result) { return result; }); }) :
-                isInSegment.some(function (result) { return result; });
-        }
-        function isInSegment(rbSegment) {
-            if (!rbSegment)
-                return false;
-            var excluded = isExcluded(rbSegment);
-            return (0, thenable_1.thenable)(excluded) ?
-                excluded.then(function (excluded) { return excluded ? false : matchConditions(rbSegment); }) :
-                excluded ? false : matchConditions(rbSegment);
-        }
-        var rbSegment = storage.rbSegments.get(segmentName);
-        return (0, thenable_1.thenable)(rbSegment) ?
-            rbSegment.then(isInSegment) :
-            isInSegment(rbSegment);
-    };
-}
-exports.ruleBasedSegmentMatcherContext = ruleBasedSegmentMatcherContext;

package/cjs/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBSegmentsCacheInLocal = void 0;
-var lang_1 = require("../../utils/lang");
-var sets_1 = require("../../utils/lang/sets");
-var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
-var constants_1 = require("./constants");
-var RBSegmentsCacheInLocal = /** @class */ (function () {
-    function RBSegmentsCacheInLocal(settings, keys) {
-        this.keys = keys;
-        this.log = settings.log;
-    }
-    RBSegmentsCacheInLocal.prototype.clear = function () {
-        var _this = this;
-        this.getNames().forEach(function (name) { return _this.remove(name); });
-        localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
-    };
-    RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        this.setChangeNumber(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;
-    };
-    RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-        }
-    };
-    RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
-        var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        var count = (0, lang_1.toNumber)(localStorage.getItem(segmentsCountKey)) + diff;
-        // @ts-expect-error
-        if (count > 0)
-            localStorage.setItem(segmentsCountKey, count);
-        else
-            localStorage.removeItem(segmentsCountKey);
-    };
-    RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
-        try {
-            var name_1 = rbSegment.name;
-            var rbSegmentKey = this.keys.buildRBSegmentKey(name_1);
-            var rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
-            var previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
-            localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
-            var usesSegmentsDiff = 0;
-            if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
-                usesSegmentsDiff--;
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
-                usesSegmentsDiff++;
-            if (usesSegmentsDiff !== 0)
-                this.updateSegmentCount(usesSegmentsDiff);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-            return false;
-        }
-    };
-    RBSegmentsCacheInLocal.prototype.remove = function (name) {
-        try {
-            var rbSegment = this.get(name);
-            if (!rbSegment)
-                return false;
-            localStorage.removeItem(this.keys.buildRBSegmentKey(name));
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
-                this.updateSegmentCount(-1);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-            return false;
-        }
-    };
-    RBSegmentsCacheInLocal.prototype.getNames = function () {
-        var len = localStorage.length;
-        var accum = [];
-        var cur = 0;
-        while (cur < len) {
-            var key = localStorage.key(cur);
-            if (key != null && this.keys.isRBSegmentKey(key))
-                accum.push(this.keys.extractKey(key));
-            cur++;
-        }
-        return accum;
-    };
-    RBSegmentsCacheInLocal.prototype.get = function (name) {
-        var item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
-        return item && JSON.parse(item);
-    };
-    RBSegmentsCacheInLocal.prototype.contains = function (names) {
-        var namesArray = (0, sets_1.setToArray)(names);
-        var namesInStorage = this.getNames();
-        return namesArray.every(function (name) { return namesInStorage.indexOf(name) !== -1; });
-    };
-    RBSegmentsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(value) ? n : value;
-        }
-        return n;
-    };
-    RBSegmentsCacheInLocal.prototype.usesSegments = function () {
-        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-        var splitsWithSegmentsCount = storedCount === null ? 0 : (0, lang_1.toNumber)(storedCount);
-        return (0, lang_1.isFiniteNumber)(splitsWithSegmentsCount) ?
-            splitsWithSegmentsCount > 0 :
-            true;
-    };
-    return RBSegmentsCacheInLocal;
-}());
-exports.RBSegmentsCacheInLocal = RBSegmentsCacheInLocal;

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBSegmentsCacheInMemory = void 0;
-var sets_1 = require("../../utils/lang/sets");
-var AbstractSplitsCacheSync_1 = require("../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 && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
-            this.segmentsCount--;
-        this.cache[name] = rbSegment;
-        if ((0, AbstractSplitsCacheSync_1.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 ((0, AbstractSplitsCacheSync_1.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.contains = function (names) {
-        var namesArray = (0, sets_1.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;
-}());
-exports.RBSegmentsCacheInMemory = RBSegmentsCacheInMemory;