@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.0

package/cjs/logger/messages/error.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codesError = void 0;
 var tslib_1 = require("tslib");
-var c = (0, tslib_1.__importStar)(require("../constants"));
+var c = tslib_1.__importStar(require("../constants"));
 exports.codesError = [
     // evaluator
-    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported targeting rule type found'],
+    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid definition, no valid rules or unsupported targeting rule type found'],
     [c.ENGINE_MATCHER_ERROR, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] %s'],
     // SDK
     [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
@@ -16,7 +16,7 @@ exports.codesError = [
     // synchronizer
     [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock feature flags data. No changes will be applied to the current cache. %s'],
     [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],
-    [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],
+    [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s'],
     [c.ERROR_HTTP, 'HTTP request failed with %s. URL: %s. Message: %s'],
     // client status
     [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'],
@@ -37,6 +37,6 @@ exports.codesError = [
     [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
     [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],
     [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
-    [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the amount of flag sets provided are big causing uri length error.'],
+    [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the number of sets provided is too high, which causes a URI length error.'],
     [c.ERROR_SETS_FILTER_EXCLUSIVE, c.LOG_PREFIX_SETTINGS + ': the Set filter is exclusive and cannot be used simultaneously with names or prefix filters. Ignoring names and prefixes.'],
 ];

package/cjs/logger/messages/info.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codesInfo = void 0;
 var tslib_1 = require("tslib");
-var c = (0, tslib_1.__importStar)(require("../constants"));
+var c = tslib_1.__importStar(require("../constants"));
 var warn_1 = require("./warn");
 var READY_MSG = 'Split SDK client is ready';
 exports.codesInfo = warn_1.codesWarn.concat([
@@ -10,8 +10,7 @@ exports.codesInfo = warn_1.codesWarn.concat([
     [c.CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'],
     [c.CLIENT_READY, READY_MSG],
     // SDK
-    [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
-    [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Queueing corresponding impression.'],
+    [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Queueing impression. %s: %s. Key: %s. Evaluation: %s. Label: %s'],
     [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
     [c.NEW_FACTORY, 'New Split SDK instance created. %s'],
     [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
@@ -23,7 +22,6 @@ exports.codesInfo = warn_1.codesWarn.concat([
     [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
     [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
-    [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying fetch of feature flags (attempt #%s). Reason: %s'],
     [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
     [c.SUBMITTERS_PUSH_PAGE_HIDDEN, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing %s because page became hidden.'],

package/cjs/logger/messages/warn.js

@@ -2,31 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codesWarn = void 0;
 var tslib_1 = require("tslib");
-var c = (0, tslib_1.__importStar)(require("../constants"));
+var c = tslib_1.__importStar(require("../constants"));
 var error_1 = require("./error");
 exports.codesWarn = error_1.codesError.concat([
     // evaluator
     [c.ENGINE_VALUE_INVALID, c.LOG_PREFIX_ENGINE_VALUE + 'Value %s doesn\'t match with expected type.'],
     [c.ENGINE_VALUE_NO_ATTRIBUTES, c.LOG_PREFIX_ENGINE_VALUE + 'Defined attribute `%s`. No attributes received.'],
     // synchronizer
-    [c.SYNC_MYSEGMENTS_FETCH_RETRY, c.LOG_PREFIX_SYNC_MYSEGMENTS + 'Retrying fetch of memberships (attempt #%s). Reason: %s'],
-    [c.SYNC_SPLITS_FETCH_FAILS, c.LOG_PREFIX_SYNC_SPLITS + 'Error while doing fetch of feature flags. %s'],
+    [c.SYNC_FETCH_RETRY, c.LOG_PREFIX_SYNC + 'Retrying fetch of %s (attempt #%s). Reason: %s'],
+    [c.SYNC_FETCH_FAILS, c.LOG_PREFIX_SYNC + 'Error while doing fetch of %s. %s'],
     [c.STREAMING_PARSING_ERROR_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE error notification: %s'],
     [c.STREAMING_PARSING_MESSAGE_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE message notification: %s'],
     [c.STREAMING_FALLBACK, c.LOG_PREFIX_SYNC_STREAMING + 'Falling back to polling mode. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s.'],
-    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],
+    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s'],
+    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s'],
     // client status
-    [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect%s. Make sure to wait for SDK readiness before using this method.'],
+    [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect. Make sure to wait for SDK readiness before using this method.'],
     [c.CLIENT_NO_LISTENER, 'No listeners for SDK_READY event detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet synchronized with the backend.'],
     // input validation
     [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
     [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],
     [c.WARN_CONVERTING, '%s: %s "%s" is not of type string, converting.'],
     [c.WARN_TRIMMING, '%s: %s "%s" has extra whitespace, trimming.'],
-    [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],
+    [c.WARN_NOT_EXISTENT_DEFINITION, '%s: "%s" does not exist in this environment. Please double check that it exists in Harness UI.'],
     [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
-    [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split user interface.'],
+    [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in Harness UI.'],
     [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: you passed %s which is not part of the configured FlagSetsFilter, ignoring Flag Set.'],
     // initialization / settings validation
     [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS + ': %s integration item(s) at settings is invalid. %s'],
@@ -38,5 +38,5 @@ exports.codesWarn = error_1.codesError.concat([
     [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing %s notification: %s'],
     [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
     [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],
-    [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in the Split user interface.'],
+    [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in Harness UI.'],
 ]);

package/cjs/platform/browser.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platform = void 0;
+var EventEmitter_1 = require("../utils/EventEmitter");
+var browser_1 = require("../platform/getFetch/browser");
+var browser_2 = require("../platform/getEventSource/browser");
+var browser_3 = require("../listeners/browser");
+var browser_4 = require("../utils/timeTracker/now/browser");
+exports.platform = {
+    getFetch: browser_1.getFetch,
+    getEventSource: browser_2.getEventSource,
+    EventEmitter: EventEmitter_1.EventEmitter,
+    now: browser_4.now,
+    SignalListener: browser_3.BrowserSignalListener
+};

package/cjs/platform/getEventSource/browser.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventSource = void 0;
+function getEventSource() {
+    // eslint-disable-next-line no-undef -- Feature detection for EventSource
+    return typeof EventSource === 'function' ? EventSource : undefined;
+}
+exports.getEventSource = getEventSource;

package/cjs/platform/getEventSource/eventsource.js

@@ -0,0 +1,480 @@
+"use strict";
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable no-restricted-syntax */
+/*
+Modified version of "eventsource" v1.1.2 package (https://www.npmjs.com/package/eventsource/v/1.1.2) that accepts a custom agent.
+Requires CommonJS and Node.js globals (require, process, Buffer).
+
+The MIT License
+
+Copyright (c) EventSource GitHub organization
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+var parse = require('url').parse;
+var events = require('events');
+var https = require('https');
+var http = require('http');
+var util = require('util');
+var httpsOptions = [
+    'pfx', 'key', 'passphrase', 'cert', 'ca', 'ciphers',
+    'rejectUnauthorized', 'secureProtocol', 'servername', 'checkServerIdentity'
+];
+var bom = [239, 187, 191];
+var colon = 58;
+var space = 32;
+var lineFeed = 10;
+var carriageReturn = 13;
+function hasBom(buf) {
+    return bom.every(function (charCode, index) {
+        return buf[index] === charCode;
+    });
+}
+/**
+ * Creates a new EventSource object
+ *
+ * @param {String} url the URL to which to connect
+ * @param {Object} [eventSourceInitDict] extra init params. See README for details.
+ * @api public
+ **/
+function EventSource(url, eventSourceInitDict) {
+    var readyState = EventSource.CONNECTING;
+    var headers = eventSourceInitDict && eventSourceInitDict.headers;
+    var hasNewOrigin = false;
+    Object.defineProperty(this, 'readyState', {
+        get: function () {
+            return readyState;
+        }
+    });
+    Object.defineProperty(this, 'url', {
+        get: function () {
+            return url;
+        }
+    });
+    var self = this;
+    self.reconnectInterval = 1000;
+    self.connectionInProgress = false;
+    var reconnectUrl = null;
+    function onConnectionClosed(message) {
+        if (readyState === EventSource.CLOSED)
+            return;
+        readyState = EventSource.CONNECTING;
+        _emit('error', new Event('error', { message: message }));
+        // The url may have been changed by a temporary redirect. If that's the case,
+        // revert it now, and flag that we are no longer pointing to a new origin
+        if (reconnectUrl) {
+            url = reconnectUrl;
+            reconnectUrl = null;
+            hasNewOrigin = false;
+        }
+        setTimeout(function () {
+            if (readyState !== EventSource.CONNECTING || self.connectionInProgress) {
+                return;
+            }
+            self.connectionInProgress = true;
+            connect();
+        }, self.reconnectInterval);
+    }
+    var req;
+    var lastEventId = '';
+    if (headers && headers['Last-Event-ID']) {
+        lastEventId = headers['Last-Event-ID'];
+        delete headers['Last-Event-ID'];
+    }
+    var discardTrailingNewline = false;
+    var data = '';
+    var eventName = '';
+    function connect() {
+        var options = parse(url);
+        var isSecure = options.protocol === 'https:';
+        options.headers = { 'Cache-Control': 'no-cache', 'Accept': 'text/event-stream' };
+        if (lastEventId)
+            options.headers['Last-Event-ID'] = lastEventId;
+        if (headers) {
+            var reqHeaders = hasNewOrigin ? removeUnsafeHeaders(headers) : headers;
+            for (var i in reqHeaders) {
+                var header = reqHeaders[i];
+                if (header) {
+                    options.headers[i] = header;
+                }
+            }
+        }
+        // Legacy: this should be specified as `eventSourceInitDict.https.rejectUnauthorized`,
+        // but for now exists as a backwards-compatibility layer
+        options.rejectUnauthorized = !(eventSourceInitDict && !eventSourceInitDict.rejectUnauthorized);
+        if (eventSourceInitDict && eventSourceInitDict.createConnection !== undefined) {
+            options.createConnection = eventSourceInitDict.createConnection;
+        }
+        // If specify agent, use it.
+        if (eventSourceInitDict && eventSourceInitDict.agent !== undefined) {
+            options.agent = eventSourceInitDict.agent;
+        }
+        // If specify http proxy, make the request to sent to the proxy server,
+        // and include the original url in path and Host headers
+        var useProxy = eventSourceInitDict && eventSourceInitDict.proxy;
+        if (useProxy) {
+            var proxy = parse(eventSourceInitDict.proxy);
+            isSecure = proxy.protocol === 'https:';
+            options.protocol = isSecure ? 'https:' : 'http:';
+            options.path = url;
+            options.headers.Host = options.host;
+            options.hostname = proxy.hostname;
+            options.host = proxy.host;
+            options.port = proxy.port;
+        }
+        // If https options are specified, merge them into the request options
+        if (eventSourceInitDict && eventSourceInitDict.https) {
+            for (var optName in eventSourceInitDict.https) {
+                if (httpsOptions.indexOf(optName) === -1) {
+                    continue;
+                }
+                var option = eventSourceInitDict.https[optName];
+                if (option !== undefined) {
+                    options[optName] = option;
+                }
+            }
+        }
+        // Pass this on to the XHR
+        if (eventSourceInitDict && eventSourceInitDict.withCredentials !== undefined) {
+            options.withCredentials = eventSourceInitDict.withCredentials;
+        }
+        req = (isSecure ? https : http).request(options, function (res) {
+            self.connectionInProgress = false;
+            // Handle HTTP errors
+            if (res.statusCode === 500 || res.statusCode === 502 || res.statusCode === 503 || res.statusCode === 504) {
+                _emit('error', new Event('error', { status: res.statusCode, message: res.statusMessage }));
+                onConnectionClosed();
+                return;
+            }
+            // Handle HTTP redirects
+            if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) {
+                var location = res.headers.location;
+                if (!location) {
+                    // Server sent redirect response without Location header.
+                    _emit('error', new Event('error', { status: res.statusCode, message: res.statusMessage }));
+                    return;
+                }
+                var prevOrigin = getOrigin(url);
+                var nextOrigin = getOrigin(location);
+                hasNewOrigin = prevOrigin !== nextOrigin;
+                if (res.statusCode === 307)
+                    reconnectUrl = url;
+                url = location;
+                process.nextTick(connect);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                _emit('error', new Event('error', { status: res.statusCode, message: res.statusMessage }));
+                return self.close();
+            }
+            readyState = EventSource.OPEN;
+            res.on('close', function () {
+                res.removeAllListeners('close');
+                res.removeAllListeners('end');
+                onConnectionClosed();
+            });
+            res.on('end', function () {
+                res.removeAllListeners('close');
+                res.removeAllListeners('end');
+                onConnectionClosed();
+            });
+            _emit('open', new Event('open'));
+            // text/event-stream parser adapted from webkit's
+            // Source/WebCore/page/EventSource.cpp
+            var isFirst = true;
+            var buf;
+            var startingPos = 0;
+            var startingFieldLength = -1;
+            res.on('data', function (chunk) {
+                buf = buf ? Buffer.concat([buf, chunk]) : chunk;
+                if (isFirst && hasBom(buf)) {
+                    buf = buf.slice(bom.length);
+                }
+                isFirst = false;
+                var pos = 0;
+                var length = buf.length;
+                while (pos < length) {
+                    if (discardTrailingNewline) {
+                        if (buf[pos] === lineFeed) {
+                            ++pos;
+                        }
+                        discardTrailingNewline = false;
+                    }
+                    var lineLength = -1;
+                    var fieldLength = startingFieldLength;
+                    var c;
+                    for (var i = startingPos; lineLength < 0 && i < length; ++i) {
+                        c = buf[i];
+                        if (c === colon) {
+                            if (fieldLength < 0) {
+                                fieldLength = i - pos;
+                            }
+                        }
+                        else if (c === carriageReturn) {
+                            discardTrailingNewline = true;
+                            lineLength = i - pos;
+                        }
+                        else if (c === lineFeed) {
+                            lineLength = i - pos;
+                        }
+                    }
+                    if (lineLength < 0) {
+                        startingPos = length - pos;
+                        startingFieldLength = fieldLength;
+                        break;
+                    }
+                    else {
+                        startingPos = 0;
+                        startingFieldLength = -1;
+                    }
+                    parseEventStreamLine(buf, pos, fieldLength, lineLength);
+                    pos += lineLength + 1;
+                }
+                if (pos === length) {
+                    buf = void 0;
+                }
+                else if (pos > 0) {
+                    buf = buf.slice(pos);
+                }
+            });
+        });
+        req.on('error', function (err) {
+            self.connectionInProgress = false;
+            onConnectionClosed(err.message);
+        });
+        if (req.setNoDelay)
+            req.setNoDelay(true);
+        req.end();
+    }
+    connect();
+    function _emit() {
+        if (self.listeners(arguments[0]).length > 0) {
+            self.emit.apply(self, arguments);
+        }
+    }
+    this._close = function () {
+        if (readyState === EventSource.CLOSED)
+            return;
+        readyState = EventSource.CLOSED;
+        if (req.abort)
+            req.abort();
+        if (req.xhr && req.xhr.abort)
+            req.xhr.abort();
+    };
+    function parseEventStreamLine(buf, pos, fieldLength, lineLength) {
+        if (lineLength === 0) {
+            if (data.length > 0) {
+                var type = eventName || 'message';
+                _emit(type, new MessageEvent(type, {
+                    data: data.slice(0, -1),
+                    lastEventId: lastEventId,
+                    origin: getOrigin(url)
+                }));
+                data = '';
+            }
+            eventName = void 0;
+        }
+        else if (fieldLength > 0) {
+            var noValue = fieldLength < 0;
+            var step = 0;
+            var field = buf.slice(pos, pos + (noValue ? lineLength : fieldLength)).toString();
+            if (noValue) {
+                step = lineLength;
+            }
+            else if (buf[pos + fieldLength + 1] !== space) {
+                step = fieldLength + 1;
+            }
+            else {
+                step = fieldLength + 2;
+            }
+            pos += step;
+            var valueLength = lineLength - step;
+            var value = buf.slice(pos, pos + valueLength).toString();
+            if (field === 'data') {
+                data += value + '\n';
+            }
+            else if (field === 'event') {
+                eventName = value;
+            }
+            else if (field === 'id') {
+                lastEventId = value;
+            }
+            else if (field === 'retry') {
+                var retry = parseInt(value, 10);
+                if (!Number.isNaN(retry)) {
+                    self.reconnectInterval = retry;
+                }
+            }
+        }
+    }
+}
+module.exports = EventSource;
+util.inherits(EventSource, events.EventEmitter);
+EventSource.prototype.constructor = EventSource; // make stacktraces readable
+['open', 'error', 'message'].forEach(function (method) {
+    Object.defineProperty(EventSource.prototype, 'on' + method, {
+        /**
+         * Returns the current listener
+         *
+         * @return {Mixed} the set function or undefined
+         * @api private
+         */
+        get: function get() {
+            var listener = this.listeners(method)[0];
+            return listener ? (listener._listener ? listener._listener : listener) : undefined;
+        },
+        /**
+         * Start listening for events
+         *
+         * @param {Function} listener the listener
+         * @return {Mixed} the set function or undefined
+         * @api private
+         */
+        set: function set(listener) {
+            this.removeAllListeners(method);
+            this.addEventListener(method, listener);
+        }
+    });
+});
+/**
+ * Ready states
+ */
+Object.defineProperty(EventSource, 'CONNECTING', { enumerable: true, value: 0 });
+Object.defineProperty(EventSource, 'OPEN', { enumerable: true, value: 1 });
+Object.defineProperty(EventSource, 'CLOSED', { enumerable: true, value: 2 });
+EventSource.prototype.CONNECTING = 0;
+EventSource.prototype.OPEN = 1;
+EventSource.prototype.CLOSED = 2;
+/**
+ * Closes the connection, if one is made, and sets the readyState attribute to 2 (closed)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource/close
+ * @api public
+ */
+EventSource.prototype.close = function () {
+    this._close();
+};
+/**
+ * Emulates the W3C Browser based WebSocket interface using addEventListener.
+ *
+ * @param {String} type A string representing the event type to listen out for
+ * @param {Function} listener callback
+ * @see https://developer.mozilla.org/en/DOM/element.addEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+EventSource.prototype.addEventListener = function addEventListener(type, listener) {
+    if (typeof listener === 'function') {
+        // store a reference so we can return the original function again
+        listener._listener = listener;
+        this.on(type, listener);
+    }
+};
+/**
+ * Emulates the W3C Browser based WebSocket interface using dispatchEvent.
+ *
+ * @param {Event} event An event to be dispatched
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent
+ * @api public
+ */
+EventSource.prototype.dispatchEvent = function dispatchEvent(event) {
+    if (!event.type) {
+        throw new Error('UNSPECIFIED_EVENT_TYPE_ERR');
+    }
+    // if event is instance of an CustomEvent (or has 'details' property),
+    // send the detail object as the payload for the event
+    this.emit(event.type, event.detail);
+};
+/**
+ * Emulates the W3C Browser based WebSocket interface using removeEventListener.
+ *
+ * @param {String} type A string representing the event type to remove
+ * @param {Function} listener callback
+ * @see https://developer.mozilla.org/en/DOM/element.removeEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+EventSource.prototype.removeEventListener = function removeEventListener(type, listener) {
+    if (typeof listener === 'function') {
+        listener._listener = undefined;
+        this.removeListener(type, listener);
+    }
+};
+/**
+ * W3C Event
+ *
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#interface-Event
+ * @api private
+ */
+function Event(type, optionalProperties) {
+    Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });
+    if (optionalProperties) {
+        for (var f in optionalProperties) {
+            if (optionalProperties.hasOwnProperty(f)) {
+                Object.defineProperty(this, f, { writable: false, value: optionalProperties[f], enumerable: true });
+            }
+        }
+    }
+}
+/**
+ * W3C MessageEvent
+ *
+ * @see http://www.w3.org/TR/webmessaging/#event-definitions
+ * @api private
+ */
+function MessageEvent(type, eventInitDict) {
+    Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });
+    for (var f in eventInitDict) {
+        if (eventInitDict.hasOwnProperty(f)) {
+            Object.defineProperty(this, f, { writable: false, value: eventInitDict[f], enumerable: true });
+        }
+    }
+}
+/**
+ * Returns a new object of headers that does not include any authorization and cookie headers
+ *
+ * @param {Object} headers An object of headers ({[headerName]: headerValue})
+ * @return {Object} a new object of headers
+ * @api private
+ */
+function removeUnsafeHeaders(headers) {
+    var safe = {};
+    for (var key in headers) {
+        if (/^(cookie|authorization)$/i.test(key)) {
+            continue;
+        }
+        safe[key] = headers[key];
+    }
+    return safe;
+}
+/**
+ * Transform an URL to a valid origin value.
+ *
+ * @param {String|Object} url URL to transform to it's origin.
+ * @returns {String} The origin.
+ * @api private
+ */
+function getOrigin(url) {
+    if (typeof url === 'string')
+        url = parse(url);
+    if (!url.protocol || !url.hostname)
+        return 'null';
+    return (url.protocol + '//' + url.host).toLowerCase();
+}

package/cjs/platform/getEventSource/node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventSource = exports.__restore = exports.__setEventSource = void 0;
+var __isCustom = false;
+var __eventSource;
+// This function is only exposed for testing purposes.
+function __setEventSource(eventSource) {
+    __eventSource = eventSource;
+    __isCustom = true;
+}
+exports.__setEventSource = __setEventSource;
+function __restore() {
+    __isCustom = false;
+}
+exports.__restore = __restore;
+function getEventSource() {
+    // returns EventSource at `eventsource` package. If not available, return global EventSource or undefined
+    try {
+        return __isCustom ? __eventSource : require('./eventsource');
+    }
+    catch (error) {
+        // eslint-disable-next-line no-undef -- Feature detection for EventSource
+        return typeof EventSource === 'function' ? EventSource : undefined;
+    }
+}
+exports.getEventSource = getEventSource;

package/cjs/platform/getFetch/browser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetch = void 0;
+// It doesn't return a ponyfill if global fetch is not available
+function getFetch() {
+    // eslint-disable-next-line no-undef
+    return typeof fetch === 'function' ? fetch : undefined;
+}
+exports.getFetch = getFetch;