@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/producer/updater/SplitChanges.js

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = SplitChangesUpdaterFactory;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _SplitChanges = _interopRequireDefault(require("../fetcher/SplitChanges"));
+
+var _segments = _interopRequireDefault(require("../../engine/parser/segments"));
+
+var _Errors = require("../../utils/lang/Errors");
+
+var _Sets = require("../../utils/lang/Sets");
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+/**
+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.
+**/
+var log = (0, _logger.default)('splitio-producer:split-changes');
+
+// 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)]);
+      (0, _segments.default)(split.conditions).forEach(function (segmentName) {
+        accum.segments.add(segmentName);
+      });
+    } else {
+      accum.removed.push(split.name);
+    }
+
+    return accum;
+  }, {
+    added: [],
+    removed: [],
+    segments: new _Sets._Set()
+  });
+  computed.segments = (0, _Sets.setToArray)(computed.segments);
+  return computed;
+}
+
+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 = (0, _SplitChanges.default)(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 _Errors.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 = (0, _thenable.default)(since) ? since : Promise.resolve(since);
+    return sincePromise.then(splitChanges);
+  };
+}

package/lib/producer/updater/SplitChangesFromFeatures.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = createSplitChangesFromObject;
+
+var _offline = _interopRequireDefault(require("../../services/splitChanges/offline"));
+
+var _SplitChangesFromObject = _interopRequireDefault(require("./SplitChangesFromObject"));
+
+/**
+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.
+**/
+function createSplitChangesFromObject(context) {
+  var fetcher = (0, _offline.default)();
+  return (0, _SplitChangesFromObject.default)(fetcher, context);
+}

package/lib/producer/updater/SplitChangesFromFileSystem.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = createSplitChangesFromObject;
+
+var _offline = _interopRequireDefault(require("../../services/splitChanges/offline"));
+
+var _SplitChangesFromObject = _interopRequireDefault(require("./SplitChangesFromObject"));
+
+/**
+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.
+**/
+function createSplitChangesFromObject(context) {
+  var fetcher = (0, _offline.default)();
+  return (0, _SplitChangesFromObject.default)(fetcher, context);
+}

package/lib/producer/updater/SplitChangesFromObject.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _constants = require("../../utils/constants");
+
+var _lang = require("../../utils/lang");
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+/**
+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.
+**/
+var log = (0, _logger.default)('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));
+      (0, _lang.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 === _constants.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();
+    }
+  };
+}
+
+var _default = FromObjectUpdaterFactory;
+exports.default = _default;

package/lib/readiness/index.js

