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

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;
-}, 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/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 {
@@ -382,7 +384,6 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     events: TEventsCache;
     telemetry?: TTelemetryCache;
     uniqueKeys?: TUniqueKeysCache;
-    init?: () => void | Promise<void>;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
@@ -392,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;
     /**
@@ -399,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/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, whenInit: (cb: () => void) => void, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -10,4 +10,4 @@ import { ISettings } from '../types';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, whenInit: (cb: () => void) => void, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

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

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

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

@@ -1,8 +1,7 @@
-import { IMap } from '../lang/maps';
 import { LinkedList, Node } from './LinkedList';
 export declare class LRUCache<K, V> {
     maxLen: number;
-    items: IMap<K, Node<{
+    items: Map<K, Node<{
         key: K;
         value: V;
     }>>;

package/types/utils/constants/browser.d.ts

@@ -1,3 +1 @@
-export declare const GOOGLE_ANALYTICS_TO_SPLIT = "GOOGLE_ANALYTICS_TO_SPLIT";
-export declare const SPLIT_TO_GOOGLE_ANALYTICS = "SPLIT_TO_GOOGLE_ANALYTICS";
 export declare const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000;

package/types/utils/lang/objectAssign.d.ts

@@ -1,3 +1,6 @@
+/**
+ * A tiny polyfill for Object.assign
+ */
 declare type ObjectAssign = (<T, U>(target: T, source: U) => T & U) & (<T, U, V>(target: T, source1: U, source2: V) => T & U & V) & (<T, U, V, W>(target: T, source1: U, source2: V, source3: W) => T & U & V & W) & (<T, U, V, W, Q>(target: T, source1: U, source2: V, source3: W, source4: Q) => T & U & V & W & Q) & (<T, U, V, W, Q, R>(target: T, source1: U, source2: V, source3: W, source4: Q, source5: R) => T & U & V & W & Q & R) & ((target: any, ...sources: any[]) => any);
 export declare const objectAssign: ObjectAssign;
 export {};

package/types/utils/lang/sets.d.ts

@@ -1,62 +1,2 @@
-/**
- * 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 declare class SetPoly<T> implements ISet<T> {
-    __setData__: T[];
-    constructor(values?: readonly T[] | null);
-    clear(): void;
-    add(value: T): this;
-    delete(value: T): boolean;
-    has(value: T): boolean;
-    forEach(callbackfn: (value: T, value2: T, set: SetPoly<T>) => void, thisArg?: any): void;
-    get size(): number;
-}
-/**
- * return an array containing the items of the given set.
- * @param set Set or SetPoly instance
- */
-export declare function setToArray<T>(set: ISet<T>): 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 declare function __getSetConstructor(): ISetConstructor;
-export declare const _Set: ISetConstructor;
-export declare function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T>;
+export declare function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T>;
 export declare function returnDifference<T>(list?: T[], list2?: T[]): T[];
-export {};

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

@@ -5,7 +5,6 @@ export declare const base: {
     core: {
         authorizationKey: undefined;
         key: undefined;
-        trafficType: undefined;
         labelsEnabled: boolean;
         IPAddressesEnabled: undefined;
     };

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

@@ -1,5 +1,10 @@
 import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
+import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
+export declare function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync;
+export declare namespace __InLocalStorageMockFactory {
+    var type: import("../../../storages/types").StorageType;
+}
 /**
  * This function validates `settings.storage` object
  *

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

@@ -15,8 +15,6 @@ export interface ISettingsValidationParams {
     };
     /** 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/cjs/integrations/browser.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.integrationsManagerFactory = void 0;
-var browser_1 = require("../utils/constants/browser");
-var pluggable_1 = require("./pluggable");
-var GoogleAnalyticsToSplit_1 = require("./ga/GoogleAnalyticsToSplit");
-var SplitToGoogleAnalytics_1 = require("./ga/SplitToGoogleAnalytics");
-/**
- * IntegrationsManager factory for the browser variant of the isomorphic JS SDK.
- * The integrations manager instantiates integration modules, and bypass tracked events and impressions to them.
- *
- * @param integrations valid integration settings object for browser sdk
- * @param params information of the Sdk factory instance that integrations can access to
- *
- * @returns integration manager or undefined if `integrations` are not present in settings.
- */
-function integrationsManagerFactory(integrations, params) {
-    // maps integration config items into integration factories to reuse the pluggable integration manager
-    var integrationFactories = integrations
-        .map(function (integrationOptions) {
-        switch (integrationOptions.type) {
-            case browser_1.GOOGLE_ANALYTICS_TO_SPLIT: return (0, GoogleAnalyticsToSplit_1.GoogleAnalyticsToSplit)(integrationOptions);
-            case browser_1.SPLIT_TO_GOOGLE_ANALYTICS: return (0, SplitToGoogleAnalytics_1.SplitToGoogleAnalytics)(integrationOptions);
-        }
-    })
-        .filter(function (integrationFactory) {
-        return integrationFactory && typeof integrationFactory === 'function';
-    });
-    return (0, pluggable_1.pluggableIntegrationsManagerFactory)(integrationFactories, params);
-}
-exports.integrationsManagerFactory = integrationsManagerFactory;