@kameleoon/react-sdk 4.0.0 → 4.0.3

package/dist/withActivateFeature.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.withActivateFeature = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useActivateFeature_1 = require("./useActivateFeature");
+/**
+ * A React HOC that gives a wrapped component access to callback
+ * function which activates a feature toggle
+ */
+function withActivateFeature(Component) {
+    return function WrappedComponent(props) {
+        var _a = (0, useActivateFeature_1.useActivateFeature)(), hasFeature = _a.hasFeature, activateFeatureError = _a.error;
+        return ((0, jsx_runtime_1.jsx)(Component, __assign({ hasFeature: hasFeature, activateFeatureError: activateFeatureError }, props), void 0));
+    };
+}
+exports.withActivateFeature = withActivateFeature;
+//# sourceMappingURL=withActivateFeature.js.map

package/dist/withActivateFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withActivateFeature.js","sourceRoot":"","sources":["../src/withActivateFeature.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,2DAA0D;AAY1D;;;GAGG;AACH,SAAgB,mBAAmB,CACjC,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QACrC,IAAA,KAA8C,IAAA,uCAAkB,GAAE,EAAhE,UAAU,gBAAA,EAAS,oBAAoB,WAAyB,CAAC;QAEzE,OAAO,CACL,uBAAC,SAAS,aACR,UAAU,EAAE,UAAU,EACtB,oBAAoB,EAAE,oBAAoB,IACrC,KAAe,UACpB,CACH,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAdD,kDAcC"}

package/dist/withAddData.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { DataInterface as IData } from 'kameleoon-client-javascript/dist/interfaces/interfaces';
+import { UnknownPropsType, Without } from './types';
+interface IWithAddData {
+    /**
+     * @param visitorCode - unique identifier of the user
+     * @param dataTypes - custom data types which may be passed separated by a comma
+     */
+    addData: (visitorCode: string, ...dataTypes: IData[]) => void;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds various data to associate this data with the current user
+ */
+export declare function withAddData<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithAddData>>;
+export {};

package/dist/withAddData.js

@@ -0,0 +1,65 @@
+"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);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAddData = 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 adds various data to associate this data with the current user
+ */
+function withAddData(Component) {
+    return function WrappedComponent(props) {
+        var client = (0, react_1.useContext)(KameleoonContext_1.KameleoonContext);
+        var addData = (0, react_1.useCallback)(function (visitorCode) {
+            var dataTypes = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                dataTypes[_i - 1] = arguments[_i];
+            }
+            if (!client) {
+                throw new ProviderError_1.ProviderError('withAddData');
+            }
+            return client.addData.apply(client, __spreadArray([visitorCode], __read(dataTypes), false));
+        }, [client]);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ addData: addData }, props), void 0);
+    };
+}
+exports.withAddData = withAddData;
+//# sourceMappingURL=withAddData.js.map

package/dist/withAddData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withAddData.js","sourceRoot":"","sources":["../src/withAddData.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAAuD;AAGvD,uDAAsD;AACtD,iDAAgD;AAUhD;;;GAGG;AACH,SAAgB,WAAW,CACzB,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,mCAAgB,CAAC,CAAC;QAE5C,IAAM,OAAO,GAAG,IAAA,mBAAW,EACzB,UAAC,WAAmB;YAAE,mBAAqB;iBAArB,UAAqB,EAArB,qBAAqB,EAArB,IAAqB;gBAArB,kCAAqB;;YACzC,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,IAAI,6BAAa,CAAC,aAAa,CAAC,CAAC;aACxC;YAED,OAAO,MAAM,CAAC,OAAO,OAAd,MAAM,iBAAS,WAAW,UAAK,SAAS,WAAE;QACnD,CAAC,EACD,CAAC,MAAM,CAAC,CACT,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,OAAO,EAAE,OAAO,IAAO,KAAe,UAAI,CAAC;IAC/D,CAAC,CAAC;AACJ,CAAC;AAnBD,kCAmBC"}

package/dist/withBrowser.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { Browser as IBrowser } from 'kameleoon-client-javascript/dist/data';
+import { Browser } from './constants';
+import { UnknownPropsType, Without } from './types';
+interface IWithBrowser {
+    /**
+     * @param browser - browser types: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER
+     */
+    addBrowser: (browser: Browser) => IBrowser;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds browser type
+ */
+export declare function withBrowser<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithBrowser>>;
+export {};

package/dist/withBrowser.js

@@ -0,0 +1,35 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withBrowser = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var data_1 = __importDefault(require("kameleoon-client-javascript/dist/data"));
+var kameleoon_client_javascript_1 = require("kameleoon-client-javascript");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds browser type
+ */
+function withBrowser(Component) {
+    return function WrappedComponent(props) {
+        var addBrowser = (0, react_1.useCallback)(function (browser) {
+            return new kameleoon_client_javascript_1.KameleoonData.Browser(data_1.default.browsers[browser]);
+        }, []);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ addBrowser: addBrowser }, props), void 0);
+    };
+}
+exports.withBrowser = withBrowser;
+//# sourceMappingURL=withBrowser.js.map

