@kameleoon/react-sdk 4.0.0 → 4.0.3

package/dist/withRunWhenReady.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { UnknownPropsType, Without } from './types';
+interface IWithRunWhenReadyData {
+    /**
+     * @param successCallback - callback which will be executed on successful client initialization
+     * @param errorCallback - callback which will be executed if client wasn't able to initialize during the timeout
+     * @param timeout - timeout which is given to perform HTTP call for initialization in ms (by default: 2 seconds)
+     */
+    runWhenReady: (successCallback: () => void, errorCallback: () => void, timeout?: number) => void;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function which makes sure that
+ * Kameleoon Client will be initialized properly using HTTP call within the specified timeout
+ */
+export declare function withRunWhenReady<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithRunWhenReadyData>>;
+export {};

package/dist/withRunWhenReady.js

@@ -0,0 +1,28 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRunWhenReady = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useRunWhenReady_1 = require("./useRunWhenReady");
+/**
+ * A React HOC that gives a wrapped component access to callback function which makes sure that
+ * Kameleoon Client will be initialized properly using HTTP call within the specified timeout
+ */
+function withRunWhenReady(Component) {
+    return function WrappedComponent(props) {
+        var runWhenReady = (0, useRunWhenReady_1.useRunWhenReady)().runWhenReady;
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ runWhenReady: runWhenReady }, props), void 0);
+    };
+}
+exports.withRunWhenReady = withRunWhenReady;
+//# sourceMappingURL=withRunWhenReady.js.map

package/dist/withRunWhenReady.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRunWhenReady.js","sourceRoot":"","sources":["../src/withRunWhenReady.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,qDAAoD;AAepD;;;GAGG;AACH,SAAgB,gBAAgB,CAC9B,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QACnC,IAAA,YAAY,GAAK,IAAA,iCAAe,GAAE,aAAtB,CAAuB;QAE3C,OAAO,uBAAC,SAAS,aAAC,YAAY,EAAE,YAAY,IAAO,KAAe,UAAI,CAAC;IACzE,CAAC,CAAC;AACJ,CAAC;AARD,4CAQC"}

