@kameleoon/react-sdk 2.1.0 → 4.0.1

package/README.md

@@ -137,26 +137,43 @@ Returns the status of a feature flag and its variables.
   - `visitorCode: string` (optional) - unique identifier of the user.
 
 #### Returns
-- `featureResult: IFeature`
+- `errors: KameleoonException[]` - an array of errors thrown as a result of getting variables or feature flag status.
+- `feature` -  an object containing feature flag status and variables
   - `isActive: boolean` - feature flag status.
   - `variables: FeatureVariableType[]` - feature flag variables.
 
+#### Exceptions
+- `KameleoonException.NotTargeted` - Exception indicating that the current visitor / user did not trigger the required targeting conditions for this feature. The targeting conditions are defined via Kameleoon's segment builder.
+- `KameleoonException.FeatureConfigurationNotFound` - Exception indicating that the requested feature ID has not been found in the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet been activated on Kameleoon's side (but code implementing the feature is already deployed on the web-application's side).
+
 
 In this examples, if the feature flag with the `red-button` key is enabled, theme of button will set to red.
 ### `useFeature`
 #### Example
 ```jsx
 import { Button } from '@kameleoon/ui';
-import { useFeature, useVisitorCode } from '@kameleoon/react-sdk';
+import { useFeature, useVisitorCode, KameleoonException } from '@kameleoon/react-sdk';
 
 function MyComponent(): JSX.Element {
   const { getVisitorCode } = useVisitorCode();
-  const { isActive } = useFeature({
+  const { feature, errors } = useFeature({
     featureKey: 'red-button',
     variableKeys: { production: 'red-button' },
     visitorCode: getVisitorCode('example.com'),
   });
 
+  for (const error of errors) {
+    if (error.type === KameleoonException.NotTargeted) {
+      // Handle error
+    }
+
+    if (error.type === KameleoonException.FeatureConfigurationNotFound) {
+      // Handle error
+    }
+  }
+
+  const { isActive, variables } = feature;
+
   return <Button theme={isActive ? 'red' : 'green'} />;
 }
 ```