package/dist/withBrowser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withBrowser.js","sourceRoot":"","sources":["../src/withBrowser.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,+BAA2C;AAC3C,+EAE+C;AAC/C,2EAA4D;AAW5D;;;GAGG;AACH,SAAgB,WAAW,CACzB,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,UAAU,GAAG,IAAA,mBAAW,EAAC,UAAC,OAAgB;YAC9C,OAAO,IAAI,2CAAa,CAAC,OAAO,CAAC,cAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;QAC3D,CAAC,EAAE,EAAE,CAAC,CAAC;QAEP,OAAO,uBAAC,SAAS,aAAC,UAAU,EAAE,UAAU,IAAO,KAAe,UAAI,CAAC;IACrE,CAAC,CAAC;AACJ,CAAC;AAVD,kCAUC"}

package/dist/withConversion.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Conversion } from 'kameleoon-client-javascript/dist/data';
+import { UnknownPropsType, Without } from './types';
+interface IWithConversion {
+    /**
+     * @param goalId - unique identifier of the goal
+     * @param revenue - conversion revenue
+     * @param negative - defines if the revenue is positive or negative
+     */
+    addConversion: (goalId: number, revenue?: number, negative?: boolean) => Conversion;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds conversion
+ */
+export declare function withConversion<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithConversion>>;
+export {};

package/dist/withConversion.js

@@ -0,0 +1,31 @@
+"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.withConversion = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var kameleoon_client_javascript_1 = require("kameleoon-client-javascript");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds conversion
+ */
+function withConversion(Component) {
+    return function WrappedComponent(props) {
+        var addConversion = (0, react_1.useCallback)(function (goalId, revenue, negative) {
+            return new kameleoon_client_javascript_1.KameleoonData.Conversion(goalId, revenue, negative);
+        }, []);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ addConversion: addConversion }, props), void 0);
+    };
+}
+exports.withConversion = withConversion;
+//# sourceMappingURL=withConversion.js.map

package/dist/withConversion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withConversion.js","sourceRoot":"","sources":["../src/withConversion.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAA2C;AAC3C,2EAA4D;AAiB5D;;;GAGG;AACH,SAAgB,cAAc,CAC5B,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,aAAa,GAAG,IAAA,mBAAW,EAC/B,UAAC,MAAc,EAAE,OAAgB,EAAE,QAAkB;YACnD,OAAO,IAAI,2CAAa,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QACjE,CAAC,EACD,EAAE,CACH,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,aAAa,EAAE,aAAa,IAAO,KAAe,UAAI,CAAC;IAC3E,CAAC,CAAC;AACJ,CAAC;AAbD,wCAaC"}

package/dist/withCustomData.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { CustomData } from 'kameleoon-client-javascript/dist/data';
+import { UnknownPropsType, Without } from './types';
+interface IWithCustomData {
+    /**
+     * @param index - index or unique identifier of the custom data to be stored
+     * @param value - value of the custom data to be stored
+     */
+    addCustomData: (index: number, value: string) => CustomData;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds custom data
+ */
+export declare function withCustomData<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithCustomData>>;
+export {};

package/dist/withCustomData.js

@@ -0,0 +1,31 @@
+"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.withCustomData = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var kameleoon_client_javascript_1 = require("kameleoon-client-javascript");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds custom data
+ */
+function withCustomData(Component) {
+    return function WrappedComponent(props) {
+        var addCustomData = (0, react_1.useCallback)(function (goalId, revenue, negative) {
+            return new kameleoon_client_javascript_1.KameleoonData.Conversion(goalId, revenue, negative);
+        }, []);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ addCustomData: addCustomData }, props), void 0);
+    };
+}
+exports.withCustomData = withCustomData;
+//# sourceMappingURL=withCustomData.js.map

