@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.1

package/src/sync/streaming/pushManager.ts

@@ -6,17 +6,17 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
+import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, 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 { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_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 { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
-import { IAuthTokenPushEnabled } from './AuthClient/types';
+import { IJwtCredentialV2 } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -55,8 +55,8 @@ export function pushManagerFactory(
   // init workers
   // 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.definitionsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
+  const definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, 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> = {};
@@ -67,10 +67,10 @@ export function pushManagerFactory(
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
 
-  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
+  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NON_RETRYABLE_ERROR error.
   // It is used to halt the `connectPush` process if it was in progress.
   let disconnected: boolean | undefined;
-  // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+  // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
   // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
   let disabled: boolean | undefined; // `disabled` implies `disconnected === true`
 
@@ -81,7 +81,7 @@ export function pushManagerFactory(
   let timeoutIdTokenRefresh: ReturnType<typeof setTimeout>;
   let timeoutIdSseOpen: ReturnType<typeof setTimeout>;
 
-  function scheduleTokenRefreshAndSse(authData: IAuthTokenPushEnabled) {
+  function scheduleTokenRefreshAndSse(authData: IJwtCredentialV2) {
     // clear scheduled tasks if exist
     if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
     if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
@@ -117,11 +117,11 @@ export function pushManagerFactory(
       function (authData) {
         if (disconnected) return;
 
-        // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+        // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
         // close the sseClient in case the org has been bloqued while the instance was connected to streaming
         if (!authData.pushEnabled) {
           log.info(STREAMING_DISABLED);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
           return;
         }
 
@@ -140,7 +140,7 @@ export function pushManagerFactory(
         // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
         if (error.statusCode >= 400 && error.statusCode < 500) {
           telemetryTracker.streamingEvent(AUTH_REJECTION);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
           return;
         }
 
@@ -168,7 +168,7 @@ export function pushManagerFactory(
 
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
-    splitsUpdateWorker.stop();
+    definitionsUpdateWorker.stop();
     if (userKey) forOwn(clients, ({ worker }) => worker.stop());
     else segmentsUpdateWorker!.stop();
   }
@@ -183,7 +183,7 @@ export function pushManagerFactory(
 
   /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
 
-  pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+  pushEmitter.on(PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
     disabled = true;
     // Note: `stopWorkers` is been called twice, but it is not harmful
     disconnectPush();
@@ -218,9 +218,9 @@ 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_KILL, definitionsUpdateWorker.killDefinition);
+  pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+  pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
     switch (parsedData.u) {

package/src/sync/streaming/types.ts

@@ -7,7 +7,7 @@ import { ControlType } from './constants';
 // Internal SDK events, subscribed by SyncManager and PushManager
 export type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP'
 export type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
-export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+export type PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
@@ -22,7 +22,7 @@ export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 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_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :

package/src/sync/submitters/telemetrySubmitter.ts

@@ -119,7 +119,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const { storage: { telemetry }, platform: { now } } = params;
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness } = params;
   const stopTimer = timer(now);
 
   const submitter = firstPushWindowDecorator(
@@ -135,7 +135,6 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
     telemetry.recordTimeUntilReadyFromCache(stopTimer());
   });
 
-  sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
     telemetry.recordTimeUntilReady(stopTimer());
 

package/src/sync/syncManagerOnline.ts

@@ -9,8 +9,8 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
 import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
 import { IDefinitionChangesFetcher } from './polling/fetchers/types';
 
@@ -102,7 +102,7 @@ export function syncManagerOnlineFactory(
           if (startFirstTime) {
             // Emits SDK_READY_FROM_CACHE
             if (!cacheMetadata.initialCacheLoad) {
-              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+              readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
             }
 
           }

package/src/utils/Backoff.ts

@@ -40,6 +40,27 @@ export class Backoff {
     return delayInMillis;
   }
 
+  /**
+   * Schedule a delayed call to `cb`
+   * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
+   */
+  scheduleCallAsync<T>(): Promise<T> {
+    const delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+
+    if (this.timeoutID) clearTimeout(this.timeoutID);
+    this.attempts++;
+
+    return new Promise<T>((resolve, reject) => {
+      this.timeoutID = setTimeout(() => {
+        this.timeoutID = undefined;
+        this.cb().then(resolve, reject);
+      }, delayInMillis);
+    });
+  }
+
+  /**
+   * Reset the backoff attempts
+   */
   reset() {
     this.attempts = 0;
     if (this.timeoutID) {

package/src/utils/inputValidation/trafficTypeExistence.ts

@@ -1,6 +1,6 @@
 import { thenable } from '../promise/thenable';
 import { LOCALHOST_MODE } from '../constants';
-import { ISplitsCacheBase } from '../../storages/types';
+import { IDefinitionsCacheBase } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import SplitIO from '../../../types/splitio';
 import { MaybeThenable } from '../../dtos/types';
@@ -14,7 +14,7 @@ function logTTExistenceWarning(log: ILogger, maybeTT: string, method: string) {
 /**
  * Separated from the previous method since on some cases it'll be async.
  */
-export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
+export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: IDefinitionsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
 
   // If not ready or in localhost mode, we won't run the validation
   if (!readinessManager.isReady() || mode === LOCALHOST_MODE) return true;

package/src/utils/jwt/types.ts

@@ -1,6 +1,6 @@
 export interface IDecodedJWTToken {
   ['x-ably-capability']: string
-  exp: number
+  exp: number // epoch seconds
   iat: number
 
   /** Unused fields: */

package/src/utils/lang/sets.ts

@@ -12,6 +12,8 @@ export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
   return new Set(setToArray(set).concat(setToArray(set2)));
 }
 
-export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
-  return list.filter(item => list2.indexOf(item) === -1);
+export function returnDifference<T>(list1?: T[] | null, list2?: T[] | null): T[] {
+  list1 = list1 || [];
+  list2 = list2 || [];
+  return list1.filter(item => list2!.indexOf(item) === -1);
 }

package/src/utils/settingsValidation/url.ts

@@ -2,7 +2,7 @@ import { ISettings } from '../../types';
 
 const telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-const authEndpointMatcher = /^\/v2\/auth/;
+const authEndpointMatcher = /^\/(v2|v3)\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;
 
 /**

package/types/splitio.d.ts

@@ -495,7 +495,7 @@ declare namespace SplitIO {
   }
 
   /**
-   * Metadata for the update event emitted when the SDK cache is updated with new data for flags or segments.
+   * Metadata for the update event emitted when the SDK cache is updated with new data for flags, configs, or segments.
    */
   type SdkUpdateMetadata = {
     /**
@@ -503,7 +503,7 @@ declare namespace SplitIO {
      */
     type: SdkUpdateMetadataType;
     /**
-     * The names of the flags or segments that were updated.
+     * The names of the flags or configs that were updated. Empty array if the update is of type 'SEGMENTS_UPDATE'.
      */
     names: string[];
   }
@@ -2316,11 +2316,23 @@ declare namespace SplitIO {
      */
     authorizationKey: string;
     /**
-     * Configs definitions refresh rate for polling, in seconds.
+     * Polling rate for configs and segments refresh, in seconds. Minimum value: 5.
      *
      * @defaultValue `60`
      */
-    configsRefreshRate?: number;
+    pollingRate?: number;
+    /**
+     * Push rate for events and impressions, in seconds. Minimum value: 60.
+     *
+     * @defaultValue `60`
+     */
+    pushRate?: number;
+    /**
+     * Maximum queue size for events and impressions. When the queue reaches this size, a flush is triggered. Minimum value: 1000.
+     *
+     * @defaultValue `10000`
+     */
+    queueSize?: number;
     /**
      * Logging level.
      *
@@ -2337,6 +2349,12 @@ declare namespace SplitIO {
      * Custom endpoints to replace the default ones used by the SDK.
      */
     urls?: {
+      /**
+       * String property to override the base URL where the SDK will get JWT authentication credentials.
+       *
+       * @defaultValue `'https://auth.split.io/api'`
+       */
+      auth?: string;
       /**
        * String property to override the base URL where the SDK will get rollout plan related data, like feature flags and segments definitions.
        *
@@ -2449,7 +2467,7 @@ declare namespace SplitIO {
   /**
    * Configs SDK client interface.
    */
-  interface ConfigsClient extends IStatusInterface {
+  interface ConfigsClient extends Omit<IStatusInterface, 'ready'> {
     /**
      * Destroys the client.
      *

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSplitsCacheAsync = void 0;
-var objectAssign_1 = require("../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); }))
-        ]).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 = (0, objectAssign_1.objectAssign)({}, split);
-                newSplit.killed = true;
-                newSplit.defaultTreatment = defaultTreatment;
-                newSplit.changeNumber = changeNumber;
-                return _this.addSplit(newSplit);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractSplitsCacheAsync;
-}());
-exports.AbstractSplitsCacheAsync = AbstractSplitsCacheAsync;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.usesSegmentsSync = exports.usesSegments = exports.AbstractSplitsCacheSync = void 0;
-var objectAssign_1 = require("../utils/lang/objectAssign");
-var constants_1 = require("../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); }).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 = (0, objectAssign_1.objectAssign)({}, split);
-            newSplit.killed = true;
-            newSplit.defaultTreatment = defaultTreatment;
-            newSplit.changeNumber = changeNumber;
-            return this.addSplit(newSplit);
-        }
-        return false;
-    };
-    return AbstractSplitsCacheSync;
-}());
-exports.AbstractSplitsCacheSync = 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
- */
-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 === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
-                return true;
-        }
-    }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
-    return false;
-}
-exports.usesSegments = usesSegments;
-function usesSegmentsSync(storage) {
-    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}
-exports.usesSegmentsSync = usesSegmentsSync;

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SplitsCacheInLocal = void 0;
-var tslib_1 = require("tslib");
-var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
-var lang_1 = require("../../utils/lang");
-var constants_1 = require("./constants");
-var sets_1 = require("../../utils/lang/sets");
-var SplitsCacheInLocal = /** @class */ (function (_super) {
-    tslib_1.__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 = (0, lang_1.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 ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this._decrementCount(segmentsCountKey);
-            }
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-        }
-    };
-    SplitsCacheInLocal.prototype._incrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this.storage.setItem(ttKey, ((0, lang_1.toNumber)(this.storage.getItem(ttKey)) + 1) + '');
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this.storage.setItem(segmentsCountKey, ((0, lang_1.toNumber)(this.storage.getItem(segmentsCountKey)) + 1) + '');
-            }
-        }
-        catch (e) {
-            this.log.error(constants_1.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(constants_1.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 (0, lang_1.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 = (0, lang_1.toNumber)(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
-        return (0, lang_1.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 : (0, lang_1.toNumber)(storedCount);
-        return (0, lang_1.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((0, sets_1.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((0, sets_1.setToArray)(flagSetCache)));
-    };
-    return SplitsCacheInLocal;
-}(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));
-exports.SplitsCacheInLocal = SplitsCacheInLocal;