@@ -165,12 +182,34 @@ function MyComponent(): JSX.Element {
 #### Example
 ```jsx
 import { Button } from '@kameleoon/ui';
-import { withFeature } from '@kameleoon/react-sdk';
+import { withFeature, KameleoonException } from '@kameleoon/react-sdk';
 
 class MyComponent extends React.Component {
+  state = { 
+    isActive: false,
+    variables: [],
+  }
+
+  componentDidMount() {
+    const { feature, errors } = this.props;
+
+    for (const error of errors) {
+      if (error.type === KameleoonException.NotTargeted) {
+        // Handle error
+      }
+
+      if (error.type === KameleoonException.FeatureConfigurationNotFound) {
+        // Handle error
+      }
+    }
+
+    const { isActive, variables } = feature;
+
+    this.setState({ isActive, variables });
+  }
+
   render() {
-    const { isActive, variables } = this.props;
-    return <Button theme={isActive ? 'red' : 'green'} />;
+    return <Button theme={this.isActive ? 'red' : 'green'} />;
   }
 }
 
@@ -189,7 +228,9 @@ export default withFeature({
 - `visitorCode: string` - unique identifier of the user.
 
 #### Returns
-- A wrapped component with the following props:
+A wrapped component with the following props:
+- `errors: KameleoonException[]` - an array of errors thrown as a result of getting variables or feature flag status.
+- `feature` -  an object containing feature flag status and variables
   - `isActive: boolean` - feature flag status.
   - `variables: FeatureVariableType[]` - feature flag variables.
 
@@ -199,18 +240,44 @@ import { Button } from '@kameleoon/ui';
 import { Feature } from '@kameleoon/react-sdk';
 
 class MyComponent extends React.Component {
+  state = { 
+    isActive: false,
+    variables: [],
+  }
+
+  componentDidMount() {
+    const { feature, errors } = this.props;
+
+    for (const error of errors) {
+      if (error.type === KameleoonException.NotTargeted) {
+        // Handle error
+      }
+
+      if (error.type === KameleoonException.FeatureConfigurationNotFound) {
+        // Handle error
+      }
+    }
+
+    const { isActive, variables } = feature;
+
+    this.setState({ isActive, variables });
+  }
+
   render() {
-    const { isActive, variables } = this.props;
-    return <Button theme={isActive ? 'red' : 'green'} />;
+    return <Button theme={this.isActive ? 'red' : 'green'} />;
   }
 }
 
-class MyCompWrapper extends React.Component { 
+class MyComponentWrapper extends React.Component { 
   render() {
     return(
-      <Feature featureKey="red-button" variableKeys={{production: "red-button"}} visitorCode="280295">
-        (({isActive, variables}) => (
-          <MyComponent isActive={isActive} variables={variables} />
+      <Feature 
+        featureKey="red-button" 
+        variableKeys={{production: "red-button"}} 
+        visitorCode="280295"
+      >
+        (({ feature, errors }) => (
+          <MyComponent feature={feature} errors={errors} />
         ))
       </Feature>;
     )
@@ -304,7 +371,7 @@ You have to make sure that proper error handling is set up in your code as shown
 ##### Please Note:
 _By convention, the reference (original variation) always has an ID equal to **0**._
 
-#### Exceptions Thrown
+#### Exceptions
 - `KameleoonException.NotTargeted` - Exception indicating that the current visitor / user did not trigger the required targeting conditions for this experiment. The targeting conditions are defined via Kameleoon's segment builder.
 - `KameleoonException.NotActivated` - Exception indicating that the current visitor / user triggered the experiment (met the targeting conditions), but did not activate it. The most common reason for that is that part of the traffic has been excluded from the experiment and should not be tracked.
 - `KameleoonException.ExperimentConfigurationNotFound` - Exception indicating that the requested experiment ID has not been found in the internal configuration of the SDK. This is usually normal and means that the experiment has not yet been started on Kameleoon's side (but code triggering / implementing variations is already deployed on the web-application's side).
@@ -320,20 +387,33 @@ _By convention, the reference (original variation) always has an ID equal to **0
 ### `useTriggerExperiment`
 #### Returns
 - A callback function `getVariationId()`.
+- An `error` object containing `name`, `type` and `message` strings, certain type of exception can be handled using `error.type` and `KameleoonException`. If there is no errors on the client `error` will be `null`. 
 
 #### Example
 ```jsx
 import { useEffect } from 'react';
-import { useTriggerExperiment, useVisitorCode } from '@kameleoon/react-sdk';
+import { useTriggerExperiment, useVisitorCode, KameleoonException } from '@kameleoon/react-sdk';
 
 function MyComponent(): JSX.Element {
-  const { getVariationId } = useTriggerExperiment();
+  const { getVariationId, error } = useTriggerExperiment();
   const { getVisitorCode } = useVisitorCode();
 
   useEffect(() => {
     const visitorCode = getVisitorCode('example.com');
     const experimentId = 12341;
 
+    if (error?.type === KameleoonException.ExperimentConfigurationNotFound) {
+      // Handle exception
+    }
+
+    if (error?.type === KameleoonException.NotTargeted) {
+      // Handle exception
+    }
+
+    if (error?.type === KameleoonException.NotActivated) {
+      // Handle exception
+    }
+
     const variationId = getVariationId(visitorCode, experimentId);
   }, []);
 
@@ -350,14 +430,26 @@ function MyComponent(): JSX.Element {
 
 #### Example
 ```jsx
-import { withVisitorCode, withTriggerExperiment, compose } from '@kameleoon/react-sdk';
+import { withVisitorCode, withTriggerExperiment, compose, KameleoonException } from '@kameleoon/react-sdk';
 
 class MyComponent extends React.Component {
   componentDidMount() {
-    const { getVisitorCode, getVariationId } = this.props;
+    const { getVisitorCode, getVariationId, triggerExperimentError } = this.props;
     const visitorCode = getVisitorCode('example.com');
     const experimentId = 230243;
 
+    if (triggerExperimentError?.type === KameleoonException.ExperimentConfigurationNotFound) {
+      // Handle exception
+    }
+
+    if (triggerExperimentError?.type === KameleoonException.NotTargeted) {
+      // Handle exception
+    }
+
+    if (triggerExperimentError?.type === KameleoonException.NotActivated) {
+      // Handle exception
+    }
+
     const variationId = getVariationId(visitorCode, experimentId);
   }
 
@@ -370,16 +462,16 @@ export default compose(withVisitorCode, withTriggerExperiment)(MyComponent);
 ## Activate feature
 A callback function `hasFeature()` which validates if user has been associated with this feature. If it is fails, callback returns value **false**, otherwise **true**.
 
-If feature flag is not activated, `KameleoonException.FeatureConfigurationNotFound` exception will be thrown. Please, make sure to handle properly the error.
+If feature flag is not activated, `KameleoonException.FeatureConfigurationNotFound` exception will be thrown. Please, make sure to handle the error properly.
 
-#### Exceptions Thrown
+#### Exceptions
 - `KameleoonException.NotTargeted` - Exception indicating that the current visitor / user did not trigger the required targeting conditions for this feature. The targeting conditions are defined via Kameleoon's segment builder.
 - `KameleoonException.FeatureConfigurationNotFound` - Exception indicating that the requested feature ID has not been found in the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet been activated on Kameleoon's side (but code implementing the feature is already deployed on the web-application's side).
 
 #### `hasFeature()`
 ##### Arguments
-- `visitorCode: string` - unique identifier of the user.
 - `featureKey: string | number` - unique identifier or key of the feature you want to expose to a user.
+- `visitorCode: string` (optional) - unique identifier of the user.
 
 ##### Returns
 - A `value: boolean` of the feature that is registered for a given `visitorCode`.
@@ -387,21 +479,30 @@ If feature flag is not activated, `KameleoonException.FeatureConfigurationNotFou
 ### `useActivateFeature`
 #### Returns
 - A callback function `hasFeature()`.
+- An `error` object containing `name`, `type` and `message` strings, certain type of exception can be handled using `error.type` and `KameleoonException`. If there is no errors on the client `error` will be `null`. 
 
 #### Example
 ```jsx
 import { useEffect } from 'react';
-import { useActivateFeature, useVisitorCode } from '@kameleoon/react-sdk';
+import { useActivateFeature, useVisitorCode, KameleoonException } from '@kameleoon/react-sdk';
 
 function MyComponent(): JSX.Element {
-  const { hasFeature } = useActivateFeature();
+  const { hasFeature, error } = useActivateFeature();
   const { getVisitorCode } = useVisitorCode();
 
   useEffect(() => {
     const visitorCode = getVisitorCode('example.com');
     const featureKey = 'example-feature-key';
 
-    const feature = hasFeature(visitorCode, featureKey);
+    if (error?.type === KameleoonException.FeatureConfigurationNotFound) {
+      // Handle exception
+    }
+
+    if (error?.type === KameleoonException.NotTargeted) {
+      // Handle exception
+    }
+
+    const feature = hasFeature(featureKey, visitorCode);
   }, []);
 
   ...
@@ -410,22 +511,30 @@ function MyComponent(): JSX.Element {
 
 ###  `withActivateFeature`
 #### Arguments
-- `Component: React.Component` - component which will be enhanced with the prop `hasFeature()`.
+- `Component: React.Component` - component which will be enhanced with the prop `hasFeature()` and `activateFeatureError`.
 
 #### Returns
 - A wrapped component with additional props as described above.
 
 #### Example
 ```jsx
-import { withVisitorCode, withActivateFeature, compose } from '@kameleoon/react-sdk';
+import { withVisitorCode, withActivateFeature, KameleoonException, compose } from '@kameleoon/react-sdk';
 
 class MyComponent extends React.Component {
   componentDidMount() {
-    const { getVisitorCode, hasFeature } = this.props;
+    const { getVisitorCode, hasFeature, activateFeatureError } = this.props;
     const visitorCode = getVisitorCode('example.com');
     const featureKey = 'example-feature-key';
 
-    const feature = hasFeature(visitorCode, featureKey);
+    if (activateFeatureError?.type === KameleoonException.FeatureConfigurationNotFound) {
+      // Handle exception
+    }
+
+    if (activateFeatureError?.type === KameleoonException.NotTargeted) {
+      // Handle exception
+    }
+
+    const feature = hasFeature(featureKey, visitorCode);
   }
 
   ...
@@ -439,7 +548,7 @@ A callback function `getVariationAssociatedData()` which retrieves JSON data ass
 
 This callback function takes the `variationId` as a parameter and will return the data as a JavaScript object. It will throw an exception `(KameleoonException.VariationConfigurationNotFound)` if the `variationId` is wrong or corresponds to an experiment that is not yet online.
 
-#### Exceptions Thrown
+#### Exceptions
 - `KameleoonException.VariationConfigurationNotFound` - Exception indicating that the requested variation ID has not been found in the internal configuration of the SDK. This is usually normal and means that the variation's corresponding experiment has not yet been activated on Kameleoon's side.
 
 #### `getVariationAssociatedData()`
@@ -453,17 +562,23 @@ This callback function takes the `variationId` as a parameter and will return th
 ### `useVariationAssociatedData`
 #### Returns
 - A callback function `getVariationAssociatedData()`.
+- An `error` object containing `name`, `type` and `message` strings, certain type of exception can be handled using `error.type` and `KameleoonException`. If there is no errors on the client `error` will be `null`. 
 
 #### Example
 ```jsx
 import { useEffect } from 'react';
-import { useVariationAssociatedData } from '@kameleoon/react-sdk';
+import { useVariationAssociatedData, KameleoonException } from '@kameleoon/react-sdk';
 
 function MyComponent(): JSX.Element {
-  const { getVariationAssociatedData } = useVariationAssociatedData();
+  const { getVariationAssociatedData, error } = useVariationAssociatedData();
 
   useEffect(() => {
     const variationId = 280295;
+
+    if (error?.type === KameleoonException.VariationConfigurationNotFound) {
+      // Handle error
+    }
+
     const data = getVariationAssociatedData(variationId);
   }, []);
 
@@ -479,12 +594,17 @@ function MyComponent(): JSX.Element {
 
 #### Example
 ```jsx
-import { withVariationAssociatedData } from '@kameleoon/react-sdk';
+import { withVariationAssociatedData, KameleoonException } from '@kameleoon/react-sdk';
 
 class MyComponent extends React.Component {
   componentDidMount() {
-    const { getVariationAssociatedData } = this.props;
+    const { getVariationAssociatedData, variationAssociatedDataError } = this.props;
     const variationId = 280295;
+
+    if (variationAssociatedDataError?.type === KameleoonException.VariationConfigurationNotFound) {
+      // Handle error
+    }
+
     const data = getVariationAssociatedData(variationId);
   }
 
@@ -798,7 +918,6 @@ The `flush()` callback function is non-blocking as the server call is made async
 #### Example
 ```jsx
 import { useEffect } from 'react';
-import { Button } from '@kameleoon/ui';
 import {
   useAddData,
   useBrowser,
@@ -862,6 +981,86 @@ export default compose(
 )(MyComponent);
 ```
 
+## Run when ready
+In certain scenarios when working with Kameleoon API it's important to make sure that the client was initialized properly within the certain timeout. It's especially important while using `triggerExperiment()` or `trackConversion()`. For these cases it's possible to use `runWhenReady()` function, retrieved by `useRunWhenReady` hook or `withRunWhenReady` high-order component.
+
+The `runWhenReady()` function makes sure that Kameleoon Client will be initialized properly using HTTP call withing the specified timeout.
+
+#### `runWhenReady()`
+##### Arguments
+- `successCallback: () => void` - callback which will be executed on successful client initialization.
+- `errorCallback: () => void` - callback which will be executed if client wasn't able to initialize during the timeout.
+- `timeout?: number` - timeout which is given to perform HTTP call for initialization in ms (by default: 2000 ms).
+
+#### Example
+```jsx
+import { useEffect, useCallback, useState } from 'react';
+import { useRunWhenReady, useTriggerExperiment } from '@kameleoon/react-sdk';
+
+function MyComponent(): JSX.Element {
+  const { runWhenReady } = useRunWhenReady();
+  const { getVariationId } = useTriggerExperiment();
+
+  const [variationId, setVariationId] = useState<number>(0);
+
+  const getVariationSuccessCallback = useCallback(() => {
+    const id = getVariationId('user_id', 12345);
+    setVariationId(id);
+  }, [getVariationId, isRenderProps]);
+
+  const getVariationErrorCallback = useCallback(() => {
+    throw new Error(
+      "Couldn't get server configuration from HTTP request in a specified time",
+    );
+  }, []);
+
+  useEffect(() => {
+    runWhenReady(
+      getVariationSuccessCallback,
+      getVariationErrorCallback,
+      1000,
+    );
+  }, [runWhenReady, getVariationSuccessCallback, getVariationErrorCallback]);
+
+  ...
+}
+```
+
+### `withRunWhenReady`
+#### Arguments
+- `Component: React.Component` - component which will be enhanced with the prop `runWhenReady()`.
+
+#### Example
+```jsx
+import { useEffect, useCallback, useState } from 'react';
+import { withRunWhenReady, withTriggerExperiment } from '@kameleoon/react-sdk';
+
+class MyComponent extends React.Component {
+  variationSuccessCallback(): void {
+    const id = this.props.getVariationId('user_id', 12345);
+    setVariationId(id);
+  }
+
+  variationErrorCallback(): void {
+    const id = this.props.getVariationId('user_id', 12345);
+    setVariationId(id);
+  }
+
+  componentDidMount() {
+    this.props.runWhenReady(this.variationSuccessCallback, this.variationErrorCallback, 1000);
+  }
+
+  ...
+}
+
+export default compose(
+  withRunWhenReady,
+  withTriggerExperiment,
+)(MyComponent);
+```
+
+#### Returns
+- A wrapped component with additional props as described above.
 
 ## Browser
 A callback function `addBrowser()` adds browser type.
@@ -1147,43 +1346,44 @@ export default compose(
 )(MyComponent);
 ```
 
-## Interest
-A callback function `addInterest()` adds interest.
+## Device
+A callback function `addDevice()` adds device.
 
-#### `addInterest`
+#### `addDevice`
 ##### Arguments
-- `index: number` - index of interest.
+- `device: DeviceType` - device type: Phone, Tablet, Desktop.
+    
 
 ##### Returns
-- An instance of `Interest: IInterest`.
+- An instance of `Device: IDevice`.
 
-### `useInterest`
+### `useDevice`
 #### Returns
-- A callback function `addInterest()`.
+- A callback function `addDevice()`.
 
 #### Example
 ```jsx
 import { useEffect } from 'react';
-import { useAddData, useInterest, useVisitorCode } from '@kameleoon/react-sdk';
+import { useAddData, useDevice, DeviceType, useVisitorCode } from '@kameleoon/react-sdk';
 
 function MyComponent(): JSX.Element {
   const { addData } = useAddData();
   const { getVisitorCode } = useVisitorCode();
-  const { addInterest } = useInterest();
+  const { addDevice } = useDevice();
 
   useEffect(() => {
     const visitorCode = getVisitorCode('example.com');
 
-    addData(visitorCode, [addInterest(0)]);
+    addData(visitorCode, [addDevice(DeviceType.Desktop)]);
   }, []);
 
   ...
 }
 ```
 
-### `withInterest`
+### `withDevice`
 #### Arguments
-- `Component: React.Component` - component which will be enhanced with the prop `addInterest()`.
+- `Component: React.Component` - component which will be enhanced with the prop `addDevice()`.
 
 #### Returns
 - A wrapped component with additional props as described above.
@@ -1193,16 +1393,17 @@ function MyComponent(): JSX.Element {
 import {
   withVisitorCode,
   withAddData,
-  withInterest,
+  withDevice,
+  DeviceType,
   compose,
 } from '@kameleoon/react-sdk';
 
 class MyComponent extends React.Component {
   componentDidMount() {
-    const { addData, addInterest, getVisitorCode } = this.props;
+    const { addData, addDevice, getVisitorCode } = this.props;
     const visitorCode = getVisitorCode('example.com');
 
-    addData(visitorCode, [addInterest(0)]);
+    addData(visitorCode, [addDevice(DeviceType.Desktop)]);
   }
 
   ...
@@ -1210,7 +1411,7 @@ class MyComponent extends React.Component {
 
 export default compose(
   withAddData,
-  withInterest,
+  withDevice,
   withVisitorCode,
 )(MyComponent);
 ```
@@ -1242,4 +1443,4 @@ class MyComponent extends React.Component {
 }
 
 export default compose(withVisitorCode, withTriggerExperiment)(MyComponent);
-```
+```

package/dist/Feature.js

@@ -19,8 +19,8 @@ var useFeature_1 = require("./useFeature");
  * to the status of a feature flag and its variables
  */
 function Feature(props) {
-    var feature = (0, useFeature_1.useFeature)(__assign({}, props));
-    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: props.children(feature) }, void 0);
+    var result = (0, useFeature_1.useFeature)(__assign({}, props));
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: props.children(result) }, void 0);
 }
 exports.Feature = Feature;
 //# sourceMappingURL=Feature.js.map

package/dist/Feature.js.map

@@ -1 +1 @@
-{"version":3,"file":"Feature.js","sourceRoot":"","sources":["../src/Feature.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,2CAA0C;AAM1C;;;GAGG;AACH,SAAgB,OAAO,CAAC,KAAoB;IAC1C,IAAM,OAAO,GAAG,IAAA,uBAAU,eAAM,KAAK,EAAG,CAAC;IAEzC,OAAO,2DAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAI,CAAC;AACxC,CAAC;AAJD,0BAIC"}
+{"version":3,"file":"Feature.js","sourceRoot":"","sources":["../src/Feature.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,2CAA0C;AAM1C;;;GAGG;AACH,SAAgB,OAAO,CAAC,KAAoB;IAC1C,IAAM,MAAM,GAAG,IAAA,uBAAU,eAAM,KAAK,EAAG,CAAC;IAExC,OAAO,2DAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAI,CAAC;AACvC,CAAC;AAJD,0BAIC"}

package/dist/KameleoonError.d.ts

@@ -0,0 +1,5 @@
+import { KameleoonException } from './constants';
+export declare class KameleoonError extends Error {
+    type: KameleoonException;
+    constructor(type: KameleoonException);
+}

package/dist/KameleoonError.js

@@ -0,0 +1,31 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KameleoonError = void 0;
+var KameleoonError = /** @class */ (function (_super) {
+    __extends(KameleoonError, _super);
+    function KameleoonError(type) {
+        var _this = _super.call(this, "Error: ".concat(type)) || this;
+        _this.name = 'KameleoonError';
+        _this.message = "".concat(_this.name, ".").concat(type);
+        _this.type = type;
+        return _this;
+    }
+    return KameleoonError;
+}(Error));
+exports.KameleoonError = KameleoonError;
+//# sourceMappingURL=KameleoonError.js.map

package/dist/KameleoonError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KameleoonError.js","sourceRoot":"","sources":["../src/KameleoonError.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAEA;IAAoC,kCAAK;IAGvC,wBAAY,IAAwB;QAApC,YACE,kBAAM,iBAAU,IAAI,CAAE,CAAC,SAIxB;QAHC,KAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;QAC7B,KAAI,CAAC,OAAO,GAAG,UAAG,KAAI,CAAC,IAAI,cAAI,IAAI,CAAE,CAAC;QACtC,KAAI,CAAC,IAAI,GAAG,IAAI,CAAC;;IACnB,CAAC;IACH,qBAAC;AAAD,CAAC,AATD,CAAoC,KAAK,GASxC;AATY,wCAAc"}

package/dist/compose.d.ts

@@ -1,7 +1,7 @@
 /**
  * Composes single-argument high order components.
  *
- * @param HOCs High order components to be composed.
+ * @param funcs High order components to be composed.
  * @returns A function obtained by composing the argument HOCs,
  * which is used as single high order component wrapper.
  */

package/dist/compose.js

@@ -1,10 +1,35 @@
 "use strict";
+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 });
 /* eslint-disable @typescript-eslint/ban-types */
 /**
  * Composes single-argument high order components.
  *
- * @param HOCs High order components to be composed.
+ * @param funcs High order components to be composed.
  * @returns A function obtained by composing the argument HOCs,
  * which is used as single high order component wrapper.
  */
@@ -25,7 +50,7 @@ function compose() {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return a(b.apply(void 0, args));
+            return a(b.apply(void 0, __spreadArray([], __read(args), false)));
         };
     });
 }