package/dist/withCustomData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withCustomData.js","sourceRoot":"","sources":["../src/withCustomData.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAA2C;AAC3C,2EAA4D;AAY5D;;;GAGG;AACH,SAAgB,cAAc,CAC5B,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,aAAa,GAAG,IAAA,mBAAW,EAC/B,UAAC,MAAc,EAAE,OAAgB,EAAE,QAAkB;YACnD,OAAO,IAAI,2CAAa,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QACjE,CAAC,EACD,EAAE,CACH,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,aAAa,EAAE,aAAa,IAAO,KAAe,UAAI,CAAC;IAC3E,CAAC,CAAC;AACJ,CAAC;AAbD,wCAaC"}

package/dist/withDevice.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { Device as IDevice, DeviceType } from 'kameleoon-client-javascript/dist/data';
+import { UnknownPropsType, Without } from './types';
+interface IWithDevice {
+    /**
+     * @param device - device types: Phone, Tablet, Desktop
+     */
+    addDevice: (device: DeviceType) => IDevice;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds device type
+ */
+export declare function withDevice<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithDevice>>;
+export {};

package/dist/withDevice.js

@@ -0,0 +1,29 @@
+"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.withDevice = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var kameleoon_client_javascript_1 = require("kameleoon-client-javascript");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds device type
+ */
+function withDevice(Component) {
+    return function WrappedComponent(props) {
+        var addDevice = (0, react_1.useCallback)(function (device) { return new kameleoon_client_javascript_1.KameleoonData.Device(device); }, []);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ addDevice: addDevice }, props), void 0);
+    };
+}
+exports.withDevice = withDevice;
+//# sourceMappingURL=withDevice.js.map

package/dist/withDevice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDevice.js","sourceRoot":"","sources":["../src/withDevice.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAA2C;AAK3C,2EAA4D;AAU5D;;;GAGG;AACH,SAAgB,UAAU,CACxB,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,SAAS,GAAG,IAAA,mBAAW,EAC3B,UAAC,MAAkB,IAAc,OAAA,IAAI,2CAAa,CAAC,MAAM,CAAC,MAAM,CAAC,EAAhC,CAAgC,EACjE,EAAE,CACH,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,SAAS,EAAE,SAAS,IAAO,KAAe,UAAI,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC;AAXD,gCAWC"}

package/dist/withFeature.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Without, IFeatureParams, UnknownPropsType } from './types';
+/**
+ * A React HOC that gives a wrapped component access to the status of a feature flag and its variables
+ */
+export declare function withFeature(args: IFeatureParams): <Props extends UnknownPropsType>(Component: React.ComponentType<Props>) => React.ComponentType<Props & Without<Props, IFeatureParams>>;

package/dist/withFeature.js

@@ -0,0 +1,31 @@
+"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.withFeature = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useFeature_1 = require("./useFeature");
+/**
+ * A React HOC that gives a wrapped component access to the status of a feature flag and its variables
+ */
+function withFeature(args) {
+    // Returns curried function that can be used with the specified args
+    // e.g. withFeature(...args)(Component)
+    return function callbackWithArgs(Component) {
+        return function WrappedComponent(props) {
+            var _a = (0, useFeature_1.useFeature)(__assign({}, args)), feature = _a.feature, featureErrors = _a.errors;
+            return ((0, jsx_runtime_1.jsx)(Component, __assign({ feature: feature, featureErrors: featureErrors }, props), void 0));
+        };
+    };
+}
+exports.withFeature = withFeature;
+//# sourceMappingURL=withFeature.js.map

package/dist/withFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFeature.js","sourceRoot":"","sources":["../src/withFeature.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,2CAA0C;AAE1C;;GAEG;AACH,SAAgB,WAAW,CAAC,IAAoB;IAC9C,oEAAoE;IACpE,uCAAuC;IACvC,OAAO,SAAS,gBAAgB,CAC9B,SAAqC;QAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;YACrC,IAAA,KAAqC,IAAA,uBAAU,eAAM,IAAI,EAAG,EAA1D,OAAO,aAAA,EAAU,aAAa,YAA4B,CAAC;YAEnE,OAAO,CACL,uBAAC,SAAS,aACR,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,IACvB,KAAe,UACpB,CACH,CAAC;QACJ,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAlBD,kCAkBC"}

