@splitsoftware/splitio-commons 1.2.1-rc.0 → 1.2.1-rc.11

package/src/trackers/impressionObserver/utils.ts

@@ -1,4 +1,4 @@
-import { CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
 import { ISettings } from '../../types';
 
 /**
@@ -15,3 +15,10 @@ export function shouldBeOptimized(settings: ISettings) {
   if (!shouldAddPt(settings)) return false;
   return settings.sync.impressionsMode === OPTIMIZED ? true : false;
 }
+
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isStorageSync(settings: ISettings) {
+  return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
+}

package/src/trackers/impressionsTracker.ts

@@ -5,8 +5,8 @@ import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/t
 import { IImpressionsHandler, IImpressionsTracker } from './types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { IImpressionObserver } from './impressionObserver/types';
-import { ILogger } from '../logger/types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
 
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
@@ -19,22 +19,21 @@ import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIO
  * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
 export function impressionsTrackerFactory(
-  log: ILogger,
+  settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
-
-  // @TODO consider passing only an optional integrationsManager to handle impressions
-  { runtime: { ip, hostname }, version }: Pick<ISettings, 'version' | 'runtime'>,
-  impressionListener?: SplitIO.IImpressionListener,
   integrationsManager?: IImpressionsHandler,
-
   // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
   observer?: IImpressionObserver,
   // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
   countsCache?: IImpressionCountsCacheSync
 ): IImpressionsTracker {
 
+  const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
+
   return {
     track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
+      if (settings.userConsent === CONSENT_DECLINED) return;
+
       const impressionsCount = impressions.length;
 
       const impressionsToStore: ImpressionDTO[] = []; // Track only the impressions that are going to be stored
@@ -85,7 +84,7 @@ export function impressionsTrackerFactory(
             // integrationsManager.handleImpression does not throw errors
             if (integrationsManager) integrationsManager.handleImpression(impressionData);
 
-            try { // An exception on the listeners should not break the SDK.
+            try { // @ts-ignore. An exception on the listeners should not break the SDK.
               if (impressionListener) impressionListener.logImpression(impressionData);
             } catch (err) {
               log.error(ERROR_IMPRESSIONS_LISTENER, [err]);

package/src/types.ts

@@ -54,6 +54,11 @@ type EventConsts = {
  * @typedef {string} SDKMode
  */
 export type SDKMode = 'standalone' | 'consumer' | 'localhost' | 'consumer_partial';
+/**
+ * User consent status.
+ * @typedef {string} ConsentStatus
+ */
+export type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
 /**
  * Settings interface. This is a representation of the settings the SDK expose, that's why
  * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
@@ -73,6 +78,7 @@ export interface ISettings {
   readonly scheduler: {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
+    impressionsQueueSize: number,
     metricsRefreshRate: number,
     segmentsRefreshRate: number,
     offlineRefreshRate: number,
@@ -110,6 +116,7 @@ export interface ISettings {
   },
   readonly log: ILogger
   readonly impressionListener?: unknown
+  readonly userConsent?: ConsentStatus
 }
 /**
  * Log levels.
@@ -255,6 +262,13 @@ interface INodeBasicSettings extends ISharedSettings {
      * @default 300
      */
     impressionsRefreshRate?: number,
+    /**
+     * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+     * If you use a 0 here, the queue will have no maximum size.
+     * @property {number} impressionsQueueSize
+     * @default 30000
+     */
+    impressionsQueueSize?: number,
     /**
      * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
      * @property {number} metricsRefreshRate
@@ -384,7 +398,7 @@ interface IBasicClient extends IStatusInterface {
 
   // Whether the client implements the client-side API, i.e, with bound key, (true), or the server-side API (false).
   // Exposed for internal purposes only. Not considered part of the public API, and might be renamed eventually.
-  isBrowserClient: boolean
+  isClientSide: boolean
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -769,6 +783,13 @@ export namespace SplitIO {
        * @default 60
        */
       impressionsRefreshRate?: number,
+      /**
+       * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+       * If you use a 0 here, the queue will have no maximum size.
+       * @property {number} impressionsQueueSize
+       * @default 30000
+       */
+      impressionsQueueSize?: number,
       /**
        * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
        * @property {number} metricsRefreshRate

package/src/utils/consent.ts

@@ -0,0 +1,8 @@
+import { ISettings } from '../types';
+import { CONSENT_GRANTED } from './constants';
+
+export function isConsentGranted(settings: ISettings) {
+  const userConsent = settings.userConsent;
+  // undefined userConsent is handled as granted (default)
+  return !userConsent || userConsent === CONSENT_GRANTED;
+}

package/src/utils/constants/index.ts

@@ -32,3 +32,8 @@ export const STORAGE_MEMORY: StorageType = 'MEMORY';
 export const STORAGE_LOCALSTORAGE: StorageType = 'LOCALSTORAGE';
 export const STORAGE_REDIS: StorageType = 'REDIS';
 export const STORAGE_PLUGGABLE: StorageType = 'PLUGGABLE';
+
+// User consent
+export const CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
+export const CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
+export const CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions

package/src/utils/inputValidation/attributes.ts

@@ -6,7 +6,7 @@ import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
   // Attributes are optional
-  if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+  if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
     return maybeAttrs;
 
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
@@ -23,5 +23,4 @@ export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<str
   });
 
   return result;
-
 }

package/src/utils/inputValidation/eventProperties.ts

@@ -1,4 +1,5 @@
-import { isObject, shallowClone, isString, isFiniteNumber, isBoolean } from '../lang';
+import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
+import { objectAssign } from '../lang/objectAssign';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
@@ -22,7 +23,8 @@ export function validateEventProperties(log: ILogger, maybeProperties: any, meth
   }
 
   const keys = Object.keys(maybeProperties);
-  const clone = shallowClone(maybeProperties);
+  // Shallow clone
+  const clone = objectAssign({}, maybeProperties);
   // To avoid calculating the size twice we'll return it from here.
   const output = {
     properties: clone,

package/src/utils/lang/index.ts

@@ -89,7 +89,7 @@ export function get(obj: any, prop: any, val: any): any {
 /**
  * Parses an array into a map of different arrays, grouping by the specified prop value.
  */
-export function groupBy<T extends Record<string, any> >(source: T[], prop: string): Record<string, T[]> {
+export function groupBy<T extends Record<string, any>>(source: T[], prop: string): Record<string, T[]> {
   const map: Record<string, any[]> = {};
 
   if (Array.isArray(source) && isString(prop)) {
@@ -151,10 +151,14 @@ export function isNaNNumber(val: any): boolean {
 }
 
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
-export function isObject(obj: any): boolean {
-  return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+export function isObject(obj: any) {
+  return obj !== null && typeof obj === 'object' && (
+    obj.constructor === Object ||
+    (obj.constructor != null && obj.constructor.name === 'Object')
+  );
 }
 
 /**
@@ -164,6 +168,13 @@ export function isString(val: any): val is string {
   return typeof val === 'string' || val instanceof String;
 }
 
+/**
+ * String sanitizer. Returns the provided value converted to uppercase if it is a string.
+ */
+export function stringToUpperCase(val: any) {
+  return isString(val) ? val.toUpperCase() : val;
+}
+
 /**
  * Deep copy version of Object.assign using recursion.
  * There are some assumptions here. It's for internal use and we don't need verbose errors
@@ -194,20 +205,6 @@ export function merge(target: { [key: string]: any }, source: { [key: string]: a
   return res;
 }
 
-/**
- * Shallow clone an object
- */
-export function shallowClone(obj: any): any {
-  const keys = Object.keys(obj);
-  const output: Record<string, any> = {};
-
-  for (let i = 0; i < keys.length; i++) {
-    output[keys[i]] = obj[keys[i]];
-  }
-
-  return output;
-}
-
 /**
  * Checks if the target string starts with the sub string.
  */

package/src/utils/lang/maps.ts

@@ -79,4 +79,18 @@ interface IMapConstructor {
   readonly prototype: IMap<any, any>;
 }
 
-export const _Map: IMapConstructor = typeof Map !== 'undefined' ? Map : MapPoly;
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export function __getMapConstructor(): IMapConstructor {
+  // eslint-disable-next-line compat/compat
+  if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {
+    return Map;
+  }
+  return MapPoly;
+}
+
+export const _Map = __getMapConstructor();

package/src/utils/settingsValidation/consent.ts

@@ -0,0 +1,16 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
+import { ConsentStatus } from '../../types';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+import { stringToUpperCase } from '../lang';
+
+const userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+
+export function validateConsent({ userConsent, log }: { userConsent?: any, log: ILogger }): ConsentStatus {
+  userConsent = stringToUpperCase(userConsent);
+
+  if (userConsentValues.indexOf(userConsent) > -1) return userConsent;
+
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);
+  return CONSENT_GRANTED;
+}

package/src/utils/settingsValidation/impressionsMode.ts

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

package/src/utils/settingsValidation/index.ts

@@ -5,6 +5,8 @@ import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
+import { validateKey } from '../inputValidation/key';
+import { validateTrafficType } from '../inputValidation/trafficType';
 
 const base = {
   // Define which kind of object you want to retrieve from SplitFactory
@@ -38,6 +40,8 @@ const base = {
     eventsPushRate: 60,
     // how many events will be queued before flushing
     eventsQueueSize: 500,
+    // how many impressions will be queued before flushing
+    impressionsQueueSize: 30000,
     // backoff base seconds to wait before re attempting to connect to push notifications
     pushRetryBackoffBase: 1,
   },
@@ -78,11 +82,6 @@ const base = {
     localhostMode: undefined
   },
 
-  runtime: {
-    ip: false,
-    hostname: false
-  },
-
   // Logger
   log: undefined
 };
@@ -100,7 +99,7 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger, localhost } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, localhost, consent } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
   const withDefaults = merge({}, base, defaults, config) as ISettings;
@@ -132,14 +131,30 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (storage) withDefaults.storage = storage(withDefaults);
 
-  // Although `key` is mandatory according to TS declaration files, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-  if (withDefaults.mode === LOCALHOST_MODE && withDefaults.core.key === undefined) {
-    withDefaults.core.key = 'localhost_key';
+  // Validate key and TT (for client-side)
+  if (validationParams.acceptKey) {
+    const maybeKey = withDefaults.core.key;
+    // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
+    if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
+      withDefaults.core.key = 'localhost_key';
+    } else {
+      // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+      // `false` value is used as binded key/TT of the default client, which leads to some issues.
+      // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
+      withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+    }
+
+    if (validationParams.acceptTT) {
+      const maybeTT = withDefaults.core.trafficType;
+      if (maybeTT !== undefined) { // @ts-ignore
+        withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+      }
+    }
   }
 
   // Current ip/hostname information
   // @ts-ignore, modify readonly prop
-  if (runtime) withDefaults.runtime = runtime(withDefaults);
+  withDefaults.runtime = runtime(withDefaults);
 
   // ensure a valid list of integrations.
   // `integrations` returns an array of valid integration items.
@@ -164,5 +179,9 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // ensure a valid impressionsMode
   withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
 
+  // ensure a valid user consent value
+  // @ts-ignore, modify readonly prop
+  withDefaults.userConsent = consent(withDefaults);
+
   return withDefaults;
 }

