@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/esm/sync/streaming/SSEClient/index.js

@@ -1,83 +0,0 @@
-import { decorateHeaders } from '../../../services/decorateHeaders';
-import { isString } from '../../../utils/lang';
-import { objectAssign } from '../../../utils/lang/objectAssign';
-var ABLY_API_VERSION = '1.1';
-var CONTROL_CHANNEL_REGEX = /^control_/;
-/**
- * Build metadata headers for SSE connection.
- *
- * @param settings - Validated settings.
- * @returns Headers object
- */
-function buildSSEHeaders(settings) {
-    var headers = {
-        SplitSDKClientKey: isString(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',
-        SplitSDKVersion: settings.version,
-    };
-    // ip and hostname are false if IPAddressesEnabled is false
-    var _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
-    if (ip)
-        headers['SplitSDKMachineIP'] = ip;
-    if (hostname)
-        headers['SplitSDKMachineName'] = hostname;
-    return headers;
-}
-/**
- * Handles streaming connections with EventSource API
- */
-var SSEClient = /** @class */ (function () {
-    /**
-     * SSEClient constructor.
-     *
-     * @param settings - Validated settings.
-     * @param platform - object containing environment-specific dependencies
-     * @throws 'EventSource API is not available.' if EventSource is not available.
-     */
-    function SSEClient(settings, _a) {
-        var getEventSource = _a.getEventSource, getOptions = _a.getOptions;
-        this.settings = settings;
-        this.eventSource = getEventSource && getEventSource(settings);
-        // if eventSource is not available, throw an exception
-        if (!this.eventSource)
-            throw new Error('EventSource API is not available.');
-        this.headers = buildSSEHeaders(settings);
-        this.options = getOptions && getOptions(settings);
-    }
-    SSEClient.prototype.setEventHandler = function (handler) {
-        this.handler = handler;
-    };
-    /**
-     * Open the connection with a given authToken
-     */
-    SSEClient.prototype.open = function (authToken) {
-        var _a;
-        this.close(); // it closes connection if previously opened
-        var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {
-            var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-            return encodeURIComponent(params + channel);
-        }).join(',');
-        var url = this.settings.urls.streaming + "/sse?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + ABLY_API_VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
-        var isServerSide = !this.settings.core.key;
-        this.connection = new this.eventSource(
-        // For client-side SDKs, metadata is passed as query param to avoid CORS issues and because native EventSource implementations in browsers do not support headers
-        isServerSide ? url : url + ("&SplitSDKVersion=" + this.headers.SplitSDKVersion + "&SplitSDKClientKey=" + this.headers.SplitSDKClientKey), 
-        // For server-side SDKs, metadata is passed via headers
-        objectAssign(isServerSide ?
-            { headers: decorateHeaders(this.settings, this.headers) } :
-            ((_a = this.settings.sync.requestOptions) === null || _a === void 0 ? void 0 : _a.getHeaderOverrides) ?
-                { headers: decorateHeaders(this.settings, {}) } : // User must provide a window.EventSource polyfill that supports headers
-                {}, this.options));
-        if (this.handler) { // no need to check if SSEClient is used only by PushManager
-            this.connection.addEventListener('open', this.handler.handleOpen);
-            this.connection.addEventListener('message', this.handler.handleMessage);
-            this.connection.addEventListener('error', this.handler.handleError);
-        }
-    };
-    /** Close connection  */
-    SSEClient.prototype.close = function () {
-        if (this.connection)
-            this.connection.close();
-    };
-    return SSEClient;
-}());
-export { SSEClient };

package/esm/sync/streaming/SSEClient/types.js

@@ -1 +0,0 @@
-export {};

package/esm/sync/streaming/SSEHandler/NotificationKeeper.js

