@splitsoftware/splitio-commons 1.17.1-rc.2 → 2.0.0-rc.0

package/src/utils/lang/sets.ts

@@ -1,129 +1,7 @@
-/**
- * Set implementation based on es6-set polyfill (https://github.com/medikoo/es6-set/blob/master/polyfill.js),
- * with the minimal features used by the SDK.
-
-Copyright (C) 2013 Mariusz Nowak (www.medikoo.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-**/
-
-export interface ISet<T> {
-  add(value: T): this;
-  clear(): void;
-  delete(value: T): boolean;
-  forEach(callbackfn: (value: T, value2: T, set: ISet<T>) => void, thisArg?: any): void;
-  has(value: T): boolean;
-  readonly size: number;
-}
-
-export class SetPoly<T> implements ISet<T>{
-  __setData__: T[] = [];
-
-  // unlike ES6 `Set`, it only accepts an array as first argument iterable
-  constructor(values?: readonly T[] | null) {
-    if (Array.isArray(values)) values.forEach(value => { this.add(value); });
-  }
-
-  clear() {
-    if (!this.__setData__.length) return;
-    this.__setData__.length = 0;
-  }
-
-  add(value: T) {
-    if (this.has(value)) return this;
-    this.__setData__.push(value);
-    return this;
-  }
-
-  delete(value: T) {
-    let index = this.__setData__.indexOf(value);
-    if (index === -1) return false;
-    this.__setData__.splice(index, 1);
-    return true;
-  }
-
-  has(value: T) {
-    return this.__setData__.indexOf(value) !== -1;
-  }
-
-  forEach(callbackfn: (value: T, value2: T, set: SetPoly<T>) => void, thisArg?: any): void {
-    if (typeof callbackfn !== 'function') throw new TypeError(callbackfn + ' is not a function');
-
-    for (let i = 0; i < this.__setData__.length; i++) {
-      const value = this.__setData__[i];
-      callbackfn.call(thisArg, value, value, this);
-    }
-  }
-
-  get size() {
-    return this.__setData__.length;
-  }
-
-}
-
-
-/**
- * return an array containing the items of the given set.
- * @param set Set or SetPoly instance
- */
-export function setToArray<T>(set: ISet<T>): T[] {
-  if (set instanceof SetPoly) {
-    return set.__setData__.slice();
-  }
-  // if not using SetPoly as set, it means Array.from is supported
-  // eslint-disable-next-line compat/compat
-  return Array.from(set as Set<T>);
-}
-
-interface ISetConstructor {
-  new <T = any>(values?: readonly T[] | null): ISet<T>;
-  readonly prototype: ISet<any>;
-}
-
-/**
- * return the Set constructor to use. If `Array.from` built-in or native Set is not available or it doesn't support the required features,
- * a ponyfill with minimal features is returned instead.
- *
- * Exported for testing purposes only.
- */
-export function __getSetConstructor(): ISetConstructor {
-  // eslint-disable-next-line compat/compat
-  if (typeof Array.from === 'function' && typeof Set === 'function' && Set.prototype && Set.prototype.values) {
-    return Set;
-  }
-  return SetPoly;
-}
-
-export const _Set = __getSetConstructor();
-
-export function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T> {
-  const result = new _Set(setToArray(set));
-  set2.forEach(value => {
-    result.add(value);
-  });
-  return result;
+export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
+  return new Set(Array.from(set).concat(Array.from(set2)));
 }
 
 export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
-  const result = new _Set(list);
-  list2.forEach(item => {
-    result.delete(item);
-  });
-  return setToArray(result);
+  return list.filter(item => list2.indexOf(item) === -1);
 }

package/src/utils/settingsValidation/index.ts

@@ -6,7 +6,6 @@ import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
 import { validateKey } from '../inputValidation/key';
-import { validateTrafficType } from '../inputValidation/trafficType';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 
 // Exported for telemetry
@@ -19,8 +18,6 @@ export const base = {
     authorizationKey: undefined,
     // key used in your system (only required for browser version)
     key: undefined,
-    // traffic type for the given key (only used on browser version)
-    trafficType: undefined,
     // toggle impressions tracking of labels
     labelsEnabled: true,
     // toggle sendind (true) or not sending (false) IP and Host Name with impressions, events, and telemetries requests (only used on nodejs version)
@@ -168,13 +165,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
       // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
       withDefaults.core.key = validateKey(log, maybeKey, LOG_PREFIX_CLIENT_INSTANTIATION);
     }
