@splitsoftware/splitio-commons 1.15.1-rc.3 → 1.16.1-rc.0

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;

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/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> {
 }

package/types/sync/polling/syncTasks/mySegmentsSyncTask.d.ts

@@ -1,9 +1,8 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
+import { ISegmentsCacheSync } from '../../../storages/types';
 import { IMySegmentsSyncTask } from '../types';
 import { IFetchMySegments } from '../../../services/types';
 import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): IMySegmentsSyncTask;
+export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, mySegmentsCache: ISegmentsCacheSync, notifyUpdate: () => void, settings: ISettings, matchingKey: string, segmentsRefreshRate: number): IMySegmentsSyncTask;

package/types/sync/polling/types.d.ts

@@ -13,18 +13,25 @@ export declare type MySegmentsData = string[] | {
     name: string;
     add: boolean;
 };
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, delay?: number], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;
     splitsSyncTask: ISplitsSyncTask;
     segmentsSyncTask: ISyncTask;
+    largeSegmentsSyncTask?: ISyncTask;
 }
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-    add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask;
+    add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): {
+        msSyncTask: IMySegmentsSyncTask;
+        mlsSyncTask?: IMySegmentsSyncTask;
+    };
     remove(matchingKey: string): void;
-    get(matchingKey: string): IMySegmentsSyncTask | undefined;
+    get(matchingKey: string): {
+        msSyncTask: IMySegmentsSyncTask;
+        mlsSyncTask?: IMySegmentsSyncTask;
+    } | undefined;
 }

package/types/sync/polling/updaters/mySegmentsUpdater.d.ts

@@ -1,13 +1,13 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
-import { ISegmentsEventEmitter } from '../../../readiness/types';
+import { ISegmentsCacheSync } from '../../../storages/types';
 import { ILogger } from '../../../logger/types';
-declare type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>;
+import { MySegmentsData } from '../types';
+declare type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>;
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, splitsCache: ISplitsCacheSync, mySegmentsCache: ISegmentsCacheSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
+export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, mySegmentsCache: ISegmentsCacheSync, notifyUpdate: () => void, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
 export {};

