@splitsoftware/splitio 10.17.3-rc.3 → 10.17.3-rc.4

package/es/producer/task.js

@@ -0,0 +1,50 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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 logFactory from '../utils/logger';
+var log = logFactory('splitio-producer:task');
+import repeat from '../utils/fn/repeat';
+import { getFnName } from '../utils/lang';
+/**
+ * Startable task factory.
+ */
+
+var TaskFactory = function TaskFactory(updater, period) {
+  var updaterName = getFnName(updater);
+  var stopUpdater = false;
+  return {
+    start: function start() {
+      if (!stopUpdater) {
+        log.debug("Starting " + updaterName + " refreshing each " + period);
+        stopUpdater = repeat(function (reschedule) {
+          log.debug("Running " + updaterName);
+          updater().then(function () {
+            return reschedule();
+          });
+        }, period);
+      }
+    },
+    stop: function stop() {
+      log.debug("Stopping " + updaterName);
+      stopUpdater && stopUpdater();
+      stopUpdater = false;
+    },
+    isRunning: function isRunning() {
+      return stopUpdater ? true : false;
+    }
+  };
+};
+
+export default TaskFactory;

package/es/producer/updater/MySegments.js

@@ -0,0 +1,108 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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 logFactory from '../../utils/logger';
+import { SplitError } from '../../utils/lang/Errors';
+var log = logFactory('splitio-producer:my-segments');
+import mySegmentsFetcher from '../fetcher/MySegments';
+export default function MySegmentsUpdaterFactory(context) {
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE],
+      metricCollectors = _context$getAll[context.constants.COLLECTORS];
+
+  var segmentsEventEmitter = readiness.segments;
+  var readyOnAlreadyExistentState = true;
+  var startingUp = true; // @TODO if allowing custom storages, handle async execution and wrap errors as SplitErrors to distinguish from user callback errors
+
+  function updateSegments(segmentsData) {
+    var mySegmentsCache = storage.segments;
+    var shouldNotifyUpdate;
+
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    } else {
+      // Add/Delete the segment
+      var name = segmentsData.name,
+          add = segmentsData.add;
+
+      if (mySegmentsCache.isInSegment(name) !== add) {
+        shouldNotifyUpdate = true;
+        if (add) mySegmentsCache.addToSegment(name);else mySegmentsCache.removeFromSegment(name);
+      } else {
+        shouldNotifyUpdate = false;
+      }
+    } // Notify update if required
+
+
+    if (storage.splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+      readyOnAlreadyExistentState = false;
+      segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+    }
+  }
+  /**
+   * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
+   *
+   * @param {number | undefined} retry current number of retry attemps. this param is only set by SplitChangesUpdater itself.
+   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData it can be:
+   *  (1) the list of segment names to sync in the storage,
+   *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+   *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+
+  return function MySegmentsUpdater(retry, segmentsData, noCache) {
+    if (retry === void 0) {
+      retry = 0;
+    }
+
+    var updaterPromise;
+
+    if (segmentsData) {
+      // If segmentsData is provided, there is no need to fetch mySegments
+      updaterPromise = new Promise(function (res) {
+        updateSegments(segmentsData);
+        res();
+      });
+    } else {
+      // NOTE: We only collect metrics on startup.
+      updaterPromise = mySegmentsFetcher(settings, startingUp, metricCollectors, noCache).then(function (segments) {
+        // Only when we have downloaded segments completely, we should not keep retrying anymore
+        startingUp = false;
+        updateSegments(segments);
+      });
+    }
+
+    return updaterPromise.catch(function (error) {
+      // handle user callback errors
+      if (!(error instanceof SplitError)) setTimeout(function () {
+        throw error;
+      }, 0);
+
+      if (startingUp && settings.startup.retriesOnFailureBeforeReady > retry) {
+        retry += 1;
+        log.warn("Retrying download of segments #" + retry + ". Reason: " + error);
+        return MySegmentsUpdater(retry);
+      } else {
+        startingUp = false;
+      }
+
+      return false; // shouldUpdate = false
+    });
+  };
+}

package/es/producer/updater/SegmentChanges.js

@@ -0,0 +1,135 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-producer:segment-changes');
+var inputValidationLog = logFactory('', {
+  displayAllErrors: true
+});
+import segmentChangesFetcher from '../fetcher/SegmentChanges';
+import { findIndex } from '../../utils/lang';
+import { SplitError } from '../../utils/lang/Errors';
+import thenable from '../../utils/promise/thenable';
+export default function SegmentChangesUpdaterFactory(context) {
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE],
+      metricCollectors = _context$getAll[context.constants.COLLECTORS];
+
+  var segmentsEventEmitter = readiness.segments;
+  var segmentsStorage = storage.segments;
+  var readyOnAlreadyExistentState = true;
+  /**
+   * Segments updater returns a promise that resolves with a `false` boolean value if it fails at least to fetch a segment or synchronize it with the storage.
+   * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
+   *
+   * @param {string[] | undefined} segmentNames list of segment names to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+   * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+   * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
+   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+   */
+
+  return function SegmentChangesUpdater(segmentNames, noCache, fetchOnlyNew) {
+    log.debug('Started segments update'); // Async fetchers are collected here.
+
+    var updaters = [];
+
+    function segmentsUpdater(segments) {
+      var sincePromises = [];
+
+      var _loop = function _loop(index) {
+        var segmentName = segments[index];
+
+        var segmentUpdater = function segmentUpdater(since) {
+          log.debug("Processing segment " + segmentName);
+          updaters.push(segmentChangesFetcher(settings, segmentName, since, metricCollectors, noCache).then(function (changes) {
+            var changeNumber = -1;
+            var changePromises = [];
+            changes.forEach(function (x) {
+              var promises = [];
+
+              if (x.added.length > 0) {
+                var result = segmentsStorage.addToSegment(segmentName, x.added);
+                if (thenable(result)) promises.push(result);
+              }
+
+              if (x.removed.length > 0) {
+                var _result = segmentsStorage.removeFromSegment(segmentName, x.removed);
+
+                if (thenable(_result)) promises.push(_result);
+              }
+
+              if (x.added.length > 0 || x.removed.length > 0) {
+                var _result2 = segmentsStorage.setChangeNumber(segmentName, x.till);
+
+                if (thenable(_result2)) promises.push(_result2);
+                changeNumber = x.till;
+              }
+
+              log.debug("Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+              if (promises.length > 0) changePromises.push.apply(changePromises, promises);
+            });
+            return Promise.all(changePromises).then(function () {
+              return changeNumber;
+            });
+          }));
+        };
+
+        var since = segmentsStorage.getChangeNumber(segmentName);
+        var sincePromise = thenable(since) ? since.then(segmentUpdater) : segmentUpdater(since);
+        sincePromises.push(sincePromise);
+      };
+
+      for (var index = 0; index < segments.length; index++) {
+        _loop(index);
+      }
+
+      return Promise.all(sincePromises).then(function () {
+        return Promise.all(updaters).then(function (shouldUpdateFlags) {
+          // if at least one segment fetch successes, mark segments ready
+          if (findIndex(shouldUpdateFlags, function (v) {
+            return v !== -1;
+          }) !== -1 || readyOnAlreadyExistentState) {
+            readyOnAlreadyExistentState = false;
+            segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+          } // if at least one segment fetch fails, return false to indicate that there was some error (e.g., invalid json, HTTP error, etc)
+
+
+          if (shouldUpdateFlags.indexOf(-1) !== -1) return false;
+        }).catch(function (error) {
+          // handle user callback errors
+          if (!(error instanceof SplitError)) setTimeout(function () {
+            throw error;
+          }, 0);
+
+          if (error.statusCode === 403) {
+            context.put(context.constants.DESTROYED, true);
+            inputValidationLog.error('Factory instantiation: you passed a Browser type authorizationKey, please grab an Api Key from the Split web console that is of type SDK.');
+          }
+
+          return false;
+        });
+      });
+    } // If not a segment name provided, read list of available segments names to be updated.
+
+
+    var segments = segmentNames ? segmentNames : segmentsStorage.getRegisteredSegments();
+    if (fetchOnlyNew) segments = segments.filter(function (segmentName) {
+      return segmentsStorage.getChangeNumber(segmentName) === -1;
+    });
+    return thenable(segments) ? segments.then(segmentsUpdater) : segmentsUpdater(segments);
+  };
+}

