@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.5

package/src/trackers/impressionsTracker.ts

@@ -19,7 +19,6 @@ export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
   strategy: IStrategy,
-  whenInit: (cb: () => void) => void,
   integrationsManager?: IImpressionsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
 ): IImpressionsTracker {
@@ -68,18 +67,16 @@ export function impressionsTrackerFactory(
           };
 
           // Wrap in a timeout because we don't want it to be blocking.
-          whenInit(() => {
-            setTimeout(() => {
-              // integrationsManager.handleImpression does not throw errors
-              if (integrationsManager) integrationsManager.handleImpression(impressionData);
+          setTimeout(function () {
+            // integrationsManager.handleImpression does not throw errors
+            if (integrationsManager) integrationsManager.handleImpression(impressionData);
 
-              try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                if (impressionListener) impressionListener.logImpression(impressionData);
-              } catch (err) {
-                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-              }
-            });
-          });
+            try { // @ts-ignore. An exception on the listeners should not break the SDK.
+              if (impressionListener) impressionListener.logImpression(impressionData);
+            } catch (err) {
+              log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+            }
+          }, 0);
         }
       }
     }

package/src/trackers/types.ts

@@ -65,7 +65,6 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
-  start(): void;
   stop(): void;
   track(key: string, featureName: string): void;
 }

package/src/trackers/uniqueKeysTracker.ts

