@splitsoftware/splitio-commons 2.0.0-rc.2 → 2.0.0-rc.3

package/src/sdkFactory/index.ts

@@ -7,7 +7,7 @@ import { IBasicClient, SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -43,7 +43,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const storage = storageFactory({
     settings,
-    onReadyCb(error) {
+    onReadyCb: (error) => {
       if (error) {
         // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
         readiness.timeout();
@@ -52,11 +52,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    onReadyFromCacheCb() {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-    }
   });
-
+  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
   const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });

package/src/storages/dataLoader.ts

@@ -1,114 +1,55 @@
 import { SplitIO } from '../types';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
-import { setToArray } from '../utils/lang/sets';
-import { getMatching } from '../utils/key';
-import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
+import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } 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 function loadData(preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  // Do not load data if current preloadedData is empty
-  if (Object.keys(preloadedData).length === 0) return;
-
-  const { segmentsData = {}, since = -1, splitsData = [] } = preloadedData;
+export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
+
+  /**
+   * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+   * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+   *
+   * @param storage object containing `splits` and `segments` cache (client-side variant)
+   * @param userId user key string of the provided MySegmentsCache
+   *
+   * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
+   * @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.
+   */
+  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0) return;
+
+    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
 
-  if (storage.splits) {
     const storedSince = storage.splits.getChangeNumber();
+    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    // Do not load data if current data is more recent
-    if (storedSince > since) return;
+    // Do not load data if current localStorage data is more recent,
+    // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+    if (storedSince > since || lastUpdated < expirationTimestamp) return;
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(splitsData.map(split => ([split.name, split])));
-  }
-
-  if (matchingKey) { // add mySegments data (client-side)
-    let membershipsData = preloadedData.membershipsData && preloadedData.membershipsData[matchingKey];
-    if (!membershipsData && segmentsData) {
-      membershipsData = {
-        ms: {
-          k: Object.keys(segmentsData).filter(segmentName => {
-            const segmentKeys = segmentsData[segmentName];
-            return segmentKeys.indexOf(matchingKey) > -1;
-          }).map(segmentName => ({ n: segmentName }))
-        }
-      };
-    }
-    if (membershipsData) {
-      if (membershipsData.ms) storage.segments.resetSegments(membershipsData.ms);
-      if (membershipsData.ls && storage.largeSegments) storage.largeSegments.resetSegments(membershipsData.ls);
+    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
+
+    // add mySegments data
+    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+    if (!mySegmentsData) {
+      // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
+      mySegmentsData = Object.keys(segmentsData).filter(segmentName => {
+        const userIds = JSON.parse(segmentsData[segmentName]).added;
+        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+      });
     }
-
-  } else { // add segments data (server-side)
-    Object.keys(segmentsData).forEach(segmentName => {
-      const segmentKeys = segmentsData[segmentName];
-      storage.segments.update(segmentName, segmentKeys, [], -1);
-    });
-  }
-}
-
-export function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
-  return {
-    // lastUpdated: Date.now(),
-    since: storage.splits.getChangeNumber(),
-    splitsData: storage.splits.getAll(),
-    segmentsData: userKeys ?
-      undefined : // @ts-ignore accessing private prop
-      Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
-        prev[cur] = setToArray(storage.segments.segmentCache[cur] as Set<string>);
-        return prev;
-      }, {}),
-    membershipsData: userKeys ?
-      userKeys.reduce<Record<string, IMembershipsResponse>>((prev, userKey) => {
-        if (storage.shared) {
-          // Client-side segments
-          // @ts-ignore accessing private prop
-          const sharedStorage = storage.shared(userKey);
-          prev[getMatching(userKey)] = {
-            ms: {
-              // @ts-ignore accessing private prop
-              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
-              // cn: sharedStorage.segments.getChangeNumber()
-            },
-            ls: sharedStorage.largeSegments ? {
-              // @ts-ignore accessing private prop
-              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
-              // cn: sharedStorage.largeSegments.getChangeNumber()
-            } : undefined
-          };
-        } else {
-          prev[getMatching(userKey)] = {
-            ms: {
-              // Server-side segments
-              // @ts-ignore accessing private prop
-              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore accessing private prop
-                return storage.segments.segmentCache[segmentName].has(userKey) ?
-                  prev!.concat({ n: segmentName }) :
-                  prev;
-              }, [])
-            },
-            ls: {
-              k: []
-            }
-          };
-        }
-        return prev;
-      }, {}) :
-      undefined
+    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
   };
 }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,8 +7,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { loadData } from '../dataLoader';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -16,7 +14,7 @@ import { loadData } from '../dataLoader';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
