@splitsoftware/splitio-commons 1.6.2-rc.3 → 1.6.2-rc.6

package/esm/sdkFactory/index.js

@@ -29,7 +29,6 @@ export function sdkFactory(params) {
         optimize: shouldBeOptimized(settings),
         // ATM, only used by InLocalStorage
         matchingKey: getMatching(settings.core.key),
-        // @ts-ignore
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // ATM, only used by PluggableStorage
         mode: settings.mode,
@@ -46,12 +45,12 @@ export function sdkFactory(params) {
     };
     var storage = storageFactory(storageFactoryParams);
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
+    var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
     var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-    var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
     var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };

package/esm/sdkManager/index.js

@@ -12,15 +12,7 @@ function collectTreatments(splitObject) {
     // Then extract the treatments from the partitions
     return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(function (v) { return v.treatment; }) : [];
 }
-function objectToView(json) {
-    var splitObject;
-    try {
-        // @ts-expect-error
-        splitObject = JSON.parse(json);
-    }
-    catch (e) {
-        return null;
-    }
+function objectToView(splitObject) {
     if (!splitObject)
         return null;
     return {
@@ -32,9 +24,9 @@ function objectToView(json) {
         configs: splitObject.configurations || {}
     };
 }
-function objectsToViews(jsons) {
+function objectsToViews(splitObjects) {
     var views = [];
-    jsons.forEach(function (split) {
+    splitObjects.forEach(function (split) {
         var view = objectToView(split);
         if (view)
             views.push(view);

package/esm/services/splitApi.js

@@ -13,7 +13,6 @@ function userKeyToQueryParam(userKey) {
  */
 export function splitApiFactory(settings, platform, telemetryTracker) {
     var urls = settings.urls;
-    // @ts-ignore
     var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -1,3 +1,4 @@
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
@@ -31,15 +32,12 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
-            if (split) {
-                var parsedSplit = JSON.parse(split);
-                if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-                    parsedSplit.killed = true;
-                    parsedSplit.defaultTreatment = defaultTreatment;
-                    parsedSplit.changeNumber = changeNumber;
-                    var newSplit = JSON.stringify(parsedSplit);
-                    return _this.addSplit(name, newSplit);
-                }
+            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+                var newSplit = objectAssign({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(name, newSplit);
             }
             return false;
         }).catch(function () { return false; });

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,3 +1,4 @@
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -44,15 +45,12 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      */
     AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
         var split = this.getSplit(name);
-        if (split) {
-            var parsedSplit = JSON.parse(split);
-            if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-                parsedSplit.killed = true;
-                parsedSplit.defaultTreatment = defaultTreatment;
-                parsedSplit.changeNumber = changeNumber;
-                var newSplit = JSON.stringify(parsedSplit);
-                return this.addSplit(name, newSplit);
-            }
+        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+            var newSplit = objectAssign({}, split);
+            newSplit.killed = true;
+            newSplit.defaultTreatment = defaultTreatment;
+            newSplit.changeNumber = changeNumber;
+            return this.addSplit(name, newSplit);
         }
         return false;
     };

package/esm/storages/dataLoader.js

@@ -32,7 +32,7 @@ export function dataLoaderFactory(preloadedData) {
         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(Object.keys(splitsData).map(function (splitName) { return [splitName, splitsData[splitName]]; }));
+        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
         // add mySegments data
         var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -93,9 +93,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
             this._decrementCounts(previousSplit);
-            localStorage.setItem(splitKey, split);
-            var parsedSplit = split ? JSON.parse(split) : null;
-            this._incrementCounts(parsedSplit);
+            localStorage.setItem(splitKey, JSON.stringify(split));
+            this._incrementCounts(split);
             return true;
         }
         catch (e) {
@@ -107,8 +106,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         try {
             var split = this.getSplit(name);
             localStorage.removeItem(this.keys.buildSplitKey(name));
-            var parsedSplit = JSON.parse(split);
-            this._decrementCounts(parsedSplit);
+            this._decrementCounts(split);
             return true;
         }
         catch (e) {
@@ -117,7 +115,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
-        return localStorage.getItem(this.keys.buildSplitKey(name));
+        var item = localStorage.getItem(this.keys.buildSplitKey(name));
+        return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when cache is ready but using a new split query, we must clear all split data

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -22,9 +22,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
-        var splitFromMemory = this.getSplit(name);
-        if (splitFromMemory) { // We had this Split already
-            var previousSplit = JSON.parse(splitFromMemory);
+        var previousSplit = this.getSplit(name);
+        if (previousSplit) { // We had this Split already
             if (previousSplit.trafficTypeName) {
                 var previousTtName = previousSplit.trafficTypeName;
                 this.ttCache[previousTtName]--;
@@ -35,19 +34,18 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 this.splitsWithSegmentsCount--;
             }
         }
-        var parsedSplit = JSON.parse(split);
-        if (parsedSplit) {
+        if (split) {
             // Store the Split.
             this.splitsCache[name] = split;
             // Update TT cache
-            var ttName = parsedSplit.trafficTypeName;
+            var ttName = split.trafficTypeName;
             if (ttName) { // safeguard
                 if (!this.ttCache[ttName])
                     this.ttCache[ttName] = 0;
                 this.ttCache[ttName]++;
             }
             // Add to segments count for the new version of the Split
-            if (usesSegments(parsedSplit))
+            if (usesSegments(split))
                 this.splitsWithSegmentsCount++;
             return true;
         }
@@ -60,15 +58,14 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         if (split) {
             // Delete the Split
             delete this.splitsCache[name];
-            var parsedSplit = JSON.parse(split);
-            var ttName = parsedSplit.trafficTypeName;
+            var ttName = split.trafficTypeName;
             if (ttName) { // safeguard
                 this.ttCache[ttName]--; // Update tt cache
                 if (!this.ttCache[ttName])
                     delete this.ttCache[ttName];
             }
             // Update the segments count.
-            if (usesSegments(parsedSplit))
+            if (usesSegments(split))
                 this.splitsWithSegmentsCount--;
             return true;
         }

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -59,17 +59,17 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.redis.get(splitKey).then(function (splitFromStorage) {
             // handling parsing errors
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, newStringifiedSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                newStringifiedSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.redis.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.redis.set(splitKey, newStringifiedSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -96,8 +96,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.redis.del(_this.keys.buildSplitKey(name));
         });
@@ -120,7 +119,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             this.log.error(LOG_PREFIX + this.redisError);
             return Promise.reject(this.redisError);
         }
-        return this.redis.get(this.keys.buildSplitKey(name));
+        return this.redis.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Set till number.
@@ -155,7 +155,12 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
      */
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); }).then(processPipelineAnswer);
+        return this.redis.keys(this.keys.searchPatternForSplitKeys())
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(processPipelineAnswer)
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.
@@ -215,7 +220,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
         return (_a = this.redis).mget.apply(_a, keys).then(function (splitDefinitions) {
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         })

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -46,17 +46,17 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.wrapper.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, stringifiedNewSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                stringifiedNewSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.wrapper.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.wrapper.set(splitKey, stringifiedNewSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type and segment count of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -80,8 +80,7 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.wrapper.del(_this.keys.buildSplitKey(name));
         });
@@ -101,7 +100,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      * or rejected if wrapper operation fails.
      */
     SplitsCachePluggable.prototype.getSplit = function (name) {
-        return this.wrapper.get(this.keys.buildSplitKey(name));
+        return this.wrapper.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Get list of splits.
@@ -114,7 +114,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getMany(keys).then(function (splitDefinitions) {
             var splits = {};
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         });
@@ -126,7 +127,11 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      */
     SplitsCachePluggable.prototype.getAll = function () {
         var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return Promise.all(listOfKeys.map(_this.wrapper.get)); });
+        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -24,8 +24,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
             log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             forOwn(splitsMock, function (val, name) {
                 splits.push([
-                    name,
-                    JSON.stringify({
+                    name, {
                         name: name,
                         status: 'ACTIVE',
                         killed: false,
@@ -34,7 +33,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                         conditions: val.conditions || [],
                         configurations: val.configurations,
                         trafficTypeName: val.trafficTypeName
-                    })
+                    }
                 ]);
             });
             return Promise.all([

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -37,7 +37,7 @@ export function computeSplitsMutation(entries) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE') {
-            accum.added.push([split.name, JSON.stringify(split)]);
+            accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });

package/esm/trackers/telemetryTracker.js

@@ -46,6 +46,11 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();
                 }
+            },
+            addTag: function (tag) {
+                // @ts-ignore
+                if (telemetryCache.addTag)
+                    telemetryCache.addTag(tag);
             }
         };
     }
@@ -56,6 +61,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
+            addTag: function () { }
         };
     }
 }

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils/key/index.js