@@ -25,6 +25,10 @@ export function uniqueKeysTrackerFactory(
 ): IUniqueKeysTracker {
   let intervalId: any;
 
+  if (filterAdapter.refreshRate) {
+    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+  }
+
   return {
 
     track(key: string, featureName: string): void {
@@ -35,12 +39,6 @@ export function uniqueKeysTrackerFactory(
       uniqueKeysCache.track(key, featureName);
     },
 
-    start(): void {
-      if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-      }
-    },
-
     stop(): void {
       clearInterval(intervalId);
     }

package/src/types.ts

@@ -1,4 +1,4 @@
-import { ISplit, ISplitFiltersValidation } from './dtos/types';
+import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -98,7 +98,6 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
-  readonly preloadedData?: SplitIO.PreloadedData,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -427,7 +426,7 @@ export interface IStatusInterface extends IEventEmitter {
  * @interface IBasicClient
  * @extends IStatusInterface
  */
-export interface IBasicClient extends IStatusInterface {
+interface IBasicClient extends IStatusInterface {
   /**
    * Flush data
    * @function flush
@@ -460,12 +459,6 @@ interface IBasicSDK {
    * @property Logger
    */
   Logger: ILoggerAPI
-  /**
-   * Destroy all the clients created by this factory.
-   * @function destroy
-   * @returns {Promise<void>}
-   */
-  destroy(): Promise<void>
 }
 /****** Exposed namespace ******/
 /**
@@ -772,20 +765,21 @@ export namespace SplitIO {
      * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
      * @TODO configurable expiration time policy?
      */
-    // lastUpdated: number,
+    lastUpdated: number,
     /**
      * Change number of the preloaded data.
      * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
      */
     since: number,
     /**
-     * List of feature flag definitions.
-     * @TODO rename to flags
+     * Map of feature flags to their stringified definitions.
      */
-    splitsData: ISplit[],
+    splitsData: {
+      [splitName: string]: string
+    },
     /**
      * Optional map of user keys to their list of segments.
-     * @TODO rename to memberships
+     * @TODO remove when releasing first version
      */
     mySegmentsData?: {
       [key: string]: string[]
@@ -793,10 +787,9 @@ export namespace SplitIO {
     /**
      * Optional map of segments to their stringified definitions.
      * This property is ignored if `mySegmentsData` was provided.
-     * @TODO rename to segments
      */
     segmentsData?: {
-      [segmentName: string]: string[]
+      [segmentName: string]: string
     },
   }
   /**

package/src/utils/constants/index.ts

@@ -75,7 +75,7 @@ export const EVENTS = 'ev';
 export const TELEMETRY = 'te';
 export const TOKEN = 'to';
 export const SEGMENT = 'se';
-export const MEMBERSHIPS = 'ms';
+export const MY_SEGMENT = 'ms';
 
 export const TREATMENT = 't';
 export const TREATMENTS = 'ts';
@@ -105,8 +105,7 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAG_SPEC_VERSION = '1.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

@@ -209,12 +209,11 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
   sync.splitFilters = splitFiltersValidation.validFilters;
   sync.__splitFiltersValidation = splitFiltersValidation;
-
-  // 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 ? consent(withDefaults) : undefined;
+  withDefaults.userConsent = consent(withDefaults);
 
   return withDefaults;
 }

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -3,6 +3,14 @@ import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
 import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
+
+export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
+  const result = InMemoryStorageCSFactory(params);
+  result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
+  return result;
+}
+__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 
 /**
  * This function validates `settings.storage` object
@@ -22,6 +30,11 @@ export function validateStorageCS(settings: { log: ILogger, storage?: any, mode:
     log.error(ERROR_STORAGE_INVALID);
   }
 
+  // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
+  if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
+    return __InLocalStorageMockFactory;
+  }
+
   if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
     // Consumer modes require an async storage
     if (storage.type !== STORAGE_PLUGGABLE) throw new Error('A PluggableStorage instance is required on consumer mode');

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

@@ -21,9 +21,6 @@ export interface IWhitelistMatcherData {
 export interface IInSegmentMatcherData {
     segmentName: string;
 }
-export interface IInLargeSegmentMatcherData {
-    largeSegmentName: string;
-}
 export interface IDependencyMatcherData {
     split: string;
     treatments: string[];
@@ -36,7 +33,6 @@ interface ISplitMatcherBase {
         attribute: string | null;
     };
     userDefinedSegmentMatcherData?: null | IInSegmentMatcherData;
-    userDefinedLargeSegmentMatcherData?: null | IInLargeSegmentMatcherData;
     whitelistMatcherData?: null | IWhitelistMatcherData;
     unaryNumericMatcherData?: null | IUnaryNumericMatcherData;
     betweenMatcherData?: null | IBetweenMatcherData;
@@ -52,10 +48,6 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
     matcherType: 'IN_SEGMENT';
     userDefinedSegmentMatcherData: IInSegmentMatcherData;
 }
-interface IInLargeSegmentMatcher extends ISplitMatcherBase {
-    matcherType: 'IN_LARGE_SEGMENT';
-    userDefinedLargeSegmentMatcherData: IInLargeSegmentMatcherData;
-}
 interface IWhitelistMatcher extends ISplitMatcherBase {
     matcherType: 'WHITELIST';
     whitelistMatcherData: IWhitelistMatcherData;
@@ -136,7 +128,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 | IInLargeSegmentMatcher;
+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;
 /** Split object */
 export interface ISplitPartition {
     treatment: string;
@@ -181,16 +173,13 @@ 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 {
-    cn?: number;
-    k?: {
-        n: string;
-    }[];
-}
-/** Interface of the parsed JSON response of `/memberships/{userKey}` */
-export interface IMembershipsResponse {
-    ms?: IMySegmentsResponse;
-    ls?: IMySegmentsResponse;
+    mySegments: IMySegmentsResponseItem[];
 }
 /** Metadata internal type for storages */
 export interface IMetadata {

package/types/evaluator/matchersTransform/segment.d.ts

@@ -1,5 +1,5 @@
-import { IInSegmentMatcherData, IInLargeSegmentMatcherData } from '../../dtos/types';
+import { IInSegmentMatcherData } from '../../dtos/types';
 /**
  * Extract segment name as a plain string.
  */
-export declare function segmentTransform(segment?: IInSegmentMatcherData | IInLargeSegmentMatcherData): string | undefined;
+export declare function segmentTransform(segment?: IInSegmentMatcherData): string | undefined;

package/types/logger/constants.d.ts

@@ -77,7 +77,7 @@ export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
-export declare const STREAMING_PARSING_MEMBERSHIPS_UPDATE = 223;
+export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export declare const WARN_INVALID_FLAGSET = 225;
 export declare const WARN_LOWERCASE_FLAGSET = 226;

package/types/readiness/readinessManager.d.ts

@@ -1,6 +1,6 @@
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } 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, settings: ISettings, splits?: ISplitsEventEmitter): IReadinessManager;
+export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, readyTimeout?: number, splits?: ISplitsEventEmitter): IReadinessManager;

package/types/readiness/sdkReadinessManager.d.ts

@@ -1,5 +1,6 @@
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } from '../types';
+import { ILogger } from '../logger/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.
@@ -7,4 +8,4 @@ import { IEventEmitter, ISettings } from '../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(EventEmitter: new () => IEventEmitter, settings: ISettings, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/readiness/types.d.ts

@@ -46,9 +46,8 @@ export interface IReadinessManager {
     timeout(): void;
     setDestroyed(): void;
     destroy(): void;
-    init(): void;
     /** for client-side */
-    shared(): IReadinessManager;
+    shared(readyTimeout?: number): IReadinessManager;
 }
 /** SDK readiness manager */
 export interface ISdkReadinessManager {
@@ -60,6 +59,6 @@ export interface ISdkReadinessManager {
      */
     incInternalReadyCbCount(): void;
     /** for client-side */
-    shared(): ISdkReadinessManager;
+    shared(readyTimeout?: number): ISdkReadinessManager;
 }
 export {};

package/types/sdkClient/sdkClientMethod.d.ts

@@ -1,6 +1,6 @@
 import { SplitIO } from '../types';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
- * Factory of client method for server-side SDKs
+ * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
 export declare function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkFactory/types.d.ts

@@ -8,7 +8,7 @@ import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
-import { SplitIO, ISettings, IEventEmitter, IBasicClient } from '../types';
+import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
  */
@@ -47,8 +47,6 @@ export interface ISdkFactoryContext {
     signalListener?: ISignalListener;
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
-    clients: Record<string, IBasicClient>;
-    whenInit(cb: () => void): void;
 }
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
     storage: IStorageSync;
@@ -64,7 +62,6 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
-    isPure?: boolean;
     settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;

package/types/services/decorateHeaders.d.ts

@@ -1,2 +1,3 @@
 import { ISettings } from '../types';
 export declare function decorateHeaders(settings: ISettings, headers: Record<string, string>): Record<string, string>;
+export declare function removeNonISO88591(input: string): string;

package/types/services/splitApi.d.ts

@@ -9,4 +9,4 @@ import { ITelemetryTracker } from '../trackers/types';
  * @param platform object containing environment-specific dependencies
  * @param telemetryTracker telemetry tracker
  */
-export declare function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISplitApi;
+export declare function splitApiFactory(settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker): ISplitApi;

package/types/services/splitHttpClient.d.ts

@@ -7,4 +7,4 @@ import { IPlatform } from '../sdkFactory/types';
  * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
  * @param platform object containing environment-specific dependencies
  */
-export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient;
+export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient;

package/types/services/types.d.ts

@@ -18,7 +18,7 @@ export declare type ISplitHttpClient = (url: string, options?: IRequestOptions,
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
-export declare type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>;
+export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
@@ -32,7 +32,7 @@ export interface ISplitApi {
     fetchAuth: IFetchAuth;
     fetchSplitChanges: IFetchSplitChanges;
     fetchSegmentChanges: IFetchSegmentChanges;
-    fetchMemberships: IFetchMemberships;
+    fetchMySegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
     postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
     postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -1,5 +1,3 @@
-import { IMySegmentsResponse } from '../dtos/types';
-import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
 /**
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
@@ -24,7 +22,7 @@ export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCach
     /**
      * clear the cache.
      */
-    clear(): void;
+    abstract clear(): void;
     /**
      * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
      * For client-side synchronizer: the method is not used.
@@ -41,14 +39,18 @@ export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCach
      */
     abstract getKeysCount(): number;
     /**
-     * For server-side synchronizer: change number of `name` segment.
-     * For client-side synchronizer: change number of mySegments.
+     * For server-side synchronizer: set the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    setChangeNumber(name: string, changeNumber: number): boolean;
+    /**
+     * For server-side synchronizer: get the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
      */
-    abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void;
-    abstract getChangeNumber(name: string): number;
+    getChangeNumber(name: string): number | undefined;
     /**
      * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: it resets or updates the cache.
+     * For client-side synchronizer: reset the cache with the given list of segments.
      */
-    resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
+    resetSegments(names: string[]): boolean;
 }

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -19,6 +19,11 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
     usesSegments(): 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.
+     */
+    checkCache(): Promise<boolean>;
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -12,13 +12,18 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
     removeSplits(names: string[]): boolean[];
     abstract getSplit(name: string): ISplit | null;
     getSplits(names: string[]): Record<string, ISplit | null>;
-    abstract setChangeNumber(changeNumber: number): boolean | void;
+    abstract setChangeNumber(changeNumber: number): boolean;
     abstract getChangeNumber(): number;
     getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
     abstract usesSegments(): boolean;
     abstract clear(): void;
+    /**
+     * Check if the splits information is already stored in cache. This data can be preloaded.
+     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+     */
+    checkCache(): boolean;
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/types/storages/KeyBuilderCS.d.ts

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

package/types/storages/dataLoader.d.ts

@@ -1,21 +1,10 @@
 import { SplitIO } from '../types';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
+import { DataLoader } from './types';
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side storage loader
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
- * @param storage object containing `splits` and `segments` cache (client-side variant)
- * @param userKey user key (matching key) of the provided MySegmentsCache
- *
- * @TODO extend to load largeSegments
- * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
- * @TODO add logs, and input validation in this module, in favor of size reduction.
- * @TODO unit tests
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
+ * and extended with a `mySegmentsData` property.
+ * @returns function to preload the storage
  */
-export declare function loadData(preloadedData: SplitIO.PreloadedData, storage: {
-    splits?: ISplitsCacheSync;
-    segments: ISegmentsCacheSync;
-    largeSegments?: ISegmentsCacheSync;
-}, matchingKey?: string): void;
-export declare function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData;
+export declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;

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

@@ -1,15 +1,25 @@
 import { ILogger } from '../../logger/types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     private readonly keys;
     private readonly log;
-    constructor(log: ILogger, keys: MySegmentsKeyBuilder);
+    constructor(log: ILogger, keys: KeyBuilderCS);
+    /**
+     * Removes list of segments from localStorage
+     * @NOTE this method is not being used at the moment.
+     */
+    clear(): void;
     addToSegment(name: string): boolean;
     removeFromSegment(name: string): boolean;
     isInSegment(name: string): boolean;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     *
+     * @param {string[]} segmentNames list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    resetSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name?: string, changeNumber?: number): void;
-    getChangeNumber(): number;
 }

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

@@ -35,6 +35,12 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): 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.
+     * @override
+     */
+    checkCache(): boolean;
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *

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

@@ -5,12 +5,18 @@ import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
  */
 export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private segmentCache;
-    private cn?;
+    clear(): void;
     addToSegment(name: string): boolean;
     removeFromSegment(name: string): boolean;
     isInSegment(name: string): boolean;
-    setChangeNumber(name?: string, changeNumber?: number): void;
-    getChangeNumber(): number;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     * @NOTE based on the way we use segments in the browser, this way is the best option
+     *
+     * @param {string[]} names list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    resetSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
 }

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

@@ -15,5 +15,5 @@ export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     getRegisteredSegments(): string[];
     getKeysCount(): number;
     setChangeNumber(name: string, changeNumber: number): boolean;
-    getChangeNumber(name: string): number;
+    getChangeNumber(name: string): number | undefined;
 }

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

@@ -10,7 +10,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private splitsCache;
     private ttCache;
     private changeNumber;
-    private segmentsCount;
+    private splitsWithSegmentsCount;
     private flagSetsCache;
     constructor(splitFiltersValidation?: ISplitFiltersValidation);
     clear(): void;