@hackler/react-sdk 2.2.3 → 3.0.0

package/lib/index.js

@@ -1,8 +1,322 @@
-export { createInstance } from "./client";
-export { HackleProvider } from "./Provider";
-export { HackleContext, HackleContextProvider, HackleContextConsumer } from "./Context";
-export { useVariation, useVariationDetail, useTrack, useFeature, useFeatureFlagDetail } from "./hooks";
-export { HackleExperiment } from "./Experiment";
-export { HackleVariation } from "./Variation";
-export { getUserId } from "@hackler/js-client-sdk";
-//# sourceMappingURL=index.js.map
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Hackle = require('@hackler/js-client-sdk');
+var React = require('react');
+var sdkCore = require('@hackler/sdk-core');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var Hackle__namespace = /*#__PURE__*/_interopNamespace(Hackle);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(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);
+};
+
+function __read(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 SDK_NAME_HEADER = "react-sdk";
+var SDK_VERSION_HEADER = "3.0.0";
+
+var HackleReactSDKClient = /** @class */ (function () {
+    function HackleReactSDKClient(sdkKey, config) {
+        this.client = Hackle__namespace.createInstance(sdkKey, __assign(__assign({}, config), { SDK_NAME_HEADER: SDK_NAME_HEADER, SDK_VERSION_HEADER: SDK_VERSION_HEADER }));
+    }
+    HackleReactSDKClient.prototype.variation = function (experimentKey, user, defaultVariation) {
+        return this.client.variation(experimentKey, user, defaultVariation);
+    };
+    HackleReactSDKClient.prototype.variationDetail = function (experimentKey, user, defaultVariation) {
+        return this.client.variationDetail(experimentKey, user, defaultVariation);
+    };
+    HackleReactSDKClient.prototype.isFeatureOn = function (featureKey, user) {
+        return this.client.isFeatureOn(featureKey, user);
+    };
+    HackleReactSDKClient.prototype.featureFlagDetail = function (featureKey, user) {
+        return this.client.featureFlagDetail(featureKey, user);
+    };
+    HackleReactSDKClient.prototype.track = function (event, user) {
+        this.client.track(event, user);
+    };
+    HackleReactSDKClient.prototype.trackPageView = function (option) {
+        this.client.trackPageView(option);
+    };
+    HackleReactSDKClient.prototype.onReady = function (cb, timeout) {
+        this.client.onReady(cb, timeout);
+    };
+    return HackleReactSDKClient;
+}());
+function createInstance(sdkKey, config) {
+    return new HackleReactSDKClient(sdkKey, config);
+}
+
+var HackleContext = React.createContext({
+    hackle: undefined,
+    user: undefined,
+});
+var HackleContextConsumer = HackleContext.Consumer;
+var HackleContextProvider = HackleContext.Provider;
+
+function HackleProvider(_a) {
+    var hackleClient = _a.hackleClient, user = _a.user, _b = _a.timeout, timeout = _b === void 0 ? 3000 : _b, children = _a.children;
+    var state = {
+        hackle: hackleClient,
+        user: user,
+    };
+    var _c = __read(React.useState(false), 2), ready = _c[0], setReady = _c[1];
+    var _d = __read(React.useState(state), 2), value = _d[0], setValue = _d[1];
+    React.useEffect(function () {
+        setValue(function (prevState) {
+            return __assign(__assign({}, prevState), { user: user });
+        });
+    }, [user]);
+    hackleClient.onReady(function () { return setReady(true); }, timeout);
+    return ready ? React__default["default"].createElement(HackleContextProvider, { value: value }, children) : null;
+}
+
+var log = sdkCore.Logger.log;
+function useVariation(experimentKey, defaultVariation) {
+    if (defaultVariation === void 0) { defaultVariation = "A"; }
+    var _a = React.useContext(HackleContext), hackle = _a.hackle, user = _a.user;
+    var getVariation = React.useCallback(function () {
+        return (hackle === null || hackle === void 0 ? void 0 : hackle.variation(experimentKey, user)) || defaultVariation;
+    }, [defaultVariation, experimentKey, user, hackle]);
+    var _b = __read(React.useState(function () {
+        if (notExistClient(hackle)) {
+            if ((typeof window) !== "undefined") {
+                log.error("HackleClient is not existed");
+            }
+            return defaultVariation;
+        }
+        return getVariation();
+    }), 2), variation = _b[0], setVariation = _b[1];
+    var currentInput = {
+        key: experimentKey,
+        user: user
+    };
+    var _c = __read(React.useState(currentInput), 2), prevInput = _c[0], setPrevInput = _c[1];
+    if (!isInputEqual(prevInput, currentInput)) {
+        setPrevInput(currentInput);
+        setVariation(getVariation());
+    }
+    return variation;
+}
+function useVariationDetail(experimentKey, defaultVariation) {
+    if (defaultVariation === void 0) { defaultVariation = "A"; }
+    var _a = React.useContext(HackleContext), hackle = _a.hackle, user = _a.user;
+    var getVariationDetail = React.useCallback(function () {
+        return (hackle === null || hackle === void 0 ? void 0 : hackle.variationDetail(experimentKey, user)) || sdkCore.Decision.of(defaultVariation, sdkCore.DecisionReason.EXCEPTION);
+    }, [defaultVariation, experimentKey, user, hackle]);
+    var _b = __read(React.useState(function () {
+        if (notExistClient(hackle)) {
+            if ((typeof window) !== "undefined") {
+                log.error("HackleClient is not existed");
+            }
+            return sdkCore.Decision.of(defaultVariation, sdkCore.DecisionReason.EXCEPTION);
+        }
+        return getVariationDetail();
+    }), 2), variationDetail = _b[0], setVariationDetail = _b[1];
+    var currentInput = {
+        key: experimentKey,
+        user: user
+    };
+    var _c = __read(React.useState(currentInput), 2), prevInput = _c[0], setPrevInput = _c[1];
+    if (!isInputEqual(prevInput, currentInput)) {
+        setPrevInput(currentInput);
+        setVariationDetail(getVariationDetail());
+    }
+    return variationDetail;
+}
+function useFeature(featureKey) {
+    var _a = React.useContext(HackleContext), hackle = _a.hackle, user = _a.user;
+    var getIsOn = React.useCallback(function () {
+        return (hackle === null || hackle === void 0 ? void 0 : hackle.isFeatureOn(featureKey, user)) || false;
+    }, [featureKey, user, hackle]);
+    var _b = __read(React.useState(function () {
+        if (notExistClient(hackle)) {
+            if ((typeof window) !== "undefined") {
+                log.error("HackleClient is not existed");
+            }
+            return false;
+        }
+        return getIsOn();
+    }), 2), isOn = _b[0], setIsOn = _b[1];
+    var currentInput = {
+        key: featureKey,
+        user: user,
+    };
+    var _c = __read(React.useState(currentInput), 2), prevInput = _c[0], setPrevInput = _c[1];
+    if (!isInputEqual(prevInput, currentInput)) {
+        setPrevInput(currentInput);
+        setIsOn(getIsOn());
+    }
+    return isOn;
+}
+function useFeatureFlagDetail(featureKey) {
+    var _a = React.useContext(HackleContext), hackle = _a.hackle, user = _a.user;
+    var getFeatureDetail = React.useCallback(function () {
+        return (hackle === null || hackle === void 0 ? void 0 : hackle.featureFlagDetail(featureKey, user)) || sdkCore.FeatureFlagDecision.off(sdkCore.DecisionReason.EXCEPTION);
+    }, [featureKey, user, hackle]);
+    var _b = __read(React.useState(function () {
+        if (notExistClient(hackle)) {
+            if ((typeof window) !== "undefined") {
+                log.error("HackleClient is not existed");
+            }
+            return sdkCore.FeatureFlagDecision.off(sdkCore.DecisionReason.EXCEPTION);
+        }
+        return getFeatureDetail();
+    }), 2), featureDetail = _b[0], setFeatureDetail = _b[1];
+    var currentInput = {
+        key: featureKey,
+        user: user,
+    };
+    var _c = __read(React.useState(currentInput), 2), prevInput = _c[0], setPrevInput = _c[1];
+    if (!isInputEqual(prevInput, currentInput)) {
+        setPrevInput(currentInput);
+        setFeatureDetail(getFeatureDetail());
+    }
+    return featureDetail;
+}
+function useTrack() {
+    var _a = React.useContext(HackleContext), hackle = _a.hackle, user = _a.user;
+    if (notExistClient(hackle)) {
+        if ((typeof window) !== "undefined") {
+            log.error("HackleClient is not existed");
+        }
+        return function () { };
+    }
+    return function (event) { return hackle === null || hackle === void 0 ? void 0 : hackle.track(event, user); };
+}
+function notExistClient(hackle) {
+    return !hackle;
+}
+function isInputEqual(prev, current) {
+    var _a, _b, _c, _d;
+    return (prev.key === current.key &&
+        ((_a = prev.user) === null || _a === void 0 ? void 0 : _a.id) === ((_b = current.user) === null || _b === void 0 ? void 0 : _b.id) &&
+        arePropertiesEqual((_c = prev.user) === null || _c === void 0 ? void 0 : _c.properties, (_d = current.user) === null || _d === void 0 ? void 0 : _d.properties));
+}
+function arePropertiesEqual(prevProps, currentProps) {
+    var prev = coerceUnknownToProperties(prevProps);
+    var current = coerceUnknownToProperties(currentProps);
+    var prevKeys = Object.keys(prev);
+    var currentKeys = Object.keys(current);
+    if (prevKeys.length !== currentKeys.length) {
+        return false;
+    }
+    return prevKeys.every(function (it) {
+        return it in current && prev[it] === current[it];
+    });
+}
+function coerceUnknownToProperties(props) {
+    if (typeof props === "object" && props !== null) {
+        return props;
+    }
+    return {};
+}
+
+function Experiment(_a) {
+    var experimentKey = _a.experimentKey, children = _a.children;
+    var variation = useVariation(experimentKey);
+    if (!!children && typeof children === "function") {
+        return children(variation);
+    }
+    var match;
+    React__namespace.Children.forEach(children, (function (it) {
+        if (!React__namespace.isValidElement(it)) {
+            return;
+        }
+        if (it.props.variation) {
+            if (variation === it.props.variation) {
+                match = it;
+            }
+        }
+        else if (it.props.default) {
+            match = it;
+        }
+    }));
+    return match ? React__namespace.cloneElement(match, { variation: variation }) : null;
+}
+var HackleExperiment = Experiment;
+
+function Variation(_a) {
+    _a.variation; var children = _a.children;
+    return React__namespace.createElement(React__namespace.Fragment, null, children);
+}
+var HackleVariation = Variation;
+
+exports.HackleContext = HackleContext;
+exports.HackleContextConsumer = HackleContextConsumer;
+exports.HackleContextProvider = HackleContextProvider;
+exports.HackleExperiment = HackleExperiment;
+exports.HackleProvider = HackleProvider;
+exports.HackleVariation = HackleVariation;
+exports.createInstance = createInstance;
+exports.useFeature = useFeature;
+exports.useFeatureFlagDetail = useFeatureFlagDetail;
+exports.useTrack = useTrack;
+exports.useVariation = useVariation;
+exports.useVariationDetail = useVariationDetail;
+Object.keys(Hackle).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return Hackle[k]; }
+    });
+});