@splitsoftware/splitio-commons 1.0.1-rc.2 → 1.0.1-rc.6

package/esm/utils/timeTracker/index.js

@@ -1,7 +1,7 @@
 var _a;
 import { uniqueId } from '../lang';
-import timer from './timer';
-import thenable from '../promise/thenable';
+import { timer } from './timer';
+import { thenable } from '../promise/thenable';
 // Map we will use for storing timers data
 var timers = {};
 // Tasks constants
@@ -86,7 +86,8 @@ function getCallbackForTask(task, collector) {
         return collector[callbackData.method];
     return false;
 }
-var TrackerAPI = {
+// Our "time tracker" API
+export var TrackerAPI = {
     /**
      * "Private" method, used to attach count/countException and stop callbacks to a promise.
      *
@@ -190,5 +191,3 @@ var TrackerAPI = {
      */
     TaskNames: CONSTANTS
 };
-// Our "time tracker" API
-export default TrackerAPI;

package/esm/utils/timeTracker/now/browser.js

@@ -9,5 +9,4 @@ function nowFactory() {
         return Date.now;
     }
 }
-var now = nowFactory();
-export default now;
+export var now = nowFactory();

package/esm/utils/timeTracker/now/node.js

@@ -1,5 +1,5 @@
 // @TODO migrate to Node SDK package eventually