@@ -1,94 +0,0 @@
-import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
-import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
-var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
-var STREAMING_EVENT_TYPES = [OCCUPANCY_PRI, OCCUPANCY_SEC];
-/**
- * Factory of notification keeper, which process OCCUPANCY and CONTROL notifications and emits the corresponding push events.
- *
- * @param pushEmitter - emitter for events related to streaming support
- */
-// @TODO update logic to handle OCCUPANCY for any region and rename according to new spec (e.g.: PUSH_SUBSYSTEM_UP --> PUSH_SUBSYSTEM_UP)
-export function notificationKeeperFactory(pushEmitter, telemetryTracker) {
-    var channels = CONTROL_CHANNEL_REGEXS.map(function (regex) { return ({
-        regex: regex,
-        hasPublishers: true,
-        oTime: -1,
-        cTime: -1 // keep track of most recent control notification timestamp per channel
-    }); });
-    // false if the number of publishers is equal to 0 in all regions
-    var hasPublishers = true;
-    // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED
-    var hasResumed = true;
-    function getHasPublishers() {
-        return channels.some(function (c) { return c.hasPublishers; });
-    }
-    return {
-        handleOpen: function () {
-            telemetryTracker.streamingEvent(CONNECTION_ESTABLISHED);
-            pushEmitter.emit(PUSH_SUBSYSTEM_UP);
-        },
-        isStreamingUp: function () {
-            return hasResumed && hasPublishers;
-        },
-        handleOccupancyEvent: function (publishers, channel, timestamp) {
-            for (var i = 0; i < channels.length; i++) {
-                var c = channels[i];
-                if (c.regex.test(channel)) {
-                    telemetryTracker.streamingEvent(STREAMING_EVENT_TYPES[i], publishers);
-                    if (timestamp > c.oTime) {
-                        c.oTime = timestamp;
-                        c.hasPublishers = publishers !== 0;
-                        var hasPublishersNow = getHasPublishers();
-                        if (hasResumed) {
-                            if (!hasPublishersNow && hasPublishers) {
-                                pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);
-                            }
-                            else if (hasPublishersNow && !hasPublishers) {
-                                pushEmitter.emit(PUSH_SUBSYSTEM_UP);
-                            }
-                            // nothing to do when hasResumed === false:
-                            // streaming is already down for `!hasPublishersNow`, and cannot be up for `hasPublishersNow`
-                        }
-                        hasPublishers = hasPublishersNow;
-                    }
-                    return;
-                }
-            }
-        },
-        handleControlEvent: function (controlType, channel, timestamp) {
-            /* STREAMING_RESET control event is handled by PushManager directly since it doesn't require
-             * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
-             * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
-            if (controlType === ControlType.STREAMING_RESET) {
-                pushEmitter.emit(controlType);
-                return;
-            }
-            for (var i = 0; i < channels.length; i++) {
-                var c = channels[i];
-                if (c.regex.test(channel)) {
-                    if (timestamp > c.cTime) {
-                        c.cTime = timestamp;
-                        if (controlType === ControlType.STREAMING_DISABLED) {
-                            telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);
-                            pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-                        }
-                        else if (hasPublishers) {
-                            if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {
-                                telemetryTracker.streamingEvent(STREAMING_STATUS, PAUSED);
-                                pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);
-                            }
-                            else if (controlType === ControlType.STREAMING_RESUMED && !hasResumed) {
-                                telemetryTracker.streamingEvent(STREAMING_STATUS, ENABLED);
-                                pushEmitter.emit(PUSH_SUBSYSTEM_UP);
-                            }
-                            // nothing to do when hasPublishers === false:
-                            // streaming is already down for `STREAMING_PAUSED`, and cannot be up for `STREAMING_RESUMED`
-                        }
-                        hasResumed = controlType === ControlType.STREAMING_RESUMED;
-                    }
-                    return;
-                }
-            }
-        },
-    };
-}

package/esm/sync/streaming/SSEHandler/NotificationParser.js

@@ -1,36 +0,0 @@
-import { OCCUPANCY } from '../constants';
-import { isString } from '../../../utils/lang';
-/**
- * Parses the `data` JSON string, if exists, of a given SSE error notifications.
- * HTTP errors handled by Ably (e.g., 400 due to invalid token, 401 due to expired token, 500) have the `data` property.
- * Other network and HTTP errors do not have this property.
- *
- * @param error - The error event to parse
- * @returns parsed notification error
- * @throws SyntaxError if `error.data` is an invalid JSON string
- */
-export function errorParser(error) {
-    // @ts-ignore
-    if (isString(error.data))
-        error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'
-    return error;
-}
-/**
- * Parses the `data` JSON string of a given SSE message notifications.
- * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
- *
- * @param message - The message event to parse
- * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
- * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
- * @throws SyntaxError if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
- */
-export function messageParser(message) {
-    if (!message.data)
-        return;
-    var messageData = JSON.parse(message.data);
-    messageData.parsedData = JSON.parse(messageData.data);
-    // set the event type to OCCUPANCY, to handle all events uniformely
-    if (messageData.name && messageData.name === '[meta]occupancy')
-        messageData.parsedData.type = OCCUPANCY;
-    return messageData;
-}

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,93 +0,0 @@
-import { errorParser, messageParser } from './NotificationParser';
-import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
-import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
-import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
-/**
- * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.
- *
- * @param log - factory logger
- * @param pushEmitter - emitter for events related to streaming support
- */
-export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
-    var notificationKeeper = notificationKeeperFactory(pushEmitter, telemetryTracker);
-    function isRetryableError(error) {
-        if (error.parsedData && error.parsedData.code) {
-            // Ably error
-            var code = error.parsedData.code;
-            telemetryTracker.streamingEvent(ABLY_ERROR, code);
-            // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
-            if (40140 <= code && code <= 40149)
-                return true;
-            // Others 4XX errors (e.g., bad request from the SDK)
-            if (40000 <= code && code <= 49999)
-                return false;
-        }
-        else {
-            // network errors or 5XX HTTP errors
-            telemetryTracker.streamingEvent(SSE_CONNECTION_ERROR, NON_REQUESTED);
-        }
-        return true;
-    }
-    return {
-        handleOpen: function () {
-            notificationKeeper.handleOpen();
-        },
-        /* HTTP & Network errors */
-        handleError: function (error) {
-            var errorWithParsedData = error;
-            try {
-                errorWithParsedData = errorParser(error);
-            }
-            catch (err) {
-                log.warn(STREAMING_PARSING_ERROR_FAILS, [err]);
-            }
-            var errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
-            log.error(ERROR_STREAMING_SSE, [errorMessage]);
-            if (isRetryableError(errorWithParsedData)) {
-                pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-            }
-            else {
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-            }
-        },
-        /* NotificationProcessor */
-        handleMessage: function (message) {
-            var messageWithParsedData;
-            try {
-                messageWithParsedData = messageParser(message);
-                if (!messageWithParsedData)
-                    return; // Messages with empty data are ignored
-            }
-            catch (err) {
-                log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]);
-                return;
-            }
-            var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
-            log.debug(STREAMING_NEW_MESSAGE, [data]);
-            // we only handle update events if streaming is up
-            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
-                return;
-            switch (parsedData.type) {
-                /* update events */
-                case SPLIT_UPDATE:
-                case SEGMENT_UPDATE:
-                case MEMBERSHIPS_MS_UPDATE:
-                case MEMBERSHIPS_LS_UPDATE:
-                case SPLIT_KILL:
-                case RB_SEGMENT_UPDATE:
-                    pushEmitter.emit(parsedData.type, parsedData);
-                    break;
-                /* occupancy & control events, handled by NotificationManagerKeeper */
-                case OCCUPANCY:
-                    notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
-                    break;
-                case CONTROL:
-                    notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
-                    break;
-                default:
-                    break;
-            }
-        },
-    };
-}