package/src/utils/settingsValidation/runtime.ts

@@ -0,0 +1,9 @@
+import { ISettings } from '../../types';
+
+// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.
+export function validateRuntime(): ISettings['runtime'] {
+  return {
+    ip: false,
+    hostname: false
+  };
+}

package/src/utils/settingsValidation/types.ts

@@ -6,18 +6,24 @@ import { ISettings } from '../../types';
  */
 export interface ISettingsValidationParams {
   /**
-   * Object of values to overwrite default settings.
-   * Version and startup properties are mandatory, because these values are not part of the base setting.
+   * Object of values to overwrite base settings.
+   * Version and startup properties are required, because they are not defined in the base settings.
    */
   defaults: Partial<ISettings> & { version: string } & { startup: ISettings['startup'] },
-  /** Function to overwrite runtime values (ip and hostname) which are false by default */
-  runtime?: (settings: ISettings) => ISettings['runtime'],
-  /** Storage validator */
+  /** If true, validates core.key */
+  acceptKey?: boolean,
+  /** If true, validates core.trafficType */
+  acceptTT?: boolean,
+  /** Define runtime values (`settings.runtime`) */
+  runtime: (settings: ISettings) => ISettings['runtime'],
+  /** Storage validator (`settings.storage`) */
   storage?: (settings: ISettings) => ISettings['storage'],
-  /** Integrations validator */
+  /** Integrations validator (`settings.integrations`) */
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator (`settings.debug`) */
   logger: (settings: ISettings) => ISettings['log'],
   /** Localhost mode validator (`settings.sync.localhostMode`) */
   localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
+  /** User consent validator (`settings.userConsent`) */
+  consent: (settings: ISettings) => ISettings['userConsent'],
 }

