@splitsoftware/splitio-commons 2.0.0-rc.3 → 2.0.0-rc.5

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

@@ -51,8 +51,8 @@ interface ISplitMutations {
  * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
  * If there are set filter defined, names filter is ignored
  *
- * @param featureFlag feature flag to be evaluated
- * @param filters splitFiltersValidation bySet | byName
+ * @param featureFlag - feature flag to be evaluated
+ * @param filters - splitFiltersValidation bySet | byName
  */
 function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
   const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
@@ -100,13 +100,13 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
  *  - updates `splitsCache`
  *  - uses `splitsEventEmitter` to emit events related to split data updates
  *
- * @param log  Logger instance
- * @param splitChangesFetcher  Fetcher of `/splitChanges`
- * @param splits  Splits storage, with sync or async methods
- * @param segments  Segments storage, with sync or async methods
- * @param splitsEventEmitter  Optional readiness manager. Not required for synchronizer or producer mode.
- * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
- * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
+ * @param log -  Logger instance
+ * @param splitChangesFetcher -  Fetcher of `/splitChanges`
+ * @param splits -  Splits storage, with sync or async methods
+ * @param segments -  Segments storage, with sync or async methods
+ * @param splitsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
+ * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
+ * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
 export function splitChangesUpdaterFactory(
   log: ILogger,
@@ -142,14 +142,14 @@ export function splitChangesUpdaterFactory(
    * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
    * Returned promise will not be rejected.
    *
-   * @param {boolean | undefined} noCache true to revalidate data to fetch
-   * @param {boolean | undefined} till query param to bypass CDN requests
+   * @param noCache - true to revalidate data to fetch
+   * @param till - query param to bypass CDN requests
    */
   return function splitChangesUpdater(noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) {
 
     /**
-     * @param {number} since current changeNumber at splitsCache
-     * @param {number} retry current number of retry attempts
+     * @param since - current changeNumber at splitsCache
+     * @param retry - current number of retry attempts
      */
     function _splitChangesUpdater(since: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);

package/src/sync/streaming/AuthClient/index.ts

@@ -8,13 +8,13 @@ import { hash } from '../../../utils/murmur3/murmur3';
 /**
  * Factory of authentication function.
  *
- * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ * @param fetchAuth - `SplitAPI.fetchAuth` endpoint
  */
 export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
 
   /**
    * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-   * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
+   * @param userKeys - set of user Keys to track membership updates. It is undefined for server-side API.
    */
   return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
     return fetchAuth(userKeys)

package/src/sync/streaming/SSEClient/index.ts

@@ -14,8 +14,8 @@ const CONTROL_CHANNEL_REGEX = /^control_/;
 /**
  * Build metadata headers for SSE connection.
  *
- * @param {ISettings} settings Validated settings.
- * @returns {Record<string, string>} Headers object
+ * @param settings - Validated settings.
+ * @returns Headers object
  */
 function buildSSEHeaders(settings: ISettings) {
   const headers: Record<string, string> = {
@@ -45,8 +45,8 @@ export class SSEClient implements ISSEClient {
   /**
    * SSEClient constructor.
    *
-   * @param settings Validated settings.
-   * @param platform object containing environment-specific dependencies
+   * @param settings - Validated settings.
+   * @param platform - object containing environment-specific dependencies
    * @throws 'EventSource API is not available.' if EventSource is not available.
    */
   constructor(private settings: ISettings, { getEventSource, getOptions }: IPlatform) {
@@ -64,9 +64,6 @@ export class SSEClient implements ISSEClient {
 
   /**
    * Open the connection with a given authToken
-   *
-   * @param {IAuthTokenPushEnabled} authToken
-   * @throws {TypeError} Will throw an error if `authToken` is undefined
    */
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened

package/src/sync/streaming/SSEHandler/NotificationKeeper.ts

@@ -10,7 +10,7 @@ const STREAMING_EVENT_TYPES: StreamingEventType[] = [OCCUPANCY_PRI, OCCUPANCY_SE
 /**
  * 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
+ * @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: IPushEventEmitter, telemetryTracker: ITelemetryTracker) {

package/src/sync/streaming/SSEHandler/NotificationParser.ts

@@ -7,8 +7,9 @@ import { INotificationMessage, INotificationError } from './types';
  * 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 {Object} error
- * @throws {SyntaxError} if `error.data` is an invalid JSON string
+ * @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: Event): INotificationError {
   // @ts-ignore
@@ -21,10 +22,10 @@ export function errorParser(error: Event): INotificationError {
  * 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
+ * @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
+ * @throws SyntaxError if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
  */
 export function messageParser(message: MessageEvent): INotificationMessage | undefined {
   if (!message.data) return;

package/src/sync/streaming/SSEHandler/index.ts

@@ -12,8 +12,8 @@ import { ITelemetryTracker } from '../../../trackers/types';
 /**
  * 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
+ * @param log - factory logger
+ * @param pushEmitter - emitter for events related to streaming support
  */
 export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker): ISseEventHandler {
 

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

@@ -87,9 +87,9 @@ export function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync,
       /**
        * 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
+       * @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(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
         const { type, cn } = mySegmentsData;

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

@@ -84,8 +84,8 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
     /**
      * Invoked by NotificationProcessor on SEGMENT_UPDATE event
      *
-     * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
-     * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
+     * @param changeNumber - change number of the SEGMENT_UPDATE notification
+     * @param segmentName - segment name of the SEGMENT_UPDATE notification
      */
     put({ changeNumber, segmentName }: ISegmentUpdateData) {
       if (!segments[segmentName]) segments[segmentName] = SegmentUpdateWorker(segmentName);

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

@@ -69,7 +69,7 @@ export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync,
   /**
    * Invoked by NotificationProcessor on SPLIT_UPDATE event
    *
-   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
+   * @param changeNumber - change number of the SPLIT_UPDATE notification
    */
   function put({ changeNumber, pcn }: ISplitUpdateData, _payload?: ISplit) {
     const currentChangeNumber = splitsCache.getChangeNumber();
@@ -94,9 +94,9 @@ export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync,
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
-     * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-     * @param {string} splitName name of split to kill
-     * @param {string} defaultTreatment default treatment value
+     * @param changeNumber - change number of the SPLIT_UPDATE notification
+     * @param splitName - name of split to kill
+     * @param defaultTreatment - default treatment value
      */
     killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
       if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {

package/src/sync/streaming/parseUtils.ts

@@ -19,9 +19,9 @@ function StringToUint8Array(myString: string) {
 /**
  * Decode and decompress 'data' with 'compression' algorithm
  *
- * @param {string} data
- * @param {number} compression 1 GZIP, 2 ZLIB
- * @returns {Uint8Array}
+ * @param data - base64 encoded string
+ * @param compression - 1 GZIP, 2 ZLIB
+ * @returns
  * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
  */
 function decompress(data: string, compression: Compression) {
@@ -37,10 +37,10 @@ function decompress(data: string, compression: Compression) {
 /**
  * Decode, decompress and parse the provided 'data' into a KeyList object
  *
- * @param {string} data
- * @param {number} compression
- * @param {boolean} avoidPrecisionLoss true as default, set it as false if dont need to avoid precission loss
- * @returns {{a?: string[], r?: string[] }}
+ * @param data - base64 encoded string
+ * @param compression - 1 GZIP, 2 ZLIB
+ * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
+ * @returns keyList
  * @throws if data string cannot be decoded, decompressed or parsed
  */
 export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
@@ -54,9 +54,9 @@ export function parseKeyList(data: string, compression: Compression, avoidPrecis
 /**
  * Decode, decompress and parse the provided 'data' into a Bitmap object
  *
- * @param {string} data
- * @param {number} compression
- * @returns {Uint8Array}
+ * @param data - base64 encoded string
+ * @param compression - 1 GZIP, 2 ZLIB
+ * @returns Bitmap
  * @throws if data string cannot be decoded or decompressed
  */
 export function parseBitmap(data: string, compression: Compression) {
@@ -66,9 +66,9 @@ export function parseBitmap(data: string, compression: Compression) {
 /**
  * Check if the 'bitmap' bit at 'hash64hex' position is 1
  *
- * @param {Uint8Array} bitmap
- * @param {string} hash64hex 16-chars string, representing a number in hexa
- * @returns {boolean}
+ * @param bitmap - Uint8Array bitmap
+ * @param hash64hex - 16-chars string, representing a number in hexa
+ * @returns whether the provided 'hash64hex' index is set in the bitmap
  */
 export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
   // using the lowest 32 bits as index, to avoid losing precision when converting to number

package/src/sync/streaming/types.ts

@@ -1,7 +1,7 @@
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, INotificationData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
-import { IEventEmitter } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { ControlType } from './constants';
 
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -34,7 +34,7 @@ type IParsedData<T extends IPushEvent> =
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it
  */
-export interface IPushEventEmitter extends IEventEmitter {
+export interface IPushEventEmitter extends SplitIO.IEventEmitter {
   once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
   on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
   emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>): boolean;

package/src/sync/submitters/impressionsSubmitter.ts

@@ -1,5 +1,5 @@
 import { groupBy, forOwn } from '../../utils/lang';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { submitterFactory } from './submitter';
 import { ImpressionsPayload } from './types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
@@ -10,7 +10,7 @@ const DATA_NAME = 'impressions';
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels: boolean, data: ImpressionDTO[]): ImpressionsPayload {
+export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
   let groupedByFeature = groupBy(data, 'feature');
   let dto: ImpressionsPayload = [];
 

package/src/sync/submitters/telemetrySubmitter.ts

@@ -3,7 +3,8 @@ import { submitterFactory, firstPushWindowDecorator } from './submitter';
 import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
 import { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
-import { ConsentStatus, ISettings, SDKMode, SplitIO } from '../../types';
+import { ISettings } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
@@ -27,7 +28,7 @@ const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,
   [CONSENT_GRANTED]: 2,
   [CONSENT_DECLINED]: 3
-} as Record<ConsentStatus, number>;
+} as Record<SplitIO.ConsentStatus, number>;
 
 function getActiveFactories() {
   return Object.keys(usedKeysMap).length;
@@ -51,7 +52,7 @@ function getTelemetryFlagSetsStats(splitFiltersValidation: ISplitFiltersValidati
   return { flagSetsTotal, flagSetsIgnored };
 }
 
-export function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats {
+export function getTelemetryConfigStats(mode: SplitIO.SDKMode, storageType: string): TelemetryConfigStats {
   return {
     oM: OPERATION_MODE_MAP[mode], // @ts-ignore lower case of storage type
     st: storageType.toLowerCase(),

package/src/sync/submitters/types.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-use-before-define */
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {

package/src/sync/syncManagerOnline.ts

@@ -14,9 +14,9 @@ import { ISdkFactoryContextSync } from '../sdkFactory/types';
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
  *
- * @param pollingManagerFactory allows to specialize the SyncManager for server-side or client-side API by passing
+ * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
- * @param pushManagerFactory optional to build a SyncManager with or without streaming support
+ * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
  */
 export function syncManagerOnlineFactory(
   pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,

package/src/sync/syncTask.ts

@@ -6,10 +6,10 @@ import { ISyncTask } from './types';
  * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.
  * The task can be also executed by calling the "execute" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).
  *
- * @param log  Logger instance.
- * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
- * @param period  Period in milliseconds to execute the task.
- * @param taskName  Optional task name for logging.
+ * @param log -  Logger instance.
+ * @param task -  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
+ * @param period -  Period in milliseconds to execute the task.
+ * @param taskName -  Optional task name for logging.
  * @returns A sync task that wraps the given task.
  */
 export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {

package/src/trackers/eventTracker.ts

@@ -2,7 +2,8 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IEventsCacheBase, ITelemetryCacheAsync, ITelemetryCacheSync } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
-import { ISettings, SplitIO } from '../types';
+import { ISettings } from '../types';
+import SplitIO from '../../types/splitio';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
 import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
@@ -10,8 +11,8 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
- * @param eventsCache cache to save events
- * @param integrationsManager optional event handler used for integrations
+ * @param eventsCache - cache to save events
+ * @param integrationsManager - optional event handler used for integrations
  */
 export function eventTrackerFactory(
   settings: ISettings,

package/src/trackers/impressionObserver/ImpressionObserver.ts

@@ -1,17 +1,17 @@
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { LRUCache } from '../../utils/LRUCache';
 import { IImpressionObserver } from './types';
 
 export class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
   private cache: LRUCache<K, number>;
-  private hasher: (impression: ImpressionDTO) => K;
+  private hasher: (impression: SplitIO.ImpressionDTO) => K;
 
-  constructor(size: number, hasher: (impression: ImpressionDTO) => K) {
+  constructor(size: number, hasher: (impression: SplitIO.ImpressionDTO) => K) {
     this.cache = new LRUCache(size);
     this.hasher = hasher;
   }
 
-  testAndSet(impression: ImpressionDTO) {
+  testAndSet(impression: SplitIO.ImpressionDTO) {
     const hash = this.hasher(impression);
     const previous = this.cache.get(hash);
     this.cache.set(hash, impression.time);

package/src/trackers/impressionObserver/buildKey.ts

@@ -1,5 +1,5 @@
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 
-export function buildKey(impression: ImpressionDTO) {
+export function buildKey(impression: SplitIO.ImpressionDTO) {
   return `${impression.keyName}:${impression.feature}:${impression.treatment}:${impression.label}:${impression.changeNumber}`;
 }

package/src/trackers/impressionObserver/impressionObserverCS.ts

@@ -1,9 +1,9 @@
 import { ImpressionObserver } from './ImpressionObserver';
 import { hash } from '../../utils/murmur3/murmur3';
 import { buildKey } from './buildKey';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 
-export function hashImpression32(impression: ImpressionDTO) {
+export function hashImpression32(impression: SplitIO.ImpressionDTO) {
   return hash(buildKey(impression));
 }
 

package/src/trackers/impressionObserver/impressionObserverSS.ts

@@ -1,9 +1,9 @@
 import { ImpressionObserver } from './ImpressionObserver';
 import { hash128 } from '../../utils/murmur3/murmur3_128_x86';
 import { buildKey } from './buildKey';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 
-export function hashImpression128(impression: ImpressionDTO) {
+export function hashImpression128(impression: SplitIO.ImpressionDTO) {
   return hash128(buildKey(impression));
 }
 

package/src/trackers/impressionObserver/types.ts

@@ -1,5 +1,5 @@
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 
 export interface IImpressionObserver {
-  testAndSet(impression: ImpressionDTO): number | undefined
+  testAndSet(impression: SplitIO.ImpressionDTO): number | undefined
 }

package/src/trackers/impressionsTracker.ts

@@ -2,18 +2,19 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
 import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
-import { SplitIO, ImpressionDTO, ISettings } from '../types';
+import { ISettings } from '../types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
+import SplitIO from '../../types/splitio';
 
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
- * @param impressionsCache cache to save impressions
- * @param metadata runtime metadata (ip, hostname and version)
- * @param impressionListener optional impression listener
- * @param integrationsManager optional integrations manager
- * @param strategy strategy for impressions tracking.
+ * @param impressionsCache - cache to save impressions
+ * @param metadata - runtime metadata (ip, hostname and version)
+ * @param impressionListener - optional impression listener
+ * @param integrationsManager - optional integrations manager
+ * @param strategy - strategy for impressions tracking.
  */
 export function impressionsTrackerFactory(
   settings: ISettings,
@@ -27,7 +28,7 @@ export function impressionsTrackerFactory(
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
 
   return {
-    track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
+    track(impressions: SplitIO.ImpressionDTO[], attributes?: SplitIO.Attributes) {
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;

package/src/trackers/strategy/strategyDebug.ts

@@ -1,11 +1,11 @@
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { IImpressionObserver } from '../impressionObserver/types';
 import { IStrategy } from '../types';
 
 /**
  * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
  *
- * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances
+ * @param impressionsObserver - impression observer. Previous time (pt property) is included in impression instances
  * @returns IStrategyResult
  */
 export function strategyDebugFactory(
@@ -13,7 +13,7 @@ export function strategyDebugFactory(
 ): IStrategy {
 
   return {
-    process(impressions: ImpressionDTO[]) {
+    process(impressions: SplitIO.ImpressionDTO[]) {
       impressions.forEach((impression) => {
         // Adds previous time if it is enabled
         impression.pt = impressionsObserver.testAndSet(impression);

package/src/trackers/strategy/strategyNone.ts

@@ -1,12 +1,12 @@
 import { IImpressionCountsCacheBase } from '../../storages/types';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { IStrategy, IUniqueKeysTracker } from '../types';
 
 /**
  * None strategy for impressions tracker.
  *
- * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
+ * @param impressionsCounter - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @param uniqueKeysTracker - unique keys tracker in charge of tracking the unique keys per split.
  * @returns IStrategyResult
  */
 export function strategyNoneFactory(
@@ -15,7 +15,7 @@ export function strategyNoneFactory(
 ): IStrategy {
 
   return {
-    process(impressions: ImpressionDTO[]) {
+    process(impressions: SplitIO.ImpressionDTO[]) {
       impressions.forEach((impression) => {
         const now = Date.now();
         // Increments impression counter per featureName

package/src/trackers/strategy/strategyOptimized.ts

@@ -1,5 +1,5 @@
 import { IImpressionCountsCacheBase } from '../../storages/types';
-import { ImpressionDTO } from '../../types';
+import SplitIO from '../../../types/splitio';
 import { truncateTimeFrame } from '../../utils/time';
 import { IImpressionObserver } from '../impressionObserver/types';
 import { IStrategy } from '../types';
@@ -7,8 +7,8 @@ import { IStrategy } from '../types';
 /**
  * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
  *
- * @param impressionsObserver impression observer. previous time (pt property) is included in impression instances
- * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @param impressionsObserver - impression observer. previous time (pt property) is included in impression instances
+ * @param impressionsCounter - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
  * @returns IStrategyResult
  */
 export function strategyOptimizedFactory(
@@ -17,8 +17,8 @@ export function strategyOptimizedFactory(
 ): IStrategy {
 
   return {
-    process(impressions: ImpressionDTO[]) {
-      const impressionsToStore: ImpressionDTO[] = [];
+    process(impressions: SplitIO.ImpressionDTO[]) {
+      const impressionsToStore: SplitIO.ImpressionDTO[] = [];
       impressions.forEach((impression) => {
         impression.pt = impressionsObserver.testAndSet(impression);
 

package/src/trackers/types.ts

@@ -1,4 +1,4 @@
-import { SplitIO, ImpressionDTO } from '../types';
+import SplitIO from '../../types/splitio';
 import { StreamingEventType, Method, OperationType, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
@@ -18,7 +18,7 @@ export interface IImpressionsHandler {
 }
 
 export interface IImpressionsTracker {
-  track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes): void
+  track(impressions: SplitIO.ImpressionDTO[], attributes?: SplitIO.Attributes): void
 }
 
 /** Telemetry tracker */
@@ -71,11 +71,11 @@ export interface IUniqueKeysTracker {
 }
 
 export interface IStrategyResult {
-  impressionsToStore: ImpressionDTO[],
-  impressionsToListener: ImpressionDTO[],
+  impressionsToStore: SplitIO.ImpressionDTO[],
+  impressionsToListener: SplitIO.ImpressionDTO[],
   deduped: number
 }
 
 export interface IStrategy {
-  process(impressions:  ImpressionDTO[]): IStrategyResult
+  process(impressions:  SplitIO.ImpressionDTO[]): IStrategyResult
 }

package/src/trackers/uniqueKeysTracker.ts

@@ -14,9 +14,9 @@ const noopFilterAdapter = {
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
  * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
- * @param log Logger instance
- * @param uniqueKeysCache cache to save unique keys
- * @param filterAdapter filter adapter
+ * @param log - Logger instance
+ * @param uniqueKeysCache - cache to save unique keys
+ * @param filterAdapter - filter adapter
  */
 export function uniqueKeysTrackerFactory(
   log: ILogger,