@splitsoftware/splitio-commons 1.0.1-rc.4 → 1.1.1-rc.0

package/src/sync/streaming/pushManager.ts

@@ -3,15 +3,15 @@ import { ISSEClient } from './SSEClient/types';
 import { IStorageSync } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
-import objectAssign from 'object-assign';
-import Backoff from '../../utils/Backoff';
-import SSEHandlerFactory from './SSEHandler';
-import MySegmentsUpdateWorker from './UpdateWorkers/MySegmentsUpdateWorker';
-import SegmentsUpdateWorker from './UpdateWorkers/SegmentsUpdateWorker';
-import SplitsUpdateWorker from './UpdateWorkers/SplitsUpdateWorker';
+import { objectAssign } from '../../utils/lang/objectAssign';
+import { Backoff } from '../../utils/Backoff';
+import { SSEHandlerFactory } from './SSEHandler';
+import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
+import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
+import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
-import SSEClient from './SSEClient';
+import { SSEClient } from './SSEClient';
 import { IFetchAuth } from '../../services/types';
 import { ISettings } from '../../types';
 import { getMatching } from '../../utils/key';
@@ -29,7 +29,7 @@ import { IAuthTokenPushEnabled } from './AuthClient/types';
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export default function pushManagerFactory(
+export function pushManagerFactory(
   pollingManager: IPollingManager,
   storage: IStorageSync,
   readiness: IReadinessManager,
@@ -115,7 +115,8 @@ export default function pushManagerFactory(
   function connectPush() {
     // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)
     if (disconnected) return;
-    log.info(STREAMING_CONNECTING, [disconnected === undefined ? '' : 'Re-']);
+    // @TODO distinguish log for 'Connecting' (1st time) and 'Re-connecting'
+    log.info(STREAMING_CONNECTING);
     disconnected = false;
 
     const userKeys = userKey ? Object.keys(clients) : undefined;

package/src/sync/submitters/submitterSyncTask.ts

@@ -1,4 +1,4 @@
-import syncTaskFactory from '../syncTask';
+import { syncTaskFactory } from '../syncTask';
 import { ISyncTask, ITimeTracker } from '../types';
 import { IRecorderCacheProducerSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';

package/src/sync/syncTask.ts

@@ -13,7 +13,7 @@ import { ISyncTask } from './types';
  * @param taskName  Optional task name for logging.
  * @returns A sync task that wraps the given task.
  */
-export default function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {
+export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {
 
   // Flag that indicates if the task is being executed
   let executing = false;

package/src/trackers/eventTracker.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 { IEventsCacheBase } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
 import { SplitIO } from '../types';
@@ -12,7 +12,7 @@ import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constant
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export default function eventTrackerFactory(
+export function eventTrackerFactory(
   log: ILogger,
   eventsCache: IEventsCacheBase,
   integrationsManager?: IEventsHandler

package/src/trackers/impressionObserver/ImpressionObserver.ts

@@ -1,8 +1,8 @@
 import { ImpressionDTO } from '../../types';
-import LRUCache from '../../utils/LRUCache';
+import { LRUCache } from '../../utils/LRUCache';
 import { IImpressionObserver } from './types';
 
-export default class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
+export class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
   private cache: LRUCache<K, number>;
   private hasher: (impression: ImpressionDTO) => K;
 

package/src/trackers/impressionObserver/impressionObserverCS.ts

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

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

@@ -1108,6 +1108,45 @@ export namespace SplitIO {
      * @returns {boolean} Whether the event was added to the queue succesfully or not.
      */
     track(...args: [trafficType: string, eventType: string, value?: number, properties?: Properties] | [eventType: string, value?: number, properties?: Properties]): boolean,
+    /**
+     * Add an attribute to client's in memory attributes storage
+     * @function setAttribute
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean,
+    /**
+     * Returns the attribute with the given key
+     * @function getAttribute
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object,
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     * @function setAttributes
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean,
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     * @function getAttributes
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>,
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     * @function removeAttribute
+     * @param {string} attributeName 
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean,
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean
   }
   /**
    * Representation of a manager instance with synchronous storage of the SDK.

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/attribute.ts

@@ -0,0 +1,21 @@
+import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+
+export function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean {
+  if (!isString(attributeKey) || attributeKey.length === 0) {
+    log.warn(`${method}: you passed an invalid attribute name, attribute name must be a non-empty string.`);
+    return false;
+  }
+
+  const isStringVal = isString(attributeValue);
+  const isFiniteVal = isFiniteNumber(attributeValue);
+  const isBoolVal = isBoolean(attributeValue);
+  const isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
+    log.warn(`${method}: you passed an invalid attribute value for ${attributeKey}. Acceptable types are: string, number, boolean and array of strings.`);
+    return false;
+  }
+
+  return true;
+}

package/src/utils/inputValidation/attributes.ts

@@ -1,6 +1,7 @@
 import { isObject } from '../lang';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
+import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
@@ -11,3 +12,16 @@ export function validateAttributes(log: ILogger, maybeAttrs: any, method: string
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
   return false;
 }
+
+export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<string, Object>, method: string): boolean {
+  if (!validateAttributes(log, maybeAttributes, method)) return false;
+
+  let result = true;
+  Object.keys(maybeAttributes).forEach(attributeKey => {
+    if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+      result = false;
+  });
+
+  return result;
+
+}

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;