package/esm/sync/streaming/SSEHandler/types.js

@@ -1,13 +0,0 @@
-export var Compression;
-(function (Compression) {
-    Compression[Compression["None"] = 0] = "None";
-    Compression[Compression["Gzip"] = 1] = "Gzip";
-    Compression[Compression["Zlib"] = 2] = "Zlib";
-})(Compression || (Compression = {}));
-export var UpdateStrategy;
-(function (UpdateStrategy) {
-    UpdateStrategy[UpdateStrategy["UnboundedFetchRequest"] = 0] = "UnboundedFetchRequest";
-    UpdateStrategy[UpdateStrategy["BoundedFetchRequest"] = 1] = "BoundedFetchRequest";
-    UpdateStrategy[UpdateStrategy["KeyList"] = 2] = "KeyList";
-    UpdateStrategy[UpdateStrategy["SegmentRemoval"] = 3] = "SegmentRemoval";
-})(UpdateStrategy || (UpdateStrategy = {}));

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -1,120 +0,0 @@
-import { Backoff } from '../../../utils/Backoff';
-import { MEMBERSHIPS } from '../../../utils/constants';
-import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
-/**
- * MySegmentsUpdateWorker factory
- */
-export function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker) {
-    var _a;
-    var _delay;
-    var _delayTimeoutID;
-    function createUpdateWorker(mySegmentsCache) {
-        var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-        var currentChangeNumber = -1;
-        var handleNewEvent = false;
-        var isHandlingEvent;
-        var cdnBypass;
-        var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-        var backoff = new Backoff(__handleMySegmentsUpdateCall);
-        function __handleMySegmentsUpdateCall() {
-            isHandlingEvent = true;
-            if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
-                handleNewEvent = false;
-                var currentMaxChangeNumber_1 = maxChangeNumber;
-                // fetch mySegments revalidating data if cached
-                var syncTask = _delay ?
-                    new Promise(function (res) {
-                        _delayTimeoutID = setTimeout(function () {
-                            _delay = undefined;
-                            mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
-                        }, _delay);
-                    }) :
-                    mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
-                syncTask.then(function (result) {
-                    if (!isHandlingEvent)
-                        return; // halt if `stop` has been called
-                    if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
-                        var storageChangeNumber = mySegmentsCache.getChangeNumber();
-                        currentChangeNumber = storageChangeNumber > -1 ?
-                            storageChangeNumber :
-                            Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-                    }
-                    if (handleNewEvent) {
-                        __handleMySegmentsUpdateCall();
-                    }
-                    else {
-                        if (_segmentsData)
-                            telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
-                        var attempts = backoff.attempts + 1;
-                        if (maxChangeNumber <= currentChangeNumber) {
-                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
-                            isHandlingEvent = false;
-                            return;
-                        }
-                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-                            backoff.scheduleCall();
-                            return;
-                        }
-                        if (cdnBypass) {
-                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
-                            isHandlingEvent = false;
-                        }
-                        else {
-                            backoff.reset();
-                            cdnBypass = true;
-                            __handleMySegmentsUpdateCall();
-                        }
-                    }
-                });
-            }
-            else {
-                isHandlingEvent = false;
-            }
-        }
-        return {
-            /**
-             * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
-             *
-             * @param changeNumber - change number of the notification
-             * @param segmentsData - data for KeyList or SegmentRemoval instant updates
-             * @param delay - optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
-             */
-            put: function (mySegmentsData, payload, delay) {
-                var type = mySegmentsData.type, cn = mySegmentsData.cn;
-                // Discard event if it is outdated or there is a pending fetch request (_delay is set), but update target change number
-                if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber)
-                    return;
-                maxChangeNumber = cn;
-                if (_delay)
-                    return;
-                handleNewEvent = true;
-                cdnBypass = false;
-                _segmentsData = payload && { type: type, cn: cn, added: payload.added, removed: payload.removed };
-                _delay = delay;
-                if (backoff.timeoutID || !isHandlingEvent)
-                    __handleMySegmentsUpdateCall();
-                backoff.reset();
-            },
-            stop: function () {
-                clearTimeout(_delayTimeoutID);
-                _delay = undefined;
-                isHandlingEvent = false;
-                backoff.reset();
-            }
-        };
-    }
-    var updateWorkers = (_a = {},
-        _a[MEMBERSHIPS_MS_UPDATE] = createUpdateWorker(storage.segments),
-        _a[MEMBERSHIPS_LS_UPDATE] = createUpdateWorker(storage.largeSegments),
-        _a);
-    return {
-        put: function (mySegmentsData, payload, delay) {
-            updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
-        },
-        stop: function () {
-            updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
-            updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
-        }
-    };
-}