@@ -44,18 +42,11 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-    shared(matchingKey: string) {
-      const segments = new MySegmentsCacheInMemory();
-      const largeSegments = new MySegmentsCacheInMemory();
-
-      if (preloadedData) {
-        loadData(preloadedData, { segments, largeSegments }, matchingKey);
-      }
-
+    shared() {
       return {
         splits: this.splits,
-        segments,
-        largeSegments,
+        segments: new MySegmentsCacheInMemory(),
+        largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -81,12 +72,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     if (storage.uniqueKeys) storage.uniqueKeys.track = noopTrack;
   }
 
-
-  if (preloadedData) {
-    loadData(preloadedData, storage, getMatching(params.settings.core.key));
-    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
-  }
-
   return storage;
 }
 

package/src/storages/types.ts

@@ -488,6 +488,8 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
+export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
+
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -495,10 +497,6 @@ export interface IStorageFactoryParams {
    * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
    */
   onReadyCb: (error?: any) => void,
-  /**
-   * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
-   */
-  onReadyFromCacheCb: () => void,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

package/src/sync/offline/LocalhostFromObject.ts

@@ -1,12 +1,6 @@
 import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
 import { syncManagerOfflineFactory } from './syncManagerOffline';
-import { SplitIO } from '../../types';
 
-// Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)
+// Singleton instance of the factory function for offline SyncManager from object
 // SDK instances instantiate their SyncManagers with the same factory
-const localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory) as SplitIO.LocalhostFactory;
-localhostFromObject.type = 'LocalhostFromObject';
-
-export function LocalhostFromObject(): SplitIO.LocalhostFactory {
-  return localhostFromObject;
-}
+export const localhostFromObjectFactory = syncManagerOfflineFactory(splitsParserFromSettingsFactory);

package/src/types.ts

@@ -1,11 +1,8 @@
-import { IMembershipsResponse, ISplit, ISplitFiltersValidation } from './dtos/types';
+/* eslint-disable no-use-before-define */
+import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
-import { ISdkFactoryContext } from './sdkFactory/types';
-/* eslint-disable no-use-before-define */
-
 import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
-import { ISyncManagerCS } from './sync/types';
 
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
@@ -97,7 +94,6 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
-  readonly preloadedData?: SplitIO.PreloadedData,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -117,7 +113,6 @@ export interface ISettings {
     splitFilters: SplitIO.SplitFilter[],
     impressionsMode: SplitIO.ImpressionsMode,
     __splitFiltersValidation: ISplitFiltersValidation,
-    localhostMode?: SplitIO.LocalhostFactory,
     enabled: boolean,
     flagSpecVersion: string,
     requestOptions?: {
@@ -667,13 +662,6 @@ export namespace SplitIO {
    * @typedef {Promise<SplitNames>} SplitNamesAsync
    */
   export type SplitNamesAsync = Promise<SplitNames>;
-  /**
-   * Localhost mode factory.
-   */
-  export type LocalhostFactory = {
-    type: 'LocalhostFromObject' | 'LocalhostFromFile'
-    (params: ISdkFactoryContext): ISyncManagerCS
-  }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
@@ -771,31 +759,31 @@ 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 memberships.
-     * @TODO rename to memberships
+     * Optional map of user keys to their list of segments.
+     * @TODO remove when releasing first version
      */
-    membershipsData?: {
-      [key: string]: IMembershipsResponse
+    mySegmentsData?: {
+      [key: string]: string[]
     },
     /**
-     * Optional map of segments to their list of keys.
-     * This property is ignored if `membershipsData` was provided.
-     * @TODO rename to segments
+     * Optional map of segments to their stringified definitions.
+     * This property is ignored if `mySegmentsData` was provided.
      */
     segmentsData?: {
-      [segmentName: string]: string[]
+      [segmentName: string]: string
     },
   }
   /**

package/src/utils/settingsValidation/index.ts

@@ -80,7 +80,6 @@ export const base = {
     splitFilters: undefined,
     // impressions collection mode
     impressionsMode: OPTIMIZED,
-    localhostMode: undefined,
     enabled: true,
     flagSpecVersion: FLAG_SPEC_VERSION
   },
@@ -102,7 +101,7 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger, localhost, consent, flagSpec } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, consent, flagSpec } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
   const withDefaults = merge({}, base, defaults, config) as ISettings;
@@ -180,8 +179,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (integrations) withDefaults.integrations = integrations(withDefaults);
 
-  if (localhost) sync.localhostMode = localhost(withDefaults);
-
   // validate push options
   if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
     withDefaults.streamingEnabled = true;

package/src/utils/settingsValidation/types.ts

@@ -20,8 +20,6 @@ export interface ISettingsValidationParams {
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator (`settings.debug`) */
   logger: (settings: ISettings) => ISettings['log'],
-  /** Localhost mode validator (`settings.sync.localhostMode`) */
-  localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
   /** User consent validator (`settings.userConsent`) */
   consent?: (settings: ISettings) => ISettings['userConsent'],
   /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */

package/types/logger/constants.d.ts

@@ -106,7 +106,6 @@ export declare const ERROR_EMPTY = 319;
 export declare const ERROR_EMPTY_ARRAY = 320;
 export declare const ERROR_INVALID_CONFIG_PARAM = 321;
 export declare const ERROR_HTTP = 322;
-export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const ERROR_STORAGE_INVALID = 324;
 export declare const ERROR_NOT_BOOLEAN = 325;
 export declare const ERROR_MIN_CONFIG_PARAM = 326;

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/types.d.ts

@@ -387,6 +387,7 @@ export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCa
 export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
+export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     settings: ISettings;
     /**
@@ -394,10 +395,6 @@ export interface IStorageFactoryParams {
      * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
      */
     onReadyCb: (error?: any) => void;
-    /**
-     * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
-     */
-    onReadyFromCacheCb: () => void;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/sync/offline/LocalhostFromObject.d.ts

@@ -1,2 +1 @@
-import { SplitIO } from '../../types';
-export declare function LocalhostFromObject(): SplitIO.LocalhostFactory;
+export declare const localhostFromObjectFactory: (params: import("../../sdkFactory/types").ISdkFactoryContextSync) => import("../types").ISyncManagerCS;

package/types/types.d.ts

@@ -1,9 +1,7 @@
-import { IMembershipsResponse, 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';
 import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
-import { ISyncManagerCS } from './sync/types';
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
  * @see {@link https://nodejs.org/api/events.html}
@@ -91,7 +89,6 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
-    readonly preloadedData?: SplitIO.PreloadedData;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -111,7 +108,6 @@ export interface ISettings {
         splitFilters: SplitIO.SplitFilter[];
         impressionsMode: SplitIO.ImpressionsMode;
         __splitFiltersValidation: ISplitFiltersValidation;
-        localhostMode?: SplitIO.LocalhostFactory;
         enabled: boolean;
         flagSpecVersion: string;
         requestOptions?: {
@@ -660,13 +656,6 @@ export declare namespace SplitIO {
      * @typedef {Promise<SplitNames>} SplitNamesAsync
      */
     type SplitNamesAsync = Promise<SplitNames>;
-    /**
-     * Localhost mode factory.
-     */
-    type LocalhostFactory = {
-        type: 'LocalhostFromObject' | 'LocalhostFromFile';
-        (params: ISdkFactoryContext): ISyncManagerCS;
-    };
     /**
      * Impression listener interface. This is the interface that needs to be implemented
      * by the element you provide to the SDK as impression listener.
@@ -770,30 +759,31 @@ export declare 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;
         /**
          * 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 memberships.
-         * @TODO rename to memberships
+         * Optional map of user keys to their list of segments.
+         * @TODO remove when releasing first version
          */
-        membershipsData?: {
-            [key: string]: IMembershipsResponse;
+        mySegmentsData?: {
+            [key: string]: string[];
         };
         /**
-         * Optional map of segments to their list of keys.
-         * This property is ignored if `membershipsData` was provided.
-         * @TODO rename to segments
+         * Optional map of segments to their stringified definitions.
+         * This property is ignored if `mySegmentsData` was provided.
          */
         segmentsData?: {
-            [segmentName: string]: string[];
+            [segmentName: string]: string;
         };
     }
     /**

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

@@ -35,7 +35,6 @@ export declare const base: {
     sync: {
         splitFilters: undefined;
         impressionsMode: string;
-        localhostMode: undefined;
         enabled: boolean;
         flagSpecVersion: string;
     };

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

@@ -23,8 +23,6 @@ export interface ISettingsValidationParams {
     integrations?: (settings: ISettings) => ISettings['integrations'];
     /** Logger validator (`settings.debug`) */
     logger: (settings: ISettings) => ISettings['log'];
-    /** Localhost mode validator (`settings.sync.localhostMode`) */
-    localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'];
     /** User consent validator (`settings.userConsent`) */
     consent?: (settings: ISettings) => ISettings['userConsent'];
     /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */

package/cjs/utils/settingsValidation/localhost/builtin.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateLocalhostWithDefault = void 0;
-var LocalhostFromObject_1 = require("../../../sync/offline/LocalhostFromObject");
-var pluggable_1 = require("./pluggable");
-/**
- * This function validates `settings.sync.localhostMode` object
- *
- * @param {any} settings config object provided by the user to initialize the sdk
- *
- * @returns {Object} provided localhost mode module at `settings.sync.localhostMode` if valid, or a default LocalhostFromObject instance if not provided or invalid
- */
-function validateLocalhostWithDefault(settings) {
-    if (!settings.sync.localhostMode)
-        return (0, LocalhostFromObject_1.LocalhostFromObject)();
-    return (0, pluggable_1.validateLocalhost)(settings) || (0, LocalhostFromObject_1.LocalhostFromObject)();
-}
-exports.validateLocalhostWithDefault = validateLocalhostWithDefault;

package/cjs/utils/settingsValidation/localhost/pluggable.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateLocalhost = void 0;
-var constants_1 = require("../../../logger/constants");
-var constants_2 = require("../../constants");
-/**
- * This function validates `settings.sync.localhostMode` object
- *
- * @param {any} settings config object provided by the user to initialize the sdk
- *
- * @returns {Object | undefined} provided localhost mode module at `settings.sync.localhostMode`, or undefined if it is not provided or invalid
- */
-function validateLocalhost(settings) {
-    var localhostMode = settings.sync.localhostMode;
-    // localhostMode.type is used for internal validation. Not considered part of the public API, and might be updated eventually.
-    if (settings.mode === constants_2.LOCALHOST_MODE && (typeof localhostMode !== 'function' || localhostMode.type !== 'LocalhostFromObject')) {
-        settings.log.error(constants_1.ERROR_LOCALHOST_MODULE_REQUIRED);
-        return undefined;
-    }
-    return localhostMode;
-}
-exports.validateLocalhost = validateLocalhost;

package/esm/utils/settingsValidation/localhost/builtin.js

@@ -1,14 +0,0 @@
-import { LocalhostFromObject } from '../../../sync/offline/LocalhostFromObject';
-import { validateLocalhost } from './pluggable';
-/**
- * This function validates `settings.sync.localhostMode` object
- *
- * @param {any} settings config object provided by the user to initialize the sdk
- *
- * @returns {Object} provided localhost mode module at `settings.sync.localhostMode` if valid, or a default LocalhostFromObject instance if not provided or invalid
- */
-export function validateLocalhostWithDefault(settings) {
-    if (!settings.sync.localhostMode)
-        return LocalhostFromObject();
-    return validateLocalhost(settings) || LocalhostFromObject();
-}

package/esm/utils/settingsValidation/localhost/pluggable.js

@@ -1,18 +0,0 @@
-import { ERROR_LOCALHOST_MODULE_REQUIRED } from '../../../logger/constants';
-import { LOCALHOST_MODE } from '../../constants';
-/**
- * This function validates `settings.sync.localhostMode` object
- *
- * @param {any} settings config object provided by the user to initialize the sdk
- *
- * @returns {Object | undefined} provided localhost mode module at `settings.sync.localhostMode`, or undefined if it is not provided or invalid
- */
-export function validateLocalhost(settings) {
-    var localhostMode = settings.sync.localhostMode;
-    // localhostMode.type is used for internal validation. Not considered part of the public API, and might be updated eventually.
-    if (settings.mode === LOCALHOST_MODE && (typeof localhostMode !== 'function' || localhostMode.type !== 'LocalhostFromObject')) {
-        settings.log.error(ERROR_LOCALHOST_MODULE_REQUIRED);
-        return undefined;
-    }
-    return localhostMode;
-}