@kameleoon/javascript-sdk-core 5.15.0 → 5.16.1

package/dist/kameleoonClient.d.ts

@@ -1,6 +1,6 @@
 import { JSONType } from './clientConfiguration';
 import { CustomData, KameleoonDataType } from './kameleoonData';
-import { TrackConversionParamsType, FeatureFlagType, GetFeatureFlagVariableParamsType, FeatureVariableResultType, SDKCoreParameters, RemoteVisitorDataParamsType, GetVisitorWarehouseAudienceParamsType, SetUserConsentParametersType, FeatureFlagVariableType, KameleoonVariationType, VariationType, GetVariationParamsType, GetVariationsParamsType, IsFeatureFlagActiveParamsType, SetForcedVariationParametersType, FlushParamsType } from './types';
+import { TrackConversionParamsType, FeatureFlagType, GetFeatureFlagVariableParamsType, SDKCoreParameters, RemoteVisitorDataParamsType, GetVisitorWarehouseAudienceParamsType, SetUserConsentParametersType, FeatureFlagVariableType, KameleoonVariationType, GetVariationParamsType, GetVariationsParamsType, IsFeatureFlagActiveParamsType, SetForcedVariationParametersType, FlushParamsType, DataFile, Variable, Variation } from './types';
 import { IKameleoonClient } from './kameleoonClientInterface';
 import { EventCallbackType, EventType } from './eventManager';
 import { Tracker } from './tracking';