package/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -1,88 +0,0 @@
-import { Backoff } from '../../../utils/Backoff';
-import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_RETRIES, FETCH_BACKOFF_MAX_WAIT } from './constants';
-/**
- * SegmentsUpdateWorker factory
- */
-export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
-    // Handles retries with CDN bypass per segment name
-    function SegmentUpdateWorker(segment) {
-        var maxChangeNumber = 0;
-        var handleNewEvent = false;
-        var isHandlingEvent;
-        var cdnBypass;
-        var backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-        function __handleSegmentUpdateCall() {
-            isHandlingEvent = true;
-            if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
-                handleNewEvent = false;
-                // fetch segments revalidating data if cached
-                segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {
-                    if (!isHandlingEvent)
-                        return; // halt if `stop` has been called
-                    if (handleNewEvent) {
-                        __handleSegmentUpdateCall();
-                    }
-                    else {
-                        var attempts = backoff.attempts + 1;
-                        if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
-                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
-                            isHandlingEvent = false;
-                            return;
-                        }
-                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-                            backoff.scheduleCall();
-                            return;
-                        }
-                        if (cdnBypass) {
-                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
-                            isHandlingEvent = false;
-                        }
-                        else {
-                            backoff.reset();
-                            cdnBypass = true;
-                            __handleSegmentUpdateCall();
-                        }
-                    }
-                });
-            }
-            else {
-                isHandlingEvent = false;
-            }
-        }
-        return {
-            put: function (changeNumber) {
-                var currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
-                if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
-                    return;
-                maxChangeNumber = changeNumber;
-                handleNewEvent = true;
-                cdnBypass = false;
-                if (backoff.timeoutID || !isHandlingEvent)
-                    __handleSegmentUpdateCall();
-                backoff.reset();
-            },
-            stop: function () {
-                isHandlingEvent = false;
-                backoff.reset();
-            }
-        };
-    }
-    var segments = {};
-    return {
-        /**
-         * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-         *
-         * @param changeNumber - change number of the SEGMENT_UPDATE notification
-         * @param segmentName - segment name of the SEGMENT_UPDATE notification
-         */
-        put: function (_a) {
-            var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
-            if (!segments[segmentName])
-                segments[segmentName] = SegmentUpdateWorker(segmentName);
-            segments[segmentName].put(changeNumber);
-        },
-        stop: function () {
-            Object.keys(segments).forEach(function (segmentName) { return segments[segmentName].stop(); });
-        }
-    };
-}

