@splitsoftware/splitio-commons 1.16.0 → 1.16.1-rc.1

package/src/sync/streaming/types.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -16,16 +16,18 @@ export type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
+export type MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_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 | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData :
   T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data :
+  T extends MY_LARGE_SEGMENTS_UPDATE ? IMyLargeSegmentsUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
   T extends SPLIT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : undefined;
@@ -45,6 +47,6 @@ export interface IPushEventEmitter extends IEventEmitter {
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
   // Methods used in client-side, to support multiple clients
-  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void,
+  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask): void,
   remove(userKey: string): void
 }

package/src/sync/submitters/telemetrySubmitter.ts

@@ -76,10 +76,12 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
 
       return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
+        lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
         rR: {
           sp: scheduler.featuresRefreshRate / 1000,
           se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
           ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+          mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
           im: scheduler.impressionsRefreshRate / 1000,
           ev: scheduler.eventsPushRate / 1000,
           te: scheduler.telemetryRefreshRate / 1000,

package/src/sync/submitters/types.ts

@@ -103,7 +103,7 @@ export type DROPPED = 1;
 export type DEDUPED = 2;
 export type ImpressionDataType = QUEUED | DROPPED | DEDUPED
 export type EventDataType = QUEUED | DROPPED;
-export type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT;
+export type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT | MY_LARGE_SEGMENT;
 
 export type SPLITS = 'sp';
 export type IMPRESSIONS = 'im';
@@ -113,7 +113,8 @@ export type TELEMETRY = 'te';
 export type TOKEN = 'to';
 export type SEGMENT = 'se';
 export type MY_SEGMENT = 'ms';
-export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
+export type MY_LARGE_SEGMENT = 'mls';
+export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT | MY_LARGE_SEGMENT;
 
 export type LastSync = Partial<Record<OperationType, number | undefined>>
 export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
@@ -158,8 +159,9 @@ export type TelemetryUsageStats = {
 
 // amount of instant updates that we are doing by avoiding fetching to Split servers
 export type UpdatesFromSSE = {
-  sp: number, // splits
+  sp?: number, // splits
   ms?: number, // my segments
+  mls?: number // my large segments
 }
 
 // 'metrics/usage' JSON request body
@@ -175,12 +177,14 @@ export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   spC?: number, // splitCount
   seC?: number, // segmentCount
   skC?: number, // segmentKeyCount
+  lseC?: number, // largeSegmentCount
+  lskC?: number, // largeSegmentKeyCount
   sL?: number, // sessionLengthMs
   eQ: number, // eventsQueued
   eD: number, // eventsDropped
   sE: Array<StreamingEvent>, // streamingEvents
   t?: Array<string>, // tags
-  ufs?: UpdatesFromSSE, //UpdatesFromSSE
+  ufs?: UpdatesFromSSE, // instant updates
 }
 
 /**
@@ -201,6 +205,7 @@ export type RefreshRates = {
   sp: number, // splits
   se?: number, // segments
   ms?: number, // mySegments
+  mls?: number, // myLargeSegments
   im: number, // impressions
   ev: number, // events
   te: number, // telemetry
@@ -226,6 +231,7 @@ export type TelemetryConfigStats = {
 // 'metrics/config' JSON request body
 export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   sE: boolean, // streamingEnabled
+  lE?: boolean, // largeSegmentsEnabled
   rR: RefreshRates, // refreshRates
   uO: UrlOverrides, // urlOverrides
   iQ: number, // impressionsQueueSize

package/src/sync/syncManagerOnline.ts

@@ -7,7 +7,7 @@ import { IPollingManager, IPollingManagerCS } from './polling/types';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
-import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
+import { IN_LARGE_SEGMENT, IN_SEGMENT, POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
 
 /**
@@ -141,36 +141,44 @@ export function syncManagerOnlineFactory(
       shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync) {
         if (!pollingManager) return;
 
-        const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
+        const { msSyncTask, mlsSyncTask } = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
 
         return {
-          isRunning: mySegmentsSyncTask.isRunning,
+          isRunning: msSyncTask.isRunning,
           start() {
             if (syncEnabled) {
               if (pushManager) {
                 if (pollingManager!.isRunning()) {
                   // if doing polling, we must start the periodic fetch of data
-                  if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
+                  if (storage.splits.usesMatcher(IN_SEGMENT)) msSyncTask.start();
+                  if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) mlsSyncTask.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();
+                  msSyncTask.execute();
+                  mlsSyncTask && mlsSyncTask.execute();
                 }
-                pushManager.add(matchingKey, mySegmentsSyncTask);
+                pushManager.add(matchingKey, msSyncTask, mlsSyncTask);
               } else {
-                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
+                if (storage.splits.usesMatcher(IN_SEGMENT)) msSyncTask.start();
+                if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) mlsSyncTask.start();
               }
             } else {
-              if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
+              if (!readinessManager.isReady()) {
+                msSyncTask.execute();
+                mlsSyncTask && mlsSyncTask.execute();
+              }
             }
           },
           stop() {
             // check in case `client.destroy()` has been invoked more than once for the same client
-            const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);
-            if (mySegmentsSyncTask) {
+            const syncTasks = (pollingManager as IPollingManagerCS).get(matchingKey);
+            if (syncTasks) {
+              const { msSyncTask, mlsSyncTask } = syncTasks;
               // stop syncing
               if (pushManager) pushManager.remove(matchingKey);
-              if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
+              if (msSyncTask.isRunning()) msSyncTask.stop();
+              if (mlsSyncTask && mlsSyncTask.isRunning()) mlsSyncTask.stop();
 
               (pollingManager as IPollingManagerCS).remove(matchingKey);
             }

package/src/types.ts

@@ -86,6 +86,7 @@ export interface ISettings {
     metricsRefreshRate?: number,
     telemetryRefreshRate: number,
     segmentsRefreshRate: number,
+    largeSegmentsRefreshRate: number,
     offlineRefreshRate: number,
     eventsPushRate: number,
     eventsQueueSize: number,
@@ -95,7 +96,8 @@ export interface ISettings {
     readyTimeout: number,
     requestTimeoutBeforeReady: number,
     retriesOnFailureBeforeReady: number,
-    eventsFirstPushWindow: number
+    eventsFirstPushWindow: number,
+    waitForLargeSegments: boolean
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
   readonly integrations: Array<{
@@ -119,6 +121,7 @@ export interface ISettings {
     __splitFiltersValidation: ISplitFiltersValidation,
     localhostMode?: SplitIO.LocalhostFactory,
     enabled: boolean,
+    largeSegmentsEnabled: boolean,
     flagSpecVersion: string
   },
   readonly runtime: {
@@ -813,6 +816,13 @@ export namespace SplitIO {
        * @default 10
        */
       eventsFirstPushWindow?: number,
+      /**
+       * Whether the SDK should wait for large segments to be ready before emitting SDK_READY event.
+       * It only applies if largeSegmentsEnabled is true.
+       * @property {number} waitForLargeSegments
+       * @default true
+       */
+      waitForLargeSegments?: boolean
     },
     /**
      * SDK scheduler settings.
@@ -857,6 +867,13 @@ export namespace SplitIO {
        * @default 60
        */
       segmentsRefreshRate?: number,