package/types/evaluator/types.d.ts

@@ -5,7 +5,7 @@ import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 export interface IDependencyMatcherValue {
     key: SplitIO.SplitKey;
-    attributes: SplitIO.Attributes;
+    attributes?: SplitIO.Attributes;
 }
 export interface IMatcherDto {
     type: number;
@@ -23,6 +23,6 @@ export interface IEvaluation {
 export declare type IEvaluationResult = IEvaluation & {
     treatment: string;
 };
-export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
+export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
 export declare type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>;
 export declare type IMatcher = (...args: any) => MaybeThenable<boolean>;

package/types/evaluator/value/index.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Defines value to be matched (key / attribute).
  */
-export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Sanitize matcher value
  */
-export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;

package/types/integrations/ga/GoogleAnalyticsToSplit.d.ts

@@ -1,3 +1,3 @@
-import { IIntegrationFactoryParams } from '../types';
+import { IntegrationFactory } from '../types';
 import { GoogleAnalyticsToSplitOptions } from './types';
-export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): (params: IIntegrationFactoryParams) => void;
+export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): IntegrationFactory;

package/types/integrations/ga/SplitToGoogleAnalytics.d.ts

@@ -1,4 +1,3 @@
-import { IIntegrationFactoryParams } from '../types';
-import { SplitToGa } from './SplitToGa';
+import { IntegrationFactory } from '../types';
 import { SplitToGoogleAnalyticsOptions } from './types';