package/dist/withTrackingConversion.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { UnknownPropsType, Without } from './types';
+interface IWithTrackingConversion {
+    /**
+     * @param visitorCode - unique identifier of the user
+     * @param goalId - unique identifier of the goal
+     * @param revenue - revenue of the conversion
+     */
+    trackConversion: (visitorCode: string, goalId: number, revenue?: number) => void;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which tracks conversion
+ */
+export declare function withTrackingConversion<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithTrackingConversion>>;
+export {};

package/dist/withTrackingConversion.js

@@ -0,0 +1,36 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTrackingConversion = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var ProviderError_1 = require("./ProviderError");
+var KameleoonContext_1 = require("./KameleoonContext");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which tracks conversion
+ */
+function withTrackingConversion(Component) {
+    return function WrappedComponent(props) {
+        var client = (0, react_1.useContext)(KameleoonContext_1.KameleoonContext);
+        var trackConversion = (0, react_1.useCallback)(function (visitorCode, goalId, revenue) {
+            if (!client) {
+                throw new ProviderError_1.ProviderError('withTrackingConversion');
+            }
+            return client.trackConversion(visitorCode, goalId, revenue);
+        }, [client]);
+        return ((0, jsx_runtime_1.jsx)(Component, __assign({ trackConversion: trackConversion }, props), void 0));
+    };
+}
+exports.withTrackingConversion = withTrackingConversion;
+//# sourceMappingURL=withTrackingConversion.js.map

package/dist/withTrackingConversion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTrackingConversion.js","sourceRoot":"","sources":["../src/withTrackingConversion.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAAuD;AAEvD,iDAAgD;AAChD,uDAAsD;AAetD;;;GAGG;AACH,SAAgB,sBAAsB,CACpC,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,mCAAgB,CAAC,CAAC;QAE5C,IAAM,eAAe,GAAG,IAAA,mBAAW,EACjC,UAAC,WAAmB,EAAE,MAAc,EAAE,OAAgB;YACpD,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,IAAI,6BAAa,CAAC,wBAAwB,CAAC,CAAC;aACnD;YAED,OAAO,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC9D,CAAC,EACD,CAAC,MAAM,CAAC,CACT,CAAC;QAEF,OAAO,CACL,uBAAC,SAAS,aAAC,eAAe,EAAE,eAAe,IAAO,KAAe,UAAI,CACtE,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AArBD,wDAqBC"}

package/dist/withTriggerExperiment.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { KameleoonError } from './KameleoonError';
+import { UnknownPropsType, Without } from './types';
+interface IWithTriggerExperiment {
+    /**
+     * @param visitorCode - unique identifier of the user
+     * @param experimentId - unique identifier of the experiment you want to expose to a user
+     */
+    getVariationId: (visitorCode: string, experimentId: number) => number;
+    triggerExperimentError: KameleoonError | null;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function which triggers experiment
+ * If such a user has never been associated with any variation, the SDK returns a randomly selected variation.
+ * If a user with a given visitorCode is already registered with a variation,
+ * it will detect the previously registered variation and return the variationID
+ */
+export declare function withTriggerExperiment<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithTriggerExperiment>>;
+export {};

package/dist/withTriggerExperiment.js

@@ -0,0 +1,30 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTriggerExperiment = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useTriggerExperiment_1 = require("./useTriggerExperiment");
+/**
+ * A React HOC that gives a wrapped component access to callback function which triggers experiment
+ * If such a user has never been associated with any variation, the SDK returns a randomly selected variation.
+ * If a user with a given visitorCode is already registered with a variation,
+ * it will detect the previously registered variation and return the variationID
+ */
+function withTriggerExperiment(Component) {
+    return function WrappedComponent(props) {
+        var _a = (0, useTriggerExperiment_1.useTriggerExperiment)(), getVariationId = _a.getVariationId, triggerExperimentError = _a.error;
+        return ((0, jsx_runtime_1.jsx)(Component, __assign({ getVariationId: getVariationId, triggerExperimentError: triggerExperimentError }, props), void 0));
+    };
+}
+exports.withTriggerExperiment = withTriggerExperiment;
+//# sourceMappingURL=withTriggerExperiment.js.map

package/dist/withTriggerExperiment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTriggerExperiment.js","sourceRoot":"","sources":["../src/withTriggerExperiment.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAGA,+DAA8D;AAW9D;;;;;GAKG;AACH,SAAgB,qBAAqB,CACnC,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QACrC,IAAA,KACJ,IAAA,2CAAoB,GAAE,EADhB,cAAc,oBAAA,EAAS,sBAAsB,WAC7B,CAAC;QAEzB,OAAO,CACL,uBAAC,SAAS,aACR,cAAc,EAAE,cAAc,EAC9B,sBAAsB,EAAE,sBAAsB,IACzC,KAAe,UACpB,CACH,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAfD,sDAeC"}

package/dist/withVariationAssociatedData.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { UnknownPropsType, Without, VariationAssociatedDataType } from './types';
+import { KameleoonError } from './KameleoonError';
+interface IWithVariationAssociatedData {
+    /**
+     * @param variationId - unique identifier of the variation you want to obtain associated data for
+     */
+    getVariationAssociatedData: (variationId: number) => VariationAssociatedDataType;
+    variationAssociatedDataError: KameleoonError | null;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function which
+ * retrieves JSON data associated with a variation.
+ * The JSON data usually represents some metadata of the variation,
+ * and can be configured on our web application interface or via our Automation API.
+ */
+export declare function withVariationAssociatedData<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithVariationAssociatedData>>;
+export {};

package/dist/withVariationAssociatedData.js

@@ -0,0 +1,30 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withVariationAssociatedData = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useVariationAssociatedData_1 = require("./useVariationAssociatedData");
+/**
+ * A React HOC that gives a wrapped component access to callback function which
+ * retrieves JSON data associated with a variation.
+ * The JSON data usually represents some metadata of the variation,
+ * and can be configured on our web application interface or via our Automation API.
+ */
+function withVariationAssociatedData(Component) {
+    return function WrappedComponent(props) {
+        var _a = (0, useVariationAssociatedData_1.useVariationAssociatedData)(), getVariationAssociatedData = _a.getVariationAssociatedData, variationAssociatedDataError = _a.error;
+        return ((0, jsx_runtime_1.jsx)(Component, __assign({ getVariationAssociatedData: getVariationAssociatedData, variationAssociatedDataError: variationAssociatedDataError }, props), void 0));
+    };
+}
+exports.withVariationAssociatedData = withVariationAssociatedData;
+//# sourceMappingURL=withVariationAssociatedData.js.map

package/dist/withVariationAssociatedData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withVariationAssociatedData.js","sourceRoot":"","sources":["../src/withVariationAssociatedData.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAMA,2EAA0E;AAa1E;;;;;GAKG;AACH,SAAgB,2BAA2B,CACzC,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QACrC,IAAA,KACJ,IAAA,uDAA0B,GAAE,EADtB,0BAA0B,gCAAA,EAAS,4BAA4B,WACzC,CAAC;QAE/B,OAAO,CACL,uBAAC,SAAS,aACR,0BAA0B,EAAE,0BAA0B,EACtD,4BAA4B,EAAE,4BAA4B,IACrD,KAAe,UACpB,CACH,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAfD,kEAeC"}

package/dist/withVisitorCode.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { UnknownPropsType, Without } from './types';
+interface IWithVisitorCode {
+    /**
+     * @param topLevelDomain - current top level domain for the concerned site
+     * @param defaultVisitorCode - this parameter will be used as the visitorCode
+     */
+    getVisitorCode: (topLevelDomain: string, defaultVisitorCode?: string) => string;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which obtains the Kameleoon visitorCode for the current visitor
+ */
+export declare function withVisitorCode<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithVisitorCode>>;
+export {};

package/dist/withVisitorCode.js

@@ -0,0 +1,36 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withVisitorCode = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var KameleoonContext_1 = require("./KameleoonContext");
+var ProviderError_1 = require("./ProviderError");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which obtains the Kameleoon visitorCode for the current visitor
+ */
+function withVisitorCode(Component) {
+    return function WrappedComponent(props) {
+        var client = (0, react_1.useContext)(KameleoonContext_1.KameleoonContext);
+        var getVisitorCode = (0, react_1.useCallback)(function (topLevelDomain, defaultVisitorCode) {
+            if (!client) {
+                throw new ProviderError_1.ProviderError('withVisitorCode');
+            }
+            return client.obtainVisitorCode(topLevelDomain, defaultVisitorCode);
+        }, [client]);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ getVisitorCode: getVisitorCode }, props), void 0);
+    };
+}
+exports.withVisitorCode = withVisitorCode;
+//# sourceMappingURL=withVisitorCode.js.map

package/dist/withVisitorCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withVisitorCode.js","sourceRoot":"","sources":["../src/withVisitorCode.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAAuD;AAEvD,uDAAsD;AACtD,iDAAgD;AAahD;;;GAGG;AACH,SAAgB,eAAe,CAC7B,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,mCAAgB,CAAC,CAAC;QAE5C,IAAM,cAAc,GAAG,IAAA,mBAAW,EAChC,UAAC,cAAsB,EAAE,kBAA2B;YAClD,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,IAAI,6BAAa,CAAC,iBAAiB,CAAC,CAAC;aAC5C;YAED,OAAO,MAAM,CAAC,iBAAiB,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;QACtE,CAAC,EACD,CAAC,MAAM,CAAC,CACT,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,cAAc,EAAE,cAAc,IAAO,KAAe,UAAI,CAAC;IAC7E,CAAC,CAAC;AACJ,CAAC;AAnBD,0CAmBC"}

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@kameleoon/react-sdk",
-  "version": "4.0.0",
+  "version": "4.0.3",
   "description": "Kameleoon React SDK",
   "files": [
     "dist"
   ],
   "main": "dist/index.js",
   "scripts": {
-    "clear": "rimraf dist",
+    "clear": "rimraf dist && rimraf tsconfig.tsbuildinfo",
     "start": "npm run clear && tsc -w",
     "build": "npm run clear && tsc",
     "deploy": "npm publish --tag latest --access public",
+    "deploy-nexus": "npm publish --registry=https://nexus.kameleoon.net/repository/npm-kameleoon/",
     "release": "../../scripts/release.sh react-sdk",
     "update-documentation": "../../scripts/update_documentation.sh react",
     "test": "jest",