@@ -0,0 +1,132 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _events = _interopRequireDefault(require("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 _events.default();
+  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 _events.default();
+    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 _events.default();
+    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;
+}
+
+var _default = GateContext;
+exports.default = _default;

package/lib/readiness/statusManager.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = callbackHandlerContext;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _wrapper = _interopRequireDefault(require("../utils/promise/wrapper"));
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var log = (0, _logger.default)('');
+var NEW_LISTENER_EVENT = 'newListener';
+var REMOVE_LISTENER_EVENT = 'removeListener'; // default onRejected handler, that just logs the error, if ready promise doesn't have one.
+
+function defaultOnRejected(err) {
+  log.error(err);
+}
+/**
+ * StatusManager factory.
+ * Responsable of exposing public status API: ready promise, event emitter and constants (SDK_READY, etc).
+ * It also updates client context according to status events and logs related warnings and errors.
+ *
+ * @param {Object} context client context
+ * @param {number} internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
+ * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
+ */
+
+
+function callbackHandlerContext(context, internalReadyCbCount) {
+  if (internalReadyCbCount === void 0) {
+    internalReadyCbCount = 0;
+  }
+
+  var gate = context.get(context.constants.READINESS).gate;
+  var readyCbCount = 0;
+  var isReady = false;
+  var hasTimedout = false;
+  var SDK_READY = gate.SDK_READY,
+      SDK_READY_FROM_CACHE = gate.SDK_READY_FROM_CACHE,
+      SDK_UPDATE = gate.SDK_UPDATE,
+      SDK_READY_TIMED_OUT = gate.SDK_READY_TIMED_OUT;
+  gate.on(REMOVE_LISTENER_EVENT, function (event) {
+    if (event === SDK_READY) readyCbCount--;
+  });
+  gate.on(NEW_LISTENER_EVENT, function (event) {
+    if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
+      if (isReady) {
+        log.error("A listener was added for " + (event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT') + " on the SDK, which has already fired and won't be emitted again. The callback won't be executed.");
+      } else if (event === SDK_READY) {
+        readyCbCount++;
+      }
+    }
+  });
+  var readyPromise = generateReadyPromise();
+  gate.once(SDK_READY_FROM_CACHE, function () {
+    log.info('Split SDK is ready from cache.');
+    context.put(context.constants.READY_FROM_CACHE, true);
+  });
+
+  function generateReadyPromise() {
+    var promise = (0, _wrapper.default)(new Promise(function (resolve, reject) {
+      gate.once(SDK_READY, function () {
+        log.info('Split SDK is ready.');
+        if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn('No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.');
+        context.put(context.constants.READY, true);
+        isReady = true;
+        resolve();
+      });
+      gate.once(SDK_READY_TIMED_OUT, function (error) {
+        context.put(context.constants.HAS_TIMEDOUT, true);
+        hasTimedout = true;
+        reject(error);
+      });
+    }), defaultOnRejected);
+    return promise;
+  }
+
+  return (0, _objectAssign.default)( // Expose Event Emitter functionality
+  Object.create(gate), {
+    // Expose the event constants without changing the interface
+    Event: {
+      SDK_READY: SDK_READY,
+      SDK_READY_FROM_CACHE: SDK_READY_FROM_CACHE,
+      SDK_UPDATE: SDK_UPDATE,
+      SDK_READY_TIMED_OUT: SDK_READY_TIMED_OUT
+    },
+
+    /**
+     * Returns a promise that will be resolved once the SDK has finished loading (SDK_READY event emitted) or rejected if the SDK has timedout (SDK_READY_TIMED_OUT event emitted).
+     * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, calling the `ready` method after the
+     * SDK had timed out will return a new promise that should eventually resolve if the SDK gets ready.
+     *
+     * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.
+     * However, when using async/await syntax, the rejection should be explicitly propagated like in the following example:
+     * ```
+     * try {
+     *   await client.ready().catch((e) => { throw e; });
+     *   // SDK is ready
+     * } catch(e) {
+     *   // SDK has timedout
+     * }
+     * ```
+     *
+     * @function ready
+     * @returns {Promise<void>}
+     */
+    ready: function ready() {
+      if (hasTimedout) {
+        if (!isReady) {
+          return (0, _wrapper.default)(Promise.reject('Split SDK has emitted SDK_READY_TIMED_OUT event.'), defaultOnRejected);
+        } else {
+          return Promise.resolve();
+        }
+      }
+
+      return readyPromise;
+    },
+    // Expose context for internal purposes only. Not considered part of the public API, and will be removed eventually.
+    __context: context
+  });
+}

package/lib/services/auth/auth.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = GET;
+
+var _request = _interopRequireDefault(require("../request"));
+
+function userKeyToQueryParam(userKey) {
+  // no need to check availability of `encodeURIComponent`, since it is a function highly supported in browsers, node and other platforms.
+  return 'users=' + encodeURIComponent(userKey);
+}
+/**
+ *
+ * @param {Object} settings Split factory config.
+ * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for Node.
+ */
+
+
+function GET(settings, userKeys) {
+  var relativeUrl = '/v2/auth';
+
+  if (userKeys) {
+    // accounting the possibility that `userKeys` is undefined (in node)
+    var queryParams = userKeys.map(userKeyToQueryParam).join('&');
+    if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
+      relativeUrl += '?' + queryParams;
+  }
+
+  return (0, _request.default)(settings, relativeUrl);
+}

package/lib/services/auth/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _transport = _interopRequireDefault(require("../transport"));
+
+var _default = _transport.default;
+exports.default = _default;

package/lib/services/events/bulk.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = BULK;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _request = _interopRequireDefault(require("../request"));
+
+/**
+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.
+**/
+function BULK(settings, params) {
+  return (0, _request.default)(settings, '/events/bulk', (0, _objectAssign.default)({
+    method: 'POST'
+  }, params));
+}

package/lib/services/events/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _transport = _interopRequireDefault(require("../transport"));
+
+/**
+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.
+**/
+var _default = _transport.default;
+exports.default = _default;

package/lib/{platform → services}/getEventSource/browser.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.getEventSource = getEventSource;
+exports.default = getEventSource;
 
 function getEventSource() {
   return typeof EventSource === 'function' ? EventSource : undefined;

package/lib/{platform → services}/getEventSource/node.js

@@ -3,7 +3,7 @@
 exports.__esModule = true;
 exports.__setEventSource = __setEventSource;
 exports.__restore = __restore;
-exports.getEventSource = getEventSource;
+exports.default = getEventSource;
 var __isCustom = false;
 var __eventSource = undefined; // This function is only exposed for testing purposes.
 

package/lib/services/getEventSource/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}