@@ -35,12 +35,12 @@ export declare class KameleoonClient implements IKameleoonClient {
     flush(params?: string | FlushParamsType): void;
     getFeatureFlags(): FeatureFlagType[];
     getVisitorFeatureFlags(visitorCode: string): FeatureFlagType[];
-    getVariation({ visitorCode, featureKey, track, }: GetVariationParamsType): VariationType;
-    getVariations({ visitorCode, onlyActive, track, }: GetVariationsParamsType): Map<string, VariationType>;
+    getVariation({ visitorCode, featureKey, track, }: GetVariationParamsType): Variation;
+    getVariations({ visitorCode, onlyActive, track, }: GetVariationsParamsType): Map<string, Variation>;
     getActiveFeatureFlags(visitorCode: string): Map<string, KameleoonVariationType>;
     getFeatureFlagVariationKey(visitorCode: string, featureKey: string): string;
     getFeatureFlagVariable({ visitorCode, featureKey, variableKey, }: GetFeatureFlagVariableParamsType): FeatureFlagVariableType;
-    getFeatureFlagVariables(visitorCode: string, featureKey: string): FeatureVariableResultType[];
+    getFeatureFlagVariables(visitorCode: string, featureKey: string): Variable[];
     isFeatureFlagActive(visitorCode: string, featureKey: string): boolean;
     isFeatureFlagActive({ visitorCode, featureKey, track, }: IsFeatureFlagActiveParamsType): boolean;
     getRemoteData(key: string): Promise<JSONType>;
@@ -51,6 +51,7 @@ export declare class KameleoonClient implements IKameleoonClient {
     setLogLevel(level: LogLevel): void;
     setForcedVariation({ visitorCode, experimentId, variationKey, forceTargeting, }: SetForcedVariationParametersType): void;
     evaluateAudiences(visitorCode: string): void;
+    getDataFile(): DataFile;
     protected setUserConsent({ visitorCode, consent, setData, }: SetUserConsentParametersType): void;
     private updateConsentData;
     protected _isConsentProvided(visitorCode: string): boolean;

package/dist/kameleoonClientInterface.d.ts

@@ -1,7 +1,7 @@
 import { JSONType } from './clientConfiguration';
 import { EventCallbackType, EventType } from './eventManager';
 import { CustomData, KameleoonDataType } from './kameleoonData';
-import { FeatureFlagType, FeatureFlagVariableType, FeatureVariableResultType, GetFeatureFlagVariableParamsType, GetVariationParamsType, GetVariationsParamsType, GetVisitorWarehouseAudienceParamsType, IsFeatureFlagActiveParamsType, KameleoonVariationType, RemoteVisitorDataParamsType, SetForcedVariationParametersType, TrackConversionParamsType, VariationType } from './types';
+import { 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
@@ -166,7 +166,7 @@ export interface IKameleoonClient {
      *
      * @param {GetVariationParamsType} parameters - an object with parameters of a type `GetVariationParamsType`, see the type for details.
      *
-     * @returns {VariationType} a variation object containing feature flag `key`, `id`, `experimentId` and `variables`, which is a `Map` of variable keys and values
+     * @returns {Variation} a variation object containing feature flag `key`, `id`, `experimentId` and `variables`, which is a `Map` of variable keys and values
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
@@ -175,7 +175,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `featureKey`
      * - `KameleoonException.FeatureFlagEnvironmentDisabled` - The feature flag is disabled for the current environment
      * */
-    getVariation: ({ visitorCode, featureKey, track, }: GetVariationParamsType) => VariationType;
+    getVariation: ({ visitorCode, featureKey, track, }: GetVariationParamsType) => Variation;
     /**
      * @method getVariation - returns all variations for the visitor under `visitorCode` for all the feature flags, this method includes targeting check, finding the according variations exposed to the visitor and saving them to storage. By default the method obtains all the variations, but if `onlyActive` is set to `true`, only active variations will be returned (those that are not `off`)
      *
@@ -184,14 +184,14 @@ export interface IKameleoonClient {
      *
      * @param {GetVariationsParamsType} parameters - an object with parameters of a type `GetVariationsParamsType`, see the type for details.
      *
-     * @returns {Map<string, VariationType>} a `Map` with variation keys and values, each value contains an object with feature flag `key`, `id`, `experimentId` and `variables`, which is a `Map` of variable keys and values
+     * @returns {Map<string, Variation>} a `Map` with variation keys and values, each value contains an object with feature flag `key`, `id`, `experimentId` and `variables`, which is a `Map` of variable keys and values
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
      * - `KameleoonException.VisitorCodeEmpty` The visitor code is empty
      * - `KameleoonException.Initialization` - Method was executed before the `kameleoonClient` completed it's `initialize` call
      */
-    getVariations: ({ visitorCode, onlyActive, track, }: GetVariationsParamsType) => Map<string, VariationType>;
+    getVariations: ({ visitorCode, onlyActive, track, }: GetVariationsParamsType) => Map<string, Variation>;
     /**
      * @deprecated this method is deprecated and will be removed in the next major release. Please use `getVariation` instead.
      * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
@@ -241,7 +241,7 @@ export interface IKameleoonClient {
      *
      * @param {string} visitorCode - a unique visitor identifier, shouldn't exceed 255 characters
      * @param {string} featureKey - a unique key for feature flag
-     * @returns {FeatureVariableResultType[]} a list of variable objects containing `key`, `type` and `value` fields. You can check the `type` field against `VariableType` enum. For example, if the `type` is `VariableType.BOOLEAN` then `value` will be a `boolean` type.
+     * @returns {Variable[]} a list of variable objects containing `key`, `type` and `value` fields. You can check the `type` field against `VariableType` enum. For example, if the `type` is `VariableType.BOOLEAN` then `value` will be a `boolean` type.
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
@@ -253,7 +253,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.JSONParse` - Couldn't parse JSON value
      * - `KameleoonException.NumberParse` - Couldn't parse Number value
      */
-    getFeatureFlagVariables: (visitorCode: string, featureKey: string) => FeatureVariableResultType[];
+    getFeatureFlagVariables: (visitorCode: string, featureKey: string) => Variable[];
     /**
      * @method getRemoteData - returns a data which is stored for specified siteCode on a remote Kameleoon server.
      * @param {string} key - unique key that the data you try to get is associated with.
@@ -338,4 +338,10 @@ export interface IKameleoonClient {
      * - `KameleoonException.Initialization` - Method was executed before the `kameleoonClient` completed its `initialize` call
      */
     evaluateAudiences(visitorCode: string): void;
+    /**
+     * @method getDataFile - retrieves the current SDK configuration (also known as the data file),
+     * containing all feature flags and their variations.
+     * @returns {DataFile} - The data file object containing the configuration details.
+     */
+    getDataFile(): DataFile;
 }

package/dist/kameleoonData/conversion.d.ts

@@ -1,6 +1,7 @@
 import { VisitType } from '../requester';
 import { ConversionDataType, ConversionParametersType, IKameleoonData } from './types';
 import { TrackingStatus } from '../types';
+import { CustomData } from '../kameleoonData/customData';
 /**
  * @class
  * Conversion - a class for creating an instance for conversion tracking
@@ -20,6 +21,7 @@ export declare class Conversion implements IKameleoonData {
     set _id(id: number);
     set _nonce(nonce: string);
     get url(): string;
+    get _metadata(): CustomData[] | undefined;
     get data(): ConversionDataType;
     private _encodeMetadata;
     /**

package/dist/kameleoonData/customData.d.ts

@@ -6,12 +6,13 @@ import { TrackingStatus } from '../types';
  * CustomData - a class for creating an instance for user's custom data
  * */
 export declare class CustomData implements IKameleoonData {
+    static readonly UNDEFINED_INDEX = -1;
     private _status;
-    private index;
+    private _index;
     private value;
     private isIdentifier;
     private overwrite;
-    private name?;
+    private _name?;
     /**
      * @param {number|string} indexOrName - either:
      *   - `number` — an index of custom data (configured in *Advanced Tools* section of Kameleoon Application)
@@ -68,8 +69,18 @@ export declare class CustomData implements IKameleoonData {
     static _updateFromVisit(visit: VisitType, dataMap: Map<number, CustomData>): void;
     /**
      * @private
-     * @method _index - an internal setter for setting index of custom data
+     * @method index - an internal setter for setting index of custom data
      * @param {number} value - an index value
      * */
-    set _index(value: number);
+    set index(value: number);
+    /**
+     * @private
+     * @method index - an internal getter for index of custom data
+     * */
+    get index(): number;
+    /**
+     * @private
+     * @method name - an internal getter for a name of custom data
+     * */
+    get name(): string | undefined;
 }

package/dist/kameleoonData/dataManager.d.ts

@@ -60,6 +60,7 @@ export declare class DataManager implements IDataManager {
     private mutUpdateTargetingData;
     private cleanupData;
     private processCustomData;
+    private trySetCustomDataIndexByName;
     get unsentDataVisitors(): string[];
     get identifierCustomDataIndex(): number | null;
     get trees(): Map<string, Tree>;

package/dist/types.d.ts

@@ -228,32 +228,52 @@ export type FeatureFlagType = {
     key: string;
 };
 /**
+ * @deprecated Use `Variable` instead.
+ *
  * @type `KameleoonVariableType` - tuple of possible feature variable result types, each possible variation is an object containing `key`, `type` and `value` fields, `type` can be checked against `VariableType` enum, if the `type` is `VariableType.BOOLEAN` then the `value` type will be `boolean` and so on.
  * */
 export type KameleoonVariableType = FeatureVariableResultType;
+/**
+ * @type `Variable` - tuple of possible feature variable result types, each possible variation is an object containing `key`, `type` and `value` fields, `type` can be checked against `VariableType` enum, if the `type` is `VariableType.BOOLEAN` then the `value` type will be `boolean` and so on.
+ * */
+export type Variable = FeatureVariableResultType;
 /**
  * @type `KameleoonVariationType` - object containing information about the variation and its variables
+ * @param {string} name - name of the variation
  * @param {string} key - key of the variation
  * @param {number | null} id - id of the variation or `null` if the visitor hit default variation
  * @param {number | null} experimentId - id of the experiment or `null` if the visitor hit default variation
- * @param {KameleoonVariableType[]} variables - array of variables for the variation
+ * @param {Variable[]} variables - array of variables for the variation
  * */
 export type KameleoonVariationType = {
+    name?: string;
     key: string;
     id: number | null;
     experimentId: number | null;
-    variables: KameleoonVariableType[];
+    variables: Variable[];
 };
 /**
+ * @deprecated Use `Variation` instead.
+ *
  * @type `VariationType` - an object containing information about the variation and its variables
+ * @param {string} name - name of the variation
  * @param {string} key - key of the variation
  * @param {number | null} id - id of the variation or `null` if the visitor hit default variation
  * @param {number | null} experimentId - id of the experiment or `null` if the visitor hit default variation
- * @param {Map<string, KameleoonVariableType>} variables - map of variables for the variation, where key is the variable key and value is the variable object
+ * @param {Map<string, Variable>} variables - map of variables for the variation, where key is the variable key and value is the variable object
  * */
 export type VariationType = Omit<KameleoonVariationType, 'variables'> & {
-    variables: Map<string, KameleoonVariableType>;
+    variables: Map<string, Variable>;
 };
+/**
+ * @type `Variation` - an object containing information about the variation and its variables
+ * @param {string} name - name of the variation
+ * @param {string} key - key of the variation
+ * @param {number | null} id - id of the variation or `null` if the visitor hit default variation
+ * @param {number | null} experimentId - id of the experiment or `null` if the visitor hit default variation
+ * @param {Map<string, Variable>} variables - map of variables for the variation, where key is the variable key and value is the variable object
+ * */
+export type Variation = VariationType;
 /**
  * @param {string} visitorCode - unique visitor identifier, shouldn't exceed 255 characters
  * @param {string} featureKey - key of the feature flag to look for, can be found on Kameleoon Platform
@@ -367,3 +387,15 @@ export type SetForcedVariationParametersType = {
     variationKey: string | null;
     forceTargeting?: boolean;
 };
+export type DataFile = {
+    featureFlags: Map<string, FeatureFlag>;
+};
+export type FeatureFlag = {
+    variations: Map<string, Variation>;
+    environmentEnabled: boolean;
+    rules: Rule[];
+    defaultVariationKey: string;
+};
+export type Rule = {
+    variations: Map<string, Variation>;
+};

package/package.json

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