package/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -1,132 +0,0 @@
-import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
-import { Backoff } from '../../../utils/Backoff';
-import { SPLITS } from '../../../utils/constants';
-import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
-import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
-/**
- * SplitsUpdateWorker factory
- */
-export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
-    var ff = SplitsUpdateWorker(storage.splits);
-    var rbs = SplitsUpdateWorker(storage.rbSegments);
-    function SplitsUpdateWorker(cache) {
-        var maxChangeNumber = -1;
-        var handleNewEvent = false;
-        var isHandlingEvent;
-        var cdnBypass;
-        var instantUpdate;
-        var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-        function __handleSplitUpdateCall() {
-            isHandlingEvent = true;
-            if (maxChangeNumber > cache.getChangeNumber()) {
-                handleNewEvent = false;
-                // fetch splits revalidating data if cached
-                splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(function () {
-                    if (!isHandlingEvent)
-                        return; // halt if `stop` has been called
-                    if (handleNewEvent) {
-                        __handleSplitUpdateCall();
-                    }
-                    else {
-                        if (instantUpdate)
-                            telemetryTracker.trackUpdatesFromSSE(SPLITS);
-                        // fetch new registered segments for server-side API. Not retrying on error
-                        if (segmentsSyncTask)
-                            segmentsSyncTask.execute(true);
-                        var attempts = backoff.attempts + 1;
-                        if (ff.isSync() && rbs.isSync()) {
-                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
-                            isHandlingEvent = false;
-                            return;
-                        }
-                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-                            backoff.scheduleCall();
-                            return;
-                        }
-                        if (cdnBypass) {
-                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
-                            isHandlingEvent = false;
-                        }
-                        else {
-                            backoff.reset();
-                            cdnBypass = true;
-                            __handleSplitUpdateCall();
-                        }
-                    }
-                });
-            }
-            else {
-                isHandlingEvent = false;
-            }
-        }
-        return {
-            /**
-             * Invoked by NotificationProcessor on SPLIT_UPDATE or RB_SEGMENT_UPDATE event
-             *
-             * @param changeNumber - change number of the notification
-             */
-            put: function (_a, payload) {
-                var changeNumber = _a.changeNumber, pcn = _a.pcn, type = _a.type;
-                var currentChangeNumber = cache.getChangeNumber();
-                if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
-                    return;
-                maxChangeNumber = changeNumber;
-                handleNewEvent = true;
-                cdnBypass = false;
-                instantUpdate = undefined;
-                if (payload && currentChangeNumber === pcn) {
-                    instantUpdate = { payload: payload, changeNumber: changeNumber, type: type };
-                }
-                if (backoff.timeoutID || !isHandlingEvent)
-                    __handleSplitUpdateCall();
-                backoff.reset();
-            },
-            stop: function () {
-                isHandlingEvent = false;
-                backoff.reset();
-            },
-            isSync: function () {
-                return maxChangeNumber <= cache.getChangeNumber();
-            }
-        };
-    }
-    return {
-        put: function (parsedData) {
-            if (parsedData.d && parsedData.c !== undefined) {
-                try {
-                    var payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
-                    if (payload) {
-                        (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
-                        return;
-                    }
-                }
-                catch (e) {
-                    log.warn(STREAMING_PARSING_SPLIT_UPDATE, [parsedData.type, e]);
-                }
-            }
-            (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData);
-        },
-        /**
-         * Invoked by NotificationProcessor on SPLIT_KILL event
-         *
-         * @param changeNumber - change number of the notification
-         * @param splitName - name of split to kill
-         * @param defaultTreatment - default treatment value
-         */
-        killSplit: function (_a) {
-            var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-            if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
-                // trigger an SDK_UPDATE if Split was killed locally
-                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
-            }
-            // queues the SplitChanges fetch (only if changeNumber is newer)
-            ff.put({ changeNumber: changeNumber });
-        },
-        stop: function () {
-            ff.stop();
-            rbs.stop();
-        }
-    };
-}

package/esm/sync/streaming/UpdateWorkers/constants.js

@@ -1,3 +0,0 @@
-export var FETCH_BACKOFF_BASE = 10000; // backoff base starting at 10 seconds
-export var FETCH_BACKOFF_MAX_WAIT = 60000; // don't wait for more than 1 minute
-export var FETCH_BACKOFF_MAX_RETRIES = 10; // max retries