package/dist/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":";;AAAA,iDAAiD;AACjD;;;;;;GAMG;AACH,SAAwB,OAAO;IAAC,eAAoB;SAApB,UAAoB,EAApB,qBAAoB,EAApB,IAAoB;QAApB,0BAAoB;;IAClD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IAED,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;KACjB;IAED,OAAO,KAAK,CAAC,MAAM,CACjB,UAAC,CAAC,EAAE,CAAC;QACH,OAAA;YAAC,cAAmB;iBAAnB,UAAmB,EAAnB,qBAAmB,EAAnB,IAAmB;gBAAnB,yBAAmB;;YAClB,OAAA,CAAC,CAAC,CAAC,eAAI,IAAI,EAAE;QAAb,CAAa;IADf,CACe,CAClB,CAAC;AACJ,CAAC;AAdD,0BAcC"}
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAiD;AACjD;;;;;;GAMG;AACH,SAAwB,OAAO;IAAC,eAAoB;SAApB,UAAoB,EAApB,qBAAoB,EAApB,IAAoB;QAApB,0BAAoB;;IAClD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IAED,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;KACjB;IAED,OAAO,KAAK,CAAC,MAAM,CACjB,UAAC,CAAC,EAAE,CAAC;QACH,OAAA;YAAC,cAAmB;iBAAnB,UAAmB,EAAnB,qBAAmB,EAAnB,IAAmB;gBAAnB,yBAAmB;;YAClB,OAAA,CAAC,CAAC,CAAC,wCAAI,IAAI,WAAE;QAAb,CAAa;IADf,CACe,CAClB,CAAC;AACJ,CAAC;AAdD,0BAcC"}