@splitsoftware/splitio-commons 1.0.1-rc.3 → 1.1.0

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,7 +11,7 @@ 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

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/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';
 
@@ -122,7 +122,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // Startup periods
   startup.requestTimeoutBeforeReady = fromSecondsToMillis(startup.requestTimeoutBeforeReady);
   startup.readyTimeout = fromSecondsToMillis(startup.readyTimeout);
-  startup.eventsFirstPushWindow = fromSecondsToMillis(withDefaults.startup.eventsFirstPushWindow);
+  startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);
 
   // ensure a valid SDK mode
   // @ts-ignore, modify readonly prop

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;

package/types/listeners/node.d.ts

@@ -8,7 +8,7 @@ import { ISyncManager } from '../sync/types';
  * you should call the cleanup logic yourself, since we cannot ensure the data is sent after
  * the process is already exiting.
  */
-export default class NodeSignalListener implements ISignalListener {
+export declare class NodeSignalListener implements ISignalListener {
     private handler;
     private settings;
     constructor(syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,

package/types/readiness/sdkReadinessManager.d.ts

@@ -10,4 +10,4 @@ import { ILogger } from '../logger/types';
  * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export default function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, internalReadyCbCount?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, internalReadyCbCount?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/sdkClient/client.d.ts

@@ -3,4 +3,4 @@ import { SplitIO } from '../types';
 /**
  * Creator of base client with getTreatments and track methods.
  */
-export default function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/clientCS.d.ts

@@ -6,4 +6,4 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export default function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;
+export declare function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;

package/types/sdkClient/clientInputValidation.d.ts

@@ -5,4 +5,4 @@ import { ILogger } from '../logger/types';
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export default function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync?: boolean): TClient;
+export declare function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync?: boolean): TClient;

package/types/services/types.d.ts

@@ -43,7 +43,5 @@ interface IEventSource {
     addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: IEventSource, ev: EventSourceEventMap[K]) => any): void;
     close(): void;
 }
-export declare type IEventSourceConstructor = new (url: string, eventSourceInitDict?: {
-    headers?: object;
-}) => IEventSource;
+export declare type IEventSourceConstructor = new (url: string, eventSourceInitDict?: any) => IEventSource;
 export {};

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheSync } from './types';
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
+export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
     /**
      * For server-side synchronizer: add `segmentKeys` list of keys to `name` segment.
      * For client-side synchronizer: add `name` segment to the cache. `segmentKeys` is undefined.

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -3,7 +3,7 @@ import { ISplitsCacheAsync } from './types';
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
+export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     abstract addSplit(name: string, split: string): Promise<boolean>;
     abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>;
     abstract removeSplits(names: string[]): Promise<boolean[] | void>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -4,7 +4,7 @@ import { ISplit } from '../dtos/types';
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
+export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     abstract addSplit(name: string, split: string): boolean;
     addSplits(entries: [string, string][]): boolean[];
     abstract removeSplit(name: string): boolean;

package/types/storages/KeyBuilder.d.ts

@@ -1,5 +1,5 @@
 export declare function validatePrefix(prefix: unknown): string;
-export default class KeyBuilder {
+export declare class KeyBuilder {
     protected readonly prefix: string;
     constructor(prefix?: string);
     buildTrafficTypeKey(trafficType: string): string;