@splitsoftware/splitio-commons 1.16.1-rc.1 → 1.16.1-rc.3

package/cjs/logger/messages/info.js

@@ -23,7 +23,7 @@ exports.codesInfo = warn_1.codesWarn.concat([
     [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 download of feature flags #%s. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+    [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.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mySegmentsUpdaterFactory = void 0;
 var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../logger/constants");
+var lang_1 = require("../../../utils/lang");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -21,23 +22,22 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notif
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (Array.isArray(segmentsData)) {
-            // Update the list of segment names available
-            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        if ((0, lang_1.isObject)(segmentsData[0])) {
+            // Add/Delete the segment names
+            segmentsData.forEach(function (_a) {
+                var name = _a.name, add = _a.add;
+                if (mySegmentsCache.isInSegment(name) !== add) {
+                    shouldNotifyUpdate = true;
+                    if (add)
+                        mySegmentsCache.addToSegment(name);
+                    else
+                        mySegmentsCache.removeFromSegment(name);
+                }
+            });
         }
         else {
-            // Add/Delete the segment
-            var name_1 = segmentsData.name, add = segmentsData.add;
-            if (mySegmentsCache.isInSegment(name_1) !== add) {
-                shouldNotifyUpdate = true;
-                if (add)
-                    mySegmentsCache.addToSegment(name_1);
-                else
-                    mySegmentsCache.removeFromSegment(name_1);
-            }
-            else {
-                shouldNotifyUpdate = false;
-            }
+            // Reset the list of segment names
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
         }
         // Notify update if required
         if (shouldNotifyUpdate || readyOnAlreadyExistentState) {

package/cjs/sync/streaming/parseUtils.js

@@ -80,15 +80,10 @@ function isInBitmap(bitmap, hash64hex) {
 exports.isInBitmap = isInBitmap;
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
 function parseFFUpdatePayload(compression, data) {
-    var avoidPrecisionLoss = false;
-    if (compression > 0)
-        return parseKeyList(data, compression, avoidPrecisionLoss);
-    else
-        return JSON.parse((0, base64_1.decodeFromBase64)(data));
+    return compression > 0 ?
+        parseKeyList(data, compression, false) :
+        JSON.parse((0, base64_1.decodeFromBase64)(data));
 }
 exports.parseFFUpdatePayload = parseFFUpdatePayload;

package/cjs/sync/streaming/pushManager.js

@@ -244,14 +244,14 @@ function pushManagerFactory(params, pollingManager) {
                     var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                     if (add !== undefined) {
                         isLS ?
-                            workerLarge && workerLarge.put(parsedData.changeNumber, {
-                                name: parsedData.largeSegments[0],
-                                add: add
-                            }) :
-                            worker.put(parsedData.changeNumber, {
-                                name: parsedData.segmentName,
-                                add: add
-                            });
+                            workerLarge && workerLarge.put(parsedData.changeNumber, [{
+                                    name: parsedData.largeSegments[0],
+                                    add: add
+                                }]) :
+                            worker.put(parsedData.changeNumber, [{
+                                    name: parsedData.segmentName,
+                                    add: add
+                                }]);
                     }
                 });
                 return;
@@ -264,16 +264,14 @@ function pushManagerFactory(params, pollingManager) {
                 (0, lang_1.forOwn)(clients, function (_a) {
                     var worker = _a.worker, workerLarge = _a.workerLarge;
                     isLS ?
-                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
-                            workerLarge.put(parsedData.changeNumber, {
-                                name: largeSegment,
-                                add: false
-                            });
-                        }) :
-                        worker.put(parsedData.changeNumber, {
-                            name: parsedData.segmentName,
+                        workerLarge && workerLarge.put(parsedData.changeNumber, parsedData.largeSegments.map(function (largeSegment) { return ({
+                            name: largeSegment,
                             add: false
-                        });
+                        }); })) :
+                        worker.put(parsedData.changeNumber, [{
+                                name: parsedData.segmentName,
+                                add: false
+                            }]);
                 });
                 return;
         }

package/esm/logger/messages/info.js

@@ -19,7 +19,7 @@ export var codesInfo = codesWarn.concat([
     [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 download of feature flags #%s. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+    [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.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -1,5 +1,6 @@
 import { timeout } from '../../../utils/promise/timeout';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { isObject } from '../../../utils/lang';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -18,23 +19,22 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (Array.isArray(segmentsData)) {
-            // Update the list of segment names available
-            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        if (isObject(segmentsData[0])) {
+            // Add/Delete the segment names
+            segmentsData.forEach(function (_a) {
+                var name = _a.name, add = _a.add;
+                if (mySegmentsCache.isInSegment(name) !== add) {
+                    shouldNotifyUpdate = true;
+                    if (add)
+                        mySegmentsCache.addToSegment(name);
+                    else
+                        mySegmentsCache.removeFromSegment(name);
+                }
+            });
         }
         else {
-            // Add/Delete the segment
-            var name_1 = segmentsData.name, add = segmentsData.add;
-            if (mySegmentsCache.isInSegment(name_1) !== add) {
-                shouldNotifyUpdate = true;
-                if (add)
-                    mySegmentsCache.addToSegment(name_1);
-                else
-                    mySegmentsCache.removeFromSegment(name_1);
-            }
-            else {
-                shouldNotifyUpdate = false;
-            }
+            // Reset the list of segment names
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
         }
         // Notify update if required
         if (shouldNotifyUpdate || readyOnAlreadyExistentState) {

package/esm/sync/streaming/parseUtils.js

@@ -74,14 +74,9 @@ export function isInBitmap(bitmap, hash64hex) {
 }
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
 export function parseFFUpdatePayload(compression, data) {
-    var avoidPrecisionLoss = false;
-    if (compression > 0)
-        return parseKeyList(data, compression, avoidPrecisionLoss);
-    else
-        return JSON.parse(decodeFromBase64(data));
+    return compression > 0 ?
+        parseKeyList(data, compression, false) :
+        JSON.parse(decodeFromBase64(data));
 }

package/esm/sync/streaming/pushManager.js

@@ -240,14 +240,14 @@ export function pushManagerFactory(params, pollingManager) {
                     var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                     if (add !== undefined) {
                         isLS ?
-                            workerLarge && workerLarge.put(parsedData.changeNumber, {
-                                name: parsedData.largeSegments[0],
-                                add: add
-                            }) :
-                            worker.put(parsedData.changeNumber, {
-                                name: parsedData.segmentName,
-                                add: add
-                            });
+                            workerLarge && workerLarge.put(parsedData.changeNumber, [{
+                                    name: parsedData.largeSegments[0],
+                                    add: add
+                                }]) :
+                            worker.put(parsedData.changeNumber, [{
+                                    name: parsedData.segmentName,
+                                    add: add
+                                }]);
                     }
                 });
                 return;
@@ -260,16 +260,14 @@ export function pushManagerFactory(params, pollingManager) {
                 forOwn(clients, function (_a) {
                     var worker = _a.worker, workerLarge = _a.workerLarge;
                     isLS ?
-                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
-                            workerLarge.put(parsedData.changeNumber, {
-                                name: largeSegment,
-                                add: false
-                            });
-                        }) :
-                        worker.put(parsedData.changeNumber, {
-                            name: parsedData.segmentName,
+                        workerLarge && workerLarge.put(parsedData.changeNumber, parsedData.largeSegments.map(function (largeSegment) { return ({
+                            name: largeSegment,
                             add: false
-                        });
+                        }); })) :
+                        worker.put(parsedData.changeNumber, [{
+                                name: parsedData.segmentName,
+                                add: false
+                            }]);
                 });
                 return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.16.1-rc.1",
+  "version": "1.16.1-rc.3",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/logger/messages/info.ts

@@ -22,7 +22,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [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 download of feature flags #%s. Reason: %s'],
-  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+  [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.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/src/sync/polling/types.ts

@@ -12,7 +12,7 @@ export type MySegmentsData = string[] | {
   name: string,
   /* action: `true` for add, and `false` for delete */
   add: boolean
-}
+}[]
 
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -4,6 +4,7 @@ import { timeout } from '../../../utils/promise/timeout';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
+import { isObject } from '../../../utils/lang';
 
 type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
 
@@ -36,19 +37,18 @@ export function mySegmentsUpdaterFactory(
   function updateSegments(segmentsData: MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if (Array.isArray(segmentsData)) {
-      // Update the list of segment names available
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    if (isObject(segmentsData[0])) {
+      // Add/Delete the segment names
+      (segmentsData as { name: string, add: boolean }[]).forEach(({ name, add }) => {
+        if (mySegmentsCache.isInSegment(name) !== add) {
+          shouldNotifyUpdate = true;
+          if (add) mySegmentsCache.addToSegment(name);
+          else mySegmentsCache.removeFromSegment(name);
+        }
+      });
     } else {
-      // Add/Delete the segment
-      const { name, add } = segmentsData;
-      if (mySegmentsCache.isInSegment(name) !== add) {
-        shouldNotifyUpdate = true;
-        if (add) mySegmentsCache.addToSegment(name);
-        else mySegmentsCache.removeFromSegment(name);
-      } else {
-        shouldNotifyUpdate = false;
-      }
+      // Reset the list of segment names
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData as string[]);
     }
 
     // Notify update if required

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -7,7 +7,7 @@ import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]> {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -15,7 +15,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
   let isHandlingEvent: boolean;
   let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
   let _delay: undefined | number;
-  let _delayTimeoutID: undefined | number;
+  let _delayTimeoutID: any;
   const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
   function __handleMySegmentsUpdateCall() {

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -9,7 +9,7 @@ import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]> {
 
   // Handles retries with CDN bypass per segment name
   function SegmentUpdateWorker(segment: string) {

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -14,7 +14,7 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;

package/src/sync/streaming/UpdateWorkers/types.ts

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
   stop(): void // clear scheduled tasks (backoff)
-  put(...args: any[]): void // handle new update event
+  put(...args: T): void // handle new update event
 }

package/src/sync/streaming/parseUtils.ts

@@ -1,6 +1,7 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { Compression, KeyList } from './SSEHandler/types';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -42,7 +43,7 @@ function decompress(data: string, compression: Compression) {
  * @returns {{a?: string[], r?: string[] }}
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss: boolean = true): KeyList {
+export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
   const binKeyList = decompress(data, compression);
   let strKeyList = Uint8ArrayToString(binKeyList);
   // replace numbers to strings, to avoid losing precision
@@ -80,14 +81,9 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined {
-  const avoidPrecisionLoss = false;
-  if (compression > 0)
-    return parseKeyList(data, compression, avoidPrecisionLoss);
-  else
-    return JSON.parse(decodeFromBase64(data));
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
+  return compression > 0 ?
+    parseKeyList(data, compression, false) :
+    JSON.parse(decodeFromBase64(data));
 }

package/src/sync/streaming/pushManager.ts

@@ -21,7 +21,6 @@ import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IUpdateWorker } from './UpdateWorkers/types';
 
 export function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
   const interval = parsedData.i || 60000;
@@ -72,7 +71,7 @@ export function pushManagerFactory(
   const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker, workerLarge?: IUpdateWorker }> = {};
+  const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker>, workerLarge?: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -284,14 +283,14 @@ export function pushManagerFactory(
           const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
           if (add !== undefined) {
             isLS ?
-              workerLarge && workerLarge.put(parsedData.changeNumber, {
+              workerLarge && workerLarge.put(parsedData.changeNumber, [{
                 name: parsedData.largeSegments[0],
                 add
-              }) :
-              worker.put(parsedData.changeNumber, {
+              }]) :
+              worker.put(parsedData.changeNumber, [{
                 name: parsedData.segmentName,
                 add
-              });
+              }]);
           }
         });
         return;
@@ -304,16 +303,14 @@ export function pushManagerFactory(
 
         forOwn(clients, ({ worker, workerLarge }) => {
           isLS ?
-            workerLarge && parsedData.largeSegments.forEach(largeSegment => {
-              workerLarge.put(parsedData.changeNumber, {
-                name: largeSegment,
-                add: false
-              });
-            }) :
-            worker.put(parsedData.changeNumber, {
+            workerLarge && workerLarge.put(parsedData.changeNumber, parsedData.largeSegments.map(largeSegment => ({
+              name: largeSegment,
+              add: false
+            }))) :
+            worker.put(parsedData.changeNumber, [{
               name: parsedData.segmentName,
               add: false
-            });
+            }]);
         });
         return;
     }

package/types/sync/polling/types.d.ts

@@ -12,7 +12,7 @@ export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, se
 export declare type MySegmentsData = string[] | {
     name: string;
     add: boolean;
-};
+}[];
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
 }
 export interface IPollingManager extends ITask {

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,8 +1,8 @@
-import { IMySegmentsSyncTask } from '../../polling/types';
+import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker;
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]>;

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -1,8 +1,9 @@
 import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { ISegmentsSyncTask } from '../../polling/types';
+import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker;
+export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]>;

package/types/sync/streaming/UpdateWorkers/SplitsUpdateWorker.d.ts

@@ -1,13 +1,14 @@
+import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { ISplitKillData } from '../SSEHandler/types';
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & {
     killSplit(event: ISplitKillData): void;
 };

package/types/sync/streaming/UpdateWorkers/types.d.ts

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
     stop(): void;
-    put(...args: any[]): void;
+    put(...args: T): void;
 }

package/types/sync/streaming/parseUtils.d.ts

@@ -1,4 +1,5 @@
 import { Compression, KeyList } from './SSEHandler/types';
+import { ISplit } from '../../dtos/types';
 /**
  * Decode, decompress and parse the provided 'data' into a KeyList object
  *
@@ -28,8 +29,5 @@ export declare function parseBitmap(data: string, compression: Compression): Uin
 export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export declare function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined;
+export declare function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined;