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

package/src/utils/murmur3/murmur3_128_x86.ts

@@ -0,0 +1,188 @@
+/* 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?: string, seed?: number): string {
+  //
+  // 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: string, seed?: number): string {
+  return hash128x86(UTF16ToUTF8(str), (seed as number) >>> 0);
+}

package/src/utils/murmur3/murmur3_64.ts

@@ -0,0 +1,36 @@
+import { hash128 } from './murmur3_128';
+
+export type Hash64 = { hex: string, dec: string };
+
+/**
+ * Use instead of parseInt, to not lose precision when converting big integers (greater than 2^53 - 1)
+ */
+function hex2dec(s: string): string {
+  let 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: string): Hash64 {
+  const hex = hash128(str).slice(0, 16);
+  return {
+    hex, // BoundedFetchRequest notification
+    dec: hex2dec(hex) // KeyList notification
+  };
+}

package/src/utils/murmur3/utfx.ts

@@ -8,128 +8,110 @@
 */
 
 export interface utfx {
-  stringSource(key: string): () => number | null,
-  stringDestination(): (...args: number[]) => string | undefined,
   encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void,
 
-  // Internal use
-  UTF16toUTF8(src: () => number | null, dst: (cp: number) => void): void,
-  encodeUTF8(src: (() => number | null) | number, dst: (cp: number) => void): void
 }
 
-export default (function () {
 
-  /**
-   * utfx namespace.
-   * @exports utfx
-   * @type {!Object.<string,*>}
-   */
-  // @ts-ignore
-  var utfx: 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;
-    }
-  };
+/**
+ * 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: (() => number | null) | number, dst: (cp: number) => void): void {
+  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;
-          }
+/**
+ * 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: () => number | null, dst: (cp: number) => void): void {
+  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);
-  };
+    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);
-    });
-  };
+/**
+ * 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: () => number | null, dst: (...args: number[]) => string | undefined): void {
+  UTF16toUTF8(src, function (cp) {
+    encodeUTF8(cp, dst);
+  });
+}
 
-  /**
-   * String.fromCharCode reference for compile time renaming.
-   * @type {!function(...[number]):string}
-   * @inner
-   */
-  var stringFromCharCode = String.fromCharCode;
+/**
+ * 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++);
-    };
+/**
+ * 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: string): () => number | null {
+  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 () {
-    const cs: number[] = [], ps: string[] = []; 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(): (...args: number[]) => string | undefined {
+  const cs: number[] = [], ps: string[] = []; 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/src/utils/promise/wrapper.ts

@@ -37,16 +37,19 @@ export default function promiseWrapper<T>(customPromise: Promise<T>, defaultOnRe
 
     const originalThen = newPromise.then;
 
-    newPromise.then = function (onfulfilled, onrejected) {
-      const result: Promise<any> = 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: any, onrejected: any) {
+        const result: Promise<any> = 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;
   }

package/src/utils/settingsValidation/index.ts

@@ -3,7 +3,8 @@ import mode from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import validImpressionsMode from './impressionsMode';
-import { ISettingsInternal, ISettingsValidationParams } from './types';
+import { ISettingsValidationParams } from './types';
+import { ISettings } from '../../types';
 
 const base = {
   // Define which kind of object you want to retrieve from SplitFactory
@@ -73,7 +74,8 @@ const base = {
   sync: {
     splitFilters: undefined,
     // impressions collection mode
-    impressionsMode: OPTIMIZED
+    impressionsMode: OPTIMIZED,
+    localhostMode: undefined
   },
 
   runtime: {
@@ -98,10 +100,10 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, localhost } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
-  const withDefaults = merge({}, base, defaults, config) as ISettingsInternal;
+  const withDefaults = merge({}, base, defaults, config) as ISettings;
 
   // ensure a valid logger.
   // First thing to validate, since other validators might use the logger.
@@ -143,6 +145,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @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/src/utils/settingsValidation/localhost/index.ts

@@ -0,0 +1,19 @@
+import { ERROR_LOCALHOST_MODULE_REQUIRED } from '../../../logger/constants';
+import { ISettings, } from '../../../types';
+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: ISettings) {
+  const 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/src/utils/settingsValidation/splitFilters.ts

@@ -107,7 +107,6 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   }
 
   // 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((filter, index) => {
     if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
       res.groupedFilters[filter.type as SplitIO.SplitFilterType] = res.groupedFilters[filter.type as SplitIO.SplitFilterType].concat(filter.values);

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -1,7 +1,16 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
-import { ISettings } from '../../../types';
+import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
 import { WARN_STORAGE_INVALID } from '../../../logger/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+import { IStorageFactoryParams, IStorageSyncCS } from '../../../storages/types';
+
+export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSyncCS {
+  const result = InMemoryStorageCSFactory(params);
+  result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
+  return result;
+}
+__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 
 /**
  * This function validates `settings.storage` object
@@ -10,16 +19,20 @@ 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: { log: ILogger, storage?: any }): ISettings['storage'] {
-  const { storage, log } = settings;
+export function validateStorageCS(settings: { log: ILogger, storage?: any, mode?: SDKMode }): ISettings['storage'] {
+  let { storage = InMemoryStorageCSFactory, log, mode } = settings;
 
-  // validate storage
-  // @TODO validate its API (Splits cache, MySegments cache, etc) when supporting custom storages
-  if (storage) {
-    if (typeof storage === 'function') return storage;
+  // 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/src/utils/settingsValidation/types.ts

@@ -1,4 +1,3 @@
-import { ISplitFiltersValidation } from '../../dtos/types';
 import { ISettings } from '../../types';
 
 /**
@@ -19,14 +18,6 @@ export interface ISettingsValidationParams {
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator */
   logger: (settings: ISettings) => ISettings['log'],
-}
-
-/**
- * Settings interface extended with private properties used for internal purposes.
- */
-export interface ISettingsInternal extends ISettings {
-  readonly sync: ISettings['sync'] & {
-    __splitFiltersValidation: ISplitFiltersValidation
-  }
-  readonly impressionListener?: unknown
+  /** Localhost mode validator */
+  localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
 }

package/src/utils/settingsValidation/url.ts

@@ -1,7 +1,7 @@
 import { ISettings } from '../../types';
 
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-const authEndpointMatcher = /^\/auth/;
+const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;
 
 /**

package/types/evaluator/matchers/matcherTypes.d.ts

@@ -1,5 +1,5 @@
 export declare const matcherTypes: Record<string, number>;
-export declare const dataTypes: {
+export declare const matcherDataTypes: {
     BOOLEAN: string;
     STRING: string;
     NUMBER: string;
@@ -7,4 +7,4 @@ export declare const dataTypes: {
     DATETIME: string;
     NOT_SPECIFIED: string;
 };
-export declare function mapper(matcherType: string): number;
+export declare function matcherTypesMapper(matcherType: string): number;

package/types/listeners/browser.d.ts

@@ -22,6 +22,7 @@ export default class BrowserSignalListener implements ISignalListener {
     /**
      * stop method.
      * Called when client is destroyed.
+     * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
      */
     stop(): void;
     /**

package/types/listeners/node.d.ts

@@ -9,7 +9,6 @@ import { ISyncManager } from '../sync/types';
  * the process is already exiting.
  */
 export default class NodeSignalListener implements ISignalListener {
-    private syncManager;
     private handler;
     private settings;
     constructor(syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,