@splitsoftware/splitio 10.15.10-rc.2 → 10.16.1-rc.0

package/CHANGES.txt

@@ -1,6 +1,15 @@
-10.15.10 (September XX, 2021)
- - Updated streaming logic with some improvements.
- - Updated localhost mode to support LocalStorage and SDK_READY_FROM_CACHE event in Browser.
+10.16.1 (October 25, 2021)
+ - Updated some internal modules to optimize the time efficiency of split evaluations (i.e., `getTreatment(s)` method calls)
+ - Updated some dependencies for vulnerability fixes.
+ - Bugfixing - Fixed localhost mode with localStorage, to use a mock in memory instead of localStorage API directly but keep emitting emit SDK_READY_FROM_CACHE event.
+
+10.16.0 (September 28, 2021)
+ - Updated localhost mode to emit SDK_READY_FROM_CACHE event in Browser when using localStorage (issue https://github.com/splitio/react-client/issues/34).
+ - Updated streaming logic to use the newest version of our streaming service, including:
+      - Integration with Auth service V2, connecting to the new channels and applying the received connection delay.
+      - Implemented handling of the new MySegmentsV2 notification types (SegmentRemoval, KeyList, Bounded and Unbounded)
+      - New control notification for environment scoped streaming reset.
+ - Updated some dependencies to their latest versions, including Webpack 4 to 5, to build a more optimized UMD bundle.
 
 10.15.9 (Aug 13, 2021)
  - Updated some dependencies with vulnerability fixes.

package/README.md

@@ -68,11 +68,12 @@ Split has built and maintains SDKs for:
 * iOS [Github](https://github.com/splitio/ios-client) [Docs](https://help.split.io/hc/en-us/articles/360020401491-iOS-SDK)
 * Java [Github](https://github.com/splitio/java-client) [Docs](https://help.split.io/hc/en-us/articles/360020405151-Java-SDK)
 * Javascript [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK)
+* Javascript for Browser [Github](https://github.com/splitio/javascript-browser-client) [Docs](https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK)
 * Node [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK)
-* Javascript for Browser [Github](https://github.com/splitio/javascript-browser-client) [Docs](https://help.split.io/hc/en-us/articles/360058730852)
 * PHP [Github](https://github.com/splitio/php-client) [Docs](https://help.split.io/hc/en-us/articles/360020350372-PHP-SDK)
 * Python [Github](https://github.com/splitio/python-client) [Docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK)
 * React [Github](https://github.com/splitio/react-client) [Docs](https://help.split.io/hc/en-us/articles/360038825091-React-SDK)
+* React Native [Github](https://github.com/splitio/react-native-client) [Docs](https://help.split.io/hc/en-us/articles/4406066357901-React-Native-SDK)
 * Redux [Github](https://github.com/splitio/redux-client) [Docs](https://help.split.io/hc/en-us/articles/360038851551-Redux-SDK)
 * Ruby [Github](https://github.com/splitio/ruby-client) [Docs](https://help.split.io/hc/en-us/articles/360020673251-Ruby-SDK)
 

package/es/engine/engine/murmur3/murmur3_128.js

@@ -234,7 +234,7 @@ function hash128x64(key
 }
 /**
  * x64 version of Murmur3 for 128bits.
- * Used in hashImpression128.
+ *
  * @param {string} str
  */
 

package/es/engine/engine/murmur3/murmur3_128_x86.js

@@ -166,10 +166,9 @@ function hash128x86(key
 }
 /**
  * x86 version of Murmur3 for 128bits.
- * @param {string} str
+ * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
  *
- * @TODO Test and use in hashImpression128 instead of the x64 version,
- * because it is more time efficient in JS, no matter the underlying CPU arch.
+ * @param {string} str
  */
 
 

package/es/engine/matchers/index.js

@@ -13,7 +13,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 **/
-import { types } from './types';
 import allMatcher from './all';
 import segmentMatcher from './segment';
 import whitelistMatcher from './whitelist';
@@ -31,6 +30,25 @@ import containsStrMatcher from './cont_str';
 import dependencyMatcher from './dependency';
 import booleanMatcher from './boolean';
 import stringMatcher from './string';
+var matchers = [undefined, // UNDEFINED: 0,
+allMatcher, // ALL_KEYS: 1,
+segmentMatcher, // IN_SEGMENT: 2,
+whitelistMatcher, // WHITELIST: 3,
+eqMatcher, // EQUAL_TO: 4,
+gteMatcher, // GREATER_THAN_OR_EQUAL_TO: 5,
+lteMatcher, // LESS_THAN_OR_EQUAL_TO: 6,
+betweenMatcher, // BETWEEN: 7,
+equalToSetMatcher, // EQUAL_TO_SET: 8,
+containsAnySetMatcher, // CONTAINS_ANY_OF_SET: 9,
+containsAllSetMatcher, // CONTAINS_ALL_OF_SET: 10,
+partOfSetMatcher, // PART_OF_SET: 11,
+ewMatcher, // ENDS_WITH: 12,
+swMatcher, // STARTS_WITH: 13,
+containsStrMatcher, // CONTAINS_STRING: 14,
+dependencyMatcher, // IN_SPLIT_TREATMENT: 15,
+booleanMatcher, // EQUAL_TO_BOOLEAN: 16,
+stringMatcher // MATCHES_STRING: 17
+];
 /**
  * Matcher factory.
  */
@@ -39,42 +57,7 @@ function MatcherFactory(matcherDto, storage) {
   var type = matcherDto.type,
       value = matcherDto.value;
   var matcherFn;
-
-  if (type === types.ALL) {
-    matcherFn = allMatcher(value);
-  } else if (type === types.SEGMENT) {
-    matcherFn = segmentMatcher(value, storage);
-  } else if (type === types.WHITELIST) {
-    matcherFn = whitelistMatcher(value);
-  } else if (type === types.EQUAL_TO) {
-    matcherFn = eqMatcher(value);
-  } else if (type === types.GREATER_THAN_OR_EQUAL_TO) {
-    matcherFn = gteMatcher(value);
-  } else if (type === types.LESS_THAN_OR_EQUAL_TO) {
-    matcherFn = lteMatcher(value);
-  } else if (type === types.BETWEEN) {
-    matcherFn = betweenMatcher(value);
-  } else if (type === types.EQUAL_TO_SET) {
-    matcherFn = equalToSetMatcher(value);
-  } else if (type === types.CONTAINS_ANY_OF_SET) {
-    matcherFn = containsAnySetMatcher(value);
-  } else if (type === types.CONTAINS_ALL_OF_SET) {
-    matcherFn = containsAllSetMatcher(value);
-  } else if (type === types.PART_OF_SET) {
-    matcherFn = partOfSetMatcher(value);
-  } else if (type === types.STARTS_WITH) {
-    matcherFn = swMatcher(value);
-  } else if (type === types.ENDS_WITH) {
-    matcherFn = ewMatcher(value);
-  } else if (type === types.CONTAINS_STRING) {
-    matcherFn = containsStrMatcher(value);
-  } else if (type === types.IN_SPLIT_TREATMENT) {
-    matcherFn = dependencyMatcher(value, storage);
-  } else if (type === types.EQUAL_TO_BOOLEAN) {
-    matcherFn = booleanMatcher(value);
-  } else if (type === types.MATCHES_STRING) {
-    matcherFn = stringMatcher(value);
-  }
+  if (matchers[type]) matcherFn = matchers[type](value, storage); // There is no index-out-of-bound exception in JavaScript
 
   return matcherFn;
 }

package/es/engine/matchers/types.js

@@ -14,27 +14,27 @@ See the License for the specific language governing permissions and
 limitations under the License.
 **/
 // @WARNING Symbol is not correctly working in PhantomJS
-export var types = {
-  ALL: 1,
-  SEGMENT: 2,
+export var matcherTypes = {
+  UNDEFINED: 0,
+  ALL_KEYS: 1,
+  IN_SEGMENT: 2,
   WHITELIST: 3,
   EQUAL_TO: 4,
   GREATER_THAN_OR_EQUAL_TO: 5,
   LESS_THAN_OR_EQUAL_TO: 6,
   BETWEEN: 7,
-  UNDEFINED: 8,
-  EQUAL_TO_SET: 9,
-  CONTAINS_ANY_OF_SET: 10,
-  CONTAINS_ALL_OF_SET: 11,
-  PART_OF_SET: 12,
-  ENDS_WITH: 13,
-  STARTS_WITH: 14,
-  CONTAINS_STRING: 15,
-  IN_SPLIT_TREATMENT: 16,
-  EQUAL_TO_BOOLEAN: 17,
-  MATCHES_STRING: 18
+  EQUAL_TO_SET: 8,
+  CONTAINS_ANY_OF_SET: 9,
+  CONTAINS_ALL_OF_SET: 10,
+  PART_OF_SET: 11,
+  ENDS_WITH: 12,
+  STARTS_WITH: 13,
+  CONTAINS_STRING: 14,
+  IN_SPLIT_TREATMENT: 15,
+  EQUAL_TO_BOOLEAN: 16,
+  MATCHES_STRING: 17
 };
-export var dataTypes = {
+export var matcherDataTypes = {
   BOOLEAN: 'BOOLEAN',
   STRING: 'STRING',
   NUMBER: 'NUMBER',
@@ -42,60 +42,7 @@ export var dataTypes = {
   DATETIME: 'DATETIME',
   NOT_SPECIFIED: 'NOT_SPECIFIED'
 };
-export var mapper = function mapper(matcherType) {
-  switch (matcherType) {
-    case 'ALL_KEYS':
-      return types.ALL;
-
-    case 'IN_SEGMENT':
-      return types.SEGMENT;
-
-    case 'WHITELIST':
-      return types.WHITELIST;
-
-    case 'EQUAL_TO':
-      return types.EQUAL_TO;
-
-    case 'GREATER_THAN_OR_EQUAL_TO':
-      return types.GREATER_THAN_OR_EQUAL_TO;
-
-    case 'LESS_THAN_OR_EQUAL_TO':
-      return types.LESS_THAN_OR_EQUAL_TO;
-
-    case 'BETWEEN':
-      return types.BETWEEN;
-
-    case 'EQUAL_TO_SET':
-      return types.EQUAL_TO_SET;
-
-    case 'CONTAINS_ANY_OF_SET':
-      return types.CONTAINS_ANY_OF_SET;
-
-    case 'CONTAINS_ALL_OF_SET':
-      return types.CONTAINS_ALL_OF_SET;
-
-    case 'PART_OF_SET':
-      return types.PART_OF_SET;
-
-    case 'ENDS_WITH':
-      return types.ENDS_WITH;
-
-    case 'STARTS_WITH':
-      return types.STARTS_WITH;
-
-    case 'CONTAINS_STRING':
-      return types.CONTAINS_STRING;
-
-    case 'IN_SPLIT_TREATMENT':
-      return types.IN_SPLIT_TREATMENT;
-
-    case 'EQUAL_TO_BOOLEAN':
-      return types.EQUAL_TO_BOOLEAN;
-
-    case 'MATCHES_STRING':
-      return types.MATCHES_STRING;
-
-    default:
-      return types.UNDEFINED;
-  }
-};
+export function matcherTypesMapper(matcherType) {
+  var type = matcherTypes[matcherType];
+  if (type) return type;else return matcherTypes.UNDEFINED;
+}

package/es/engine/transforms/matcherGroup.js

@@ -13,7 +13,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 **/
-import { types as matcherTypes, mapper as matcherTypesMapper } from '../matchers/types';
+import { matcherTypes, matcherTypesMapper } from '../matchers/types';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 /**
@@ -28,7 +28,7 @@ function transform(matcherGroup) {
   var type = matcherTypesMapper(matcherType);
   var value = undefined;
 
-  if (type === matcherTypes.SEGMENT) {
+  if (type === matcherTypes.IN_SEGMENT) {
     value = segmentTransform(segmentObject);
   } else if (type === matcherTypes.WHITELIST) {
     value = whitelistTransform(whitelistObject);

package/es/engine/transforms/matchers.js

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 **/
 import { findIndex } from '../../utils/lang';
-import { types as matcherTypes, mapper as matcherTypesMapper, dataTypes as matcherDataTypes } from '../matchers/types';
+import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/types';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 import setTransform from './set';
@@ -39,7 +39,7 @@ function transform(matchers) {
     var dataType = matcherDataTypes.STRING;
     var value = undefined;
 
-    if (type === matcherTypes.SEGMENT) {
+    if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(segmentObject);
     } else if (type === matcherTypes.WHITELIST) {
       value = whitelistTransform(whitelistObject);

package/es/engine/value/sanitize.js

@@ -17,9 +17,7 @@ import logFactory from '../../utils/logger';
 var log = logFactory('splitio-engine:sanitize');
 import { isObject, uniq, toString, toNumber } from '../../utils/lang';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { types as matcherTypes, dataTypes as matcherDataTypes } from '../matchers/types';
-var MATCHERS = matcherTypes;
-var DATA_TYPES = matcherDataTypes;
+import { matcherTypes, matcherDataTypes } from '../matchers/types';
 
 function sanitizeNumber(val) {
   var num = toNumber(val);
@@ -70,15 +68,15 @@ function dependencyProcessor(sanitizedValue, attributes) {
 
 function getProcessingFunction(matcherTypeID, dataType) {
   switch (matcherTypeID) {
-    case MATCHERS.EQUAL_TO:
+    case matcherTypes.EQUAL_TO:
       return dataType === 'DATETIME' ? zeroSinceHH : undefined;
 
-    case MATCHERS.GREATER_THAN_OR_EQUAL_TO:
-    case MATCHERS.LESS_THAN_OR_EQUAL_TO:
-    case MATCHERS.BETWEEN:
+    case matcherTypes.GREATER_THAN_OR_EQUAL_TO:
+    case matcherTypes.LESS_THAN_OR_EQUAL_TO:
+    case matcherTypes.BETWEEN:
       return dataType === 'DATETIME' ? zeroSinceSS : undefined;
 
-    case MATCHERS.IN_SPLIT_TREATMENT:
+    case matcherTypes.IN_SPLIT_TREATMENT:
       return dependencyProcessor;
 
     default:
@@ -91,24 +89,24 @@ function sanitizeValue(matcherTypeID, value, dataType, attributes) {
   var sanitizedValue;
 
   switch (dataType) {
-    case DATA_TYPES.NUMBER:
-    case DATA_TYPES.DATETIME:
+    case matcherDataTypes.NUMBER:
+    case matcherDataTypes.DATETIME:
       sanitizedValue = sanitizeNumber(value);
       break;
 
-    case DATA_TYPES.STRING:
+    case matcherDataTypes.STRING:
       sanitizedValue = sanitizeString(value);
       break;
 
-    case DATA_TYPES.SET:
+    case matcherDataTypes.SET:
       sanitizedValue = sanitizeArray(value);
       break;
 
-    case DATA_TYPES.BOOLEAN:
+    case matcherDataTypes.BOOLEAN:
       sanitizedValue = sanitizeBoolean(value);
       break;
 
-    case DATA_TYPES.NOT_SPECIFIED:
+    case matcherDataTypes.NOT_SPECIFIED:
       sanitizedValue = value;
       break;
 

package/es/impressions/hasher/hashImpression128.js

@@ -1,4 +1,4 @@
-import { hash128 } from '../../engine/engine/murmur3/murmur3_128';
+import { hash128 } from '../../engine/engine/murmur3/murmur3_128_x86';
 import { buildKey } from './buildKey';
 export function hashImpression128(impression) {
   return hash128(buildKey(impression));

package/es/impressions/observer/observer.js

@@ -9,7 +9,6 @@ var ImpressionObserver = /*#__PURE__*/function () {
   var _proto = ImpressionObserver.prototype;
 
   _proto.testAndSet = function testAndSet(impression) {
-    if (!impression) return null;
     var hash = this.hasher(impression);
     var previous = this.cache.get(hash);
     this.cache.set(hash, impression.time);

package/es/listeners/browser.js

@@ -7,19 +7,9 @@ import { fromImpressionsCollector, fromImpressionsCountCollector } from '../serv
 import logFactory from '../utils/logger';
 import { OPTIMIZED, DEBUG } from '../utils/constants';
 import objectAssign from 'object-assign';
-var log = logFactory('splitio-client:cleanup');
+var log = logFactory('splitio-client:cleanup'); // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 
-function getUnloadDomEvent() {
-  // Except for Firefox (See https://github.com/splitio/react-client/issues/71), 'unload' event is used instead of 'beforeunload',
-  // since it is not a cancelable event and no other listeners can stop the event from occurring.
-  if (typeof navigator == 'object' && navigator.userAgent && navigator.userAgent.indexOf('Firefox') !== -1) {
-    return 'beforeunload';
-  }
-
-  return 'unload';
-}
-
-var UNLOAD_DOM_EVENT = getUnloadDomEvent();
+var UNLOAD_DOM_EVENT = 'unload';
 /**
  * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
  *

package/es/producer/updater/SplitChangesFromObject.js

@@ -13,6 +13,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 **/
+import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { forOwn } from '../../utils/lang';
 import logFactory from '../../utils/logger';
 var log = logFactory('splitio-producer:offline');
@@ -52,13 +53,13 @@ function FromObjectUpdaterFactory(Fetcher, context) {
         })]);
       });
       return Promise.all([storage.splits.flush(), // required to sync removed splits from mock
-      storage.splits.setChangeNumber(Date.now()), storage.splits.addSplits(splits)]).then(function () {
+      storage.splits.addSplits(splits)]).then(function () {
         readiness.splits.emit(readiness.splits.SDK_SPLITS_ARRIVED);
 
         if (startingUp) {
           startingUp = false; // Emits SDK_READY_FROM_CACHE
 
-          if (storage.splits.checkCache()) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED); // Only emits SDK_SEGMENTS_ARRIVED the first time for SDK_READY
+          if (settings.storage.__originalType === STORAGE_LOCALSTORAGE) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED); // Only emits SDK_SEGMENTS_ARRIVED the first time for SDK_READY
 
           readiness.segments.emit(readiness.segments.SDK_SEGMENTS_ARRIVED);
         }

package/es/storage/SplitCache/InLocalStorage.js

@@ -11,6 +11,17 @@ var SplitCacheLocalStorage = /*#__PURE__*/function () {
    * @param {Object} splitFiltersValidation
    */
   function SplitCacheLocalStorage(keys, expirationTimestamp, splitFiltersValidation) {
+    if (splitFiltersValidation === void 0) {
+      splitFiltersValidation = {
+        validFilters: [],
+        queryString: null,
+        groupedFilters: {
+          byName: [],
+          byPrefix: []
+        }
+      };
+    }
+
     this.keys = keys;
     this.splitFiltersValidation = splitFiltersValidation;
 

package/es/sync/PushManager/index.js

@@ -67,9 +67,9 @@ export default function PushManagerFactory(context, clientContexts
     if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen); // Set token refresh 10 minutes before expirationTime - issuedAt
 
     var decodedToken = authData.decodedToken;
-    var refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION; // connDelay is present in AuthV2 but not in AuthV1
+    var refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION; // Default connDelay of 60 secs
 
-    var connDelay = authData.connDelay || 0;
+    var connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;
     log.info("Refreshing streaming token in " + refreshTokenDelay + " seconds, and connecting streaming in " + connDelay + " seconds");
     timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
     timeoutIdSseOpen = setTimeout(function () {
@@ -232,21 +232,13 @@ export default function PushManagerFactory(context, clientContexts
             forOwn(clients, function (_ref3) {
               var hash64 = _ref3.hash64,
                   worker = _ref3.worker;
+              var add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
 
-              if (added.has(hash64.dec)) {
+              if (add !== undefined) {
                 worker.put(parsedData.changeNumber, {
                   name: parsedData.segmentName,
-                  add: true
+                  add: add
                 });
-                return;
-              }
-
-              if (removed.has(hash64.dec)) {
-                worker.put(parsedData.changeNumber, {
-                  name: parsedData.segmentName,
-                  add: false
-                });
-                return;
               }
             });
             return;

package/es/utils/inputValidation/splitFilters.js

@@ -78,7 +78,10 @@ export default function validateSplitFilters(splitFilters, mode) {
   var res = {
     validFilters: [],
     queryString: null,
-    groupedFilters: {}
+    groupedFilters: {
+      byName: [],
+      byPrefix: []
+    }
   }; // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
 
   if (!splitFilters) return res; // Warn depending on the mode
@@ -95,10 +98,6 @@ export default function validateSplitFilters(splitFilters, mode) {
   } // Validate filters and group their values by filter type inside `groupedFilters` object
 
 
-  FILTERS_METADATA.forEach(function (metadata) {
-    res.groupedFilters[metadata.type] = [];
-  }); // Assign the valid filters to the output of the validator by using filter function
-
   res.validFilters = splitFilters.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/es/utils/logger/LoggerFactory.js

@@ -8,11 +8,22 @@ export var LogLevels = {
   'WARN': 'WARN',
   'ERROR': 'ERROR',
   'NONE': 'NONE'
+};
+var LogLevelIndexes = {
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  NONE: 5
 }; // DEBUG is the default. The log level is not specific to an SDK instance.
 
-var GlobalLogLevel = LogLevels.DEBUG;
+var GlobalLogLevel = LogLevelIndexes.DEBUG;
+/**
+ * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'|'NONE'} level
+ */
+
 export var setLogLevel = function setLogLevel(level) {
-  GlobalLogLevel = level;
+  GlobalLogLevel = LogLevelIndexes[level];
 };
 var defaultOptions = {
   showLevel: true,
@@ -27,19 +38,19 @@ export var Logger = /*#__PURE__*/function () {
   var _proto = Logger.prototype;
 
   _proto.debug = function debug(msg) {
-    if (this._shouldLog(LogLevels.DEBUG)) this._log(LogLevels.DEBUG, msg);
+    if (this._shouldLog(LogLevelIndexes.DEBUG)) this._log(LogLevels.DEBUG, msg);
   };
 
   _proto.info = function info(msg) {
-    if (this._shouldLog(LogLevels.INFO)) this._log(LogLevels.INFO, msg);
+    if (this._shouldLog(LogLevelIndexes.INFO)) this._log(LogLevels.INFO, msg);
   };
 
   _proto.warn = function warn(msg) {
-    if (this._shouldLog(LogLevels.WARN)) this._log(LogLevels.WARN, msg);
+    if (this._shouldLog(LogLevelIndexes.WARN)) this._log(LogLevels.WARN, msg);
   };
 
   _proto.error = function error(msg) {
-    if (this.options.displayAllErrors || this._shouldLog(LogLevels.ERROR)) this._log(LogLevels.ERROR, msg);
+    if (this.options.displayAllErrors || this._shouldLog(LogLevelIndexes.ERROR)) this._log(LogLevels.ERROR, msg);
   };
 
   _proto._log = function _log(level, text) {
@@ -61,18 +72,14 @@ export var Logger = /*#__PURE__*/function () {
     }
 
     return result += text;
-  };
+  }
+  /**
+   * @param {number} level
+   */
+  ;
 
   _proto._shouldLog = function _shouldLog(level) {
-    var logLevel = GlobalLogLevel;
-    var levels = Object.keys(LogLevels).map(function (f) {
-      return LogLevels[f];
-    });
-    var index = levels.indexOf(level); // What's the index of what it's trying to check if it should log
-
-    var levelIdx = levels.indexOf(logLevel); // What's the current log level index.
-
-    return index >= levelIdx;
+    return level >= GlobalLogLevel;
   };
 
   return Logger;

package/es/utils/settings/index.js

@@ -25,7 +25,7 @@ import validateSplitFilters from '../inputValidation/splitFilters';
 import { API } from '../../utils/logger';
 import { STANDALONE_MODE, STORAGE_MEMORY, CONSUMER_MODE, OPTIMIZED } from '../../utils/constants';
 import validImpressionsMode from './impressionsMode';
-var version = '10.15.10-rc.2';
+var version = '10.16.1-rc.0';
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/es/utils/settings/storage/browser.js

@@ -16,33 +16,48 @@ limitations under the License.
 import logFactory from '../../../utils/logger';
 var log = logFactory('splitio-settings');
 import isLocalStorageAvailable from '../../../utils/localstorage/isAvailable';
-import { STORAGE_MEMORY, STORAGE_LOCALSTORAGE } from '../../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_LOCALSTORAGE } from '../../../utils/constants';
 
 var ParseStorageSettings = function ParseStorageSettings(settings) {
-  var _settings$storage = settings.storage,
+  var mode = settings.mode,
+      _settings$storage = settings.storage,
       _settings$storage$typ = _settings$storage.type,
       type = _settings$storage$typ === void 0 ? STORAGE_MEMORY : _settings$storage$typ,
       _settings$storage$opt = _settings$storage.options,
       options = _settings$storage$opt === void 0 ? {} : _settings$storage$opt,
       prefix = _settings$storage.prefix;
 
+  var __originalType;
+
   if (prefix) {
     prefix += '.SPLITIO';
   } else {
     prefix = 'SPLITIO';
+  }
+
+  var fallbackToMemory = function fallbackToMemory() {
+    __originalType = type;
+    type = STORAGE_MEMORY;
+  }; // In localhost mode, fallback to Memory storage and track original
+  // type to emit SDK_READY_FROM_CACHE if corresponds
+
+
+  if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
+    fallbackToMemory();
   } // If an invalid storage type is provided OR we want to use LOCALSTORAGE and
   // it's not available, fallback into MEMORY
 
 
   if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE || type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
-    type = STORAGE_MEMORY;
+    fallbackToMemory();
     log.warn('Invalid or unavailable storage. Fallbacking into MEMORY storage');
   }
 
   return {
     type: type,
     options: options,
-    prefix: prefix
+    prefix: prefix,
+    __originalType: __originalType
   };
 };
 

package/lib/engine/engine/murmur3/murmur3_128.js

@@ -240,7 +240,7 @@ function hash128x64(key
 }
 /**
  * x64 version of Murmur3 for 128bits.
- * Used in hashImpression128.
+ *
  * @param {string} str
  */
 

package/lib/engine/engine/murmur3/murmur3_128_x86.js

@@ -172,10 +172,9 @@ function hash128x86(key
 }
 /**
  * x86 version of Murmur3 for 128bits.
- * @param {string} str
+ * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
  *
- * @TODO Test and use in hashImpression128 instead of the x64 version,
- * because it is more time efficient in JS, no matter the underlying CPU arch.
+ * @param {string} str
  */