+      /**
+       * The SDK polls Split servers for changes to large segment definitions. This parameter controls this polling period in seconds.
+       * It only applies if largeSegmentsEnabled is true.
+       * @property {number} largeSegmentsRefreshRate
+       * @default 60
+       */
+      largeSegmentsRefreshRate?: number,
       /**
        * The SDK posts the queued events data in bulks. This parameter controls the posting rate in seconds.
        * @property {number} eventsPushRate
@@ -929,6 +946,14 @@ export namespace SplitIO {
      * @property {Object} urls
      */
     urls?: UrlSettings,
+    sync?: ISharedSettings['sync'] & {
+      /**
+       * Enables synchronization of large segments.
+       * @property {boolean} largeSegmentsEnabled
+       * @default false
+       */
+      largeSegmentsEnabled?: boolean
+    }
   }
   /**
    * Settings interface for SDK instances created on NodeJS.

package/src/utils/constants/index.ts

@@ -76,6 +76,7 @@ export const TELEMETRY = 'te';
 export const TOKEN = 'to';
 export const SEGMENT = 'se';
 export const MY_SEGMENT = 'ms';
+export const MY_LARGE_SEGMENT = 'mls';
 
 export const TREATMENT = 't';
 export const TREATMENTS = 'ts';
@@ -106,3 +107,7 @@ export const ENABLED = 1;
 export const PAUSED = 2;
 
 export const FLAG_SPEC_VERSION = '1.1';
+
+// Matcher types
+export const IN_SEGMENT = 'IN_SEGMENT';
+export const IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/src/utils/settingsValidation/index.ts

@@ -7,7 +7,7 @@ import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
 import { validateKey } from '../inputValidation/key';
 import { validateTrafficType } from '../inputValidation/trafficType';
-import { ERROR_MIN_CONFIG_PARAM } from '../../logger/constants';
+import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 
 // Exported for telemetry
 export const base = {
@@ -32,6 +32,8 @@ export const base = {
     featuresRefreshRate: 60,
     // fetch segments updates each 60 sec
     segmentsRefreshRate: 60,
+    // fetch large segments updates each 60 sec
+    largeSegmentsRefreshRate: 60,
     // publish telemetry stats each 3600 secs (1 hour)
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
@@ -85,7 +87,8 @@ export const base = {
     impressionsMode: OPTIMIZED,
     localhostMode: undefined,
     enabled: true,
-    flagSpecVersion: FLAG_SPEC_VERSION
+    flagSpecVersion: FLAG_SPEC_VERSION,
+    largeSegmentsEnabled: false
   },
 
   // Logger
@@ -132,6 +135,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const { scheduler, startup } = withDefaults;
   scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
+  scheduler.largeSegmentsRefreshRate = fromSecondsToMillis(scheduler.largeSegmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
@@ -166,13 +170,13 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
       // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
       // `false` value is used as bound key/TT of the default client, which leads to some issues.
       // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
-      withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+      withDefaults.core.key = validateKey(log, maybeKey, LOG_PREFIX_CLIENT_INSTANTIATION);
     }
 
     if (validationParams.acceptTT) {
       const maybeTT = withDefaults.core.trafficType;
       if (maybeTT !== undefined) { // @ts-ignore
-        withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+        withDefaults.core.trafficType = validateTrafficType(log, maybeTT, LOG_PREFIX_CLIENT_INSTANTIATION);
       }
     }
   } else {
@@ -209,11 +213,12 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
   sync.splitFilters = splitFiltersValidation.validFilters;
   sync.__splitFiltersValidation = splitFiltersValidation;
-  sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
 
+  // ensure a valid flag spec version
+  sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
   // ensure a valid user consent value
   // @ts-ignore, modify readonly prop
-  withDefaults.userConsent = consent(withDefaults);
+  withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
 
   return withDefaults;
 }

package/src/utils/settingsValidation/types.ts

@@ -25,7 +25,7 @@ export interface ISettingsValidationParams {
   /** Localhost mode validator (`settings.sync.localhostMode`) */
   localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
   /** User consent validator (`settings.userConsent`) */
