@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

package/cjs/utils/murmur3/murmur3_128_x86.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash128 = void 0;
+/* eslint-disable no-fallthrough */
+var common_1 = require("./common");
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+// PUBLIC FUNCTIONS
+// ----------------
+function hash128x86(key, seed) {
+    //
+    // Given a string and an optional seed as an int, returns a 128 bit
+    // hash using the x86 flavor of MurmurHash3, as an unsigned hex.
+    //
+    key = key || '';
+    seed = seed || 0;
+    var remainder = key.length % 16;
+    var bytes = key.length - remainder;
+    var h1 = seed;
+    var h2 = seed;
+    var h3 = seed;
+    var h4 = seed;
+    var k1 = 0;
+    var k2 = 0;
+    var k3 = 0;
+    var k4 = 0;
+    var c1 = 0x239b961b;
+    var c2 = 0xab0e9789;
+    var c3 = 0x38b34ae5;
+    var c4 = 0xa1e38b93;
+    for (var i = 0; i < bytes; i = i + 16) {
+        k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
+        k2 = ((key.charCodeAt(i + 4) & 0xff)) | ((key.charCodeAt(i + 5) & 0xff) << 8) | ((key.charCodeAt(i + 6) & 0xff) << 16) | ((key.charCodeAt(i + 7) & 0xff) << 24);
+        k3 = ((key.charCodeAt(i + 8) & 0xff)) | ((key.charCodeAt(i + 9) & 0xff) << 8) | ((key.charCodeAt(i + 10) & 0xff) << 16) | ((key.charCodeAt(i + 11) & 0xff) << 24);
+        k4 = ((key.charCodeAt(i + 12) & 0xff)) | ((key.charCodeAt(i + 13) & 0xff) << 8) | ((key.charCodeAt(i + 14) & 0xff) << 16) | ((key.charCodeAt(i + 15) & 0xff) << 24);
+        k1 = common_1.x86Multiply(k1, c1);
+        k1 = common_1.x86Rotl(k1, 15);
+        k1 = common_1.x86Multiply(k1, c2);
+        h1 ^= k1;
+        h1 = common_1.x86Rotl(h1, 19);
+        h1 += h2;
+        h1 = common_1.x86Multiply(h1, 5) + 0x561ccd1b;
+        k2 = common_1.x86Multiply(k2, c2);
+        k2 = common_1.x86Rotl(k2, 16);
+        k2 = common_1.x86Multiply(k2, c3);
+        h2 ^= k2;
+        h2 = common_1.x86Rotl(h2, 17);
+        h2 += h3;
+        h2 = common_1.x86Multiply(h2, 5) + 0x0bcaa747;
+        k3 = common_1.x86Multiply(k3, c3);
+        k3 = common_1.x86Rotl(k3, 17);
+        k3 = common_1.x86Multiply(k3, c4);
+        h3 ^= k3;
+        h3 = common_1.x86Rotl(h3, 15);
+        h3 += h4;
+        h3 = common_1.x86Multiply(h3, 5) + 0x96cd1c35;
+        k4 = common_1.x86Multiply(k4, c4);
+        k4 = common_1.x86Rotl(k4, 18);
+        k4 = common_1.x86Multiply(k4, c1);
+        h4 ^= k4;
+        h4 = common_1.x86Rotl(h4, 13);
+        h4 += h1;
+        h4 = common_1.x86Multiply(h4, 5) + 0x32ac3b17;
+    }
+    k1 = 0;
+    k2 = 0;
+    k3 = 0;
+    k4 = 0;
+    switch (remainder) {
+        case 15:
+            k4 ^= key.charCodeAt(i + 14) << 16;
+        case 14:
+            k4 ^= key.charCodeAt(i + 13) << 8;
+        case 13:
+            k4 ^= key.charCodeAt(i + 12);
+            k4 = common_1.x86Multiply(k4, c4);
+            k4 = common_1.x86Rotl(k4, 18);
+            k4 = common_1.x86Multiply(k4, c1);
+            h4 ^= k4;
+        case 12:
+            k3 ^= key.charCodeAt(i + 11) << 24;
+        case 11:
+            k3 ^= key.charCodeAt(i + 10) << 16;
+        case 10:
+            k3 ^= key.charCodeAt(i + 9) << 8;
+        case 9:
+            k3 ^= key.charCodeAt(i + 8);
+            k3 = common_1.x86Multiply(k3, c3);
+            k3 = common_1.x86Rotl(k3, 17);
+            k3 = common_1.x86Multiply(k3, c4);
+            h3 ^= k3;
+        case 8:
+            k2 ^= key.charCodeAt(i + 7) << 24;
+        case 7:
+            k2 ^= key.charCodeAt(i + 6) << 16;
+        case 6:
+            k2 ^= key.charCodeAt(i + 5) << 8;
+        case 5:
+            k2 ^= key.charCodeAt(i + 4);
+            k2 = common_1.x86Multiply(k2, c2);
+            k2 = common_1.x86Rotl(k2, 16);
+            k2 = common_1.x86Multiply(k2, c3);
+            h2 ^= k2;
+        case 4:
+            k1 ^= key.charCodeAt(i + 3) << 24;
+        case 3:
+            k1 ^= key.charCodeAt(i + 2) << 16;
+        case 2:
+            k1 ^= key.charCodeAt(i + 1) << 8;
+        case 1:
+            k1 ^= key.charCodeAt(i);
+            k1 = common_1.x86Multiply(k1, c1);
+            k1 = common_1.x86Rotl(k1, 15);
+            k1 = common_1.x86Multiply(k1, c2);
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h2 ^= key.length;
+    h3 ^= key.length;
+    h4 ^= key.length;
+    h1 += h2;
+    h1 += h3;
+    h1 += h4;
+    h2 += h1;
+    h3 += h1;
+    h4 += h1;
+    h1 = common_1.x86Fmix(h1);
+    h2 = common_1.x86Fmix(h2);
+    h3 = common_1.x86Fmix(h3);
+    h4 = common_1.x86Fmix(h4);
+    h1 += h2;
+    h1 += h3;
+    h1 += h4;
+    h2 += h1;
+    h3 += h1;
+    h4 += h1;
+    return ('00000000' + (h1 >>> 0).toString(16)).slice(-8) + ('00000000' + (h2 >>> 0).toString(16)).slice(-8) + ('00000000' + (h3 >>> 0).toString(16)).slice(-8) + ('00000000' + (h4 >>> 0).toString(16)).slice(-8);
+}
+/**
+ * x86 version of Murmur3 for 128bits.
+ * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
+ *
+ * @param {string} str
+ */
+function hash128(str, seed) {
+    return hash128x86(common_1.UTF16ToUTF8(str), seed >>> 0);
+}
+exports.hash128 = hash128;

package/cjs/utils/murmur3/murmur3_64.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash64 = void 0;
+var murmur3_128_1 = require("./murmur3_128");
+/**
+ * Use instead of parseInt, to not lose precision when converting big integers (greater than 2^53 - 1)
+ */
+function hex2dec(s) {
+    var i, j, digits = [0], carry;
+    for (i = 0; i < s.length; i += 1) {
+        carry = parseInt(s.charAt(i), 16);
+        for (j = digits.length - 1; j >= 0; j -= 1) {
+            digits[j] = digits[j] * 16 + carry;
+            carry = digits[j] / 10 | 0;
+            digits[j] %= 10;
+        }
+        while (carry > 0) {
+            digits.unshift(carry % 10);
+            carry = carry / 10 | 0;
+        }
+    }
+    return digits.join('');
+}
+/**
+ * Gets the higher 64 bits of the x64 version of Murmur3 for 128bits, as decimal and hexadecimal number strings.
+ * Used for MySegments channel V2 notifications.
+ * @param {string} str
+ */
+function hash64(str) {
+    var hex = murmur3_128_1.hash128(str).slice(0, 16);
+    return {
+        hex: hex,
+        dec: hex2dec(hex) // KeyList notification
+    };
+}
+exports.hash64 = hash64;

package/cjs/utils/murmur3/utfx.js

@@ -8,114 +8,108 @@
  see: https://github.com/dcodeIO/utfx for details
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (function () {
-    /**
-     * utfx namespace.
-     * @exports utfx
-     * @type {!Object.<string,*>}
-     */
-    // @ts-ignore
-    var utfx = {};
-    /**
-     * Encodes UTF8 code points to UTF8 bytes.
-     * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
-     *  respectively `null` if there are no more code points left or a single numeric code point.
-     * @param {!function(number)} dst Bytes destination as a function successively called with the next byte
-     * @expose
-     */
-    utfx.encodeUTF8 = function (src, dst) {
-        var cp = null;
-        if (typeof src === 'number')
-            cp = src, src = function () { return null; };
-        while (cp !== null || (cp = src()) !== null) {
-            if (cp < 0x80)
-                dst(cp & 0x7F);
-            else if (cp < 0x800)
-                dst(((cp >> 6) & 0x1F) | 0xC0), dst((cp & 0x3F) | 0x80);
-            else if (cp < 0x10000)
-                dst(((cp >> 12) & 0x0F) | 0xE0), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);
-            else
-                dst(((cp >> 18) & 0x07) | 0xF0), dst(((cp >> 12) & 0x3F) | 0x80), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);
-            cp = null;
-        }
-    };
-    /**
-     * Converts UTF16 characters to UTF8 code points.
-     * @param {!function():number|null} src Characters source as a function returning the next char code respectively
-     *  `null` if there are no more characters left.
-     * @param {!function(number)} dst Code points destination as a function successively called with each converted code
-     *  point.
-     * @expose
-     */
-    utfx.UTF16toUTF8 = function (src, dst) {
-        var c1, c2 = null;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            if ((c1 = c2 !== null ? c2 : src()) === null)
-                break;
-            if (c1 >= 0xD800 && c1 <= 0xDFFF) {
-                if ((c2 = src()) !== null) {
-                    if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
-                        dst((c1 - 0xD800) * 0x400 + c2 - 0xDC00 + 0x10000);
-                        c2 = null;
-                        continue;
-                    }
+exports.stringDestination = exports.stringSource = exports.encodeUTF16toUTF8 = void 0;
+/**
+ * Encodes UTF8 code points to UTF8 bytes.
+ * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
+ *  respectively `null` if there are no more code points left or a single numeric code point.
+ * @param {!function(number)} dst Bytes destination as a function successively called with the next byte
+ * @expose
+ */
+function encodeUTF8(src, dst) {
+    var cp = null;
+    if (typeof src === 'number')
+        cp = src, src = function () { return null; };
+    while (cp !== null || (cp = src()) !== null) {
+        if (cp < 0x80)
+            dst(cp & 0x7F);
+        else if (cp < 0x800)
+            dst(((cp >> 6) & 0x1F) | 0xC0), dst((cp & 0x3F) | 0x80);
+        else if (cp < 0x10000)
+            dst(((cp >> 12) & 0x0F) | 0xE0), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);
+        else
+            dst(((cp >> 18) & 0x07) | 0xF0), dst(((cp >> 12) & 0x3F) | 0x80), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);
+        cp = null;
+    }
+}
+/**
+ * Converts UTF16 characters to UTF8 code points.
+ * @param {!function():number|null} src Characters source as a function returning the next char code respectively
+ *  `null` if there are no more characters left.
+ * @param {!function(number)} dst Code points destination as a function successively called with each converted code
+ *  point.
+ * @expose
+ */
+function UTF16toUTF8(src, dst) {
+    var c1, c2 = null;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if ((c1 = c2 !== null ? c2 : src()) === null)
+            break;
+        if (c1 >= 0xD800 && c1 <= 0xDFFF) {
+            if ((c2 = src()) !== null) {
+                if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
+                    dst((c1 - 0xD800) * 0x400 + c2 - 0xDC00 + 0x10000);
+                    c2 = null;
+                    continue;
                 }
             }
-            dst(c1);
         }
-        if (c2 !== null)
-            dst(c2);
-    };
-    /**
-     * Converts and encodes UTF16 characters to UTF8 bytes.
-     * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
-     *  if there are no more characters left.
-     * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
-     * @expose
-     */
-    utfx.encodeUTF16toUTF8 = function (src, dst) {
-        utfx.UTF16toUTF8(src, function (cp) {
-            utfx.encodeUTF8(cp, dst);
-        });
-    };
-    /**
-     * String.fromCharCode reference for compile time renaming.
-     * @type {!function(...[number]):string}
-     * @inner
-     */
-    var stringFromCharCode = String.fromCharCode;
-    /**
-     * Creates a source function for a string.
-     * @param {string} s String to read from
-     * @returns {!function():number|null} Source function returning the next char code respectively `null` if there are
-     *  no more characters left.
-     * @throws {TypeError} If the argument is invalid
-     * @expose
-     */
-    utfx.stringSource = function (s) {
-        if (typeof s !== 'string')
-            throw TypeError('Illegal argument: ' + (typeof s));
-        var i = 0;
-        return function () {
-            return i >= s.length ? null : s.charCodeAt(i++);
-        };
+        dst(c1);
+    }
+    if (c2 !== null)
+        dst(c2);
+}
+/**
+ * Converts and encodes UTF16 characters to UTF8 bytes.
+ * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
+ *  if there are no more characters left.
+ * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
+ * @expose
+ */
+function encodeUTF16toUTF8(src, dst) {
+    UTF16toUTF8(src, function (cp) {
+        encodeUTF8(cp, dst);
+    });
+}
+exports.encodeUTF16toUTF8 = encodeUTF16toUTF8;
+/**
+ * String.fromCharCode reference for compile time renaming.
+ * @type {!function(...[number]):string}
+ * @inner
+ */
+var stringFromCharCode = String.fromCharCode;
+/**
+ * Creates a source function for a string.
+ * @param {string} s String to read from
+ * @returns {!function():number|null} Source function returning the next char code respectively `null` if there are
+ *  no more characters left.
+ * @throws {TypeError} If the argument is invalid
+ * @expose
+ */
+function stringSource(s) {
+    if (typeof s !== 'string')
+        throw TypeError('Illegal argument: ' + (typeof s));
+    var i = 0;
+    return function () {
+        return i >= s.length ? null : s.charCodeAt(i++);
     };
-    /**
-     * Creates a destination function for a string.
-     * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
-     *  Returns the final string when called without arguments.
-     * @expose
-     */
-    utfx.stringDestination = function () {
-        var cs = [], ps = [];
-        return function () {
-            if (arguments.length === 0)
-                return ps.join('') + stringFromCharCode.apply(String, cs);
-            if (cs.length + arguments.length > 1024)
-                ps.push(stringFromCharCode.apply(String, cs)), cs.length = 0; // @ts-ignore
-            Array.prototype.push.apply(cs, arguments);
-        };
+}
+exports.stringSource = stringSource;
+/**
+ * Creates a destination function for a string.
+ * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
+ *  Returns the final string when called without arguments.
+ * @expose
+ */
+function stringDestination() {
+    var cs = [], ps = [];
+    return function () {
+        if (arguments.length === 0)
+            return ps.join('') + stringFromCharCode.apply(String, cs);
+        if (cs.length + arguments.length > 1024)
+            ps.push(stringFromCharCode.apply(String, cs)), cs.length = 0; // @ts-ignore
+        Array.prototype.push.apply(cs, arguments);
     };
-    return utfx;
-})();
+}
+exports.stringDestination = stringDestination;