package/es/producer/updater/SplitChanges.js

@@ -0,0 +1,131 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-producer:split-changes');
+import splitChangesFetcher from '../fetcher/SplitChanges';
+import parseSegments from '../../engine/parser/segments';
+import { SplitError } from '../../utils/lang/Errors';
+import { _Set, setToArray } from '../../utils/lang/Sets';
+import thenable from '../../utils/promise/thenable'; // For server-side segments storage, returns true if all registered segments have been fetched (changeNumber !== -1)
+
+function checkAllSegmentsExist(segmentsStorage) {
+  return segmentsStorage.getRegisteredSegments().every(function (segmentName) {
+    return segmentsStorage.getChangeNumber(segmentName) !== -1;
+  });
+}
+
+function computeSplitsMutation(entries) {
+  var computed = entries.reduce(function (accum, split) {
+    if (split.status === 'ACTIVE') {
+      accum.added.push([split.name, JSON.stringify(split)]);
+      parseSegments(split.conditions).forEach(function (segmentName) {
+        accum.segments.add(segmentName);
+      });
+    } else {
+      accum.removed.push(split.name);
+    }
+
+    return accum;
+  }, {
+    added: [],
+    removed: [],
+    segments: new _Set()
+  });
+  computed.segments = setToArray(computed.segments);
+  return computed;
+}
+
+export default function SplitChangesUpdaterFactory(context, isNode) {
+  if (isNode === void 0) {
+    isNode = false;
+  }
+
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE],
+      metricCollectors = _context$getAll[context.constants.COLLECTORS];
+
+  var splitsEventEmitter = readiness.splits;
+  var startingUp = true;
+  var readyOnAlreadyExistentState = true;
+  /**
+   * Split updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
+   *
+   * @param {number | undefined} retry current number of retry attemps. this param is only set by SplitChangesUpdater itself.
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+  return function SplitChangesUpdater(retry, noCache) {
+    if (retry === void 0) {
+      retry = 0;
+    }
+
+    function splitChanges(since) {
+      log.debug("Spin up split update using since = " + since);
+      var fetcherPromise = splitChangesFetcher(settings, since, startingUp, metricCollectors, isNode, noCache).then(function (splitChanges) {
+        startingUp = false;
+        var mutation = computeSplitsMutation(splitChanges.splits);
+        log.debug("New splits " + mutation.added.length);
+        log.debug("Removed splits " + mutation.removed.length);
+        log.debug("Segment names collected " + mutation.segments); // Write into storage
+        // @TODO if allowing custom storages, wrap errors as SplitErrors to distinguish from user callback errors
+
+        return Promise.all([// calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
+        storage.splits.setChangeNumber(splitChanges.till), storage.splits.addSplits(mutation.added), storage.splits.removeSplits(mutation.removed), storage.segments.registerSegments(mutation.segments)]).then(function () {
+          // On server-side SDK, we must check that all registered segments have been fetched
+          if (readyOnAlreadyExistentState || since !== splitChanges.till && (!isNode || checkAllSegmentsExist(storage.segments))) {
+            readyOnAlreadyExistentState = false;
+            splitsEventEmitter.emit(splitsEventEmitter.SDK_SPLITS_ARRIVED);
+          }
+        });
+      }).catch(function (error) {
+        // handle user callback errors
+        if (!(error instanceof SplitError)) {
+          setTimeout(function () {
+            throw error;
+          }, 0);
+          startingUp = false; // Stop retrying.
+        }
+
+        log.warn("Error while doing fetch of Splits. " + error);
+
+        if (startingUp && settings.startup.retriesOnFailureBeforeReady > retry) {
+          retry += 1;
+          log.info("Retrying download of splits #" + retry + ". Reason: " + error);
+          return SplitChangesUpdater(retry, noCache);
+        } else {
+          startingUp = false;
+        }
+
+        return false;
+      }); // After triggering the requests, if we have cached splits information let's notify that.
+      // There is no need to emit the event asynchronously to let attach a listener for SDK_READY_FROM_CACHE,
+      // because the current event-loop callback executes after SplitFactory is created.
+
+      if (startingUp && storage.splits.checkCache()) {
+        splitsEventEmitter.emit(splitsEventEmitter.SDK_SPLITS_CACHE_LOADED);
+      }
+
+      return fetcherPromise;
+    } // @TODO check why e2e tests take so much time when sync storage result is not handled in a promise
+
+
+    var since = storage.splits.getChangeNumber();
+    var sincePromise = thenable(since) ? since : Promise.resolve(since);
+    return sincePromise.then(splitChanges);
+  };
+}

package/es/producer/updater/SplitChangesFromFeatures.js

@@ -0,0 +1,21 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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 FromSettingsFetcher from '../../services/splitChanges/offline';
+import SplitChangesFromObject from './SplitChangesFromObject';
+export default function createSplitChangesFromObject(context) {
+  var fetcher = FromSettingsFetcher();
+  return SplitChangesFromObject(fetcher, context);
+}

package/es/producer/updater/SplitChangesFromFileSystem.js

@@ -0,0 +1,21 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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 FromFileSystemFetcher from '../../services/splitChanges/offline';
+import SplitChangesFromObject from './SplitChangesFromObject';
+export default function createSplitChangesFromObject(context) {
+  var fetcher = FromFileSystemFetcher();
+  return SplitChangesFromObject(fetcher, context);
+}

package/es/producer/updater/SplitChangesFromObject.js

@@ -0,0 +1,73 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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');
+
+function FromObjectUpdaterFactory(Fetcher, context) {
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE];
+
+  var startingUp = true;
+  return function ObjectUpdater() {
+    var splits = [];
+    var loadError = null;
+    var splitsMock = {};
+
+    try {
+      splitsMock = Fetcher(settings);
+    } catch (err) {
+      loadError = err;
+      log.error("There was an issue loading the mock Splits data, no changes will be applied to the current cache. " + err);
+    }
+
+    if (!loadError && splitsMock) {
+      log.debug('Splits data: ');
+      log.debug(JSON.stringify(splitsMock));
+      forOwn(splitsMock, function (val, name) {
+        splits.push([name, JSON.stringify({
+          name: name,
+          status: 'ACTIVE',
+          killed: false,
+          trafficAllocation: 100,
+          defaultTreatment: 'control',
+          conditions: val.conditions || [],
+          configurations: val.configurations,
+          trafficTypeName: val.trafficTypeName
+        })]);
+      });
+      return Promise.all([storage.splits.flush(), // required to sync removed splits from mock
+      storage.splits.addSplits(splits)]).then(function () {
+        readiness.splits.emit(readiness.splits.SDK_SPLITS_ARRIVED);
+
+        if (startingUp) {
+          startingUp = false; // Emits SDK_READY_FROM_CACHE
+
+          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);
+        }
+      });
+    } else {
+      return Promise.resolve();
+    }
+  };
+}
+
+export default FromObjectUpdaterFactory;

package/es/readiness/index.js

@@ -0,0 +1,123 @@
+import EventEmitter from 'events';
+var SPLITS_READY = 2;
+var SEGMENTS_READY = 4;
+var SDK_FIRE_READY = SPLITS_READY | SEGMENTS_READY; // 2 + 4 = 6
+
+var SDK_NOTIFY_UPDATE_SINCE_NOW = 8;
+var SDK_FIRE_UPDATE = SDK_FIRE_READY | SDK_NOTIFY_UPDATE_SINCE_NOW; // 6 + 8 = 14
+
+var Events = {
+  SDK_READY_TIMED_OUT: 'init::timeout',
+  SDK_READY: 'init::ready',
+  SDK_READY_FROM_CACHE: 'init::cache-ready',
+  SDK_SPLITS_ARRIVED: 'state::splits-arrived',
+  SDK_SEGMENTS_ARRIVED: 'state::segments-arrived',
+  SDK_SPLITS_CACHE_LOADED: 'state::splits-cache-loaded',
+  SDK_UPDATE: 'state::update',
+  READINESS_GATE_CHECK_STATE: 'state::check'
+};
+/**
+ * Machine state to handle the ready / update event propagation.
+ */
+
+function GateContext() {
+  // Splits are shared through all instances of the same SDK.
+  var splitsStatus = 0;
+  var splits = new EventEmitter();
+  splits.SDK_SPLITS_CACHE_LOADED = Events.SDK_SPLITS_CACHE_LOADED;
+  splits.SDK_SPLITS_ARRIVED = Events.SDK_SPLITS_ARRIVED; // references counter: how many
+
+  var refCount = 0;
+
+  function ReadinessGateFactory(splits, segments) {
+    var gate = new EventEmitter();
+    var segmentsStatus = 0;
+    var status = 0;
+    gate.on(Events.READINESS_GATE_CHECK_STATE, function () {
+      // @TODO catch and handle user callback errors. Required for localhost and consumer modes. In standalone mode, it is done in 'SplitChangesUpdater'.
+      if (status !== SDK_FIRE_UPDATE && splitsStatus + segmentsStatus === SDK_FIRE_READY) {
+        status = SDK_FIRE_UPDATE;
+        gate.emit(Events.SDK_READY);
+      } else if (status === SDK_FIRE_UPDATE) {
+        gate.emit(Events.SDK_UPDATE);
+      }
+    });
+    splits.on(Events.SDK_SPLITS_ARRIVED, function (isSplitKill) {
+      // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
+      // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+      // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
+      if (!isSplitKill) splitsStatus = SPLITS_READY;
+      gate.emit(Events.READINESS_GATE_CHECK_STATE);
+    });
+    splits.once(Events.SDK_SPLITS_CACHE_LOADED, function () {
+      try {
+        gate.emit(Events.SDK_READY_FROM_CACHE);
+      } catch (e) {
+        // handle user callback errors
+        setTimeout(function () {
+          throw e;
+        }, 0);
+      }
+    });
+    segments.on(Events.SDK_SEGMENTS_ARRIVED, function () {
+      segmentsStatus = SEGMENTS_READY;
+      gate.emit(Events.READINESS_GATE_CHECK_STATE);
+    });
+    return gate;
+  }
+  /**
+   * SDK Readiness Gate Factory
+   *
+   * The ready state in the browser relay on sharing the splits ready flag across
+   * all the gates, and have an extra flag for the segments which is per gate
+   * instance.
+   */
+
+
+  function SDKReadinessGateFactory(timeout) {
+    if (timeout === void 0) {
+      timeout = 0;
+    }
+
+    var readinessTimeoutId = 0;
+    var segments = new EventEmitter();
+    segments.SDK_SEGMENTS_ARRIVED = Events.SDK_SEGMENTS_ARRIVED;
+    var gate = ReadinessGateFactory(splits, segments);
+
+    if (timeout > 0) {
+      // Add the timeout.
+      readinessTimeoutId = setTimeout(function () {
+        gate.emit(Events.SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
+      }, timeout); // Clear it if the SDK get's ready.
+
+      gate.once(Events.SDK_READY, function () {
+        return clearTimeout(readinessTimeoutId);
+      });
+    }
+
+    gate.SDK_READY = Events.SDK_READY;
+    gate.SDK_READY_FROM_CACHE = Events.SDK_READY_FROM_CACHE;
+    gate.SDK_UPDATE = Events.SDK_UPDATE;
+    gate.SDK_READY_TIMED_OUT = Events.SDK_READY_TIMED_OUT; // New Gate has been created, so increase the counter
+
+    refCount++;
+    return {
+      // Emitters
+      splits: splits,
+      segments: segments,
+      gate: gate,
+      // Cleanup listeners
+      destroy: function destroy() {
+        segments.removeAllListeners();
+        gate.removeAllListeners();
+        clearTimeout(readinessTimeoutId);
+        if (refCount > 0) refCount--;
+        if (refCount === 0) splits.removeAllListeners();
+      }
+    };
+  }
+
+  return SDKReadinessGateFactory;
+}
+
+export default GateContext;