-  consent: (settings: ISettings) => ISettings['userConsent'],
+  consent?: (settings: ISettings) => ISettings['userConsent'],
   /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */
   flagSpec?: (settings: ISettings) => ISettings['sync']['flagSpecVersion']
 }

package/types/dtos/types.d.ts

@@ -48,6 +48,10 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
     matcherType: 'IN_SEGMENT';
     userDefinedSegmentMatcherData: IInSegmentMatcherData;
 }
+interface IInLargeSegmentMatcher extends ISplitMatcherBase {
+    matcherType: 'IN_LARGE_SEGMENT';
+    userDefinedSegmentMatcherData: IInSegmentMatcherData;
+}
 interface IWhitelistMatcher extends ISplitMatcherBase {
     matcherType: 'WHITELIST';
     whitelistMatcherData: IWhitelistMatcherData;
@@ -128,7 +132,7 @@ interface IInListSemverMatcher extends ISplitMatcherBase {
     matcherType: 'IN_LIST_SEMVER';
     whitelistMatcherData: IWhitelistMatcherData;
 }
-export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher;
+export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher | IInLargeSegmentMatcher;
 /** Split object */
 export interface ISplitPartition {
     treatment: string;
@@ -173,13 +177,17 @@ export interface ISegmentChangesResponse {
     since: number;
     till: number;
 }
-export interface IMySegmentsResponseItem {
-    id: string;
-    name: string;
-}
 /** Interface of the parsed JSON response of `/mySegments/{userKey}` */
 export interface IMySegmentsResponse {
-    mySegments: IMySegmentsResponseItem[];
+    mySegments: {
+        id: string;
+        name: string;
+    }[];
+}
+/** Interface of the parsed JSON response of `/myLargeSegments/{userKey}` */
+export interface IMyLargeSegmentsResponse {
+    myLargeSegments: string[];
+    changeNumber: number;
 }
 /** Metadata internal type for storages */
 export interface IMetadata {

package/types/evaluator/matchers/large_segment.d.ts

@@ -0,0 +1,5 @@
+import { MaybeThenable } from '../../dtos/types';
+import { ISegmentsCacheBase } from '../../storages/types';
+export declare function largeSegmentMatcherContext(largeSegmentName: string, storage: {
+    largeSegments?: ISegmentsCacheBase;
+}): (key: string) => MaybeThenable<boolean>;

package/types/logger/constants.d.ts

@@ -35,7 +35,6 @@ export declare const IMPRESSION = 102;
 export declare const IMPRESSION_QUEUEING = 103;
 export declare const NEW_SHARED_CLIENT = 104;
 export declare const NEW_FACTORY = 105;
-export declare const POLLING_SMART_PAUSING = 106;
 export declare const POLLING_START = 107;
 export declare const POLLING_STOP = 108;
 export declare const SYNC_SPLITS_FETCH_RETRY = 109;
@@ -115,6 +114,7 @@ export declare const ERROR_SETS_FILTER_EXCLUSIVE = 328;
 export declare const ENGINE_MATCHER_ERROR = 329;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
+export declare const LOG_PREFIX_CLIENT_INSTANTIATION = "Client instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";
 export declare const LOG_PREFIX_ENGINE_COMBINER: string;
 export declare const LOG_PREFIX_ENGINE_MATCHER: string;

package/types/readiness/readinessManager.d.ts

@@ -1,6 +1,6 @@
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } from '../types';
 import { IReadinessManager, ISplitsEventEmitter } from './types';
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, readyTimeout?: number, splits?: ISplitsEventEmitter): IReadinessManager;
+export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, settings: ISettings, splits?: ISplitsEventEmitter): IReadinessManager;