package/types/sync/streaming/SSEHandler/types.d.ts

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE } from '../types';
 export interface IMySegmentsUpdateData {
     type: MY_SEGMENTS_UPDATE;
     changeNumber: number;
@@ -29,6 +29,17 @@ export interface IMySegmentsUpdateV2Data {
     d: string;
     u: UpdateStrategy;
 }
+export interface IMyLargeSegmentsUpdateData {
+    type: MY_LARGE_SEGMENTS_UPDATE;
+    changeNumber: number;
+    largeSegments: string[];
+    c: Compression;
+    d: string;
+    u: UpdateStrategy;
+    i?: number;
+    h?: number;
+    s?: number;
+}
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
     changeNumber: number;
@@ -57,7 +68,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,7 +1,8 @@
 import { IMySegmentsSyncTask } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
+import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker;
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker;

package/types/sync/streaming/constants.d.ts

@@ -24,6 +24,7 @@ export declare const MY_SEGMENTS_UPDATE_V2 = "MY_SEGMENTS_UPDATE_V2";
 export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
 export declare const SPLIT_KILL = "SPLIT_KILL";
 export declare const SPLIT_UPDATE = "SPLIT_UPDATE";
+export declare const MY_LARGE_SEGMENTS_UPDATE = "MY_LARGE_SEGMENTS_UPDATE";
 export declare const CONTROL = "CONTROL";
 export declare const OCCUPANCY = "OCCUPANCY";
 export declare enum ControlType {

package/types/sync/streaming/pushManager.d.ts

@@ -1,6 +1,8 @@
 import { IPushManager } from './types';
 import { IPollingManager } from '../polling/types';
+import { IMyLargeSegmentsUpdateData } from './SSEHandler/types';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+export declare function getDelay(parsedData: IMyLargeSegmentsUpdateData, matchingKey: string): number;
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.

package/types/sync/streaming/types.d.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';
@@ -12,10 +12,11 @@ export declare type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export declare type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export declare type SPLIT_KILL = 'SPLIT_KILL';
 export declare type SPLIT_UPDATE = 'SPLIT_UPDATE';
+export declare type MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 export declare type CONTROL = 'CONTROL';
 export declare type OCCUPANCY = 'OCCUPANCY';
-export declare 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;
-declare type IParsedData<T extends IPushEvent> = T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData : T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : undefined;
+export declare 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;
+declare 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;
 /**
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it
@@ -29,7 +30,7 @@ export interface IPushEventEmitter extends IEventEmitter {
  * PushManager
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
-    add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void;
+    add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask): void;
     remove(userKey: string): void;
 }
 export {};

package/types/sync/submitters/types.d.ts

@@ -90,7 +90,7 @@ export declare type DROPPED = 1;
 export declare type DEDUPED = 2;
 export declare type ImpressionDataType = QUEUED | DROPPED | DEDUPED;
 export declare type EventDataType = QUEUED | DROPPED;
-export declare type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT;
+export declare type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT | MY_LARGE_SEGMENT;
 export declare type SPLITS = 'sp';
 export declare type IMPRESSIONS = 'im';
 export declare type IMPRESSIONS_COUNT = 'ic';
@@ -99,7 +99,8 @@ export declare type TELEMETRY = 'te';
 export declare type TOKEN = 'to';
 export declare type SEGMENT = 'se';
 export declare type MY_SEGMENT = 'ms';
-export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
+export declare type MY_LARGE_SEGMENT = 'mls';
+export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT | MY_LARGE_SEGMENT;
 export declare type LastSync = Partial<Record<OperationType, number | undefined>>;
 export declare type HttpErrors = Partial<Record<OperationType, {
     [statusCode: string]: number;
@@ -136,8 +137,9 @@ export declare type TelemetryUsageStats = {
     mE?: MethodExceptions;
 };
 export declare type UpdatesFromSSE = {
-    sp: number;
+    sp?: number;
     ms?: number;
+    mls?: number;
 };
 export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     lS: LastSync;
@@ -151,6 +153,8 @@ export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     spC?: number;
     seC?: number;
     skC?: number;
+    lseC?: number;
+    lskC?: number;
     sL?: number;
     eQ: number;
     eD: number;
@@ -173,6 +177,7 @@ export declare type RefreshRates = {
     sp: number;
     se?: number;
     ms?: number;
+    mls?: number;
     im: number;
     ev: number;
     te: number;
@@ -193,6 +198,7 @@ export declare type TelemetryConfigStats = {
 };
 export declare type TelemetryConfigStatsPayload = TelemetryConfigStats & {
     sE: boolean;
+    lE?: boolean;
     rR: RefreshRates;
     uO: UrlOverrides;
     iQ: number;

package/types/types.d.ts

@@ -80,6 +80,7 @@ export interface ISettings {
         metricsRefreshRate?: number;
         telemetryRefreshRate: number;
         segmentsRefreshRate: number;
+        largeSegmentsRefreshRate: number;
         offlineRefreshRate: number;
         eventsPushRate: number;
         eventsQueueSize: number;
@@ -90,6 +91,7 @@ export interface ISettings {
         requestTimeoutBeforeReady: number;
         retriesOnFailureBeforeReady: number;
         eventsFirstPushWindow: number;
+        waitForLargeSegments: boolean;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
     readonly integrations: Array<{
@@ -113,6 +115,7 @@ export interface ISettings {
         __splitFiltersValidation: ISplitFiltersValidation;
         localhostMode?: SplitIO.LocalhostFactory;
         enabled: boolean;
+        largeSegmentsEnabled: boolean;
         flagSpecVersion: string;
     };
     readonly runtime: {
@@ -810,6 +813,13 @@ export declare 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.
@@ -854,6 +864,13 @@ export declare 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
@@ -926,6 +943,14 @@ export declare 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/types/utils/constants/index.d.ts

@@ -53,6 +53,7 @@ export declare const TELEMETRY = "te";
 export declare const TOKEN = "to";
 export declare const SEGMENT = "se";
 export declare const MY_SEGMENT = "ms";
+export declare const MY_LARGE_SEGMENT = "mls";
 export declare const TREATMENT = "t";
 export declare const TREATMENTS = "ts";
 export declare const TREATMENT_WITH_CONFIG = "tc";
@@ -79,3 +80,5 @@ export declare const DISABLED = 0;
 export declare const ENABLED = 1;
 export declare const PAUSED = 2;
 export declare const FLAG_SPEC_VERSION = "1.1";
+export declare const IN_SEGMENT = "IN_SEGMENT";
+export declare const IN_LARGE_SEGMENT = "IN_LARGE_SEGMENT";

package/types/utils/settingsValidation/index.d.ts

@@ -12,6 +12,7 @@ export declare const base: {
     scheduler: {
         featuresRefreshRate: number;
         segmentsRefreshRate: number;
+        largeSegmentsRefreshRate: number;
         telemetryRefreshRate: number;
         impressionsRefreshRate: number;
         offlineRefreshRate: number;
@@ -39,6 +40,7 @@ export declare const base: {
         localhostMode: undefined;
         enabled: boolean;
         flagSpecVersion: string;
+        largeSegmentsEnabled: boolean;
     };
     log: undefined;
 };

package/types/utils/settingsValidation/types.d.ts

@@ -28,7 +28,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'];
 }