@splitsoftware/splitio-commons 1.2.1-rc.0 → 1.2.1-rc.11

package/esm/sync/submitters/impressionsSyncTask.js

@@ -1,5 +1,7 @@
 import { groupBy, forOwn } from '../../utils/lang';
 import { submitterSyncTaskFactory } from './submitterSyncTask';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+var DATA_NAME = 'impressions';
 /**
  * Converts `impressions` data from cache into request payload.
  */
@@ -32,5 +34,15 @@ export function fromImpressionsCollector(sendLabels, data) {
 export function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, sendLabels, latencyTracker) {
     if (sendLabels === void 0) { sendLabels = false; }
     // retry impressions only once.
-    return submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, 'impressions', latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    var syncTask = submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, DATA_NAME, latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    // register impressions submitter to be executed when impressions cache is full
+    impressionsCache.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
 }

package/esm/sync/submitters/submitterManager.js

@@ -2,7 +2,8 @@ import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSyncTaskFactory } from './eventsSyncTask';
 import { impressionsSyncTaskFactory } from './impressionsSyncTask';
 import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
-export function submitterManagerFactory(settings, storage, splitApi) {
+export function submitterManagerFactory(params) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
     var log = settings.log;
     var submitters = [
         impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),

package/esm/sync/syncManagerOnline.js

@@ -1,6 +1,7 @@
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
+import { isConsentGranted } from '../utils/consent';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -13,18 +14,17 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
     /**
      * SyncManager factory for modular SDK
      */
-    return function (_a) {
-        var settings = _a.settings, platform = _a.platform, splitApi = _a.splitApi, storage = _a.storage, readiness = _a.readiness;
-        var log = settings.log;
+    return function (params) {
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(splitApi, storage, readiness, settings);
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
-        var pushManager = settings.streamingEnabled && pollingManager && pushManagerFactory ?
-            pushManagerFactory(pollingManager, storage, readiness, splitApi.fetchAuth, platform, settings) :
+        var pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+            pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
         // It is not inyected as push and polling managers, because at the moment it is required
-        var submitter = submitterManagerFactory(settings, storage, splitApi);
+        var submitter = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
             if (pollingManager.isRunning()) {
@@ -50,13 +50,15 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
         var running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
         var startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
         return {
+            // Exposed for fine-grained control of synchronization.
+            // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
+            pollingManager: pollingManager,
             pushManager: pushManager,
+            submitter: submitter,
             /**
              * Method used to start the syncManager for the first time, or resume it after being stopped.
              */
             start: function () {
-                if (running)
-                    return;
                 running = true;
                 // start syncing splits and segments
                 if (pollingManager) {
@@ -73,15 +75,13 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                if (submitter)
+                if (isConsentGranted(settings))
                     submitter.start();
             },
             /**
              * Method used to stop/pause the syncManager.
              */
             stop: function () {
-                if (!running)
-                    return;
                 running = false;
                 // stop syncing
                 if (pushManager)
@@ -89,14 +89,13 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 if (pollingManager && pollingManager.isRunning())
                     pollingManager.stop();
                 // stop periodic data recording (events, impressions, telemetry).
-                if (submitter)
-                    submitter.stop();
+                submitter.stop();
             },
             isRunning: function () {
                 return running;
             },
             flush: function () {
-                if (submitter)
+                if (isConsentGranted(settings))
                     return submitter.execute();
                 else
                     return Promise.resolve();

package/esm/trackers/eventTracker.js

@@ -1,13 +1,17 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
+import { isStorageSync } from './impressionObserver/utils';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(log, eventsCache, integrationsManager) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager) {
+    var log = settings.log;
+    var isSync = isStorageSync(settings);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
@@ -33,6 +37,9 @@ export function eventTrackerFactory(log, eventsCache, integrationsManager) {
     }
     return {
         track: function (eventData, size) {
+            if (settings.userConsent === CONSENT_DECLINED) {
+                return isSync ? false : Promise.resolve(false);
+            }
             var tracked = eventsCache.track(eventData, size);
             if (thenable(tracked)) {
                 return tracked.then(queueEventsCallback.bind(null, eventData));

package/esm/trackers/impressionObserver/utils.js

@@ -1,4 +1,4 @@
-import { CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
 /**
  * Checks if impressions previous time should be added or not.
  */
@@ -13,3 +13,9 @@ export function shouldBeOptimized(settings) {
         return false;
     return settings.sync.impressionsMode === OPTIMIZED ? true : false;
 }
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isStorageSync(settings) {
+    return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
+}

package/esm/trackers/impressionsTracker.js

@@ -2,6 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -12,16 +13,16 @@ 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 function impressionsTrackerFactory(log, impressionsCache, 
-// @TODO consider passing only an optional integrationsManager to handle impressions
-_a, impressionListener, integrationsManager, 
+export function impressionsTrackerFactory(settings, impressionsCache, integrationsManager, 
 // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
 countsCache) {
-    var _b = _a.runtime, ip = _b.ip, hostname = _b.hostname, version = _a.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
+            if (settings.userConsent === CONSENT_DECLINED)
+                return;
             var impressionsCount = impressions.length;
             var impressionsToStore = []; // Track only the impressions that are going to be stored
             // Wraps impressions to store and adds previousTime if it corresponds
@@ -65,7 +66,7 @@ countsCache) {
                         // integrationsManager.handleImpression does not throw errors
                         if (integrationsManager)
                             integrationsManager.handleImpression(impressionData);
-                        try { // An exception on the listeners should not break the SDK.
+                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
                             if (impressionListener)
                                 impressionListener.logImpression(impressionData);
                         }

package/esm/utils/consent.js

@@ -0,0 +1,6 @@
+import { CONSENT_GRANTED } from './constants';
+export function isConsentGranted(settings) {
+    var userConsent = settings.userConsent;
+    // undefined userConsent is handled as granted (default)
+    return !userConsent || userConsent === CONSENT_GRANTED;
+}

package/esm/utils/constants/index.js

@@ -24,3 +24,7 @@ export var STORAGE_MEMORY = 'MEMORY';
 export var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
 export var STORAGE_REDIS = 'REDIS';
 export var STORAGE_PLUGGABLE = 'PLUGGABLE';
+// User consent
+export var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
+export var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
+export var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions

package/esm/utils/inputValidation/attributes.js

@@ -3,7 +3,7 @@ import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 export function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
-    if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+    if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
         return maybeAttrs;
     log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
     return false;

package/esm/utils/inputValidation/eventProperties.js

@@ -1,4 +1,5 @@
-import { isObject, shallowClone, isString, isFiniteNumber, isBoolean } from '../lang';
+import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
+import { objectAssign } from '../lang/objectAssign';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
 var ECMA_SIZES = {
     NULL: 0,
@@ -17,7 +18,8 @@ export function validateEventProperties(log, maybeProperties, method) {
         return { properties: false, size: BASE_EVENT_SIZE };
     }
     var keys = Object.keys(maybeProperties);
-    var clone = shallowClone(maybeProperties);
+    // Shallow clone
+    var clone = objectAssign({}, maybeProperties);
     // To avoid calculating the size twice we'll return it from here.
     var output = {
         properties: clone,

package/esm/utils/inputValidation/key.js

@@ -35,7 +35,8 @@ export function validateKey(log, maybeKey, method) {
         var bucketingKey = validateKeyValue(log, maybeKey.bucketingKey, method, 'bucketingKey');
         if (matchingKey && bucketingKey)
             return {
-                matchingKey: matchingKey, bucketingKey: bucketingKey
+                matchingKey: matchingKey,
+                bucketingKey: bucketingKey
             };
         log.error(ERROR_INVALID_KEY_OBJECT, [method]);
         return false;

package/esm/utils/lang/index.js

@@ -1,4 +1,4 @@
-import { __spreadArrays } from "tslib";
+import { __spreadArray } from "tslib";
 /**
  * Checks if the target string ends with the sub string.
  */
@@ -141,10 +141,12 @@ export function isNaNNumber(val) {
     return val !== val;
 }
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
 export function isObject(obj) {
-    return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+    return obj !== null && typeof obj === 'object' && (obj.constructor === Object ||
+        (obj.constructor != null && obj.constructor.name === 'Object'));
 }
 /**
  * Checks if a given value is a string.
@@ -152,6 +154,12 @@ export function isObject(obj) {
 export function isString(val) {
     return typeof val === 'string' || val instanceof String;
 }
+/**
+ * String sanitizer. Returns the provided value converted to uppercase if it is a string.
+ */
+export function stringToUpperCase(val) {
+    return isString(val) ? val.toUpperCase() : val;
+}
 /**
  * Deep copy version of Object.assign using recursion.
  * There are some assumptions here. It's for internal use and we don't need verbose errors
@@ -179,21 +187,10 @@ export function merge(target, source) {
     });
     if (rest && rest.length) {
         var nextSource = rest.splice(0, 1)[0];
-        res = merge.apply(void 0, __spreadArrays([res, nextSource], rest));
+        res = merge.apply(void 0, __spreadArray([res, nextSource], rest, false));
     }
     return res;
 }
-/**
- * Shallow clone an object
- */
-export function shallowClone(obj) {
-    var keys = Object.keys(obj);
-    var output = {};
-    for (var i = 0; i < keys.length; i++) {
-        output[keys[i]] = obj[keys[i]];
-    }
-    return output;
-}
 /**
  * Checks if the target string starts with the sub string.
  */

package/esm/utils/lang/maps.js

@@ -68,4 +68,17 @@ var MapPoly = /** @class */ (function () {
     return MapPoly;
 }());
 export { MapPoly };
-export var _Map = typeof Map !== 'undefined' ? Map : MapPoly;
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export function __getMapConstructor() {
+    // eslint-disable-next-line compat/compat
+    if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {
+        return Map;
+    }
+    return MapPoly;
+}
+export var _Map = __getMapConstructor();

package/esm/utils/settingsValidation/consent.js

@@ -0,0 +1,12 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+import { stringToUpperCase } from '../lang';
+var userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+export function validateConsent(_a) {
+    var userConsent = _a.userConsent, log = _a.log;
+    userConsent = stringToUpperCase(userConsent);
+    if (userConsentValues.indexOf(userConsent) > -1)
+        return userConsent;
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);
+    return CONSENT_GRANTED;
+}

package/esm/utils/settingsValidation/impressionsMode.js

@@ -1,10 +1,10 @@
-import { ERROR_INVALID_IMPRESSIONS_MODE } from '../../logger/constants';
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 import { DEBUG, OPTIMIZED } from '../constants';
+import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
-    impressionsMode = impressionsMode.toUpperCase();
-    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) === -1) {
-        log.error(ERROR_INVALID_IMPRESSIONS_MODE, [[DEBUG, OPTIMIZED], OPTIMIZED]);
-        impressionsMode = OPTIMIZED;
-    }
-    return impressionsMode;
+    impressionsMode = stringToUpperCase(impressionsMode);
+    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
+        return impressionsMode;
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+    return OPTIMIZED;
 }

package/esm/utils/settingsValidation/index.js

@@ -3,6 +3,8 @@ import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
+import { validateKey } from '../inputValidation/key';
+import { validateTrafficType } from '../inputValidation/trafficType';
 var base = {
     // Define which kind of object you want to retrieve from SplitFactory
     mode: STANDALONE_MODE,
@@ -33,6 +35,8 @@ var base = {
         eventsPushRate: 60,
         // how many events will be queued before flushing
         eventsQueueSize: 500,
+        // how many impressions will be queued before flushing
+        impressionsQueueSize: 30000,
         // backoff base seconds to wait before re attempting to connect to push notifications
         pushRetryBackoffBase: 1,
     },
@@ -64,10 +68,6 @@ var base = {
         impressionsMode: OPTIMIZED,
         localhostMode: undefined
     },
-    runtime: {
-        ip: false,
-        hostname: false
-    },
     // Logger
     log: undefined
 };
@@ -82,7 +82,7 @@ function fromSecondsToMillis(n) {
  * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config
  */
 export function settingsValidation(config, validationParams) {
-    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost;
+    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost, consent = validationParams.consent;
     // creates a settings object merging base, defaults and config objects.
     var withDefaults = merge({}, base, defaults, config);
     // ensure a valid logger.
@@ -108,14 +108,29 @@ export function settingsValidation(config, validationParams) {
     // @ts-ignore, modify readonly prop
     if (storage)
         withDefaults.storage = storage(withDefaults);
-    // Although `key` is mandatory according to TS declaration files, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-    if (withDefaults.mode === LOCALHOST_MODE && withDefaults.core.key === undefined) {
-        withDefaults.core.key = 'localhost_key';
+    // Validate key and TT (for client-side)
+    if (validationParams.acceptKey) {
+        var maybeKey = withDefaults.core.key;
+        // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
+        if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
+            withDefaults.core.key = 'localhost_key';
+        }
+        else {
+            // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+            // `false` value is used as binded key/TT of the default client, which leads to some issues.
+            // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
+            withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+        }
+        if (validationParams.acceptTT) {
+            var maybeTT = withDefaults.core.trafficType;
+            if (maybeTT !== undefined) { // @ts-ignore
+                withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+            }
+        }
     }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop
-    if (runtime)
-        withDefaults.runtime = runtime(withDefaults);
+    withDefaults.runtime = runtime(withDefaults);
     // ensure a valid list of integrations.
     // `integrations` returns an array of valid integration items.
     // @ts-ignore, modify readonly prop
@@ -136,5 +151,8 @@ export function settingsValidation(config, validationParams) {
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
     // ensure a valid impressionsMode
     withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
+    // ensure a valid user consent value
+    // @ts-ignore, modify readonly prop
+    withDefaults.userConsent = consent(withDefaults);
     return withDefaults;
 }

package/esm/utils/settingsValidation/runtime.js

@@ -0,0 +1,7 @@
+// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.
+export function validateRuntime() {
+    return {
+        ip: false,
+        hostname: false
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.2.1-rc.0",
+  "version": "1.2.1-rc.11",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -20,8 +20,8 @@
     "check:lint": "eslint src --ext .js,.ts",
     "check:types": "tsc --noEmit",
     "build": "npm run build:cjs && npm run build:esm",
-    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types --importHelpers",
-    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs --importHelpers",
+    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
+    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
@@ -44,7 +44,7 @@
   "bugs": "https://github.com/splitio/javascript-commons/issues",
   "homepage": "https://github.com/splitio/javascript-commons#readme",
   "dependencies": {
-    "tslib": "^2.1.0"
+    "tslib": "^2.3.1"
   },
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
@@ -58,7 +58,7 @@
     "eslint": "^7.32.0",
     "eslint-plugin-compat": "3.7.0",
     "eslint-plugin-import": "^2.25.3",
-    "fetch-mock": "^9.10.7",
+    "fetch-mock": "^9.11.0",
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
@@ -68,7 +68,7 @@
     "redis-server": "1.2.2",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.0.5",
-    "typescript": "^4.0.2"
+    "typescript": "4.4.4"
   },
   "sideEffects": false
 }

package/src/evaluator/matchers/ew.ts

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

package/src/evaluator/parser/index.ts

@@ -31,7 +31,7 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
       const matcher = matcherFactory(log, matcherDto, storage);
 
       // Evaluator function.
-      return (key: string, attributes: SplitIO.Attributes, splitEvaluator: ISplitEvaluator) => {
+      return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
         const result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
 

package/src/evaluator/types.ts

@@ -6,7 +6,7 @@ import { ILogger } from '../logger/types';
 
 export interface IDependencyMatcherValue {
   key: SplitIO.SplitKey,
-  attributes: SplitIO.Attributes
+  attributes?: SplitIO.Attributes
 }
 
 export interface IMatcherDto {
@@ -27,7 +27,7 @@ export interface IEvaluation {
 
 export type IEvaluationResult = IEvaluation & { treatment: string }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
 export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
 

package/src/evaluator/value/index.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: string, attributeName: string | null, attributes: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {
@@ -23,7 +23,7 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: 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 = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);

package/src/evaluator/value/sanitize.ts

@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes: SplitIO.Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: 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;
 

package/src/integrations/ga/GoogleAnalyticsToSplit.ts

@@ -1,11 +1,14 @@
-import { IIntegrationFactoryParams } from '../types';
+import { IIntegrationFactoryParams, IntegrationFactory } from '../types';
 import { GaToSplit } from './GaToSplit';
 import { GoogleAnalyticsToSplitOptions } from './types';
 
-export function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions) {
+export function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): IntegrationFactory {
 
   // GaToSplit integration factory
-  return (params: IIntegrationFactoryParams) => {
+  function GoogleAnalyticsToSplitFactory(params: IIntegrationFactoryParams) {
     return GaToSplit(options, params);
-  };
+  }
+
+  GoogleAnalyticsToSplitFactory.type = 'GOOGLE_ANALYTICS_TO_SPLIT';
+  return GoogleAnalyticsToSplitFactory;
 }

package/src/integrations/ga/SplitToGoogleAnalytics.ts

@@ -1,11 +1,14 @@
-import { IIntegrationFactoryParams } from '../types';
+import { IIntegrationFactoryParams, IntegrationFactory } from '../types';
 import { SplitToGa } from './SplitToGa';
 import { SplitToGoogleAnalyticsOptions } from './types';
 
-export function SplitToGoogleAnalytics(options: SplitToGoogleAnalyticsOptions = {}) {
+export function SplitToGoogleAnalytics(options: SplitToGoogleAnalyticsOptions = {}): IntegrationFactory {
 
   // SplitToGa integration factory
-  return (params: IIntegrationFactoryParams) => {
+  function SplitToGoogleAnalyticsFactory(params: IIntegrationFactoryParams) {
     return new SplitToGa(params.settings.log, options);
-  };
+  }
+
+  SplitToGoogleAnalyticsFactory.type = 'SPLIT_TO_GOOGLE_ANALYTICS';
+  return SplitToGoogleAnalyticsFactory;
 }