package/types/readiness/sdkReadinessManager.d.ts

@@ -1,6 +1,5 @@
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter } from '../types';
-import { ILogger } from '../logger/types';
+import { IEventEmitter, ISettings } from '../types';
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
  * It also updates logs related warnings and errors.
@@ -8,4 +7,4 @@ import { ILogger } from '../logger/types';
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(EventEmitter: new () => IEventEmitter, settings: ISettings, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/readiness/types.d.ts

@@ -34,6 +34,7 @@ export interface IReadinessManager {
     /** Event emitters */
     splits: ISplitsEventEmitter;
     segments: ISegmentsEventEmitter;
+    largeSegments?: ISegmentsEventEmitter;
     gate: IReadinessEventEmitter;
     /** Readiness status */
     isReady(): boolean;
@@ -45,7 +46,7 @@ export interface IReadinessManager {
     setDestroyed(): void;
     destroy(): void;
     /** for client-side */
-    shared(readyTimeout?: number): IReadinessManager;
+    shared(): IReadinessManager;
 }
 /** SDK readiness manager */
 export interface ISdkReadinessManager {
@@ -57,6 +58,6 @@ export interface ISdkReadinessManager {
      */
     incInternalReadyCbCount(): void;
     /** for client-side */
-    shared(readyTimeout?: number): ISdkReadinessManager;
+    shared(): ISdkReadinessManager;
 }
 export {};

package/types/services/types.d.ts

@@ -33,6 +33,7 @@ export interface ISplitApi {
     fetchSplitChanges: IFetchSplitChanges;
     fetchSegmentChanges: IFetchSegmentChanges;
     fetchMySegments: IFetchMySegments;
+    fetchMyLargeSegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
     postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
     postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -18,7 +18,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
-    usesSegments(): Promise<boolean>;
+    usesMatcher(): Promise<boolean>;
     /**
      * Check if the splits information is already stored in cache.
      * Noop, just keeping the interface. This is used by client-side implementations only.

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -17,7 +17,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
     getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
-    abstract usesSegments(): boolean;
+    abstract usesMatcher(matcherType: string): boolean;
     abstract clear(): void;
     /**
      * Check if the splits information is already stored in cache. This data can be preloaded.
@@ -39,6 +39,6 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
 }
 /**
  * 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
+ * This util is intended to simplify the implementation of `splitsCache::usesMatcher` method
  */
-export declare function usesSegments(split: ISplit): boolean;
+export declare function usesMatcher(split: ISplit, matcherType: string): boolean;

package/types/storages/KeyBuilder.d.ts

@@ -10,6 +10,7 @@ export declare class KeyBuilder {
     isSplitKey(key: string): boolean;
     buildSplitKeyPrefix(): string;
     buildSplitsWithSegmentCountKey(): string;
+    buildSplitsWithLargeSegmentCountKey(): string;
     buildSegmentNameKey(segmentName: string): string;
     buildSegmentTillKey(segmentName: string): string;
     extractKey(builtKey: string): string;

package/types/storages/KeyBuilderCS.d.ts

@@ -1,5 +1,10 @@
 import { KeyBuilder } from './KeyBuilder';
-export declare class KeyBuilderCS extends KeyBuilder {
+export interface MySegmentsKeyBuilder {
+    buildSegmentNameKey(segmentName: string): string;
+    extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
+}
+export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     protected readonly regexSplitsCacheKey: RegExp;
     protected readonly matchingKey: string;
     constructor(prefix: string, matchingKey: string);
@@ -8,8 +13,8 @@ export declare class KeyBuilderCS extends KeyBuilder {
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
-    buildOldSegmentNameKey(segmentName: string): string;
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
 }
+export declare function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder;

package/types/storages/inLocalStorage/MySegmentsCacheInLocal.d.ts

@@ -1,10 +1,10 @@
 import { ILogger } from '../../logger/types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import { KeyBuilderCS } from '../KeyBuilderCS';
+import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     private readonly keys;
     private readonly log;
-    constructor(log: ILogger, keys: KeyBuilderCS);
+    constructor(log: ILogger, keys: MySegmentsKeyBuilder);
     /**
      * Removes list of segments from localStorage
      * @NOTE this method is not being used at the moment.

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -34,7 +34,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     getChangeNumber(): number;
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
+    usesMatcher(matcherType: string): boolean;
     /**
      * Check if the splits information is already stored in browser LocalStorage.
      * In this function we could add more code to check if the data is valid.

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -10,7 +10,8 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private splitsCache;
     private ttCache;
     private changeNumber;
-    private splitsWithSegmentsCount;
+    private segmentsCount;
+    private largeSegmentsCount;
     private flagSetsCache;
     constructor(splitFiltersValidation?: ISplitFiltersValidation);
     clear(): void;
@@ -21,7 +22,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getChangeNumber(): number;
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
+    usesMatcher(matcherType: string): boolean;
     getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 export declare const MAX_LATENCY_BUCKET_COUNT = 23;
 export declare function newBuckets(): number[];
@@ -10,7 +10,8 @@ export declare function shouldRecordTelemetry({ settings }: IStorageFactoryParam
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private splits?;
     private segments?;
-    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined);
+    private largeSegments?;
+    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined, largeSegments?: ISegmentsCacheSync | undefined);
     private e;
     isEmpty(): boolean;
     clear(): void;
@@ -65,9 +66,6 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
     private updatesFromSSE;
-    popUpdatesFromSSE(): {
-        sp: number;
-        ms: number;
-    };
+    popUpdatesFromSSE(): UpdatesFromSSE;
     recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }

package/types/storages/pluggable/inMemoryWrapper.d.ts

@@ -5,7 +5,7 @@ import { ISet } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;

package/types/storages/types.d.ts

@@ -189,7 +189,7 @@ export interface ISplitsCacheBase {
     getAll(): MaybeThenable<ISplit[]>;
     getSplitNames(): MaybeThenable<string[]>;
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
-    usesSegments(): MaybeThenable<boolean>;
+    usesMatcher(matcherType: string): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
     checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
@@ -205,7 +205,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     getAll(): ISplit[];
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
+    usesMatcher(matcherType: string): boolean;
     clear(): void;
     checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
@@ -221,7 +221,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     getAll(): Promise<ISplit[]>;
     getSplitNames(): Promise<string[]>;
     trafficTypeExists(trafficType: string): Promise<boolean>;
-    usesSegments(): Promise<boolean>;
+    usesMatcher(matcherType: string): Promise<boolean>;
     clear(): Promise<boolean | void>;
     checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
@@ -388,6 +388,7 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
 export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
+    largeSegments?: ISegmentsCacheSync;
 }
 export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }