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

package/src/trackers/impressionObserver/impressionObserverSS.ts

@@ -1,4 +1,4 @@
-import ImpressionObserver from './ImpressionObserver';
+import { ImpressionObserver } from './ImpressionObserver';
 import { hash128 } from '../../utils/murmur3/murmur3_128_x86';
 import { buildKey } from './buildKey';
 import { ImpressionDTO } from '../../types';

package/src/trackers/impressionsTracker.ts

@@ -1,5 +1,5 @@
-import objectAssign from 'object-assign';
-import thenable from '../utils/promise/thenable';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { thenable } from '../utils/promise/thenable';
 import { truncateTimeFrame } from '../utils/time';
 import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/types';
 import { IImpressionsHandler, IImpressionsTracker } from './types';
@@ -18,7 +18,7 @@ import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIO
  * @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 default function impressionsTrackerFactory(
+export function impressionsTrackerFactory(
   log: ILogger,
   impressionsCache: IImpressionsCacheBase,
 

package/src/types.ts

@@ -7,15 +7,16 @@ import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory
 import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
 
 /**
- * EventEmitter interface with the minimal methods used by the SDK
+ * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
+ * @see {@link https://nodejs.org/api/events.html}
  */
-export interface IEventEmitter extends Pick<NodeJS.EventEmitter, 'addListener' | 'on' | 'once' | 'removeListener' | 'off' | 'removeAllListeners' | 'emit'> {
-  addListener(event: string, listener: (...args: any[]) => void): any;
-  on(event: string, listener: (...args: any[]) => void): any
-  once(event: string, listener: (...args: any[]) => void): any
-  removeListener(event: string, listener: (...args: any[]) => void): any;
-  off(event: string, listener: (...args: any[]) => void): any;
-  removeAllListeners(event?: string): any
+export interface IEventEmitter {
+  addListener(event: string, listener: (...args: any[]) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this
+  once(event: string, listener: (...args: any[]) => void): this
+  removeListener(event: string, listener: (...args: any[]) => void): this;
+  off(event: string, listener: (...args: any[]) => void): this;
+  removeAllListeners(event?: string): this
   emit(event: string, ...args: any[]): boolean
 }
 

package/src/utils/Backoff.ts

@@ -1,4 +1,4 @@
-export default class Backoff {
+export class Backoff {
 
   static DEFAULT_BASE_MILLIS = 1000; // 1 second
   static DEFAULT_MAX_MILLIS = 1800000; // 30 minutes

package/src/utils/LRUCache/index.ts

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

package/src/utils/MinEventEmitter.ts

@@ -11,14 +11,14 @@ function checkListener(listener: unknown) {
 }
 
 // @TODO implement missing methods, check spec and add UTs
-export default class EventEmitter implements IEventEmitter {
+export class EventEmitter implements IEventEmitter {
 
   private listeners: Record<string, Array<[
     (...args: any[]) => void, // the event listener
     boolean // whether it is a one-time listener or not
   ]>> = {};
 
-  private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean): EventEmitter {
+  private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean) {
     checkListener(listener);
 
     // To avoid recursion in the case that type === "newListener" before
@@ -33,27 +33,27 @@ export default class EventEmitter implements IEventEmitter {
     return this;
   }
 
-  addListener(type: string, listener: (...args: any[]) => void): EventEmitter {
+  addListener(type: string, listener: (...args: any[]) => void) {
     return this.registerListener(type, listener, false);
   }
 
   // alias of addListener
-  on(type: string, listener: (...args: any[]) => void): EventEmitter {
+  on(type: string, listener: (...args: any[]) => void) {
     return this.addListener(type, listener);
   }
 
-  once(type: string, listener: (...args: any[]) => void): EventEmitter {
+  once(type: string, listener: (...args: any[]) => void) {
     return this.registerListener(type, listener, true);
   }
 
-  // eslint-disable-next-line
-  removeListener(type: string, listener: (...args: any[]) => void): EventEmitter {
+  // @ts-ignore
+  removeListener(/* type: string, listener: (...args: any[]) => void */) {
     throw new Error('Method not implemented.');
   }
 
-  // alias of removeListener
-  off(type: string, listener: (...args: any[]) => void): EventEmitter {
-    return this.removeListener(type, listener);
+  // @ts-ignore alias of removeListener
+  off(/* type: string, listener: (...args: any[]) => void */) {
+    return this.removeListener(/* type, listener */);
   }
 
   emit(type: string, ...args: any[]): boolean {
@@ -68,7 +68,7 @@ export default class EventEmitter implements IEventEmitter {
     return true;
   }
 
-  removeAllListeners(type?: string): EventEmitter {
+  removeAllListeners(type?: string) {
     if (!this.listeners[REMOVE_LISTENER_EVENT]) {
       // if not listening for `removeListener`, no need to emit
       if (type) {

package/src/utils/MinEvents.ts

@@ -39,14 +39,9 @@ var ReflectApply = R && typeof R.apply === 'function'
     return Function.prototype.apply.call(target, receiver, args);
   };
 
-function EventEmitter() {
+export const EventEmitter: { new(): IEventEmitter } = function EventEmitter() {
   EventEmitter.init.call(this);
-}
-
-export default EventEmitter as new () => IEventEmitter;
-
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+};
 
 EventEmitter.prototype._events = undefined;
 EventEmitter.prototype._eventsCount = 0;

package/src/utils/env/isNode.ts

@@ -1,3 +1,6 @@
-// We check for version truthiness since most shims will have that as empty string.
+/**
+ * 'true' if running in Node.js, or 'false' otherwise.
+ * We check for version truthiness since most shims will have that as empty string.
+ */
 // eslint-disable-next-line no-undef
 export const isNode: boolean = typeof process !== 'undefined' && typeof process.version !== 'undefined' && !!process.version ? true : false;

package/src/utils/inputValidation/trafficTypeExistance.ts

@@ -1,4 +1,4 @@
-import thenable from '../promise/thenable';
+import { thenable } from '../promise/thenable';
 import { LOCALHOST_MODE } from '../constants';
 import { ISplitsCacheBase } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';

package/src/utils/lang/binarySearch.ts

@@ -6,7 +6,7 @@
  * @returns integer number between 0 and `items.length`. This value is the index of the search value,
  * if it is contained in the array, or the index at which the value should be inserted to keep the array ordered.
  */
-export default function binarySearch(items: number[], value: number): number {
+export function binarySearch(items: number[], value: number): number {
   let startIndex = 0;
   let stopIndex = items.length - 1;
   let middle = Math.floor((stopIndex + startIndex) / 2);

package/src/utils/lang/objectAssign.ts

@@ -0,0 +1,104 @@
+/*
+Adaptation of "object-assign" library (https://www.npmjs.com/package/object-assign)
+exported as an ES module instead of CommonJS, to avoid extra configuration steps when using
+the ESM build of the SDK with tools that doesn't support CommonJS by default (e.g. Rollup).
+
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/* eslint-disable */
+// @ts-nocheck
+
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+  if (val === null || val === undefined) {
+    throw new TypeError('Object.assign cannot be called with null or undefined');
+  }
+
+  return Object(val);
+}
+
+function shouldUseNative() {
+  try {
+    if (!Object.assign) {
+      return false;
+    }
+
+    // Detect buggy property enumeration order in older V8 versions.
+
+    // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+    var test1 = new String('abc');
+    test1[5] = 'de';
+    if (Object.getOwnPropertyNames(test1)[0] === '5') {
+      return false;
+    }
+
+    // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+    var test2 = {};
+    for (var i = 0; i < 10; i++) {
+      test2['_' + String.fromCharCode(i)] = i;
+    }
+    var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+      return test2[n];
+    });
+    if (order2.join('') !== '0123456789') {
+      return false;
+    }
+
+    // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+    var test3 = {};
+    'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+      test3[letter] = letter;
+    });
+    if (Object.keys(Object.assign({}, test3)).join('') !==
+      'abcdefghijklmnopqrst') {
+      return false;
+    }
+
+    return true;
+  } catch (err) {
+    // We don't expect any of the above to throw, but better to be safe.
+    return false;
+  }
+}
+
+// https://www.npmjs.com/package/@types/object-assign
+type ObjectAssign = (<T, U>(target: T, source: U) => T & U) &
+  (<T, U, V>(target: T, source1: U, source2: V) => T & U & V) &
+  (<T, U, V, W>(target: T, source1: U, source2: V, source3: W) => T & U & V & W) &
+  (<T, U, V, W, Q>(target: T, source1: U, source2: V, source3: W, source4: Q) => T & U & V & W & Q) &
+  (<T, U, V, W, Q, R>(target: T, source1: U, source2: V, source3: W, source4: Q, source5: R) => T & U & V & W & Q & R) &
+  ((target: any, ...sources: any[]) => any);
+
+export const objectAssign: ObjectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+  var from;
+  var to = toObject(target);
+  var symbols;
+
+  for (var s = 1; s < arguments.length; s++) {
+    from = Object(arguments[s]);
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (var key in from) {
+      if (hasOwnProperty.call(from, key)) {
+        to[key] = from[key];
+      }
+    }
+
+    if (getOwnPropertySymbols) {
+      symbols = getOwnPropertySymbols(from);
+      for (var i = 0; i < symbols.length; i++) {
+        if (propIsEnumerable.call(from, symbols[i])) {
+          to[symbols[i]] = from[symbols[i]];
+        }
+      }
+    }
+  }
+
+  return to;
+};

package/src/utils/promise/thenable.ts

@@ -1,2 +1,4 @@
 // returns true if the given value is a thenable object
-export default (o: any): o is Promise<any> => o !== undefined && o !== null && typeof o.then === 'function';
+export function thenable(o: any): o is Promise<any> {
+  return o !== undefined && o !== null && typeof o.then === 'function';
+}

package/src/utils/promise/timeout.ts

@@ -1,4 +1,4 @@
-export default function timeout<T>(ms: number, promise: Promise<T>): Promise<T> {
+export function timeout<T>(ms: number, promise: Promise<T>): Promise<T> {
   if (ms < 1) return promise;
 
   return new Promise((resolve, reject) => {

package/src/utils/promise/wrapper.ts

@@ -16,7 +16,7 @@
  * @returns a promise that doesn't need to be handled for rejection (except when using async/await syntax) and
  * includes a method named `hasOnFulfilled` that returns true if the promise has attached an onFulfilled handler.
  */
-export default function promiseWrapper<T>(customPromise: Promise<T>, defaultOnRejected: (_: any) => any): Promise<T> & { hasOnFulfilled: () => boolean } {
+export function promiseWrapper<T>(customPromise: Promise<T>, defaultOnRejected: (_: any) => any): Promise<T> & { hasOnFulfilled: () => boolean } {
 
   let hasOnFulfilled = false;
   let hasOnRejected = false;

package/src/utils/settingsValidation/impressionsMode.ts

@@ -3,7 +3,7 @@ import { ILogger } from '../../logger/types';
 import { SplitIO } from '../../types';
 import { DEBUG, OPTIMIZED } from '../constants';
 
-export default function validImpressionsMode(log: ILogger, impressionsMode: string): SplitIO.ImpressionsMode {
+export function validImpressionsMode(log: ILogger, impressionsMode: string): SplitIO.ImpressionsMode {
   impressionsMode = impressionsMode.toUpperCase();
   if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) === -1) {
     log.error(ERROR_INVALID_IMPRESSIONS_MODE, [[DEBUG, OPTIMIZED], OPTIMIZED]);

package/src/utils/settingsValidation/index.ts

@@ -1,8 +1,8 @@
 import { merge } from '../lang';
-import mode from './mode';
+import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
-import validImpressionsMode from './impressionsMode';
+import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
 

package/src/utils/settingsValidation/mode.ts

@@ -1,6 +1,6 @@
 import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 
-export default function mode(key: string, mode: string) {
+export function mode(key: string, mode: string) {
   // Leaving the comparison as is, in case we change the mode name but not the setting.
   if (key === 'localhost') return LOCALHOST_MODE;
 

package/src/utils/timeTracker/index.ts

@@ -1,6 +1,6 @@
 import { uniqueId } from '../lang';
-import timer from './timer';
-import thenable from '../promise/thenable';
+import { timer } from './timer';
+import { thenable } from '../promise/thenable';
 import { ILogger } from '../../logger/types';
 import { IResponse } from '../../services/types';
 
@@ -112,7 +112,8 @@ function getCallbackForTask(task: string, collector: MetricsCollector | false):
   return false;
 }
 
-const TrackerAPI = {
+// Our "time tracker" API
+export const TrackerAPI = {
   /**
    * "Private" method, used to attach count/countException and stop callbacks to a promise.
    *
@@ -223,6 +224,3 @@ const TrackerAPI = {
    */
   TaskNames: CONSTANTS
 };
-
-// Our "time tracker" API
-export default TrackerAPI;

package/src/utils/timeTracker/now/browser.ts

@@ -9,6 +9,4 @@ function nowFactory() {
   }
 }
 
-const now = nowFactory();
-
-export default now;
+export const now = nowFactory();

package/src/utils/timeTracker/now/node.ts

@@ -1,5 +1,5 @@
 // @TODO migrate to Node SDK package eventually
-export default function now() {
+export function now() {
   // eslint-disable-next-line no-undef
   let time = process.hrtime();
 

package/src/utils/timeTracker/timer.ts

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

package/types/evaluator/Engine.d.ts

@@ -3,7 +3,7 @@ import { SplitIO } from '../types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
 import { ILogger } from '../logger/types';
-export default class Engine {
+export declare class Engine {
     private baseInfo;
     private evaluator;
     constructor(baseInfo: ISplit, evaluator: IEvaluator);

package/types/evaluator/combiners/and.d.ts

@@ -1,4 +1,4 @@
 import { ILogger } from '../../logger/types';
 import { MaybeThenable } from '../../dtos/types';
 import { IMatcher } from '../types';
-export default function andCombinerContext(log: ILogger, matchers: IMatcher[]): (...params: any) => MaybeThenable<boolean>;
+export declare function andCombinerContext(log: ILogger, matchers: IMatcher[]): (...params: any) => MaybeThenable<boolean>;

package/types/evaluator/combiners/ifelseif.d.ts

@@ -1,3 +1,3 @@
 import { ILogger } from '../../logger/types';
 import { IEvaluator } from '../types';
-export default function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator;
+export declare function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator;

package/types/evaluator/condition/index.d.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable } from '../../dtos/types';
 import { IEvaluator } from '../types';
 import { ILogger } from '../../logger/types';
-export default function conditionContext(log: ILogger, matcherEvaluator: (...args: any) => MaybeThenable<boolean>, treatments: {
+export declare function conditionContext(log: ILogger, matcherEvaluator: (...args: any) => MaybeThenable<boolean>, treatments: {
     getTreatmentFor: (x: number) => string;
 }, label: string, conditionType: 'ROLLOUT' | 'WHITELIST'): IEvaluator;

package/types/evaluator/matchers/all.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function allMatcherContext(log: ILogger): (runtimeAttr: string) => boolean;
+export declare function allMatcherContext(log: ILogger): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/between.d.ts

@@ -1,3 +1,3 @@
 import { IBetweenMatcherData } from '../../dtos/types';
 import { ILogger } from '../../logger/types';
-export default function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData): (runtimeAttr: number) => boolean;
+export declare function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/boolean.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function booleanMatcherContext(log: ILogger, ruleAttr: boolean): (runtimeAttr: boolean) => boolean;
+export declare function booleanMatcherContext(log: ILogger, ruleAttr: boolean): (runtimeAttr: boolean) => boolean;

package/types/evaluator/matchers/cont_all.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function containsAllMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/cont_any.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function containsAnyMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/cont_str.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function containsStringMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;
+export declare function containsStringMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/dependency.d.ts

@@ -2,4 +2,4 @@ import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
-export default function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync): ({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator) => MaybeThenable<boolean>;
+export declare function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync): ({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator) => MaybeThenable<boolean>;

package/types/evaluator/matchers/eq.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function equalToMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;
+export declare function equalToMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/eq_set.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/ew.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function endsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;
+export declare function endsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/gte.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;
+export declare function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/index.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Matcher factory.
  */
-export default function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined;
+export declare function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined;

package/types/evaluator/matchers/lte.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;
+export declare function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/part_of.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function partOfMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/segment.d.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-export default function matcherSegmentContext(log: ILogger, segmentName: string, storage: {
+export declare function segmentMatcherContext(log: ILogger, segmentName: string, storage: {
     segments: ISegmentsCacheBase;
 }): (key: string) => MaybeThenable<boolean>;

package/types/evaluator/matchers/string.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function stringMatcherContext(log: ILogger, ruleAttr: string): (runtimeAttr: string) => boolean;
+export declare function stringMatcherContext(log: ILogger, ruleAttr: string): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/sw.d.ts

@@ -1,2 +1,2 @@
 import { ILogger } from '../../logger/types';
-export default function startsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;
+export declare function startsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/whitelist.d.ts

@@ -1,3 +1,3 @@
 import { ISet } from '../../utils/lang/sets';
 import { ILogger } from '../../logger/types';
-export default function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>): (runtimeAttr: string) => boolean;
+export declare function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>): (runtimeAttr: string) => boolean;

package/types/evaluator/matchersTransform/index.d.ts

@@ -3,4 +3,4 @@ import { IMatcherDto } from '../types';
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
-export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[];
+export declare function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[];

package/types/evaluator/matchersTransform/segment.d.ts

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

package/types/evaluator/matchersTransform/set.d.ts

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

package/types/evaluator/matchersTransform/unaryNumeric.d.ts

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

package/types/evaluator/matchersTransform/whitelist.d.ts

@@ -2,4 +2,4 @@ import { IWhitelistMatcherData } from '../../dtos/types';
 /**
  * Extract whitelist as a set. Used by 'WHITELIST' matcher.
  */
-export default function transform(whitelistObject: IWhitelistMatcherData): import("../../utils/lang/sets").ISet<string>;
+export declare function whitelistTransform(whitelistObject: IWhitelistMatcherData): import("../../utils/lang/sets").ISet<string>;

package/types/evaluator/parser/index.d.ts

@@ -2,4 +2,4 @@ import { IEvaluator } from '../types';
 import { ISplitCondition } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-export default function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator;
+export declare function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator;

package/types/evaluator/treatments/index.d.ts

@@ -1,5 +1,5 @@
 import { ISplitPartition } from '../../dtos/types';
-export default class Treatments {
+export declare class Treatments {
     private _ranges;
     private _treatments;
     constructor(ranges: number[], treatments: string[]);

package/types/evaluator/value/index.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Defines value to be matched (key / attribute).
  */
-export default function value(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Sanitize matcher value
  */
-export default function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;

package/types/integrations/browser.d.ts

@@ -9,4 +9,4 @@ import { BrowserIntegration } from './ga/types';
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(integrations: BrowserIntegration[], params: IIntegrationFactoryParams): IIntegrationManager | undefined;
+export declare function integrationsManagerFactory(integrations: BrowserIntegration[], params: IIntegrationFactoryParams): IIntegrationManager | undefined;

package/types/integrations/pluggable.d.ts

@@ -8,4 +8,4 @@ import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>, params: IIntegrationFactoryParams): IIntegrationManager | undefined;
+export declare function pluggableIntegrationsManagerFactory(integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>, params: IIntegrationFactoryParams): IIntegrationManager | undefined;

package/types/listeners/browser.d.ts

@@ -6,7 +6,7 @@ import { ISyncManager } from '../sync/types';
 /**
  * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
  */
-export default class BrowserSignalListener implements ISignalListener {
+export declare class BrowserSignalListener implements ISignalListener {
     private syncManager;
     private settings;
     private storage;