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

package/esm/utils/murmur3/murmur3_128_x86.js

@@ -0,0 +1,150 @@
+/* eslint-disable no-fallthrough */
+import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './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 = x86Multiply(k1, c1);
+        k1 = x86Rotl(k1, 15);
+        k1 = x86Multiply(k1, c2);
+        h1 ^= k1;
+        h1 = x86Rotl(h1, 19);
+        h1 += h2;
+        h1 = x86Multiply(h1, 5) + 0x561ccd1b;
+        k2 = x86Multiply(k2, c2);
+        k2 = x86Rotl(k2, 16);
+        k2 = x86Multiply(k2, c3);
+        h2 ^= k2;
+        h2 = x86Rotl(h2, 17);
+        h2 += h3;
+        h2 = x86Multiply(h2, 5) + 0x0bcaa747;
+        k3 = x86Multiply(k3, c3);
+        k3 = x86Rotl(k3, 17);
+        k3 = x86Multiply(k3, c4);
+        h3 ^= k3;
+        h3 = x86Rotl(h3, 15);
+        h3 += h4;
+        h3 = x86Multiply(h3, 5) + 0x96cd1c35;
+        k4 = x86Multiply(k4, c4);
+        k4 = x86Rotl(k4, 18);
+        k4 = x86Multiply(k4, c1);
+        h4 ^= k4;
+        h4 = x86Rotl(h4, 13);
+        h4 += h1;
+        h4 = 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 = x86Multiply(k4, c4);
+            k4 = x86Rotl(k4, 18);
+            k4 = 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 = x86Multiply(k3, c3);
+            k3 = x86Rotl(k3, 17);
+            k3 = 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 = x86Multiply(k2, c2);
+            k2 = x86Rotl(k2, 16);
+            k2 = 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 = x86Multiply(k1, c1);
+            k1 = x86Rotl(k1, 15);
+            k1 = 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 = x86Fmix(h1);
+    h2 = x86Fmix(h2);
+    h3 = x86Fmix(h3);
+    h4 = 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
+ */
+export function hash128(str, seed) {
+    return hash128x86(UTF16ToUTF8(str), seed >>> 0);
+}

package/esm/utils/murmur3/murmur3_64.js

@@ -0,0 +1,32 @@
+import { hash128 } from './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
+ */
+export function hash64(str) {
+    var hex = hash128(str).slice(0, 16);
+    return {
+        hex: hex,
+        dec: hex2dec(hex) // KeyList notification
+    };
+}

package/esm/utils/murmur3/utfx.js

@@ -6,114 +6,104 @@
  Released under the Apache License, Version 2.0
  see: https://github.com/dcodeIO/utfx for details
 */
-export 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;
-                    }
+/**
+ * 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
+ */
+export function encodeUTF16toUTF8(src, dst) {
+    UTF16toUTF8(src, function (cp) {
+        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
+ */
+export 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);
-        };
+}
+/**
+ * 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
+ */
+export 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;
-})();
+}

package/esm/utils/promise/wrapper.js

@@ -31,18 +31,21 @@ export default 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/esm/utils/settingsValidation/index.js

@@ -61,7 +61,8 @@ var base = {
     sync: {
         splitFilters: undefined,
         // impressions collection mode
-        impressionsMode: OPTIMIZED
+        impressionsMode: OPTIMIZED,
+        localhostMode: undefined
     },
     runtime: {
         ip: false,
@@ -81,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;
+    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 = merge({}, base, defaults, config);
     // ensure a valid logger.
@@ -119,6 +120,8 @@ export 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/esm/utils/settingsValidation/localhost/index.js

@@ -0,0 +1,16 @@
+import { ERROR_LOCALHOST_MODULE_REQUIRED } from '../../../logger/constants';
+import { LOCALHOST_MODE } from '../../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.
+ */
+export function validateLocalhost(settings) {
+    var localhostMode = settings.sync.localhostMode;
+    if (settings.mode === LOCALHOST_MODE && (typeof localhostMode !== 'function' || localhostMode.type !== LOCALHOST_MODE)) {
+        settings.log.error(ERROR_LOCALHOST_MODULE_REQUIRED);
+    }
+    return localhostMode;
+}

package/esm/utils/settingsValidation/splitFilters.js

@@ -99,7 +99,6 @@ export 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/esm/utils/settingsValidation/storage/storageCS.js

@@ -1,5 +1,12 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
 import { WARN_STORAGE_INVALID } from '../../../logger/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+export function __InLocalStorageMockFactory(params) {
+    var result = InMemoryStorageCSFactory(params);
+    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    return result;
+}
+__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -8,14 +15,16 @@ import { WARN_STORAGE_INVALID } from '../../../logger/constants';
  * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
  */
 export 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 ? InMemoryStorageCSFactory : _a, log = settings.log, mode = settings.mode;
+    // If an invalid storage is provided, fallback into MEMORY
+    if (typeof storage !== 'function' || storage.type !== STORAGE_MEMORY && storage.type !== STORAGE_LOCALSTORAGE) {
+        storage = InMemoryStorageCSFactory;
         log.warn(WARN_STORAGE_INVALID);
     }
+    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
+    if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
+        return __InLocalStorageMockFactory;
+    }
     // return default InMemory storage if provided one is not valid
-    return InMemoryStorageCSFactory;
+    return storage;
 }

package/esm/utils/settingsValidation/url.js

@@ -1,5 +1,5 @@
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "0.1.1-canary.9",
+  "version": "0.1.1-rc.18",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -50,7 +50,7 @@
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
     "@types/ioredis": "^4.14.1",
-    "@types/jest": "^26.0.10",
+    "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
     "@types/node": "^14.14.7",
     "@types/object-assign": "^4.0.30",
@@ -58,18 +58,18 @@
     "@typescript-eslint/parser": "^4.2.0",
     "cross-env": "^7.0.2",
     "csv-streamify": "^4.0.0",
-    "eslint": "^7.9.0",
+    "eslint": "^7.32.0",
     "eslint-plugin-compat": "3.7.0",
     "fetch-mock": "^9.10.7",
     "ioredis": "^4.26.0",
-    "jest": "^26.6.3",
+    "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
     "js-yaml": "^3.14.0",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.1",
     "redis-server": "1.2.2",
     "rimraf": "^3.0.2",
-    "ts-jest": "^26.3.0",
+    "ts-jest": "^27.0.5",
     "typescript": "^4.0.2"
   },
   "sideEffects": false

package/src/evaluator/matchers/matcherTypes.ts

@@ -19,7 +19,7 @@ export const matcherTypes: Record<string, number> = {
   MATCHES_STRING: 17
 };
 
-export const dataTypes = {
+export const matcherDataTypes = {
   BOOLEAN: 'BOOLEAN',
   STRING: 'STRING',
   NUMBER: 'NUMBER',
@@ -28,7 +28,7 @@ export const dataTypes = {
   NOT_SPECIFIED: 'NOT_SPECIFIED'
 };
 
-export function mapper(matcherType: string) {
+export function matcherTypesMapper(matcherType: string) {
   const type = matcherTypes[matcherType];
   if (type) return type;
   else return matcherTypes.UNDEFINED;