@@ -1,5 +1,5 @@
 import { isObject } from '../lang';
-// function isSplitKeyObject(key: any): key is SplitKeyObject {
+// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
 //   return key !== undefined && key !== null && typeof key.matchingKey === 'string';
 // }
 // returns the matchingKey if the Key is defined as an object or the key itself if it is a string

package/esm/utils/settingsValidation/index.js

@@ -172,7 +172,6 @@ export function settingsValidation(config, validationParams) {
     // validate the `splitFilters` settings and parse splits query
     var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
-    // @ts-ignore
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.3",
+  "version": "1.6.2-rc.6",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -20,7 +20,7 @@
     "check:lint": "eslint src --ext .js,.ts",
     "check:types": "tsc --noEmit",
     "build": "npm run build:cjs && npm run build:esm",
-    "build:esm": "rimraf esm types && tsc -m es2015 --outDir esm -d true --declarationDir types",
+    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",

package/src/consent/sdkUserConsent.ts

@@ -3,10 +3,9 @@ import { isConsentGranted } from './index';
 import { CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../utils/constants';
 import { isBoolean } from '../utils/lang';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { IUserConsentAPI } from '../types';
 
 // User consent enum
-const ConsentStatus: IUserConsentAPI['Status'] = {
+const ConsentStatus = {
   GRANTED: CONSENT_GRANTED,
   DECLINED: CONSENT_DECLINED,
   UNKNOWN: CONSENT_UNKNOWN,
@@ -15,7 +14,7 @@ const ConsentStatus: IUserConsentAPI['Status'] = {
 /**
  * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
  */
-export function createUserConsentAPI(params: ISdkFactoryContext): IUserConsentAPI {
+export function createUserConsentAPI(params: ISdkFactoryContext) {
   const { settings, settings: { log }, syncManager, storage: { events, impressions, impressionCounts } } = params;
 
   if (!isConsentGranted(settings)) log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
@@ -52,7 +51,7 @@ export function createUserConsentAPI(params: ISdkFactoryContext): IUserConsentAP
     },
 
     getStatus() {
-      return settings.userConsent!;
+      return settings.userConsent;
     },
 
     Status: ConsentStatus

package/src/dtos/types.ts

@@ -1,3 +1,5 @@
+import { SplitIO } from '../types';
+
 export type MaybeThenable<T> = T | Promise<T>
 
 /** Split Matchers */
@@ -202,3 +204,9 @@ export interface IMetadata {
   /** host name */
   n: string
 }
+
+export type ISplitFiltersValidation = {
+  queryString: string | null,
+  groupedFilters: Record<SplitIO.SplitFilterType, string[]>,
+  validFilters: SplitIO.SplitFilter[]
+};

package/src/evaluator/Engine.ts

@@ -5,10 +5,10 @@ import { thenable } from '../utils/promise/thenable';
 import * as LabelsConstants from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
-import { SplitKey, Attributes } from '../types';
+import { SplitIO } from '../types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluation, IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
-import { ILogger } from '../types';
+import { ILogger } from '../logger/types';
 
 function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
   return {
@@ -38,7 +38,7 @@ export class Engine {
     return this.baseInfo.name;
   }
 
-  getTreatment(key: SplitKey, attributes: Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
+  getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
     const {
       killed,
       seed,

package/src/evaluator/combiners/and.ts

@@ -1,5 +1,5 @@
 import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { MaybeThenable } from '../../dtos/types';
 import { IMatcher } from '../types';

package/src/evaluator/combiners/ifelseif.ts

@@ -1,9 +1,9 @@
 import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
-import { SplitKey, Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
 import { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants';
 
@@ -35,7 +35,7 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     return undefined;
   }
 
-  function ifElseIfCombiner(key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: Attributes, splitEvaluator?: ISplitEvaluator) {
+  function ifElseIfCombiner(key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
     // In Async environments we are going to have async predicates. There is none way to know
     // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
     // define how to return the treatment (wrap result into a Promise or not).

package/src/evaluator/condition/engineUtils.ts

@@ -1,5 +1,5 @@
 import { ENGINE_BUCKET } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { bucket } from '../../utils/murmur3/murmur3';
 
 /**

package/src/evaluator/condition/index.ts

@@ -3,8 +3,8 @@ import { thenable } from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
 import { MaybeThenable } from '../../dtos/types';
 import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
-import { SplitKey, SplitKeyObject, Attributes } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 
 // Build Evaluation object if and only if matchingResult is true
 function match(log: ILogger, matchingResult: boolean, bucketingKey: string | undefined, seed: number, treatments: { getTreatmentFor: (x: number) => string }, label: string): IEvaluation | undefined {
@@ -24,10 +24,10 @@ function match(log: ILogger, matchingResult: boolean, bucketingKey: string | und
 // Condition factory
 export function conditionContext(log: ILogger, matcherEvaluator: (...args: any) => MaybeThenable<boolean>, treatments: { getTreatmentFor: (x: number) => string }, label: string, conditionType: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
 
-  return function conditionEvaluator(key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: Attributes, splitEvaluator?: ISplitEvaluator) {
+  return function conditionEvaluator(key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
 
     // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
-    if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation as number, (key as SplitKeyObject).bucketingKey as string, trafficAllocationSeed as number)) {
+    if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation as number, (key as SplitIO.SplitKeyObject).bucketingKey as string, trafficAllocationSeed as number)) {
       return {
         treatment: undefined, // treatment value is assigned later
         label: LabelsConstants.NOT_IN_SPLIT
@@ -41,10 +41,10 @@ export function conditionContext(log: ILogger, matcherEvaluator: (...args: any)
     const matches = matcherEvaluator(key, attributes, splitEvaluator);
 
     if (thenable(matches)) {
-      return matches.then(result => match(log, result, (key as SplitKeyObject).bucketingKey, seed, treatments, label));
+      return matches.then(result => match(log, result, (key as SplitIO.SplitKeyObject).bucketingKey, seed, treatments, label));
     }
 
-    return match(log, matches, (key as SplitKeyObject).bucketingKey, seed, treatments, label);
+    return match(log, matches, (key as SplitIO.SplitKeyObject).bucketingKey, seed, treatments, label);
   };
 
 }