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

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

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSEClient = void 0;
-var decorateHeaders_1 = require("../../../services/decorateHeaders");
-var lang_1 = require("../../../utils/lang");
-var objectAssign_1 = require("../../../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: (0, lang_1.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
-        (0, objectAssign_1.objectAssign)(isServerSide ?
-            { headers: (0, decorateHeaders_1.decorateHeaders)(this.settings, this.headers) } :
-            ((_a = this.settings.sync.requestOptions) === null || _a === void 0 ? void 0 : _a.getHeaderOverrides) ?
-                { headers: (0, decorateHeaders_1.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;
-}());
-exports.SSEClient = SSEClient;

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notificationKeeperFactory = void 0;
-var constants_1 = require("../../../utils/constants");
-var constants_2 = require("../constants");
-var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
-var STREAMING_EVENT_TYPES = [constants_1.OCCUPANCY_PRI, constants_1.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)
-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(constants_1.CONNECTION_ESTABLISHED);
-            pushEmitter.emit(constants_2.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(constants_2.PUSH_SUBSYSTEM_DOWN);
-                            }
-                            else if (hasPublishersNow && !hasPublishers) {
-                                pushEmitter.emit(constants_2.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 === constants_2.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 === constants_2.ControlType.STREAMING_DISABLED) {
-                            telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.DISABLED);
-                            pushEmitter.emit(constants_2.PUSH_NONRETRYABLE_ERROR);
-                        }
-                        else if (hasPublishers) {
-                            if (controlType === constants_2.ControlType.STREAMING_PAUSED && hasResumed) {
-                                telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.PAUSED);
-                                pushEmitter.emit(constants_2.PUSH_SUBSYSTEM_DOWN);
-                            }
-                            else if (controlType === constants_2.ControlType.STREAMING_RESUMED && !hasResumed) {
-                                telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.ENABLED);
-                                pushEmitter.emit(constants_2.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 === constants_2.ControlType.STREAMING_RESUMED;
-                    }
-                    return;
-                }
-            }
-        },
-    };
-}
-exports.notificationKeeperFactory = notificationKeeperFactory;

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

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.messageParser = exports.errorParser = void 0;
-var constants_1 = require("../constants");
-var lang_1 = require("../../../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
- */
-function errorParser(error) {
-    // @ts-ignore
-    if ((0, lang_1.isString)(error.data))
-        error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'
-    return error;
-}
-exports.errorParser = errorParser;
-/**
- * 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
- */
-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 = constants_1.OCCUPANCY;
-    return messageData;
-}
-exports.messageParser = messageParser;

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

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSEHandlerFactory = void 0;
-var NotificationParser_1 = require("./NotificationParser");
-var NotificationKeeper_1 = require("./NotificationKeeper");
-var constants_1 = require("../constants");
-var constants_2 = require("../../../logger/constants");
-var constants_3 = require("../../../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
- */
-function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
-    var notificationKeeper = (0, NotificationKeeper_1.notificationKeeperFactory)(pushEmitter, telemetryTracker);
-    function isRetryableError(error) {
-        if (error.parsedData && error.parsedData.code) {
-            // Ably error
-            var code = error.parsedData.code;
-            telemetryTracker.streamingEvent(constants_3.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(constants_3.SSE_CONNECTION_ERROR, constants_3.NON_REQUESTED);
-        }
-        return true;
-    }
-    return {
-        handleOpen: function () {
-            notificationKeeper.handleOpen();
-        },
-        /* HTTP & Network errors */
-        handleError: function (error) {
-            var errorWithParsedData = error;
-            try {
-                errorWithParsedData = (0, NotificationParser_1.errorParser)(error);
-            }
-            catch (err) {
-                log.warn(constants_2.STREAMING_PARSING_ERROR_FAILS, [err]);
-            }
-            var errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
-            log.error(constants_2.ERROR_STREAMING_SSE, [errorMessage]);
-            if (isRetryableError(errorWithParsedData)) {
-                pushEmitter.emit(constants_1.PUSH_RETRYABLE_ERROR);
-            }
-            else {
-                pushEmitter.emit(constants_1.PUSH_NONRETRYABLE_ERROR);
-            }
-        },
-        /* NotificationProcessor */
-        handleMessage: function (message) {
-            var messageWithParsedData;
-            try {
-                messageWithParsedData = (0, NotificationParser_1.messageParser)(message);
-                if (!messageWithParsedData)
-                    return; // Messages with empty data are ignored
-            }
-            catch (err) {
-                log.warn(constants_2.STREAMING_PARSING_MESSAGE_FAILS, [err]);
-                return;
-            }
-            var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
-            log.debug(constants_2.STREAMING_NEW_MESSAGE, [data]);
-            // we only handle update events if streaming is up
-            if (!notificationKeeper.isStreamingUp() && [constants_1.OCCUPANCY, constants_1.CONTROL].indexOf(parsedData.type) === -1)
-                return;
-            switch (parsedData.type) {
-                /* update events */
-                case constants_1.SPLIT_UPDATE:
-                case constants_1.SEGMENT_UPDATE:
-                case constants_1.MEMBERSHIPS_MS_UPDATE:
-                case constants_1.MEMBERSHIPS_LS_UPDATE:
-                case constants_1.SPLIT_KILL:
-                case constants_1.RB_SEGMENT_UPDATE:
-                    pushEmitter.emit(parsedData.type, parsedData);
-                    break;
-                /* occupancy & control events, handled by NotificationManagerKeeper */
-                case constants_1.OCCUPANCY:
-                    notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
-                    break;
-                case constants_1.CONTROL:
-                    notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
-                    break;
-                default:
-                    break;
-            }
-        },
-    };
-}
-exports.SSEHandlerFactory = SSEHandlerFactory;

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateStrategy = exports.Compression = void 0;
-var Compression;
-(function (Compression) {
-    Compression[Compression["None"] = 0] = "None";
-    Compression[Compression["Gzip"] = 1] = "Gzip";
-    Compression[Compression["Zlib"] = 2] = "Zlib";
-})(Compression = exports.Compression || (exports.Compression = {}));
-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 = exports.UpdateStrategy || (exports.UpdateStrategy = {}));

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

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySegmentsUpdateWorker = void 0;
-var Backoff_1 = require("../../../utils/Backoff");
-var constants_1 = require("../../../utils/constants");
-var constants_2 = require("./constants");
-var constants_3 = require("../constants");
-/**
- * MySegmentsUpdateWorker factory
- */
-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_1.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(constants_1.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 < constants_2.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[constants_3.MEMBERSHIPS_MS_UPDATE] = createUpdateWorker(storage.segments),
-        _a[constants_3.MEMBERSHIPS_LS_UPDATE] = createUpdateWorker(storage.largeSegments),
-        _a);
-    return {
-        put: function (mySegmentsData, payload, delay) {
-            updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
-        },
-        stop: function () {
-            updateWorkers[constants_3.MEMBERSHIPS_MS_UPDATE].stop();
-            updateWorkers[constants_3.MEMBERSHIPS_LS_UPDATE].stop();
-        }
-    };
-}
-exports.MySegmentsUpdateWorker = MySegmentsUpdateWorker;

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

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SegmentsUpdateWorker = void 0;
-var Backoff_1 = require("../../../utils/Backoff");
-var constants_1 = require("./constants");
-/**
- * SegmentsUpdateWorker factory
- */
-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_1.Backoff(__handleSegmentUpdateCall, constants_1.FETCH_BACKOFF_BASE, constants_1.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 < constants_1.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(); });
-        }
-    };
-}
-exports.SegmentsUpdateWorker = SegmentsUpdateWorker;