package/cjs/utils/promise/wrapper.js

@@ -33,18 +33,21 @@ function promiseWrapper(customPromise, defaultOnRejected) {
             });
         });
         var originalThen = newPromise.then;
-        newPromise.then = function (onfulfilled, onrejected) {
-            var result = originalThen.call(newPromise, onfulfilled, onrejected);
-            if (typeof onfulfilled === 'function')
-                hasOnFulfilled = true;
-            if (typeof onrejected === 'function') {
-                hasOnRejected = true;
-                return result;
-            }
-            else {
-                return chain(result);
+        // Using `defineProperty` in case Promise.prototype.then property is not writable
+        Object.defineProperty(newPromise, 'then', {
+            value: function (onfulfilled, onrejected) {
+                var result = originalThen.call(newPromise, onfulfilled, onrejected);
+                if (typeof onfulfilled === 'function')
+                    hasOnFulfilled = true;
+                if (typeof onrejected === 'function') {
+                    hasOnRejected = true;
+                    return result;
+                }
+                else {
+                    return chain(result);
+                }
             }
-        };
+        });
         return newPromise;
     }
     var result = chain(customPromise);

package/cjs/utils/settingsValidation/index.js

@@ -65,7 +65,8 @@ var base = {
     sync: {
         splitFilters: undefined,
         // impressions collection mode
-        impressionsMode: constants_1.OPTIMIZED
+        impressionsMode: constants_1.OPTIMIZED,
+        localhostMode: undefined
     },
     runtime: {
         ip: false,
@@ -85,7 +86,7 @@ function fromSecondsToMillis(n) {
  * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config
  */
 function settingsValidation(config, validationParams) {
-    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger;
+    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost;
     // creates a settings object merging base, defaults and config objects.
     var withDefaults = lang_1.merge({}, base, defaults, config);
     // ensure a valid logger.
@@ -123,6 +124,8 @@ function settingsValidation(config, validationParams) {
     // @ts-ignore, modify readonly prop
     if (integrations)
         withDefaults.integrations = integrations(withDefaults);
+    if (localhost)
+        withDefaults.sync.localhostMode = localhost(withDefaults);
     // validate push options
     if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
         withDefaults.streamingEnabled = true;

package/cjs/utils/settingsValidation/localhost/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLocalhost = void 0;
+var constants_1 = require("../../../logger/constants");
+var constants_2 = require("../../constants");
+/**
+ * This function validates `settings.storage` object
+ *
+ * @param {any} settings config object provided by the user to initialize the sdk
+ *
+ * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ */
+function validateLocalhost(settings) {
+    var localhostMode = settings.sync.localhostMode;
+    if (settings.mode === constants_2.LOCALHOST_MODE && (typeof localhostMode !== 'function' || localhostMode.type !== constants_2.LOCALHOST_MODE)) {
+        settings.log.error(constants_1.ERROR_LOCALHOST_MODULE_REQUIRED);
+    }
+    return localhostMode;
+}
+exports.validateLocalhost = validateLocalhost;

package/cjs/utils/settingsValidation/splitFilters.js

@@ -102,7 +102,6 @@ function validateSplitFilters(log, maybeSplitFilters, mode) {
         return res;
     }
     // Validate filters and group their values by filter type inside `groupedFilters` object
-    // Assign the valid filters to the output of the validator by using filter function
     res.validFilters = maybeSplitFilters.filter(function (filter, index) {
         if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
             res.groupedFilters[filter.type] = res.groupedFilters[filter.type].concat(filter.values);

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateStorageCS = void 0;
+exports.validateStorageCS = exports.__InLocalStorageMockFactory = void 0;
 var InMemoryStorageCS_1 = require("../../../storages/inMemory/InMemoryStorageCS");
 var constants_1 = require("../../../logger/constants");
+var constants_2 = require("../../../utils/constants");
+function __InLocalStorageMockFactory(params) {
+    var result = InMemoryStorageCS_1.InMemoryStorageCSFactory(params);
+    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    return result;
+}
+exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;
+__InLocalStorageMockFactory.type = constants_2.STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -11,15 +19,17 @@ var constants_1 = require("../../../logger/constants");
  * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
  */
 function validateStorageCS(settings) {
-    var storage = settings.storage, log = settings.log;
-    // validate storage
-    // @TODO validate its API (Splits cache, MySegments cache, etc) when supporting custom storages
-    if (storage) {
-        if (typeof storage === 'function')
-            return storage;
+    var _a = settings.storage, storage = _a === void 0 ? InMemoryStorageCS_1.InMemoryStorageCSFactory : _a, log = settings.log, mode = settings.mode;
+    // If an invalid storage is provided, fallback into MEMORY
+    if (typeof storage !== 'function' || storage.type !== constants_2.STORAGE_MEMORY && storage.type !== constants_2.STORAGE_LOCALSTORAGE) {
+        storage = InMemoryStorageCS_1.InMemoryStorageCSFactory;
         log.warn(constants_1.WARN_STORAGE_INVALID);
     }
+    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
+    if (mode === constants_2.LOCALHOST_MODE && storage.type === constants_2.STORAGE_LOCALSTORAGE) {
+        return __InLocalStorageMockFactory;
+    }
     // return default InMemory storage if provided one is not valid
-    return InMemoryStorageCS_1.InMemoryStorageCSFactory;
+    return storage;
 }
 exports.validateStorageCS = validateStorageCS;

package/cjs/utils/settingsValidation/url.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.url = void 0;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/auth/;
+var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
 /**
  * Get URL based on a given target (path).

package/esm/evaluator/matchers/matcherTypes.js

@@ -18,7 +18,7 @@ export var matcherTypes = {
     EQUAL_TO_BOOLEAN: 16,
     MATCHES_STRING: 17
 };
-export var dataTypes = {
+export var matcherDataTypes = {
     BOOLEAN: 'BOOLEAN',
     STRING: 'STRING',
     NUMBER: 'NUMBER',
@@ -26,7 +26,7 @@ export var dataTypes = {
     DATETIME: 'DATETIME',
     NOT_SPECIFIED: 'NOT_SPECIFIED'
 };
-export function mapper(matcherType) {
+export function matcherTypesMapper(matcherType) {
     var type = matcherTypes[matcherType];
     if (type)
         return type;

package/esm/evaluator/matchersTransform/index.js

@@ -1,5 +1,5 @@
 import { findIndex } from '../../utils/lang';
-import { matcherTypes, mapper, dataTypes } from '../matchers/matcherTypes';
+import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 import setTransform from './set';
@@ -12,9 +12,9 @@ export default function matchersTransform(matchers) {
     var parsedMatchers = matchers.map(function (matcher) {
         var matcherType = matcher.matcherType /* string */, negate = matcher.negate /* boolean */, keySelector = matcher.keySelector /* keySelectorObject */, segmentObject = matcher.userDefinedSegmentMatcherData /* segmentObject */, whitelistObject = matcher.whitelistMatcherData /* whiteListObject, provided by 'WHITELIST', set and string matchers */, unaryNumericObject = matcher.unaryNumericMatcherData /* unaryNumericObject */, betweenObject = matcher.betweenMatcherData /* betweenObject */, dependencyObject = matcher.dependencyMatcherData /* dependencyObject */, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData;
         var attribute = keySelector && keySelector.attribute;
-        var type = mapper(matcherType);
+        var type = matcherTypesMapper(matcherType);
         // As default input data type we use string (even for ALL_KEYS)
-        var dataType = dataTypes.STRING;
+        var dataType = matcherDataTypes.STRING;
         var value = undefined;
         if (type === matcherTypes.IN_SEGMENT) {
             value = segmentTransform(segmentObject);
@@ -24,28 +24,28 @@ export default function matchersTransform(matchers) {
         }
         else if (type === matcherTypes.EQUAL_TO) {
             value = numericTransform(unaryNumericObject);
-            dataType = dataTypes.NUMBER;
+            dataType = matcherDataTypes.NUMBER;
             if (unaryNumericObject.dataType === 'DATETIME') {
                 value = zeroSinceHH(value);
-                dataType = dataTypes.DATETIME;
+                dataType = matcherDataTypes.DATETIME;
             }
         }
         else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||
             type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
             value = numericTransform(unaryNumericObject);
-            dataType = dataTypes.NUMBER;
+            dataType = matcherDataTypes.NUMBER;
             if (unaryNumericObject.dataType === 'DATETIME') {
                 value = zeroSinceSS(value);
-                dataType = dataTypes.DATETIME;
+                dataType = matcherDataTypes.DATETIME;
             }
         }
         else if (type === matcherTypes.BETWEEN) {
             value = betweenObject;
-            dataType = dataTypes.NUMBER;
+            dataType = matcherDataTypes.NUMBER;
             if (value.dataType === 'DATETIME') {
                 value.start = zeroSinceSS(value.start);
                 value.end = zeroSinceSS(value.end);
-                dataType = dataTypes.DATETIME;
+                dataType = matcherDataTypes.DATETIME;
             }
         }
         else if (type === matcherTypes.EQUAL_TO_SET ||
@@ -53,7 +53,7 @@ export default function matchersTransform(matchers) {
             type === matcherTypes.CONTAINS_ALL_OF_SET ||
             type === matcherTypes.PART_OF_SET) {
             value = setTransform(whitelistObject);
-            dataType = dataTypes.SET;
+            dataType = matcherDataTypes.SET;
         }
         else if (type === matcherTypes.STARTS_WITH ||
             type === matcherTypes.ENDS_WITH ||
@@ -62,10 +62,10 @@ export default function matchersTransform(matchers) {
         }
         else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
             value = dependencyObject;
-            dataType = dataTypes.NOT_SPECIFIED;
+            dataType = matcherDataTypes.NOT_SPECIFIED;
         }
         else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
-            dataType = dataTypes.BOOLEAN;
+            dataType = matcherDataTypes.BOOLEAN;
             value = booleanMatcherData;
         }
         else if (type === matcherTypes.MATCHES_STRING) {