@flagship.io/react-sdk 3.0.3-alpha.0 → 3.0.3-alpha.3

package/dist/esm/Flag.js

@@ -0,0 +1,55 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { FlagMetadata, LogLevel } from '@flagship.io/js-sdk';
+import { noVisitorMessage } from './constants';
+import { log } from './utils';
+export var Flag = /*#__PURE__*/function () {
+  function Flag(defaultValue) {
+    _classCallCheck(this, Flag);
+
+    _defineProperty(this, "_defaultValue", void 0);
+
+    log(LogLevel.WARNING, noVisitorMessage, 'GetFlag');
+    this._defaultValue = defaultValue;
+  }
+
+  _createClass(Flag, [{
+    key: "getValue",
+    value: function getValue() {
+      log(LogLevel.WARNING, noVisitorMessage, 'getValue');
+      return this._defaultValue;
+    }
+  }, {
+    key: "exists",
+    value: function exists() {
+      log(LogLevel.WARNING, noVisitorMessage, 'exists');
+      return false;
+    }
+  }, {
+    key: "userExposed",
+    value: function userExposed() {
+      log(LogLevel.WARNING, noVisitorMessage, 'userExposed');
+      return Promise.resolve();
+    }
+  }, {
+    key: "metadata",
+    get: function get() {
+      log(LogLevel.WARNING, noVisitorMessage, 'metadata');
+      return new FlagMetadata({
+        campaignId: '',
+        campaignType: '',
+        isReference: false,
+        variationGroupId: '',
+        variationId: ''
+      });
+    }
+  }]);
+
+  return Flag;
+}();

package/dist/esm/FlagshipContext.js