-
-    if (validationParams.acceptTT) {
-      const maybeTT = withDefaults.core.trafficType;
-      if (maybeTT !== undefined) { // @ts-ignore
-        withDefaults.core.trafficType = validateTrafficType(log, maybeTT, LOG_PREFIX_CLIENT_INSTANTIATION);
-      }
-    }
   } else {
     // On server-side, key is undefined and used to distinguish from client-side
     if (maybeKey !== undefined) log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore

package/src/utils/settingsValidation/logger/builtinLogger.ts

@@ -3,11 +3,10 @@ import { ILogger } from '../../../logger/types';
 import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable';
 import { isNode } from '../../env/isNode';
 import { codesDebug } from '../../../logger/messages/debug';
-import { _Map } from '../../lang/maps';
 import { getLogLevel } from './commons';
 import { LogLevel } from '../../../types';
 
-const allCodes = new _Map(codesDebug);
+const allCodes = new Map(codesDebug);
 
 // @TODO set default debug setting instead of initialLogLevel when integrating in JS and Node packages
 const LS_KEY = 'splitio_debug';

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

@@ -12,8 +12,6 @@ export interface ISettingsValidationParams {
   defaults: Partial<ISettings> & { version: string } & { startup: ISettings['startup'] },
   /** If true, validates core.key */
   acceptKey?: boolean,
-  /** If true, validates core.trafficType */
-  acceptTT?: boolean,
   /** Define runtime values (`settings.runtime`) */
   runtime: (settings: ISettings) => ISettings['runtime'],
   /** Storage validator (`settings.storage`) */

package/types/logger/index.d.ts

@@ -1,6 +1,5 @@
 import { ILoggerOptions, ILogger } from './types';
 import { LogLevel } from '../types';
-import { IMap } from '../utils/lang/maps';
 export declare const LogLevels: {
     [level: string]: LogLevel;
 };
@@ -10,7 +9,7 @@ export declare class Logger implements ILogger {
     private options;
     private codes;
     private logLevel;
-    constructor(options?: ILoggerOptions, codes?: IMap<number, string>);
+    constructor(options?: ILoggerOptions, codes?: Map<number, string>);
     setLogLevel(logLevel: LogLevel): void;
     debug(msg: string | number, args?: any[]): void;
     info(msg: string | number, args?: any[]): void;

package/types/sdkClient/clientCS.d.ts

@@ -1,10 +1,9 @@
 import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
 /**
- * Decorator that binds a key and (optionally) a traffic type to client methods
+ * Decorator that binds a key to client methods
  *
  * @param client sync client instance
  * @param key validated split key
- * @param trafficType validated traffic type
  */
-export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;
+export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey): SplitIO.ICsClient;

package/types/sdkFactory/types.d.ts

@@ -71,7 +71,7 @@ export interface ISdkFactoryParams {
     sdkManagerFactory: typeof sdkManagerFactory;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;
-        (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
+        (key: SplitIO.SplitKey): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
     impressionsObserverFactory: () => IImpressionObserver;
     filterAdapterFactory?: () => IFilterAdapter;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -1,6 +1,5 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
-import { ISet } from '../utils/lang/sets';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
@@ -15,10 +14,15 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract getChangeNumber(): Promise<number>;
     abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
-    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
+    abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>;
     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

@@ -1,6 +1,5 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
-import { ISet } from '../utils/lang/sets';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -19,6 +18,11 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
     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.
@@ -30,7 +34,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      */
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>[];
+    abstract getNamesByFlagSets(flagSets: string[]): Set<string>[];
 }
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).

package/types/storages/KeyBuilderCS.d.ts

@@ -2,7 +2,6 @@ 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 {
@@ -14,7 +13,6 @@ export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBui
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
-    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
     buildTillKey(): string;

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;
-}, userKey?: string): void;
-export declare function getSnapshot(storage: IStorageSync, userKeys?: string[]): SplitIO.PreloadedData;
+export declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;

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

@@ -1,7 +1,6 @@
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ISet } from '../../utils/lang/sets';
 import { ISettings } from '../../types';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -35,6 +34,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`,
      *
@@ -42,7 +47,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      */
     private _checkExpiration;
     private _checkFilterQuery;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
+    getNamesByFlagSets(flagSets: string[]): Set<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

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

@@ -1,6 +1,5 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
-import { ISet } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -22,7 +21,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
+    getNamesByFlagSets(flagSets: string[]): Set<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

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

@@ -1,18 +1,17 @@
 import { IUniqueKeysCacheBase } from '../types';
-import { ISet } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
  */
 export declare function fromUniqueKeysCollector(uniqueKeys: {
-    [featureName: string]: ISet<string>;
+    [featureName: string]: Set<string>;
 }): UniqueKeysPayloadSs;
 export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     protected onFullQueue?: () => void;
     private readonly maxStorage;
     private uniqueTrackerSize;
     protected uniqueKeysTracker: {
-        [featureName: string]: ISet<string>;
+        [featureName: string]: Set<string>;
     };
     constructor(uniqueKeysQueueSize?: number);
     setOnFullQueueCb(cb: () => void): void;

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -2,7 +2,6 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ILogger } from '../../logger/types';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -79,7 +78,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * The returned promise is resolved with the list of feature flag names per flag set,
      * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
-    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
+    getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

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

@@ -3,7 +3,6 @@ import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -75,7 +74,7 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved with the list of feature flag names per flag set.
      * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
      */
-    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
+    getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

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

@@ -1,5 +1,4 @@
 import { IPluggableStorageWrapper } from '../types';
-import { ISet } from '../../utils/lang/sets';
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
@@ -8,6 +7,6 @@ import { ISet } from '../../utils/lang/sets';
  * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
-    _cache: Record<string, string | string[] | ISet<string>>;
+    _cache: Record<string, string | string[] | Set<string>>;
     _setConnDelay(connDelay: number): void;
 };

package/types/storages/types.d.ts

@@ -2,7 +2,6 @@ import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
-import { ISet } from '../utils/lang/sets';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -192,8 +191,9 @@ export interface ISplitsCacheBase {
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
+    checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
-    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>;
+    getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): boolean[];
@@ -207,8 +207,9 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
     clear(): void;
+    checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
+    getNamesByFlagSets(flagSets: string[]): Set<string>[];
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
@@ -222,8 +223,9 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;
     clear(): Promise<boolean | void>;
+    checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
-    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
+    getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>;
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {
@@ -391,6 +393,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;
     /**
@@ -398,7 +401,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;
-    onReadyFromCacheCb: (error?: any) => void;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

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

@@ -1,4 +1,3 @@
-import { ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit, ISplitFiltersValidation } from '../../../dtos/types';
@@ -12,7 +11,7 @@ declare type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpda
  * Collect segments from a raw split definition.
  * Exported for testing purposes.
  */
-export declare function parseSegments({ conditions }: ISplit): ISet<string>;
+export declare function parseSegments({ conditions }: ISplit): Set<string>;
 interface ISplitMutations {
     added: [string, ISplit][];
     removed: string[];

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

@@ -1,6 +1,5 @@
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
-import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 export declare type ImpressionsPayload = {
     /** Split name */
@@ -79,9 +78,9 @@ export declare type StoredEventWithMetadata = {
     /** Stored event */
     e: SplitIO.EventData;
 };
-export declare type MultiMethodLatencies = IMap<string, MethodLatencies>;
-export declare type MultiMethodExceptions = IMap<string, MethodExceptions>;
-export declare type MultiConfigs = IMap<string, TelemetryConfigStats>;
+export declare type MultiMethodLatencies = Map<string, MethodLatencies>;
+export declare type MultiMethodExceptions = Map<string, MethodExceptions>;
+export declare type MultiConfigs = Map<string, TelemetryConfigStats>;
 /**
  * Telemetry usage stats
  */

package/types/types.d.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';
@@ -65,7 +65,6 @@ export interface ISettings {
     readonly core: {
         authorizationKey: string;
         key: SplitIO.SplitKey;
-        trafficType?: string;
         labelsEnabled: boolean;
         IPAddressesEnabled: boolean;
     };
@@ -92,7 +91,6 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
-    readonly preloadedData?: SplitIO.PreloadedData;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -771,19 +769,21 @@ 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 list of segments.
-         * @TODO rename to memberships
+         * @TODO remove when releasing first version
          */
         mySegmentsData?: {
             [key: string]: string[];
@@ -791,10 +791,9 @@ export declare 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;
         };
     }
     /**
@@ -922,12 +921,6 @@ export declare namespace SplitIO {
              * @property {SplitKey} key
              */
             key: SplitKey;
-            /**
-             * Traffic type associated with the customer identifier. @see {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
-             * If no provided as a setting it will be required on the client.track() calls.
-             * @property {string} trafficType
-             */
-            trafficType?: string;
             /**
              * Disable labels from being sent to Split backend. Labels may contain sensitive information.
              * @property {boolean} labelsEnabled
@@ -1036,10 +1029,9 @@ export declare namespace SplitIO {
          * Returns a shared client of the SDK, with the given key and optional traffic type.
          * @function client
          * @param {SplitKey} key The key for the new client instance.
-         * @param {string=} trafficType The traffic type of the provided key.
          * @returns {ICsClient} The client instance.
          */
-        client(key: SplitKey, trafficType?: string): ICsClient;
+        client(key: SplitKey): ICsClient;
         /**
          * Returns a manager instance of the SDK to explore available information.
          * @function manager