@splitsoftware/splitio-commons 1.6.2-rc.4 → 1.6.2-rc.5

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.4",
+  "version": "1.6.2-rc.5",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
-  "types": "src/types.d.ts",
+  "types": "types",
   "files": [
     "README.md",
     "CONTRIBUTORS-GUIDE.md",
@@ -12,14 +12,15 @@
     "CHANGES.txt",
     "cjs",
     "esm",
-    "src"
+    "src",
+    "types"
   ],
   "scripts": {
     "check": "npm run check:lint && npm run check:types",
     "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",
+    "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]);
@@ -41,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext): IUserConsentAP
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();
-          if (impressionCounts) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
@@ -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);
   };
 
 }

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 { SplitKey, Attributes } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 
 const treatmentException = {
   treatment: CONTROL,
@@ -24,9 +24,9 @@ function treatmentsException(splitNames: string[]) {
 
 export function evaluateFeature(
   log: ILogger,
-  key: SplitKey,
+  key: SplitIO.SplitKey,
   splitName: string,
-  attributes: Attributes | undefined,
+  attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
   let stringifiedSplit;
@@ -63,9 +63,9 @@ export function evaluateFeature(
 
 export function evaluateFeatures(
   log: ILogger,
-  key: SplitKey,
+  key: SplitIO.SplitKey,
   splitNames: string[],
-  attributes: Attributes | undefined,
+  attributes: SplitIO.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: SplitKey,
-  attributes: Attributes | undefined,
+  key: SplitIO.SplitKey,
+  attributes: SplitIO.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: SplitKey,
-  attributes: Attributes | undefined,
+  key: SplitIO.SplitKey,
+  attributes: SplitIO.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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 '../../types';
+import { ILogger } from '../../logger/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 { Attributes } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/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: Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
+      return (key: string, attributes: SplitIO.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 { SplitKey, Attributes } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 
 export interface IDependencyMatcherValue {
-  key: SplitKey,
-  attributes?: Attributes
+  key: SplitIO.SplitKey,
+  attributes?: SplitIO.Attributes
 }
 
 export interface IMatcherDto {
@@ -27,8 +27,8 @@ export interface IEvaluation {
 
 export type IEvaluationResult = IEvaluation & { treatment: string }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitKey, splitName: string, attributes: Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
+export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
 
 export type IMatcher = (...args: any) => MaybeThenable<boolean>

package/src/evaluator/value/index.ts

@@ -1,10 +1,10 @@
-import { Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IMatcherDto } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/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?: Attributes) {
+function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.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?: Attributes) {
+export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
   const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);

package/src/evaluator/value/sanitize.ts

@@ -1,6 +1,6 @@
-import { Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IDependencyMatcherValue } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isObject, uniq, toString, toNumber } from '../../utils/lang';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
 import { matcherTypes, matcherDataTypes } from '../matchers/matcherTypes';
@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes?: Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 

package/src/integrations/ga/GaToSplit.ts

@@ -8,9 +8,9 @@ import {
   validateKey,
   validateTrafficType,
 } from '../../utils/inputValidation';
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
 
 const logPrefix = 'ga-to-split: ';
@@ -67,7 +67,7 @@ const defaultMapping = {
  * @param {object} mapping
  */
 function mapperBuilder(mapping: typeof defaultMapping) {
-  return function (model: UniversalAnalytics.Model): EventData {
+  return function (model: UniversalAnalytics.Model): SplitIO.EventData {
     const hitType: string = model.get('hitType');
     // @ts-expect-error
     const eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');
@@ -133,7 +133,7 @@ export function validateIdentities(identities?: Identity[]) {
  * @param {EventData} data event data instance to validate. Precondition: data != undefined
  * @returns {boolean} Whether the data instance is a valid EventData or not.
  */
-export function validateEventData(log: ILogger, eventData: any): eventData is EventData {
+export function validateEventData(log: ILogger, eventData: any): eventData is SplitIO.EventData {
   if (!validateEvent(log, eventData.eventTypeId, logNameMapper))
     return false;
 
@@ -251,10 +251,10 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
         }
 
         // map hit into an EventData instance
-        let eventData: EventData = defaultMapper(model);
+        let eventData: SplitIO.EventData = defaultMapper(model);
         if (opts.mapper) {
           try {
-            eventData = opts.mapper(model, eventData as EventData);
+            eventData = opts.mapper(model, eventData as SplitIO.EventData);
           } catch (err) {
             log.warn(logPrefix + `custom mapper threw: ${err}`);
             return;

package/src/integrations/ga/SplitToGa.ts

@@ -1,10 +1,10 @@
 /* eslint-disable no-undef */
 import { uniq } from '../../utils/lang';
 import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';
-import { IntegrationData, ImpressionData, EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { IIntegration } from '../types';
 import { SplitToGoogleAnalyticsOptions } from './types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 const logPrefix = 'split-to-ga: ';
 const noGaWarning = '`ga` command queue not found.';
@@ -16,29 +16,29 @@ export class SplitToGa implements IIntegration {
   static defaultTrackerNames = [''];
 
   private trackerNames: string[];
-  private filter?: (data: IntegrationData) => boolean;
-  private mapper?: (data: IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
+  private filter?: (data: SplitIO.IntegrationData) => boolean;
+  private mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
   private impressions: boolean | undefined;
   private events: boolean | undefined;
   private log: ILogger;
 
   // Default mapper function.
-  static defaultMapper({ type, payload }: IntegrationData): UniversalAnalytics.FieldsObject {
+  static defaultMapper({ type, payload }: SplitIO.IntegrationData): UniversalAnalytics.FieldsObject {
     switch (type) {
       case SPLIT_IMPRESSION:
         return {
           hitType: 'event',
           eventCategory: 'split-impression',
-          eventAction: 'Evaluate ' + (payload as ImpressionData).impression.feature,
-          eventLabel: 'Treatment: ' + (payload as ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as ImpressionData).impression.label + '.',
+          eventAction: 'Evaluate ' + (payload as SplitIO.ImpressionData).impression.feature,
+          eventLabel: 'Treatment: ' + (payload as SplitIO.ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as SplitIO.ImpressionData).impression.label + '.',
           nonInteraction: true,
         };
       case SPLIT_EVENT:
         return {
           hitType: 'event',
           eventCategory: 'split-event',
-          eventAction: (payload as EventData).eventTypeId,
-          eventValue: (payload as EventData).value,
+          eventAction: (payload as SplitIO.EventData).eventTypeId,
+          eventValue: (payload as SplitIO.EventData).value,
           nonInteraction: true,
         };
     }
@@ -93,7 +93,7 @@ export class SplitToGa implements IIntegration {
     if (typeof SplitToGa.getGa() !== 'function') log.warn(logPrefix + `${noGaWarning} No hits will be sent until it is available.`);
   }
 
-  queue(data: IntegrationData) {
+  queue(data: SplitIO.IntegrationData) {
     // access ga command queue via `getGa` method, accounting for the possibility that
     // the global `ga` reference was not yet mutated by analytics.js.
     const ga = SplitToGa.getGa();

package/src/integrations/ga/types.ts

@@ -1,4 +1,4 @@
-import { IntegrationData, EventData } from '../../types';
+import { SplitIO } from '../../types';
 
 /**
  * A pair of user key and it's trafficType, required for tracking valid Split events.
@@ -41,7 +41,7 @@ export interface GoogleAnalyticsToSplitOptions {
    *      return defaultMapping;
    *  }`
    */
-  mapper?: (model: UniversalAnalytics.Model, defaultMapping: EventData) => EventData,
+  mapper?: (model: UniversalAnalytics.Model, defaultMapping: SplitIO.EventData) => SplitIO.EventData,
   /**
    * Optional prefix for EventTypeId, to prevent any kind of data collision between events.
    * @property {string} prefix
@@ -97,7 +97,7 @@ export interface SplitToGoogleAnalyticsOptions {
    * For example, the following filter allows to track only impressions, equivalent to setting events to false:
    *  `(data) => data.type === 'IMPRESSION'`
    */
-  filter?: (data: IntegrationData) => boolean,
+  filter?: (data: SplitIO.IntegrationData) => boolean,
   /**
    * Optional function useful when you need to modify the GA hit before sending it.
    * This function is invoked with two arguments:
@@ -128,7 +128,7 @@ export interface SplitToGoogleAnalyticsOptions {
    *    nonInteraction: true,
    *  }`
    */
-  mapper?: (data: IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject,
+  mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject,
   /**
    * List of tracker names to send the hit. An empty string represents the default tracker.
    * If not provided, hits are only sent to default tracker.