@@ -0,0 +1,253 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// eslint-disable-next-line no-use-before-define
+import React, { useState, useEffect, createContext, useRef } from "react";
+import { Flagship, FlagshipStatus } from "@flagship.io/js-sdk";
+import { getModificationsFromCampaigns, logError, useNonInitialEffect } from "./utils";
+var initStat = {
+  status: {
+    isLoading: true,
+    isSdkReady: false
+  }
+};
+export var FlagshipContext = /*#__PURE__*/createContext({
+  state: _objectSpread({}, initStat)
+});
+export var FlagshipProvider = function FlagshipProvider(_ref) {
+  var children = _ref.children,
+      fetchNow = _ref.fetchNow,
+      envId = _ref.envId,
+      apiKey = _ref.apiKey,
+      decisionMode = _ref.decisionMode,
+      decisionApiUrl = _ref.decisionApiUrl,
+      timeout = _ref.timeout,
+      logLevel = _ref.logLevel,
+      statusChangedCallback = _ref.statusChangedCallback,
+      logManager = _ref.logManager,
+      pollingInterval = _ref.pollingInterval,
+      visitorData = _ref.visitorData,
+      onInitStart = _ref.onInitStart,
+      onInitDone = _ref.onInitDone,
+      onBucketingSuccess = _ref.onBucketingSuccess,
+      onBucketingFail = _ref.onBucketingFail,
+      loadingComponent = _ref.loadingComponent,
+      onBucketingUpdated = _ref.onBucketingUpdated,
+      onUpdate = _ref.onUpdate,
+      enableClientCache = _ref.enableClientCache,
+      initialBucketing = _ref.initialBucketing,
+      initialCampaigns = _ref.initialCampaigns,
+      initialModifications = _ref.initialModifications,
+      initialFlagsData = _ref.initialFlagsData,
+      synchronizeOnBucketingUpdated = _ref.synchronizeOnBucketingUpdated,
+      activateDeduplicationTime = _ref.activateDeduplicationTime,
+      hitDeduplicationTime = _ref.hitDeduplicationTime,
+      visitorCacheImplementation = _ref.visitorCacheImplementation,
+      hitCacheImplementation = _ref.hitCacheImplementation,
+      disableCache = _ref.disableCache;
+  var modifications = new Map();
+
+  if (initialFlagsData && initialFlagsData.forEach) {
+    initialFlagsData.forEach(function (flag) {
+      modifications.set(flag.key, flag);
+    });
+  } else if (initialModifications && initialModifications.forEach) {
+    initialModifications.forEach(function (modification) {
+      modifications.set(modification.key, modification);
+    });
+  } else if (initialCampaigns) {
+    modifications = getModificationsFromCampaigns(initialCampaigns);
+  }
+
+  var _useState = useState(_objectSpread(_objectSpread({}, initStat), {}, {
+    modifications: modifications
+  })),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+
+  var _useState3 = useState(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      lastModified = _useState4[0],
+      setLastModified = _useState4[1];
+
+  var stateRef = useRef();
+  stateRef.current = state;
+  useNonInitialEffect(function () {
+    if (synchronizeOnBucketingUpdated) {
+      var _state$visitor;
+
+      (_state$visitor = state.visitor) === null || _state$visitor === void 0 ? void 0 : _state$visitor.fetchFlags();
+    }
+  }, [lastModified]);
+  useNonInitialEffect(function () {
+    createVisitor(true);
+  }, [JSON.stringify(visitorData)]);
+  useEffect(function () {
+    initSdk();
+  }, [envId, apiKey, decisionMode]);
+
+  function initializeState(param) {
+    var newStatus = {
+      isSdkReady: param.isSdkReady,
+      isLoading: param.isLoading,
+      isVisitorDefined: !!param.fsVisitor,
+      lastRefresh: new Date().toISOString()
+    };
+    setState(function (currentState) {
+      if (!currentState.status.firstInitSuccess) {
+        newStatus.firstInitSuccess = new Date().toISOString();
+      }
+
+      return _objectSpread(_objectSpread({}, currentState), {}, {
+        visitor: param.fsVisitor,
+        modifications: param.fsVisitor.modifications,
+        config: Flagship.getConfig(),
+        status: _objectSpread(_objectSpread({}, currentState.status), newStatus)
+      });
+    });
+    return newStatus;
+  } // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+  var onVisitorReady = function onVisitorReady(fsVisitor, error) {
+    if (error) {
+      logError(Flagship.getConfig(), error.message || error, "onReady");
+      return;
+    }
+
+    var newStatus = initializeState({
+      fsVisitor: fsVisitor,
+      isSdkReady: true,
+      isLoading: false
+    });
+
+    if (onUpdate) {
+      onUpdate({
+        fsModifications: fsVisitor.modifications,
+        config: Flagship.getConfig(),
+        status: newStatus
+      });
+    }
+  };
+
+  var createVisitor = function createVisitor() {
+    var fetchFlags = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    if (!visitorData) {
+      return;
+    }
+
+    var fsVisitor = Flagship.newVisitor({
+      visitorId: visitorData.id,
+      context: visitorData.context,
+      isAuthenticated: visitorData.isAuthenticated,
+      hasConsented: visitorData.hasConsented,
+      initialCampaigns: initialCampaigns,
+      initialModifications: initialModifications,
+      initialFlagsData: initialFlagsData
+    });
+    fsVisitor === null || fsVisitor === void 0 ? void 0 : fsVisitor.on("ready", function (error) {
+      onVisitorReady(fsVisitor, error);
+    });
+
+    if (!fetchNow && fsVisitor && !fetchFlags) {
+      initializeState({
+        fsVisitor: fsVisitor,
+        isSdkReady: true,
+        isLoading: false
+      });
+    }
+
+    if (fetchFlags && !fetchNow) {
+      fsVisitor === null || fsVisitor === void 0 ? void 0 : fsVisitor.fetchFlags();
+    }
+  };
+
+  var statusChanged = function statusChanged(status) {
+    if (statusChangedCallback) {
+      statusChangedCallback(status);
+    }
+
+    if (status === FlagshipStatus.STARTING && onInitStart) {
+      onInitStart();
+      return;
+    }
+
+    if (status === FlagshipStatus.READY_PANIC_ON || status === FlagshipStatus.READY) {
+      if (onInitDone) {
+        onInitDone();
+      }
+
+      createVisitor();
+    }
+  };
+
+  var onBucketingLastModified = function onBucketingLastModified(lastUpdate) {
+    if (onBucketingUpdated) {
+      onBucketingUpdated(lastUpdate);
+    }
+
+    setLastModified(lastUpdate);
+  };
+
+  var initSdk = function initSdk() {
+    Flagship.start(envId, apiKey, {
+      decisionMode: decisionMode,
+      fetchNow: fetchNow,
+      timeout: timeout,
+      logLevel: logLevel,
+      statusChangedCallback: statusChanged,
+      logManager: logManager,
+      pollingInterval: pollingInterval,
+      onBucketingFail: onBucketingFail,
+      onBucketingSuccess: onBucketingSuccess,
+      enableClientCache: enableClientCache,
+      decisionApiUrl: decisionApiUrl,
+      onBucketingUpdated: onBucketingLastModified,
+      initialBucketing: initialBucketing,
+      activateDeduplicationTime: activateDeduplicationTime,
+      hitDeduplicationTime: hitDeduplicationTime,
+      visitorCacheImplementation: visitorCacheImplementation,
+      hitCacheImplementation: hitCacheImplementation,
+      disableCache: disableCache,
+      language: 1
+    });
+  };
+
+  var handleDisplay = function handleDisplay() {
+    var isFirstInit = !state.visitor;
+
+    if (state.status.isLoading && loadingComponent && isFirstInit && fetchNow) {
+      return /*#__PURE__*/React.createElement(React.Fragment, null, loadingComponent);
+    }
+
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  };
+
+  return /*#__PURE__*/React.createElement(FlagshipContext.Provider, {
+    value: {
+      state: state,
+      setState: setState
+    }
+  }, handleDisplay());
+};
+FlagshipProvider.defaultProps = {
+  activateDeduplicationTime: 10,
+  hitDeduplicationTime: 10
+};