@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.4

package/src/utils/constants/index.ts

@@ -1,4 +1,4 @@
-import { StorageType } from '../../storages/types';
+import { StorageType } from '../../types';
 import { SDKMode } from '../../types';
 
 // Special treatments
@@ -19,7 +19,6 @@ export const SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export const DEBUG = 'DEBUG';
 export const OPTIMIZED = 'OPTIMIZED';
-export const NONE = 'NONE';
 
 // SDK Modes
 export const LOCALHOST_MODE: SDKMode = 'localhost';

package/src/utils/inputValidation/apiKey.ts

@@ -1,5 +1,5 @@
 import { ERROR_NULL, ERROR_EMPTY, ERROR_INVALID, WARN_API_KEY, LOG_PREFIX_INSTANTIATION } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isString } from '../lang';
 
 const item = 'api_key';

package/src/utils/inputValidation/attribute.ts

@@ -1,5 +1,5 @@
 import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 
 export function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean {
   if (!isString(attributeKey) || attributeKey.length === 0) {

package/src/utils/inputValidation/attributes.ts

@@ -1,10 +1,10 @@
 import { isObject } from '../lang';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { Attributes } from '../../types';
+import { ILogger } from '../../types';
 import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
-export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
+export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): Attributes | undefined | false {
   // Attributes are optional
   if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
     return maybeAttrs;

package/src/utils/inputValidation/event.ts

@@ -1,5 +1,5 @@
 import { ERROR_EVENT_TYPE_FORMAT, ERROR_NULL, ERROR_INVALID, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isString } from '../lang';
 
 const EVENT_TYPE_REGEX = /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/;

package/src/utils/inputValidation/eventProperties.ts

@@ -1,7 +1,7 @@
 import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
 import { objectAssign } from '../lang/objectAssign';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { Properties } from '../../types';
+import { ILogger } from '../../types';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
 
 const ECMA_SIZES = {
@@ -14,7 +14,7 @@ const MAX_PROPERTIES_AMOUNT = 300;
 const MAX_EVENT_SIZE = 1024 * 32;
 const BASE_EVENT_SIZE = 1024; // We assume 1kb events without properties (avg measured)
 
-export function validateEventProperties(log: ILogger, maybeProperties: any, method: string): { properties: SplitIO.Properties | null | false, size: number } {
+export function validateEventProperties(log: ILogger, maybeProperties: any, method: string): { properties: Properties | null | false, size: number } {
   if (maybeProperties == undefined) return { properties: null, size: BASE_EVENT_SIZE }; // eslint-disable-line eqeqeq
 
   if (!isObject(maybeProperties)) {

package/src/utils/inputValidation/eventValue.ts

@@ -1,5 +1,5 @@
 import { ERROR_NOT_FINITE } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isFiniteNumber } from '../lang';
 
 export function validateEventValue(log: ILogger, maybeValue: any, method: string): number | false {

package/src/utils/inputValidation/isOperational.ts

@@ -1,5 +1,5 @@
 import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { IReadinessManager } from '../../readiness/types';
 
 export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadinessManager, method: string): boolean {

package/src/utils/inputValidation/key.ts

@@ -1,6 +1,6 @@
 import { isObject, isString, isFiniteNumber, toString } from '../lang';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { SplitKey } from '../../types';
+import { ILogger } from '../../types';
 import { ERROR_NULL, WARN_CONVERTING, ERROR_EMPTY, ERROR_TOO_LONG, ERROR_INVALID, ERROR_INVALID_KEY_OBJECT } from '../../logger/constants';
 
 const KEY_MAX_LENGTH = 250;
@@ -33,7 +33,7 @@ function validateKeyValue(log: ILogger, maybeKey: any, method: string, type: str
   return false;
 }
 
-export function validateKey(log: ILogger, maybeKey: any, method: string): SplitIO.SplitKey | false {
+export function validateKey(log: ILogger, maybeKey: any, method: string): SplitKey | false {
   if (isObject(maybeKey)) {
     // Validate key object
     const matchingKey = validateKeyValue(log, maybeKey.matchingKey, method, 'matchingKey');

package/src/utils/inputValidation/preloadedData.ts

@@ -1,7 +1,7 @@
 import { isObject, isString, isFiniteNumber } from '../lang';
 import { validateSplit } from './split';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
+import { PreloadedData } from '../../storages/types';
 
 function validateTimestampData(log: ILogger, maybeTimestamp: any, method: string, item: string) {
   if (isFiniteNumber(maybeTimestamp) && maybeTimestamp > -1) return true;
@@ -42,7 +42,7 @@ function validateSegmentsData(log: ILogger, maybeSegmentsData: any, method: stri
   return false;
 }
 
-export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string): maybePreloadedData is SplitIO.PreloadedData {
+export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string): maybePreloadedData is PreloadedData {
   if (!isObject(maybePreloadedData)) {
     log.error(`${method}: preloadedData must be an object.`);
   } else if (

package/src/utils/inputValidation/split.ts

@@ -1,5 +1,5 @@
 import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isString } from '../lang';
 
 // include BOM and nbsp

package/src/utils/inputValidation/splitExistance.ts

@@ -1,6 +1,6 @@
 import { SPLIT_NOT_FOUND } from '../labels';
 import { IReadinessManager } from '../../readiness/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
 
 /**

package/src/utils/inputValidation/splits.ts

@@ -1,5 +1,5 @@
 import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { uniq } from '../lang';
 import { validateSplit } from './split';
 

package/src/utils/inputValidation/trafficType.ts

@@ -1,5 +1,5 @@
 import { ERROR_NULL, ERROR_INVALID, ERROR_EMPTY, WARN_LOWERCASE_TRAFFIC_TYPE } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { isString } from '../lang';
 
 const CAPITAL_LETTERS_REGEX = /[A-Z]/;

package/src/utils/inputValidation/trafficTypeExistance.ts

@@ -4,7 +4,7 @@ import { ISplitsCacheBase } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import { SDKMode } from '../../types';
 import { MaybeThenable } from '../../dtos/types';
-import { ILogger } from '../../logger/types';
+import { ILogger } from '../../types';
 import { WARN_NOT_EXISTENT_TT } from '../../logger/constants';
 
 function logTTExistanceWarning(log: ILogger, maybeTT: string, method: string) {

package/src/utils/key/index.ts

@@ -1,29 +1,29 @@
-import { SplitIO } from '../../types';
+import { SplitKey, SplitKeyObject } from '../../types';
 import { isObject } from '../lang';
 
-// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
+// function isSplitKeyObject(key: any): key is SplitKeyObject {
 //   return key !== undefined && key !== null && typeof key.matchingKey === 'string';
 // }
 
 // returns the matchingKey if the Key is defined as an object or the key itself if it is a string
-export function getMatching(key: SplitIO.SplitKey): string {
-  return isObject(key) ? (key as SplitIO.SplitKeyObject).matchingKey : key as string;
+export function getMatching(key?: SplitKey): string {
+  return isObject(key) ? (key as SplitKeyObject).matchingKey : key as string;
 }
 
 // if the key is a string, there's no bucketingKey (undefined)
-export function getBucketing(key: SplitIO.SplitKey): string | undefined {
-  return isObject(key) ? (key as SplitIO.SplitKeyObject).bucketingKey : undefined;
+export function getBucketing(key: SplitKey): string | undefined {
+  return isObject(key) ? (key as SplitKeyObject).bucketingKey : undefined;
 }
 
 /**
  * Verify type of key and return a valid object key used for get treatment for a
  * specific split.
  */
-export function keyParser(key: SplitIO.SplitKey): SplitIO.SplitKeyObject {
+export function keyParser(key: SplitKey): SplitKeyObject {
   if (isObject(key)) {
     return {
-      matchingKey: (key as SplitIO.SplitKeyObject).matchingKey,
-      bucketingKey: (key as SplitIO.SplitKeyObject).bucketingKey
+      matchingKey: (key as SplitKeyObject).matchingKey,
+      bucketingKey: (key as SplitKeyObject).bucketingKey
     };
   } else {
     return {

package/src/utils/settingsValidation/consent.ts

@@ -1,6 +1,5 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { ConsentStatus } from '../../types';
+import { ConsentStatus, ILogger } from '../../types';
 import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
 import { stringToUpperCase } from '../lang';
 

package/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +1,14 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { SplitIO } from '../../types';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
+import { ILogger } from '../../types';
+import { ImpressionsMode } from '../../types';
+import { DEBUG, OPTIMIZED } from '../constants';
 import { stringToUpperCase } from '../lang';
 
-export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
+export function validImpressionsMode(log: ILogger, impressionsMode: any): ImpressionsMode {
   impressionsMode = stringToUpperCase(impressionsMode);
 
-  if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1) return impressionsMode;
+  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1) return impressionsMode;
 
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
   return OPTIMIZED;
 }

package/src/utils/settingsValidation/index.ts

@@ -36,8 +36,6 @@ export const base = {
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
     impressionsRefreshRate: 300,
-    // publish unique Keys each 900 sec (15 min) 
-    uniqueKeysRefreshRate: 900,
     // fetch offline changes each 15 sec
     offlineRefreshRate: 15,
     // publish events every 60 seconds after the first flush
@@ -132,13 +130,11 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-  scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
   // Default impressionsRefreshRate for DEBUG mode is 60 secs
   if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
   scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
-  
 
   // Log deprecation for old telemetry param
   if (scheduler.metricsRefreshRate) log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');
@@ -204,6 +200,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // validate the `splitFilters` settings and parse splits query
   const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
+  // @ts-ignore
   withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
 
   // ensure a valid user consent value

package/src/utils/settingsValidation/integrations/common.ts

@@ -1,5 +1,5 @@
 import { WARN_INTEGRATION_INVALID } from '../../../logger/constants';
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 
 /**
  * This function validates `settings.integrations` object

package/src/utils/settingsValidation/integrations/configurable.ts

@@ -1,6 +1,6 @@
 import { validateIntegrations } from './common';
 import { isString } from '../../lang';
-import { ILogger } from '../../../logger/types';
+import { ILogger } from '../../../types';
 
 /**
  * This function validates `settings.integrations` object that consists of a list of configuration items, used by the isomorphic JS SDK.

package/src/utils/settingsValidation/integrations/pluggable.ts

@@ -1,6 +1,5 @@
-import { ISettings } from '../../../types';
+import { ISettings, ILogger } from '../../../types';
 import { validateIntegrations } from './common';
-import { ILogger } from '../../../logger/types';
 
 /**
  * This function validates `settings.integrations` object that consists of a list of pluggable integration factories.

package/src/utils/settingsValidation/localhost/builtin.ts

@@ -1,5 +1,4 @@
-import { ILogger } from '../../../logger/types';
-import { SDKMode, } from '../../../types';
+import { SDKMode, ILogger } from '../../../types';
 import { LocalhostFromObject } from '../../../sync/offline/LocalhostFromObject';
 import { validateLocalhost } from './pluggable';
 

package/src/utils/settingsValidation/localhost/pluggable.ts

@@ -1,6 +1,5 @@
 import { ERROR_LOCALHOST_MODULE_REQUIRED } from '../../../logger/constants';
-import { ILogger } from '../../../logger/types';
-import { SDKMode, } from '../../../types';
+import { SDKMode, ILogger } from '../../../types';
 import { LOCALHOST_MODE } from '../../constants';
 
 /**

package/src/utils/settingsValidation/logger/builtinLogger.ts

@@ -1,11 +1,10 @@
 import { isLogLevelString, Logger, LogLevels } from '../../../logger';
-import { ILogger } from '../../../logger/types';
 import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable';
 import { isNode } from '../../env/isNode';
 import { codesDebug } from '../../../logger/messages/debug';
 import { _Map } from '../../lang/maps';
 import { getLogLevel } from './commons';
-import { LogLevel } from '../../../types';
+import { LogLevel, ILogger } from '../../../types';
 
 const allCodes = new _Map(codesDebug);
 

package/src/utils/settingsValidation/logger/pluggableLogger.ts

@@ -1,6 +1,5 @@
 import { Logger, LogLevels } from '../../../logger';
-import { ILogger } from '../../../logger/types';
-import { LogLevel } from '../../../types';
+import { LogLevel, ILogger } from '../../../types';
 import { getLogLevel } from './commons';
 
 function isLogger(log: any): log is ILogger {

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,20 +1,18 @@
 import { STANDALONE_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-import { ISplitFiltersValidation } from '../../dtos/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { ISplitFiltersValidation, SplitFilterType, ILogger } from '../../types';
 import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS } from '../../logger/constants';
 
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
 const FILTERS_METADATA = [
   {
-    type: 'byName' as SplitIO.SplitFilterType,
+    type: 'byName' as SplitFilterType,
     maxLength: 400,
     queryParam: 'names='
   },
   {
-    type: 'byPrefix' as SplitIO.SplitFilterType,
+    type: 'byPrefix' as SplitFilterType,
     maxLength: 50,
     queryParam: 'prefixes='
   }
@@ -23,7 +21,7 @@ const FILTERS_METADATA = [
 /**
  * Validates that the given value is a valid filter type
  */
-function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.SplitFilterType {
+function validateFilterType(maybeFilterType: any): maybeFilterType is SplitFilterType {
   return FILTERS_METADATA.some(filterMetadata => filterMetadata.type === maybeFilterType);
 }
 
@@ -37,7 +35,7 @@ function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.Sp
  *
  * @throws Error if the sanitized list exceeds the length indicated by `maxLength`
  */
-function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) {
+function validateSplitFilter(log: ILogger, type: SplitFilterType, values: string[], maxLength: number) {
   // validate and remove invalid and duplicated values
   let result = validateSplits(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
 
@@ -63,7 +61,7 @@ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values
  * @param {Object} groupedFilters object of filters. Each filter must be a list of valid, unique and ordered string values.
  * @returns null or string with the `split filter query` component of the URL.
  */
-function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, string[]>) {
+function queryStringBuilder(groupedFilters: Record<SplitFilterType, string[]>) {
   const queryParams: string[] = [];
   FILTERS_METADATA.forEach(({ type, queryParam }) => {
     const filter = groupedFilters[type];
@@ -109,7 +107,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   // Validate filters and group their values by filter type inside `groupedFilters` object
   res.validFilters = maybeSplitFilters.filter((filter, index) => {
     if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
-      res.groupedFilters[filter.type as SplitIO.SplitFilterType] = res.groupedFilters[filter.type as SplitIO.SplitFilterType].concat(filter.values);
+      res.groupedFilters[filter.type as SplitFilterType] = res.groupedFilters[filter.type as SplitFilterType].concat(filter.values);
       return true;
     } else {
       log.warn(WARN_SPLITS_FILTER_INVALID, [index]);

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -1,6 +1,5 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
-import { ISettings, SDKMode } from '../../../types';
-import { ILogger } from '../../../logger/types';
+import { ISettings, SDKMode, ILogger } from '../../../types';
 import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';

package/cjs/sync/submitters/uniqueKeysSubmitter.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uniqueKeysSubmitterFactory = exports.fromUniqueKeysCollectorSs = exports.fromUniqueKeysCollectorCs = void 0;
-var sets_1 = require("../../utils/lang/sets");
-var submitter_1 = require("./submitter");
-/**
- * Invert keys for feature to features for key
- */
-function invertUniqueKeys(uniqueKeys) {
-    var featureNames = Object.keys(uniqueKeys);
-    var inverted = {};
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
-        for (var j = 0; j < featureKeys.length; j++) {
-            var featureKey = featureKeys[j];
-            if (!inverted[featureKey])
-                inverted[featureKey] = [];
-            inverted[featureKey].push(featureName);
-        }
-    }
-    return inverted;
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-function fromUniqueKeysCollectorCs(uniqueKeys) {
-    var payload = [];
-    var featuresPerKey = invertUniqueKeys(uniqueKeys);
-    var keys = Object.keys(featuresPerKey);
-    for (var k = 0; k < keys.length; k++) {
-        var key = keys[k];
-        var uniqueKeysPayload = {
-            k: key,
-            fs: featuresPerKey[key]
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-exports.fromUniqueKeysCollectorCs = fromUniqueKeysCollectorCs;
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-function fromUniqueKeysCollectorSs(uniqueKeys) {
-    var payload = [];
-    var featureNames = Object.keys(uniqueKeys);
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
-        var uniqueKeysPayload = {
-            f: featureName,
-            ks: featureKeys
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-exports.fromUniqueKeysCollectorSs = fromUniqueKeysCollectorSs;
-/**
- * Submitter that periodically posts impression counts
- */
-function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, uniqueKeysRefreshRate = _a.scheduler.uniqueKeysRefreshRate, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
-    var isClientSide = key !== undefined;
-    var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-    var fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
-    return (0, submitter_1.submitterFactory)(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
-}
-exports.uniqueKeysSubmitterFactory = uniqueKeysSubmitterFactory;

package/cjs/trackers/strategy/strategyDebug.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.strategyDebugFactory = void 0;
-/**
- * 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
- * @returns IStrategyResult
- */
-function strategyDebugFactory(impressionsObserver) {
-    return {
-        process: function (impressions) {
-            impressions.forEach(function (impression) {
-                // Adds previous time if it is enabled
-                impression.pt = impressionsObserver.testAndSet(impression);
-            });
-            return {
-                impressionsToStore: impressions,
-                impressionsToListener: impressions,
-                deduped: 0
-            };
-        }
-    };
-}
-exports.strategyDebugFactory = strategyDebugFactory;

package/cjs/trackers/strategy/strategyNone.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.strategyNoneFactory = void 0;
-/**
- * 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.
- * @returns IStrategyResult
- */
-function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
-    return {
-        process: function (impressions) {
-            impressions.forEach(function (impression) {
-                var now = Date.now();
-                // Increments impression counter per featureName
-                impressionsCounter.track(impression.feature, now, 1);
-                // Keep track by unique key
-                uniqueKeysTracker.track(impression.feature, impression.keyName);
-            });
-            return {
-                impressionsToStore: [],
-                impressionsToListener: impressions,
-                deduped: 0
-            };
-        }
-    };
-}
-exports.strategyNoneFactory = strategyNoneFactory;

package/cjs/trackers/strategy/strategyOptimized.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.strategyOptimizedFactory = void 0;
-var time_1 = require("../../utils/time");
-/**
- * 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)
- * @returns IStrategyResult
- */
-function strategyOptimizedFactory(impressionsObserver, impressionsCounter) {
-    return {
-        process: function (impressions) {
-            var impressionsToStore = [];
-            impressions.forEach(function (impression) {
-                impression.pt = impressionsObserver.testAndSet(impression);
-                var now = Date.now();
-                // Increments impression counter per featureName
-                impressionsCounter.track(impression.feature, now, 1);
-                // Checks if the impression should be added in queue to be sent
-                if (!impression.pt || impression.pt < (0, time_1.truncateTimeFrame)(now)) {
-                    impressionsToStore.push(impression);
-                }
-            });
-            return {
-                impressionsToStore: impressionsToStore,
-                impressionsToListener: impressions,
-                deduped: impressions.length - impressionsToStore.length
-            };
-        }
-    };
-}
-exports.strategyOptimizedFactory = strategyOptimizedFactory;