@splitsoftware/splitio 10.17.1-rc.0 → 10.17.3-rc.0

package/src/producer/updater/MySegments.js

@@ -1,104 +0,0 @@
-/**
-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';
-const log = logFactory('splitio-producer:my-segments');
-import mySegmentsFetcher from '../fetcher/MySegments';
-
-export default function MySegmentsUpdaterFactory(context) {
-  const {
-    [context.constants.SETTINGS]: settings,
-    [context.constants.READINESS]: readiness,
-    [context.constants.STORAGE]: storage,
-    [context.constants.COLLECTORS]: metricCollectors
-  } = context.getAll();
-
-  const segmentsEventEmitter = readiness.segments;
-
-  let readyOnAlreadyExistentState = true;
-  let startingUp = true;
-
-  // @TODO if allowing custom storages, handle async execution and wrap errors as SplitErrors to distinguish from user callback errors
-  function updateSegments(segmentsData) {
-
-    const mySegmentsCache = storage.segments;
-    let shouldNotifyUpdate;
-    if (Array.isArray(segmentsData)) {
-      // Update the list of segment names available
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
-    } else {
-      // Add/Delete the segment
-      const { name, add } = segmentsData;
-      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 = 0, segmentsData, noCache) {
-    let updaterPromise;
-
-    if (segmentsData) {
-      // If segmentsData is provided, there is no need to fetch mySegments
-      updaterPromise = new Promise((res) => { updateSegments(segmentsData); res(); });
-    } else {
-      // NOTE: We only collect metrics on startup.
-      updaterPromise = mySegmentsFetcher(settings, startingUp, metricCollectors, noCache).then(segments => {
-        // Only when we have downloaded segments completely, we should not keep retrying anymore
-        startingUp = false;
-
-        updateSegments(segments);
-      });
-    }
-
-    return updaterPromise.catch(error => {
-      // handle user callback errors
-      if (!(error instanceof SplitError)) setTimeout(() => { 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/src/producer/updater/SegmentChanges.js

@@ -1,126 +0,0 @@
-/**
-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';
-const log = logFactory('splitio-producer:segment-changes');
-const 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) {
-  const {
-    [context.constants.SETTINGS]: settings,
-    [context.constants.READINESS]: readiness,
-    [context.constants.STORAGE]: storage,
-    [context.constants.COLLECTORS]: metricCollectors
-  } = context.getAll();
-  const segmentsEventEmitter = readiness.segments;
-  const segmentsStorage = storage.segments;
-
-  let 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.
-    const updaters = [];
-
-    function segmentsUpdater(segments) {
-      const sincePromises = [];
-
-      for (let index = 0; index < segments.length; index++) {
-        const segmentName = segments[index];
-
-        const segmentUpdater = function (since) {
-          log.debug(`Processing segment ${segmentName}`);
-
-          updaters.push(segmentChangesFetcher(settings, segmentName, since, metricCollectors, noCache).then(function (changes) {
-            let changeNumber = -1;
-            const changePromises = [];
-            changes.forEach(x => {
-              let promises = [];
-              if (x.added.length > 0) {
-                const result = segmentsStorage.addToSegment(segmentName, x.added);
-                if (thenable(result)) promises.push(result);
-              }
-              if (x.removed.length > 0) {
-                const result = segmentsStorage.removeFromSegment(segmentName, x.removed);
-                if (thenable(result)) promises.push(result);
-              }
-              if (x.added.length > 0 || x.removed.length > 0) {
-                const result = segmentsStorage.setChangeNumber(segmentName, x.till);
-                if (thenable(result)) promises.push(result);
-                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(...promises);
-            });
-
-            return Promise.all(changePromises).then(function () {
-              return changeNumber;
-            });
-          }));
-        };
-
-        const since = segmentsStorage.getChangeNumber(segmentName);
-        const sincePromise = thenable(since) ? since.then(segmentUpdater) : segmentUpdater(since);
-        sincePromises.push(sincePromise);
-      }
-
-      return Promise.all(sincePromises).then(function () {
-        return Promise.all(updaters).then(shouldUpdateFlags => {
-          // if at least one segment fetch successes, mark segments ready
-          if (findIndex(shouldUpdateFlags, v => 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(error => {
-          // handle user callback errors
-          if (!(error instanceof SplitError)) setTimeout(() => { 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.
-    let segments = segmentNames ? segmentNames : segmentsStorage.getRegisteredSegments();
-    if(fetchOnlyNew) segments = segments.filter(segmentName => segmentsStorage.getChangeNumber(segmentName) === -1 );
-
-    return thenable(segments) ? segments.then(segmentsUpdater) : segmentsUpdater(segments);
-  };
-
-}

package/src/producer/updater/SplitChanges.js

@@ -1,138 +0,0 @@
-/**
-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';
-const 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(segmentName => segmentsStorage.getChangeNumber(segmentName) !== -1);
-}
-
-function computeSplitsMutation(entries) {
-  const computed = entries.reduce((accum, split) => {
-    if (split.status === 'ACTIVE') {
-      accum.added.push([split.name, JSON.stringify(split)]);
-
-      parseSegments(split.conditions).forEach(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 = false) {
-  const {
-    [context.constants.SETTINGS]: settings,
-    [context.constants.READINESS]: readiness,
-    [context.constants.STORAGE]: storage,
-    [context.constants.COLLECTORS]: metricCollectors
-  } = context.getAll();
-  const splitsEventEmitter = readiness.splits;
-
-  let startingUp = true;
-  let 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 = 0, noCache) {
-
-    function splitChanges(since) {
-      log.debug(`Spin up split update using since = ${since}`);
-
-      const fetcherPromise = splitChangesFetcher(settings, since, startingUp, metricCollectors, isNode, noCache)
-        .then(splitChanges => {
-          startingUp = false;
-
-          const 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(() => {
-            // 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(error => {
-          // handle user callback errors
-          if (!(error instanceof SplitError)) {
-            setTimeout(() => { 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
-    const since = storage.splits.getChangeNumber();
-    const sincePromise = thenable(since) ? since : Promise.resolve(since);
-    return sincePromise.then(splitChanges);
-  };
-}

package/src/producer/updater/SplitChangesFromFeatures.js

@@ -1,23 +0,0 @@
-/**
-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) {
-  const fetcher = FromSettingsFetcher();
-  return SplitChangesFromObject(fetcher, context);
-}

package/src/producer/updater/SplitChangesFromFileSystem.js

@@ -1,23 +0,0 @@
-/**
-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) {
-  const fetcher = FromFileSystemFetcher();
-  return SplitChangesFromObject(fetcher, context);
-}

package/src/producer/updater/SplitChangesFromObject.js

@@ -1,81 +0,0 @@
-/**
-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';
-const log = logFactory('splitio-producer:offline');
-
-function FromObjectUpdaterFactory(Fetcher, context) {
-  const {
-    [context.constants.SETTINGS]: settings,
-    [context.constants.READINESS]: readiness,
-    [context.constants.STORAGE]: storage
-  } = context.getAll();
-
-  let startingUp = true;
-
-  return function ObjectUpdater() {
-    const splits = [];
-    let loadError = null;
-    let 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,
-            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(() => {
-        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/src/readiness/index.js

@@ -1,125 +0,0 @@
-import EventEmitter from 'events';
-
-const SPLITS_READY = 2;
-const SEGMENTS_READY = 4;
-const SDK_FIRE_READY = SPLITS_READY | SEGMENTS_READY; // 2 + 4 = 6
-const SDK_NOTIFY_UPDATE_SINCE_NOW = 8;
-const SDK_FIRE_UPDATE = SDK_FIRE_READY | SDK_NOTIFY_UPDATE_SINCE_NOW; // 6 + 8 = 14
-
-const 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.
-  let splitsStatus = 0;
-
-  const 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
-  let refCount = 0;
-
-  function ReadinessGateFactory(splits, segments) {
-    const gate = new EventEmitter();
-    let segmentsStatus = 0;
-    let status = 0;
-
-    gate.on(Events.READINESS_GATE_CHECK_STATE, () => {
-      // @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, (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, () => {
-      try {
-        gate.emit(Events.SDK_READY_FROM_CACHE);
-      } catch (e) {
-        // handle user callback errors
-        setTimeout(() => { throw e; }, 0);
-      }
-    });
-
-    segments.on(Events.SDK_SEGMENTS_ARRIVED, () => {
-      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 = 0) {
-    let readinessTimeoutId = 0;
-    const segments = new EventEmitter();
-    segments.SDK_SEGMENTS_ARRIVED = Events.SDK_SEGMENTS_ARRIVED;
-
-    const gate = ReadinessGateFactory(splits, segments);
-
-    if (timeout > 0) {
-      // Add the timeout.
-      readinessTimeoutId = setTimeout(() => {
-        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, () => 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,
-      segments,
-      gate,
-      // Cleanup listeners
-      destroy() {
-        segments.removeAllListeners();
-        gate.removeAllListeners();
-        clearTimeout(readinessTimeoutId);
-
-        if (refCount > 0) refCount--;
-        if (refCount === 0) splits.removeAllListeners();
-      }
-    };
-  }
-
-  return SDKReadinessGateFactory;
-}
-
-export default GateContext;