-export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): (params: IIntegrationFactoryParams) => SplitToGa;
+export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): IntegrationFactory;

package/types/integrations/types.d.ts

@@ -11,3 +11,7 @@ export interface IIntegrationFactoryParams {
     };
     settings: ISettings;
 }
+export declare type IntegrationFactory = {
+    readonly type: string;
+    (params: IIntegrationFactoryParams): IIntegration | void;
+};

package/types/logger/constants.d.ts

@@ -60,13 +60,16 @@ export declare const STREAMING_RECONNECT = 111;
 export declare const STREAMING_CONNECTING = 112;
 export declare const STREAMING_DISABLED = 113;
 export declare const STREAMING_DISCONNECTING = 114;
-export declare const SUBMITTERS_PUSH_FULL_EVENTS_QUEUE = 115;
+export declare const SUBMITTERS_PUSH_FULL_QUEUE = 115;
 export declare const SUBMITTERS_PUSH = 116;
 export declare const SYNC_START_POLLING = 117;
 export declare const SYNC_CONTINUE_POLLING = 118;
 export declare const SYNC_STOP_POLLING = 119;
 export declare const EVENTS_TRACKER_SUCCESS = 120;
 export declare const IMPRESSIONS_TRACKER_SUCCESS = 121;
+export declare const USER_CONSENT_UPDATED = 122;
+export declare const USER_CONSENT_NOT_UPDATED = 123;
+export declare const USER_CONSENT_INITIAL = 124;
 export declare const ENGINE_VALUE_INVALID = 200;
 export declare const ENGINE_VALUE_NO_ATTRIBUTES = 201;
 export declare const CLIENT_NO_LISTENER = 202;
