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

package/esm/sync/submitters/submitterManager.js

@@ -2,7 +2,6 @@ import { eventsSubmitterFactory } from './eventsSubmitter';
 import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
-import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 export function submitterManagerFactory(params) {
     var submitters = [
         impressionsSubmitterFactory(params),
@@ -12,8 +11,6 @@ export function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = telemetrySubmitterFactory(params);
-    if (params.uniqueKeysTracker)
-        submitters.push(uniqueKeysSubmitterFactory(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
         start: function (onlyTelemetry) {

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,6 +1,6 @@
 var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
@@ -46,7 +46,6 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
-    _b[NONE] = NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[CONSENT_UNKNOWN] = 1,

package/esm/trackers/impressionsTracker.js

@@ -1,5 +1,6 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
+import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 /**
@@ -9,17 +10,37 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param strategy strategy for impressions tracking.
+ * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
+ * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, integrationsManager, 
+// if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
+observer, 
+// if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
+countsCache, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
                 return;
             var impressionsCount = impressions.length;
-            var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
-            var impressionsToListenerCount = impressionsToListener.length;
+            var impressionsToStore = []; // Track only the impressions that are going to be stored
+            // Wraps impressions to store and adds previousTime if it corresponds
+            impressions.forEach(function (impression) {
+                if (observer) {
+                    // Adds previous time if it is enabled
+                    impression.pt = observer.testAndSet(impression);
+                }
+                var now = Date.now();
+                if (countsCache) {
+                    // Increments impression counter per featureName
+                    countsCache.track(impression.feature, now, 1);
+                }
+                // Checks if the impression should be added in queue to be sent
+                if (!countsCache || !impression.pt || impression.pt < truncateTimeFrame(now)) {
+                    impressionsToStore.push(impression);
+                }
+            });
             var res = impressionsCache.track(impressionsToStore);
             // If we're on an async storage, handle error and log it.
             if (thenable(res)) {
@@ -34,7 +55,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                 // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
                 if (telemetryCache) {
                     telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
-                    telemetryCache.recordImpressionStats(DEDUPED, deduped);
+                    telemetryCache.recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
@@ -42,7 +63,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-                        impression: objectAssign({}, impressionsToListener[i]),
+                        impression: objectAssign({}, impressions[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -62,7 +83,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         }
                     }, 0);
                 };
-                for (var i = 0; i < impressionsToListenerCount; i++) {
+                for (var i = 0; i < impressionsCount; i++) {
                     _loop_1(i);
                 }
             }

package/esm/utils/constants/index.js

@@ -13,7 +13,6 @@ export var SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export var DEBUG = 'DEBUG';
 export var OPTIMIZED = 'OPTIMIZED';
-export var NONE = 'NONE';
 // SDK Modes
 export var LOCALHOST_MODE = 'localhost';
 export var STANDALONE_MODE = 'standalone';
@@ -38,7 +37,6 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
-export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/esm/utils/key/index.js

@@ -1,5 +1,5 @@
 import { isObject } from '../lang';
-// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
+// function isSplitKeyObject(key: any): key is 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/impressionsMode.js

@@ -1,10 +1,10 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
+import { DEBUG, OPTIMIZED } from '../constants';
 import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
     impressionsMode = stringToUpperCase(impressionsMode);
-    if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1)
+    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
     return OPTIMIZED;
 }

package/esm/utils/settingsValidation/index.js

@@ -31,8 +31,6 @@ export var base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -111,7 +109,6 @@ export function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)
@@ -175,6 +172,7 @@ 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.2",
+  "version": "1.6.2-rc.3",
   "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 && tsc -m es2015 --outDir esm -d true --declarationDir types",
+    "build:esm": "rimraf esm types && 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,9 +3,10 @@ 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 = {
+const ConsentStatus: IUserConsentAPI['Status'] = {
   GRANTED: CONSENT_GRANTED,
   DECLINED: CONSENT_DECLINED,
   UNKNOWN: CONSENT_UNKNOWN,
@@ -14,7 +15,7 @@ const ConsentStatus = {
 /**
  * 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) {
+export function createUserConsentAPI(params: ISdkFactoryContext): IUserConsentAPI {
   const { settings, settings: { log }, syncManager, storage: { events, impressions, impressionCounts } } = params;
 
   if (!isConsentGranted(settings)) log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
@@ -51,7 +52,7 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
     },
 
     getStatus() {
-      return settings.userConsent;
+      return settings.userConsent!;
     },
 
     Status: ConsentStatus

package/src/dtos/types.ts

@@ -1,5 +1,3 @@
-import { SplitIO } from '../types';
-
 export type MaybeThenable<T> = T | Promise<T>
 
 /** Split Matchers */
@@ -204,9 +202,3 @@ 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 { SplitIO } from '../types';
+import { SplitKey, Attributes } from '../types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluation, IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
-import { ILogger } from '../logger/types';
+import { ILogger } from '../types';
 
 function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
   return {
@@ -38,7 +38,7 @@ export class Engine {
     return this.baseInfo.name;
   }
 
-  getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
+  getTreatment(key: SplitKey, attributes: 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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../types';
 import { thenable } from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
-import { SplitIO } from '../../types';
+import { SplitKey, Attributes } 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: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  function ifElseIfCombiner(key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: 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 '../../logger/types';
+import { ILogger } from '../../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 { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { SplitKey, SplitKeyObject, Attributes } from '../../types';
+import { ILogger } from '../../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: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  return function conditionEvaluator(key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: 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 SplitIO.SplitKeyObject).bucketingKey as string, trafficAllocationSeed as number)) {
+    if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation as number, (key as 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 SplitIO.SplitKeyObject).bucketingKey, seed, treatments, label));
+      return matches.then(result => match(log, result, (key as SplitKeyObject).bucketingKey, seed, treatments, label));
     }
 
-    return match(log, matches, (key as SplitIO.SplitKeyObject).bucketingKey, seed, treatments, label);
+    return match(log, matches, (key as SplitKeyObject).bucketingKey, seed, treatments, label);
   };
 
 }

package/src/evaluator/index.ts

@@ -5,8 +5,8 @@ import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { SplitKey, Attributes } from '../types';
+import { ILogger } from '../types';
 
 const treatmentException = {
   treatment: CONTROL,
@@ -24,9 +24,9 @@ function treatmentsException(splitNames: string[]) {
 
 export function evaluateFeature(
   log: ILogger,
-  key: SplitIO.SplitKey,
+  key: SplitKey,
   splitName: string,
-  attributes: SplitIO.Attributes | undefined,
+  attributes: Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
   let stringifiedSplit;
@@ -63,9 +63,9 @@ export function evaluateFeature(
 
 export function evaluateFeatures(
   log: ILogger,
-  key: SplitIO.SplitKey,
+  key: SplitKey,
   splitNames: string[],
-  attributes: SplitIO.Attributes | undefined,
+  attributes: Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   let stringifiedSplits;
@@ -90,8 +90,8 @@ export function evaluateFeatures(
 function getEvaluation(
   log: ILogger,
   stringifiedSplit: string | null,
-  key: SplitIO.SplitKey,
-  attributes: SplitIO.Attributes | undefined,
+  key: SplitKey,
+  attributes: Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
   let evaluation: MaybeThenable<IEvaluationResult> = {
@@ -126,8 +126,8 @@ function getEvaluations(
   log: ILogger,
   splitNames: string[],
   splits: Record<string, string | null>,
-  key: SplitIO.SplitKey,
-  attributes: SplitIO.Attributes | undefined,
+  key: SplitKey,
+  attributes: Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   const result: Record<string, IEvaluationResult> = {};

package/src/evaluator/matchers/all.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_ALL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function allMatcherContext(log: ILogger) {
   return function allMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/between.ts

@@ -1,6 +1,6 @@
 import { IBetweenMatcherData } from '../../dtos/types';
 import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ {
   return function betweenMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/boolean.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function booleanMatcherContext(log: ILogger, ruleAttr: boolean) /*: Function */ {
   return function booleanMatcher(runtimeAttr: boolean): boolean {

package/src/evaluator/matchers/cont_all.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { findIndex } from '../../utils/lang';
 
 export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/cont_any.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { findIndex } from '../../utils/lang';
 
 export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/cont_str.ts

@@ -1,5 +1,5 @@
 import { isString } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
 export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/dependency.ts

@@ -1,6 +1,6 @@
 import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { thenable } from '../../utils/promise/thenable';
 import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types';
 import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';

package/src/evaluator/matchers/eq.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_EQUAL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function equalToMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
   return function equalToMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/eq_set.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { findIndex } from '../../utils/lang';
 
 export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/ew.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { endsWith } from '../../utils/lang';
 
 export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/gte.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/index.ts

@@ -17,7 +17,7 @@ import { booleanMatcherContext } from './boolean';
 import { stringMatcherContext } from './string';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 const matchers = [
   undefined, // UNDEFINED: 0,

package/src/evaluator/matchers/lte.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_LESS } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: function */ {
   return function lessThanEqualMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/part_of.ts

@@ -1,5 +1,5 @@
 import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
 export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/segment.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { thenable } from '../../utils/promise/thenable';
 import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
 

package/src/evaluator/matchers/string.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
   return function stringMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/sw.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { startsWith } from '../../utils/lang';
 
 export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/whitelist.ts

@@ -1,5 +1,5 @@
 import { setToArray, ISet } from '../../utils/lang/sets';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 
 export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {

package/src/evaluator/parser/index.ts

@@ -9,8 +9,8 @@ import { thenable } from '../../utils/promise/thenable';
 import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
 import { ISplitCondition } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { Attributes } from '../../types';
+import { ILogger } from '../../types';
 
 export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
@@ -31,7 +31,7 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
       const matcher = matcherFactory(log, matcherDto, storage);
 
       // Evaluator function.
-      return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
+      return (key: string, attributes: Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
         const result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
 

package/src/evaluator/types.ts

@@ -1,12 +1,12 @@
 import { IBetweenMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { ISet } from '../utils/lang/sets';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { SplitKey, Attributes } from '../types';
+import { ILogger } from '../types';
 
 export interface IDependencyMatcherValue {
-  key: SplitIO.SplitKey,
-  attributes?: SplitIO.Attributes
+  key: SplitKey,
+  attributes?: Attributes
 }
 
 export interface IMatcherDto {
@@ -27,8 +27,8 @@ export interface IEvaluation {
 
 export type IEvaluationResult = IEvaluation & { treatment: string }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type ISplitEvaluator = (log: ILogger, key: SplitKey, splitName: string, attributes: Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
+export type IEvaluator = (key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
 
 export type IMatcher = (...args: any) => MaybeThenable<boolean>

package/src/evaluator/value/index.ts

@@ -1,10 +1,10 @@
-import { SplitIO } from '../../types';
+import { Attributes } from '../../types';
 import { IMatcherDto } from '../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {
@@ -23,7 +23,7 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
+export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
   const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);