-export default function now() {
+export function now() {
     // eslint-disable-next-line no-undef
     var time = process.hrtime();
     return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis

package/esm/utils/timeTracker/timer.js

@@ -1,4 +1,4 @@
-export default function start(now) {
+export function timer(now) {
     var st = now ? now() : Date.now();
     return function stop() {
         return Math.round(now ? now() : Date.now() - st);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.0.1-rc.2",
+  "version": "1.0.1-rc.6",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -44,24 +44,22 @@
   "bugs": "https://github.com/splitio/javascript-commons/issues",
   "homepage": "https://github.com/splitio/javascript-commons#readme",
   "dependencies": {
-    "object-assign": "^4.1.1",
     "tslib": "^2.1.0"
   },
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
-    "@types/ioredis": "^4.14.1",
+    "@types/ioredis": "^4.28.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
-    "@types/node": "^14.14.7",
-    "@types/object-assign": "^4.0.30",
     "@typescript-eslint/eslint-plugin": "^4.2.0",
     "@typescript-eslint/parser": "^4.2.0",
     "cross-env": "^7.0.2",
     "csv-streamify": "^4.0.0",
     "eslint": "^7.32.0",
     "eslint-plugin-compat": "3.7.0",
+    "eslint-plugin-import": "^2.25.3",
     "fetch-mock": "^9.10.7",
-    "ioredis": "^4.26.0",
+    "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
     "js-yaml": "^3.14.0",

package/src/evaluator/Engine.ts

@@ -1,7 +1,7 @@
 import { get } from '../utils/lang';
-import parser from './parser';
+import { parser } from './parser';
 import { keyParser } from '../utils/key';
-import thenable from '../utils/promise/thenable';
+import { thenable } from '../utils/promise/thenable';
 import * as LabelsConstants from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
@@ -17,7 +17,7 @@ function evaluationResult(result: IEvaluation | undefined, defaultTreatment: str
   };
 }
 
-export default class Engine {
+export class Engine {
 
   constructor(private baseInfo: ISplit, private evaluator: IEvaluator) {
 

package/src/evaluator/combiners/and.ts

@@ -1,11 +1,11 @@
 import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import { MaybeThenable } from '../../dtos/types';
 import { IMatcher } from '../types';
 import { ENGINE_COMBINER_AND } from '../../logger/constants';
 
-export default function andCombinerContext(log: ILogger, matchers: IMatcher[]) {
+export function andCombinerContext(log: ILogger, matchers: IMatcher[]) {
 
   function andResults(results: boolean[]): boolean {
     // Array.prototype.every is supported by target environments

package/src/evaluator/combiners/ifelseif.ts

@@ -1,13 +1,13 @@
 import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
 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';
 
-export default function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator {
+export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator {
 
   function unexpectedInputHandler() {
     log.error(ERROR_ENGINE_COMBINER_IFELSEIF);

package/src/evaluator/condition/index.ts

@@ -1,5 +1,5 @@
 import { getTreatment, shouldApplyRollout } from './engineUtils';
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
 import { MaybeThenable } from '../../dtos/types';
 import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
@@ -22,7 +22,7 @@ function match(log: ILogger, matchingResult: boolean, bucketingKey: string | und
 }
 
 // Condition factory
-export default function conditionContext(log: ILogger, matcherEvaluator: (...args: any) => MaybeThenable<boolean>, treatments: { getTreatmentFor: (x: number) => string }, label: string, conditionType: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
+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) {
 

package/src/evaluator/index.ts

@@ -1,7 +1,6 @@
-import Engine from './Engine';
-import thenable from '../utils/promise/thenable';
+import { Engine } from './Engine';
+import { thenable } from '../utils/promise/thenable';
 import * as LabelsConstants from '../utils/labels';
-import { get } from '../utils/lang';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
@@ -106,17 +105,17 @@ function getEvaluation(
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async, evaluation and changeNumber will return a thenable
+    // If the storage is async and the evaluated split uses segment, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();
-        result.config = get(splitJSON, `configurations.${result.treatment}`, null);
+        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
 
         return result;
       });
     } else {
       evaluation.changeNumber = split.getChangeNumber(); // Always sync and optional
-      evaluation.config = get(splitJSON, `configurations.${evaluation.treatment}`, null);
+      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
     }
   }
 

package/src/evaluator/matchers/all.ts

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

package/src/evaluator/matchers/between.ts

@@ -2,7 +2,7 @@ import { IBetweenMatcherData } from '../../dtos/types';
 import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export default function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ {
+export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ {
   return function betweenMatcher(runtimeAttr: number): boolean {
 
     let isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;

package/src/evaluator/matchers/boolean.ts

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

package/src/evaluator/matchers/cont_all.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export default function containsAllMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function containsAllMatcher(runtimeAttr: string[]): boolean {
     let containsAll = true;
 

package/src/evaluator/matchers/cont_any.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export default function containsAnyMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function containsAnyMatcher(runtimeAttr: string[]): boolean {
     let containsAny = false;
 

package/src/evaluator/matchers/cont_str.ts

@@ -2,7 +2,7 @@ import { isString } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
-export default function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function containsStringMatcher(runtimeAttr: string): boolean {
     let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
 

package/src/evaluator/matchers/dependency.ts

@@ -1,11 +1,11 @@
 import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types';
 import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';
 
-export default function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync) {
+export function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync) {
 
   function checkTreatment(evaluation: IEvaluation, acceptableTreatments: string[], parentName: string) {
     let matches = false;

package/src/evaluator/matchers/eq.ts

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

package/src/evaluator/matchers/eq_set.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export default function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function equalToSetMatcher(runtimeAttr: string[]): boolean {
     // Length being the same is the first condition.
     let isEqual = runtimeAttr.length === ruleAttr.length;

package/src/evaluator/matchers/ew.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { endsWith as strEndsWith } from '../../utils/lang';
 
-export default function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function endsWithMatcher(runtimeAttr: string): boolean {
     let endsWith = ruleAttr.some(e => strEndsWith(runtimeAttr, e));
 

package/src/evaluator/matchers/gte.ts

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

package/src/evaluator/matchers/index.ts

@@ -1,49 +1,49 @@
-import allMatcher from './all';
-import segmentMatcher from './segment';
-import whitelistMatcher from './whitelist';
-import eqMatcher from './eq';
-import gteMatcher from './gte';
-import lteMatcher from './lte';
-import betweenMatcher from './between';
-import equalToSetMatcher from './eq_set';
-import containsAllSetMatcher from './cont_all';
-import containsAnySetMatcher from './cont_any';
-import partOfSetMatcher from './part_of';
-import swMatcher from './sw';
-import ewMatcher from './ew';
-import containsStrMatcher from './cont_str';
-import dependencyMatcher from './dependency';
-import booleanMatcher from './boolean';
-import stringMatcher from './string';
+import { allMatcherContext } from './all';
+import { segmentMatcherContext } from './segment';
+import { whitelistMatcherContext } from './whitelist';
+import { equalToMatcherContext } from './eq';
+import { greaterThanEqualMatcherContext } from './gte';
+import { lessThanEqualMatcherContext } from './lte';
+import { betweenMatcherContext } from './between';
+import { equalToSetMatcherContext } from './eq_set';
+import { containsAnySetMatcherContext } from './cont_any';
+import { containsAllSetMatcherContext } from './cont_all';
+import { partOfSetMatcherContext } from './part_of';
+import { endsWithMatcherContext } from './ew';
+import { startsWithMatcherContext } from './sw';
+import { containsStringMatcherContext } from './cont_str';
+import { dependencyMatcherContext } from './dependency';
+import { booleanMatcherContext } from './boolean';
+import { stringMatcherContext } from './string';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
 import { ILogger } from '../../logger/types';
 
 const matchers = [
   undefined, // UNDEFINED: 0,
-  allMatcher, // ALL_KEYS: 1,
-  segmentMatcher, // IN_SEGMENT: 2,
-  whitelistMatcher, // WHITELIST: 3,
-  eqMatcher, // EQUAL_TO: 4,
-  gteMatcher, // GREATER_THAN_OR_EQUAL_TO: 5,
-  lteMatcher, // LESS_THAN_OR_EQUAL_TO: 6,
-  betweenMatcher, // BETWEEN: 7,
-  equalToSetMatcher, // EQUAL_TO_SET: 8,
-  containsAnySetMatcher, // CONTAINS_ANY_OF_SET: 9,
-  containsAllSetMatcher, // CONTAINS_ALL_OF_SET: 10,
-  partOfSetMatcher, // PART_OF_SET: 11,
-  ewMatcher, // ENDS_WITH: 12,
-  swMatcher, // STARTS_WITH: 13,
-  containsStrMatcher, // CONTAINS_STRING: 14,
-  dependencyMatcher, // IN_SPLIT_TREATMENT: 15,
-  booleanMatcher, // EQUAL_TO_BOOLEAN: 16,
-  stringMatcher // MATCHES_STRING: 17
+  allMatcherContext, // ALL_KEYS: 1,
+  segmentMatcherContext, // IN_SEGMENT: 2,
+  whitelistMatcherContext, // WHITELIST: 3,
+  equalToMatcherContext, // EQUAL_TO: 4,
+  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5,
+  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6,
+  betweenMatcherContext, // BETWEEN: 7,
+  equalToSetMatcherContext, // EQUAL_TO_SET: 8,
+  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9,
+  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10,
+  partOfSetMatcherContext, // PART_OF_SET: 11,
+  endsWithMatcherContext, // ENDS_WITH: 12,
+  startsWithMatcherContext, // STARTS_WITH: 13,
+  containsStringMatcherContext, // CONTAINS_STRING: 14,
+  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15,
+  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16,
+  stringMatcherContext // MATCHES_STRING: 17
 ];
 
 /**
  * Matcher factory.
  */
-export default function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined {
+export function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined {
   let {
     type,
     value

package/src/evaluator/matchers/lte.ts

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

package/src/evaluator/matchers/part_of.ts

@@ -2,7 +2,7 @@ import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
-export default function partOfMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function partOfMatcher(runtimeAttr: string[]): boolean {
     // To be part of the length should be minor or equal.
     let isPartOf = runtimeAttr.length <= ruleAttr.length;

package/src/evaluator/matchers/segment.ts

@@ -1,10 +1,10 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
 
-export default function matcherSegmentContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) {
+export function segmentMatcherContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) {
 
   return function segmentMatcher(key: string): MaybeThenable<boolean> {
     const isInSegment = storage.segments.isInSegment(segmentName, key);

package/src/evaluator/matchers/string.ts

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

package/src/evaluator/matchers/sw.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { startsWith } from '../../utils/lang';
 
-export default function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function startsWithMatcher(runtimeAttr: string): boolean {
     let matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
 

package/src/evaluator/matchers/whitelist.ts

@@ -2,7 +2,7 @@ import { setToArray, ISet } from '../../utils/lang/sets';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 
-export default function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {
+export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {
   return function whitelistMatcher(runtimeAttr: string): boolean {
     let isInWhitelist = ruleAttr.has(runtimeAttr);
 

package/src/evaluator/matchersTransform/index.ts

@@ -1,9 +1,9 @@
 import { findIndex } from '../../utils/lang';
 import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
-import segmentTransform from './segment';
-import whitelistTransform from './whitelist';
-import setTransform from './set';
-import numericTransform from './unaryNumeric';
+import { segmentTransform } from './segment';
+import { whitelistTransform } from './whitelist';
+import { setTransform } from './set';
+import { numericTransform } from './unaryNumeric';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
 import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData, IWhitelistMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
@@ -11,7 +11,7 @@ import { IMatcherDto } from '../types';
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
-export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
+export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
 
   let parsedMatchers = matchers.map(matcher => {
     let {

package/src/evaluator/matchersTransform/segment.ts

@@ -3,6 +3,6 @@ import { IInSegmentMatcherData } from '../../dtos/types';
 /**
  * Extract segment name as a plain string.
  */
-export default function transform(segment?: IInSegmentMatcherData) {
+export function segmentTransform(segment?: IInSegmentMatcherData) {
   return segment ? segment.segmentName : undefined;
 }

package/src/evaluator/matchersTransform/set.ts

@@ -3,6 +3,6 @@ import { IWhitelistMatcherData } from '../../dtos/types';
 /**
  * Extract whitelist array. Used by set and string matchers
  */
-export default function transform(whitelistObject: IWhitelistMatcherData) {
+export function setTransform(whitelistObject: IWhitelistMatcherData) {
   return whitelistObject.whitelist;
 }

package/src/evaluator/matchersTransform/unaryNumeric.ts

@@ -3,6 +3,6 @@ import { IUnaryNumericMatcherData } from '../../dtos/types';
 /**
  * Extract value from unary matcher data.
  */
-export default function transform(unaryNumericObject: IUnaryNumericMatcherData) {
+export function numericTransform(unaryNumericObject: IUnaryNumericMatcherData) {
   return unaryNumericObject.value;
 }

package/src/evaluator/matchersTransform/whitelist.ts

@@ -4,6 +4,6 @@ import { _Set } from '../../utils/lang/sets';
 /**
  * Extract whitelist as a set. Used by 'WHITELIST' matcher.
  */
-export default function transform(whitelistObject: IWhitelistMatcherData) {
+export function whitelistTransform(whitelistObject: IWhitelistMatcherData) {
   return new _Set(whitelistObject.whitelist);
 }

package/src/evaluator/parser/index.ts

@@ -1,18 +1,18 @@
-import matchersTransform from '../matchersTransform';
-import Treatments from '../treatments';
-import matcherFactory from '../matchers';
-import sanitizeValue from '../value';
-import conditionFactory from '../condition';
-import ifElseIfCombiner from '../combiners/ifelseif';
-import andCombiner from '../combiners/and';
-import thenable from '../../utils/promise/thenable';
+import { matchersTransform } from '../matchersTransform';
+import { Treatments } from '../treatments';
+import { matcherFactory } from '../matchers';
+import { sanitizeValue } from '../value';
+import { conditionContext } from '../condition';
+import { ifElseIfCombinerContext } from '../combiners/ifelseif';
+import { andCombinerContext } from '../combiners/and';
+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';
 
-export default function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
+export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
 
   for (let i = 0; i < conditions.length; i++) {
@@ -53,9 +53,9 @@ export default function parser(log: ILogger, conditions: ISplitCondition[], stor
       break;
     }
 
-    predicates.push(conditionFactory(
+    predicates.push(conditionContext(
       log,
-      andCombiner(log, expressions),
+      andCombinerContext(log, expressions),
       Treatments.parse(partitions),
       label,
       conditionType
@@ -63,5 +63,5 @@ export default function parser(log: ILogger, conditions: ISplitCondition[], stor
   }
 
   // Instanciate evaluator given the set of conditions using if else if logic
-  return ifElseIfCombiner(log, predicates);
+  return ifElseIfCombinerContext(log, predicates);
 }

package/src/evaluator/treatments/index.ts

@@ -1,7 +1,7 @@
 import { ISplitPartition } from '../../dtos/types';
 import { findIndex } from '../../utils/lang';
 
-export default class Treatments {
+export class Treatments {
 
   private _ranges: number[];
   private _treatments: string[];

package/src/evaluator/value/index.ts

@@ -1,7 +1,7 @@
 import { SplitIO } from '../../types';
 import { IMatcherDto } from '../types';
 import { ILogger } from '../../logger/types';
-import sanitizeValue from './sanitize';
+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) {
@@ -23,10 +23,10 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export default function value(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.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 = sanitizeValue(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
+  const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
 
   if (sanitizedValue !== undefined) {
     return sanitizedValue;

package/src/evaluator/value/sanitize.ts

@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export default function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.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;