@kameleoon/javascript-sdk-core 5.17.3 → 5.18.0

package/dist/kameleoonClient.d.ts

@@ -5,24 +5,25 @@ import { IKameleoonClient } from './kameleoonClientInterface';
 import { EventCallbackType, EventType } from './eventManager';
 import { Tracker } from './tracking';
 import { LogLevel } from './logging';
+import { AddDataParamsType } from './kameleoonData/types';
 /**
  * @class
  * KameleoonClient - a class for creating kameleoon client instance
  * for communicating with Kameleoon JavaScript SDK Core, when new instance is created
  */
 export declare class KameleoonClient implements IKameleoonClient {
-    private variationConfiguration;
-    private clientConfiguration;
-    private dataManager;
-    private consentDataStorage;
-    private trackingCache;
-    private requester;
-    private externalPackageInfo;
+    private readonly variationConfiguration;
+    private readonly clientConfiguration;
+    private readonly dataManager;
+    private readonly consentDataStorage;
+    private readonly trackingCache;
+    private readonly requester;
+    private readonly externalPackageInfo;
     protected initialized: boolean;
-    private visitorCodeManager;
-    private eventManager;
+    private readonly visitorCodeManager;
+    private readonly eventManager;
     protected readonly tracker: Tracker;
-    private environment;
+    private readonly environment;
     protected readonly stubMode?: boolean;
     /**
      * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core
@@ -30,6 +31,7 @@ export declare class KameleoonClient implements IKameleoonClient {
     constructor({ siteCode, dependencies, configuration, internalConfiguration, stubMode, }: SDKCoreParameters);
     initialize(): Promise<boolean>;
     addData(visitorCode: string, ...data: KameleoonDataType[]): void;
+    addData({ visitorCode, data, track }: AddDataParamsType): void;
     getRemoteVisitorData({ visitorCode, shouldAddData, filters, }: RemoteVisitorDataParamsType): Promise<KameleoonDataType[]>;
     trackConversion({ visitorCode, goalId, negative, revenue, metadata, }: TrackConversionParamsType): void;
     flush(params?: string | FlushParamsType): void;

package/dist/kameleoonClientInterface.d.ts

@@ -1,7 +1,7 @@
 import { JSONType } from './clientConfiguration';
 import { EventCallbackType, EventType } from './eventManager';
 import { CustomData, KameleoonDataType } from './kameleoonData';
-import { DataFile, FeatureFlagType, FeatureFlagVariableType, GetFeatureFlagVariableParamsType, GetVariationParamsType, GetVariationsParamsType, GetVisitorWarehouseAudienceParamsType, IsFeatureFlagActiveParamsType, KameleoonVariationType, RemoteVisitorDataParamsType, SetForcedVariationParametersType, TrackConversionParamsType, Variable, Variation } from './types';
+import { AddDataParamsType, DataFile, FeatureFlagType, FeatureFlagVariableType, GetFeatureFlagVariableParamsType, GetVariationParamsType, GetVariationsParamsType, GetVisitorWarehouseAudienceParamsType, IsFeatureFlagActiveParamsType, KameleoonVariationType, RemoteVisitorDataParamsType, SetForcedVariationParametersType, TrackConversionParamsType, Variable, Variation } from './types';
 import { LogLevel } from './logging';
 /**
  * @interface an interface of KameleoonClient instance
@@ -21,18 +21,26 @@ export interface IKameleoonClient {
      */
     initialize(): Promise<boolean>;
     /**
-     * @method addData - method for adding targeting data to the storage so that other methods could decide whether the current visitor is targeted or not. Note: userAgent data will not be stored in storage like other data, and it will be sent with every tracking request for bot filtration.
-     * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length
-     * @param {KameleoonDataType[]} kameleoonData - number of instances of any type of `KameleoonData`, can be added solely in array or as a sequential arguments
-     * @returns {void}
-     * @throws `KameleoonError` with one of the following `type` s:
+     * @method addData - Stores targeting data for a visitor so other methods can evaluate targeting rules.
      *
-     * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded
-     * - `KameleoonException.VisitorCodeEmpty` The visitor code is empty
+     * This method supports two calling forms:
+     * 1) `addData(visitorCode, ...data)`
+     * 2) `addData({ visitorCode, data, track })`
+     *
+     * Note: `UserAgent` data is not persisted in storage like other data; it is sent with every tracking request for bot filtration.
+     *
+     * @param visitorCode - Unique visitor identifier, must not exceed 255 characters.
+     * @param track - Optional flag (only via `AddDataParamsType`) controlling whether the added data should be tracked/marked as unsent.
+     * @param data - One or more instances of `KameleoonData` (either as rest args or via `AddDataParamsType.data`).
+     *
+     * @returns void
+     * @throws KameleoonError with one of:
+     * - `KameleoonException.VisitorCodeMaxLength` Visitor code length was exceeded
+     * - `KameleoonException.VisitorCodeEmpty` Visitor code is empty
      * - `KameleoonException.StorageWrite` Couldn't update storage data
-     * - `KameleoonException.Initialization` - Method was executed before the `kameleoonClient` completed it's `initialize` call
+     * - `KameleoonException.Initialization` Called before `kameleoonClient.initialize` completed
      */
-    addData: (visitorCode: string, ...data: KameleoonDataType[]) => void;
+    addData: ((visitorCode: string, ...data: KameleoonDataType[]) => void) & (({ visitorCode, track, data }: AddDataParamsType) => void);
     /**
      * @method getRemoteVisitorData - an asynchronous method for retrieving KameleoonData from Data API and optionally adding it to the storage so that other methods could decide whether the current visitor is targeted or not.
      * @param {RemoteVisitorDataParamsType} remoteVisitorDataParameters - `visitorCode`, `shouldAddData` and `filters` parameters

package/dist/kameleoonData/browser.d.ts

@@ -7,8 +7,8 @@ import { TrackingStatus } from '../types';
  * */
 export declare class Browser implements IKameleoonData {
     status: TrackingStatus;
-    private browser;
-    private version?;
+    private readonly browser;
+    private readonly version?;
     /**
      * @param {BrowserType} browser - one of the browser types available for data, if browser can not be found in a list, it can be marked as `BrowserType.Other`
      * @param {number | undefined} version - version of the browser, floating point number represents major and minor version of the browser

package/dist/kameleoonData/conversion.d.ts

@@ -8,9 +8,9 @@ import { CustomData } from '../kameleoonData/customData';
  * */
 export declare class Conversion implements IKameleoonData {
     status: TrackingStatus;
-    private goalId;
-    private revenue;
-    private negative;
+    private readonly goalId;
+    private readonly revenue;
+    private readonly negative;
     private id;
     private nonce;
     private metadata;

package/dist/kameleoonData/customData.d.ts

@@ -9,10 +9,10 @@ export declare class CustomData implements IKameleoonData {
     static readonly UNDEFINED_INDEX = -1;
     private _status;
     private _index;
-    private value;
+    private readonly value;
     private isIdentifier;
-    private overwrite;
-    private _name?;
+    private readonly overwrite;
+    private readonly _name?;
     /**
      * @param {number|string} indexOrName - either:
      *   - `number` — an index of custom data (configured in *Advanced Tools* section of Kameleoon Application)

package/dist/kameleoonData/dataManager.d.ts

@@ -8,16 +8,16 @@ import { DataManagerParametersType, KameleoonData, KameleoonDataType, KameleoonV
 import { IStorage } from '../storage';
 import { CustomDataConfigurationType } from '../clientConfiguration';
 import { DataInfoType, MappingIdentifierType } from '../storage/types';
+import { AddDataParamsType } from '../types';
 import { ExternalPackageInfoType } from '../sdkInfoTypes';
 import { StaticData } from '../kameleoonData/staticData';
 export interface IDataManager {
-    storeData(data: VisitorsDataType, extendTtl: boolean): Result<void, KameleoonError>;
     storeTrackedData(data: VisitorsDataType): void;
     getTree(segment: SegmentType): Tree;
     clearTrees(): void;
     isPersistentCustomData(dataItem: KameleoonDataType): dataItem is CustomData;
     isUniqueIdentifier(visitorCode: string): boolean;
-    getLinkedVisitor(visitorCode: string, index: number | null): string | null;
+    getLinkedVisitor(visitorCode: string): string | null;
     getVisitorData(visitorCode: string): KameleoonVisitorDataType | undefined;
     getVisitorIdentifier(visitorCode: string): string;
     getPendingData(visitorCode: string): KameleoonDataType[];
@@ -45,8 +45,15 @@ export declare class DataManager implements IDataManager {
     getPendingData(visitorCode: string): KameleoonDataType[];
     private getDataFromRaw;
     storeTrackedData(data: VisitorsDataType): void;
-    storeData(data: VisitorsDataType, extendTtl: boolean): Result<void, KameleoonError>;
-    storeData(visitorCode: string, ...data: KameleoonDataType[]): Result<void, KameleoonError>;
+    /**
+     * Store data for a single visitor
+     */
+    storeData({ visitorCode, data, track, }: AddDataParamsType): Result<void, KameleoonError>;
+    /**
+     * Store data for multiple visitors
+     */
+    storeDataForVisitors(data: VisitorsDataType, extendTtl: boolean): Result<void, KameleoonError>;
+    private storeDataInternal;
     getTree(segment: SegmentType): Tree;
     clearTrees(): void;
     isPersistentCustomData(dataItem: KameleoonDataType): dataItem is CustomData;

package/dist/kameleoonData/device.d.ts

@@ -7,7 +7,7 @@ import { TrackingStatus } from '../types';
  * */
 export declare class Device implements IKameleoonData {
     status: TrackingStatus;
-    private device;
+    private readonly device;
     /**
      * @param {DeviceType} device - one of the available device types from `DeviceType` enum
      * */

package/dist/kameleoonData/geolocation.d.ts

@@ -7,11 +7,11 @@ import { TrackingStatus } from '../types';
  * */
 export declare class GeolocationData implements IKameleoonData {
     status: TrackingStatus;
-    private country;
-    private region?;
-    private city?;
-    private postalCode?;
-    private coordinates?;
+    private readonly country;
+    private readonly region?;
+    private readonly city?;
+    private readonly postalCode?;
+    private readonly coordinates?;
     /**
      * @param {GeolocationInfoType} geolocationInfo - an object containing information about geolocation of a visitor
      * @example

package/dist/kameleoonData/index.d.ts

@@ -13,5 +13,5 @@ export { VisitsData } from './visitsData';
 export { KameleoonConversionScore } from './kameleoonConversionScore';
 export { DataProcessor } from './dataProcessor';
 export { StaticData } from './staticData';
-export { DeviceType, CookieType, VisitsDataType, BrowserType, KameleoonData, DeviceDataType, CustomDataType, BrowserDataType, BrowserIndexMap, PageViewDataType, KameleoonDataType, UserAgentDataType, IdentifierDataType, ConversionDataType, OperatingSystemType, GeolocationInfoType, KameleoonDataItemType, PageViewParametersType, ConversionParametersType, ApplicationVersionDataType, } from './types';
+export { DeviceType, CookieType, VisitsDataType, BrowserType, KameleoonData, DeviceDataType, CustomDataType, BrowserDataType, BrowserIndexMap, PageViewDataType, KameleoonDataType, UserAgentDataType, IdentifierDataType, ConversionDataType, OperatingSystemType, GeolocationInfoType, KameleoonDataItemType, PageViewParametersType, ConversionParametersType, ApplicationVersionDataType, AddDataParamsType, } from './types';
 export { DataManager, IDataManager } from './dataManager';

package/dist/kameleoonData/pageView.d.ts

@@ -7,10 +7,10 @@ import { TrackingStatus } from '../types';
  * */
 export declare class PageView implements IKameleoonData {
     timestamps: TimestampType[];
-    private urlAddress;
-    private title;
+    private readonly urlAddress;
+    private readonly title;
     private nonce?;
-    private referrers?;
+    private readonly referrers?;
     /**
      * @param {PageViewParametersType} pageViewParameters - an object with page view parameters
      * */

package/dist/kameleoonData/targetedSegment.d.ts

@@ -2,7 +2,7 @@ import { IKameleoonData, TargetedSegmentDataType } from './types';
 import { TrackingStatus } from '../types';
 export declare class TargetedSegment implements IKameleoonData {
     status: TrackingStatus;
-    private id;
+    private readonly id;
     constructor(id: number);
     get url(): string;
     get data(): TargetedSegmentDataType;

package/dist/kameleoonData/types.d.ts

@@ -177,6 +177,7 @@ export type MutUpdateTargetingDataParametersType = {
     kameleoonData: KameleoonDataType[];
     targetingData: TargetingDataType;
     extendTtl: boolean;
+    track?: boolean;
 };
 export type ReferenceParametersType = {
     mutData: TargetingDataType;
@@ -401,4 +402,15 @@ export type StaticDataType = {
     deviceType?: DeviceType;
     os?: OperatingSystemType;
 };
+/**
+ * @type `AddDataParamsType` Parameters for the object-style `KameleoonClient.addData` call.
+ * @param {string} visitorCode - Unique visitor identifier.
+ * @param {boolean} [track=true] - When `false`, stored items are treated as already tracked (no tracking will be sent for them).
+ * @param {KameleoonDataType[]} data - One or more `KameleoonData` instances to store for this visitor.
+ */
+export type AddDataParamsType = {
+    visitorCode: string;
+    track?: boolean;
+    data: KameleoonDataType[];
+};
 export {};

package/dist/kameleoonData/uniqueIdentifier.d.ts

@@ -2,7 +2,7 @@ import { TrackingStatus } from '../types';
 import { IKameleoonData, IdentifierDataType } from './types';
 export declare class UniqueIdentifier implements IKameleoonData {
     status: TrackingStatus;
-    private _value;
+    private readonly _value;
     /**
      * @param {boolean} value - a boolean value that indicates if the visitor has a unique identifier
      * */

package/dist/kameleoonData/userAgent.d.ts

@@ -6,7 +6,7 @@ import { TrackingStatus } from '../types';
  * */
 export declare class UserAgent implements IKameleoonData {
     status: TrackingStatus;
-    private value;
+    private readonly value;
     constructor(value: string);
     get url(): string;
     get data(): UserAgentDataType;

package/dist/tracking/tracker.d.ts

@@ -3,13 +3,13 @@ export interface ITracker {
     scheduleVisitor: (visitorCode: string, isConsentProvided: boolean) => void;
 }
 export declare class Tracker implements ITracker {
-    private dataManager;
-    private variationConfiguration;
-    private requester;
-    private bodyProvider;
-    private intervalId;
-    private trackingStorage;
-    private clientConfiguration;
+    private readonly dataManager;
+    private readonly variationConfiguration;
+    private readonly requester;
+    private readonly bodyProvider;
+    private readonly intervalId;
+    private readonly trackingStorage;
+    private readonly clientConfiguration;
     constructor({ dataManager, trackingStorage, variationConfiguration, trackingInterval, requester, prng, clientConfiguration, }: TrackerParametersType);
     scheduleVisitor(visitorCode: string, isConsentProvided: boolean): void;
     private checkIsIdentifier;

package/dist/types.d.ts

@@ -8,6 +8,7 @@ import { IExternalLogger } from './logging';
 import { FeatureFlagType as ConfigFeatureFlagType } from './clientConfiguration/types';
 import { Environment, ExternalPackageInfoType } from './sdkInfoTypes';
 import { CustomData, DataManager } from './kameleoonData';
+export { AddDataParamsType } from './kameleoonData/types';
 /**
  * @param {number} updateInterval - update interval in _minutes_ for sdk configuration, minimum value is 1 minute
  * @defaultvalue 60
@@ -26,7 +27,7 @@ import { CustomData, DataManager } from './kameleoonData';
  * @param {string | undefined} networkDomain - custom domain to be used in place of all requests URL, domain format is `example.com`, if the format is incorrect, default Kameleoon domain will be used
  * @param {number | undefined} requestTimeout - timeout in _milliseconds_ for requests
  * @defaultvalue `10_000` (10 seconds)
- * @param {number | undefined} trackingInterval - interval in _milliseconds_ for performing background tracking requests, must be a value between `100` to `1_000` milliseconds
+ * @param {number | undefined} trackingInterval - interval in _milliseconds_ for performing background tracking requests, must be a value between `1_000` to `5_000` milliseconds
  * @defaultvalue `1_000` (1 second)
  * @param {string | undefined} defaultDataFile - json string containing default configuration data, used to initialize the SDK when no data is available in the storage or when the data is not up-to-date
  * @defaultvalue `undefined` (no default data file)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kameleoon/javascript-sdk-core",
-  "version": "5.17.3",
+  "version": "5.18.0",
   "description": "Kameleoon JS SDK Core",
   "main": "dist/javascript-sdk-core.cjs.js",
   "module": "dist/javascript-sdk-core.es.js",