package/dist/withFeatureVariable.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { KameleoonError } from './KameleoonError';
+import { FeatureFlagVariableType, UnknownPropsType, Without } from './types';
+interface IWithFeatureVariable {
+    /**
+     * @param featureKey - unique identifier or key of the feature you want to obtain to a user
+     * @param variableKey - key of the variable
+     */
+    getFeatureVariable: (featureKey: string | number, variableKey: string) => FeatureFlagVariableType;
+    featureVariableError: KameleoonError | null;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which retrieves a feature variable
+ */
+export declare function withFeatureVariable<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithFeatureVariable>>;
+export {};

package/dist/withFeatureVariable.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.withFeatureVariable = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useFeatureVariable_1 = require("./useFeatureVariable");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which retrieves a feature variable
+ */
+function withFeatureVariable(Component) {
+    return function WrappedComponent(props) {
+        var _a = (0, useFeatureVariable_1.useFeatureVariable)(), getFeatureVariable = _a.getFeatureVariable, featureVariableError = _a.error;
+        return ((0, jsx_runtime_1.jsx)(Component, __assign({ getFeatureVariable: getFeatureVariable, featureVariableError: featureVariableError }, props), void 0));
+    };
+}
+exports.withFeatureVariable = withFeatureVariable;
+//# sourceMappingURL=withFeatureVariable.js.map

package/dist/withFeatureVariable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFeatureVariable.js","sourceRoot":"","sources":["../src/withFeatureVariable.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAGA,2DAA0D;AAc1D;;;GAGG;AACH,SAAgB,mBAAmB,CACjC,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QACrC,IAAA,KACJ,IAAA,uCAAkB,GAAE,EADd,kBAAkB,wBAAA,EAAS,oBAAoB,WACjC,CAAC;QAEvB,OAAO,CACL,uBAAC,SAAS,aACR,kBAAkB,EAAE,kBAAkB,EACtC,oBAAoB,EAAE,oBAAoB,IACrC,KAAe,UACpB,CACH,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAfD,kDAeC"}

package/dist/withFlush.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { UnknownPropsType, Without } from './types';
+interface IWithFlush {
+    /**
+     * @param visitorCode - unique identifier of the user
+     */
+    flush: (visitorCode: string) => void;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which allows to flush data to servers
+ */
+export declare function withFlush<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithFlush>>;
+export {};

package/dist/withFlush.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.withFlush = 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 allows to flush data to servers
+ */
+function withFlush(Component) {
+    return function WrappedComponent(props) {
+        var client = (0, react_1.useContext)(KameleoonContext_1.KameleoonContext);
+        var flush = (0, react_1.useCallback)(function (visitorCode) {
+            if (!client) {
+                throw new ProviderError_1.ProviderError('withFlush');
+            }
+            client.flush(visitorCode);
+        }, [client]);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ flush: flush }, props), void 0);
+    };
+}
+exports.withFlush = withFlush;
+//# sourceMappingURL=withFlush.js.map

package/dist/withFlush.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFlush.js","sourceRoot":"","sources":["../src/withFlush.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAAuD;AACvD,iDAAgD;AAEhD,uDAAsD;AAStD;;;GAGG;AACH,SAAgB,SAAS,CACvB,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,mCAAgB,CAAC,CAAC;QAE5C,IAAM,KAAK,GAAG,IAAA,mBAAW,EACvB,UAAC,WAAmB;YAClB,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,IAAI,6BAAa,CAAC,WAAW,CAAC,CAAC;aACtC;YACD,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC,EACD,CAAC,MAAM,CAAC,CACT,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,KAAK,EAAE,KAAK,IAAO,KAAe,UAAI,CAAC;IAC3D,CAAC,CAAC;AACJ,CAAC;AAlBD,8BAkBC"}

package/dist/withKameleoon.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { KameleoonClient } from 'kameleoon-client-javascript';
+import { UnknownPropsType, Without } from './types';
+interface IWithKameleoonProps {
+    /** An instance of KameleoonClient */
+    client: KameleoonClient;
+}
+/**
+ * A React HOC that gives a wrapped component direct access
+ * to Kameleoon client via props
+ */
+export declare function withKameleoon<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithKameleoonProps>>;
+export {};

package/dist/withKameleoon.js

@@ -0,0 +1,33 @@
+"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.withKameleoon = 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 direct access
+ * to Kameleoon client via props
+ */
+function withKameleoon(Component) {
+    return function WrappedComponent(props) {
+        var client = (0, react_1.useContext)(KameleoonContext_1.KameleoonContext);
+        if (!client) {
+            throw new ProviderError_1.ProviderError('withKameleoon');
+        }
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ client: client }, props), void 0);
+    };
+}
+exports.withKameleoon = withKameleoon;
+//# sourceMappingURL=withKameleoon.js.map

package/dist/withKameleoon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withKameleoon.js","sourceRoot":"","sources":["../src/withKameleoon.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAA0C;AAE1C,uDAAsD;AACtD,iDAAgD;AAQhD;;;GAGG;AACH,SAAgB,aAAa,CAC3B,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,mCAAgB,CAAC,CAAC;QAE5C,IAAI,CAAC,MAAM,EAAE;YACX,MAAM,IAAI,6BAAa,CAAC,eAAe,CAAC,CAAC;SAC1C;QAED,OAAO,uBAAC,SAAS,aAAC,MAAM,EAAE,MAAM,IAAO,KAAe,UAAI,CAAC;IAC7D,CAAC,CAAC;AACJ,CAAC;AAZD,sCAYC"}