@@ -112,10 +115,11 @@ export declare const ERROR_INVALID_KEY_OBJECT = 317;
 export declare const ERROR_INVALID = 318;
 export declare const ERROR_EMPTY = 319;
 export declare const ERROR_EMPTY_ARRAY = 320;
-export declare const ERROR_INVALID_IMPRESSIONS_MODE = 321;
+export declare const ERROR_INVALID_CONFIG_PARAM = 321;
 export declare const ERROR_HTTP = 322;
 export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const ERROR_STORAGE_INVALID = 324;
+export declare const ERROR_NOT_BOOLEAN = 325;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/logger/types.d.ts

@@ -6,8 +6,12 @@ export interface ILoggerOptions {
 }
 export interface ILogger {
     setLogLevel(logLevel: LogLevel): void;
+    debug(msg: any): void;
     debug(msg: string | number, args?: any[]): void;
+    info(msg: any): void;
     info(msg: string | number, args?: any[]): void;
+    warn(msg: any): void;
     warn(msg: string | number, args?: any[]): void;
+    error(msg: any): void;
     error(msg: string | number, args?: any[]): void;
 }

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -8,7 +8,7 @@ export declare function clientAttributesDecoration<TClient extends SplitIO.IClie
     getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
     getTreatments: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
     getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
-    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => import("../dtos/types").MaybeThenable<boolean>;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => boolean | Promise<boolean>;
     /**
      * Add an attribute to client's in memory attributes storage
      *

package/types/sdkClient/clientInputValidation.d.ts

@@ -1,8 +1,7 @@
 import { IReadinessManager } from '../readiness/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { ISettings, SplitIO } from '../types';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export declare function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync?: boolean): TClient;
+export declare function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient;

package/types/sdkFactory/types.d.ts

@@ -36,7 +36,7 @@ export interface ISdkFactoryParams {
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
     serviceApi: ISplitApi | undefined) => ISignalListener;
-    impressionListener?: SplitIO.IImpressionListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
     impressionsObserverFactory?: () => IImpressionObserver;
+    extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object;
 }

package/types/sdkFactory/userConsentProps.d.ts

@@ -0,0 +1,6 @@
+import { ISyncManager } from '../sync/types';
+import { ISettings } from '../types';
+export declare function userConsentProps(settings: ISettings, syncManager?: ISyncManager): {
+    setUserConsent(consent: unknown): boolean;
+    getUserConsent(): import("../types").ConsentStatus | undefined;
+};

package/types/storages/KeyBuilderCS.d.ts

@@ -8,6 +8,8 @@ export declare class KeyBuilderCS extends KeyBuilder {
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    buildOldSegmentNameKey(segmentName: string): string;
+    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
     buildSplitsFilterQueryKey(): string;

package/types/storages/inMemory/ImpressionsCacheInMemory.d.ts

@@ -1,7 +1,16 @@
 import { IImpressionsCacheSync } from '../types';
 import { ImpressionDTO } from '../../types';
 export declare class ImpressionsCacheInMemory implements IImpressionsCacheSync {
+    private onFullQueue?;
+    private readonly maxQueue;
     private queue;
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    constructor(impressionsQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
     /**
      * Store impressions in sequential order
      */

package/types/storages/inMemory/index.d.ts

@@ -0,0 +1,10 @@
+import { IStorageFactoryParams, IStorageSync } from '../types';
+/**
+ * InMemory storage factory for standalone server-side SplitFactory
+ *
+ * @param params parameters required by EventsCacheSync
+ */
+export declare function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync;
+export declare namespace InMemoryStorageFactory {
+    var type: import("../types").StorageType;
+}

package/types/storages/inRedis/RedisAdapter.d.ts

@@ -20,5 +20,5 @@ export declare class RedisAdapter extends ioredis {
     /**
      * Parses the options into what we care about.
      */
-    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }: Record<string, any>): object;
+    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
 }

package/types/storages/parseSegments.d.ts

@@ -0,0 +1,6 @@
+import { ISplit } from '../dtos/types';
+import { ISet } from '../utils/lang/sets';
+/**
+ * Collect segments from a list of splits.
+ */
+export declare function parseSegments(splits: ISplit[]): ISet<string>;