package/dist/withPageView.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { PageView } from 'kameleoon-client-javascript/dist/data';
+import { UnknownPropsType, Without } from './types';
+interface IWithPageView {
+    /**
+     * @param url - URL of the page viewed
+     * @param title - title of the page viewed
+     * @param referrer - referrer of the page viewed
+     */
+    addPageView: (url: string, title: string, referrer?: number) => PageView;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds page view
+ */
+export declare function withPageView<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithPageView>>;
+export {};

package/dist/withPageView.js

@@ -0,0 +1,31 @@
+"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.withPageView = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var kameleoon_client_javascript_1 = require("kameleoon-client-javascript");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which adds page view
+ */
+function withPageView(Component) {
+    return function WrappedComponent(props) {
+        var addPageView = (0, react_1.useCallback)(function (url, title, referrer) {
+            return new kameleoon_client_javascript_1.KameleoonData.PageView(url, title, referrer);
+        }, []);
+        return (0, jsx_runtime_1.jsx)(Component, __assign({ addPageView: addPageView }, props), void 0);
+    };
+}
+exports.withPageView = withPageView;
+//# sourceMappingURL=withPageView.js.map

package/dist/withPageView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withPageView.js","sourceRoot":"","sources":["../src/withPageView.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,+BAA2C;AAE3C,2EAA4D;AAY5D;;;GAGG;AACH,SAAgB,YAAY,CAC1B,SAAqC;IAErC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QAC3C,IAAM,WAAW,GAAG,IAAA,mBAAW,EAC7B,UAAC,GAAW,EAAE,KAAa,EAAE,QAAiB;YAC5C,OAAO,IAAI,2CAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC1D,CAAC,EACD,EAAE,CACH,CAAC;QAEF,OAAO,uBAAC,SAAS,aAAC,WAAW,EAAE,WAAW,IAAO,KAAe,UAAI,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC;AAbD,oCAaC"}

package/dist/withRetrieveDataFromRemoteSource.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { UnknownPropsType, Without, RemoteSourceDataType } from './types';
+interface IWithRetrieveDataFromRemoteSource {
+    /**
+     * @param key - unique key for data defined for Kameleoon Data API
+     */
+    retrieveDataFromRemoteSource: (key: string) => Promise<RemoteSourceDataType>;
+}
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which retrieves data from Kameleoon Data API
+ */
+export declare function withRetrieveDataFromRemoteSource<Props extends UnknownPropsType>(Component: React.ComponentType<Props>): React.ComponentType<Props & Without<Props, IWithRetrieveDataFromRemoteSource>>;
+export {};

package/dist/withRetrieveDataFromRemoteSource.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.withRetrieveDataFromRemoteSource = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var useRetrieveDataFromRemoteSource_1 = require("./useRetrieveDataFromRemoteSource");
+/**
+ * A React HOC that gives a wrapped component access to callback function
+ * which retrieves data from Kameleoon Data API
+ */
+function withRetrieveDataFromRemoteSource(Component) {
+    return function WrappedComponent(props) {
+        var retrieveDataFromRemoteSource = (0, useRetrieveDataFromRemoteSource_1.useRetrieveDataFromRemoteSource)().retrieveDataFromRemoteSource;
+        return ((0, jsx_runtime_1.jsx)(Component, __assign({ retrieveDataFromRemoteSource: retrieveDataFromRemoteSource }, props), void 0));
+    };
+}
+exports.withRetrieveDataFromRemoteSource = withRetrieveDataFromRemoteSource;
+//# sourceMappingURL=withRetrieveDataFromRemoteSource.js.map

package/dist/withRetrieveDataFromRemoteSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRetrieveDataFromRemoteSource.js","sourceRoot":"","sources":["../src/withRetrieveDataFromRemoteSource.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,qFAAoF;AASpF;;;GAGG;AACH,SAAgB,gCAAgC,CAG9C,SAAqC;IAIrC,OAAO,SAAS,gBAAgB,CAAC,KAAY;QACnC,IAAA,4BAA4B,GAAK,IAAA,iEAA+B,GAAE,6BAAtC,CAAuC;QAE3E,OAAO,CACL,uBAAC,SAAS,aACR,4BAA4B,EAAE,4BAA4B,IACrD,KAAe,UACpB,CACH,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAjBD,4EAiBC"}