@flagship.io/react-sdk 3.0.6 → 3.0.8

package/dist/Flag.js

@@ -1,8 +1,8 @@
 import Flagship, { FlagMetadata } from '@flagship.io/js-sdk';
 import { GET_FLAG_CAST_ERROR, GET_METADATA_CAST_ERROR, noVisitorMessage } from './constants';
 import { hasSameType, logInfo, logWarn, sprintf } from './utils';
-var Flag = /** @class */ (function () {
-    function Flag(defaultValue, key, flagsData) {
+export class Flag {
+    constructor(defaultValue, key, flagsData) {
         if (!flagsData) {
             logWarn(Flagship.getConfig(), noVisitorMessage, 'GetFlag');
         }
@@ -10,57 +10,51 @@ var Flag = /** @class */ (function () {
         this.key = key;
         this.flag = flagsData === null || flagsData === void 0 ? void 0 : flagsData.get(key);
     }
-    Flag.prototype.NotSameType = function () {
+    NotSameType() {
         var _a;
         return this.defaultValue !== null && this.defaultValue !== undefined && !hasSameType((_a = this.flag) === null || _a === void 0 ? void 0 : _a.value, this.defaultValue);
-    };
-    Flag.prototype.getValue = function () {
+    }
+    getValue() {
         if (!this.flag) {
             logWarn(Flagship.getConfig(), noVisitorMessage, 'getValue');
             return this.defaultValue;
         }
         if (this.NotSameType()) {
-            logInfo(Flagship.getConfig(), sprintf(GET_FLAG_CAST_ERROR, this.key), "getValue");
+            logInfo(Flagship.getConfig(), sprintf(GET_FLAG_CAST_ERROR, this.key), 'getValue');
             return this.defaultValue;
         }
         return this.flag.value;
-    };
-    Flag.prototype.exists = function () {
+    }
+    exists() {
         if (!this.flag) {
             logWarn(Flagship.getConfig(), noVisitorMessage, 'exists');
             return false;
         }
         return !!(this.flag.campaignId && this.flag.variationId && this.flag.variationGroupId);
-    };
-    Flag.prototype.userExposed = function () {
+    }
+    userExposed() {
         if (!this.flag) {
             logWarn(Flagship.getConfig(), noVisitorMessage, 'userExposed');
         }
         return Promise.resolve();
-    };
-    Object.defineProperty(Flag.prototype, "metadata", {
-        get: function () {
-            var functionName = 'metadata';
-            if (!this.flag) {
-                logWarn(Flagship.getConfig(), noVisitorMessage, functionName);
-                return FlagMetadata.Empty();
-            }
-            if (this.NotSameType()) {
-                logInfo(Flagship.getConfig(), sprintf(GET_METADATA_CAST_ERROR, this.key), functionName);
-                return FlagMetadata.Empty();
-            }
-            return new FlagMetadata({
-                campaignId: this.flag.campaignId,
-                variationGroupId: this.flag.variationGroupId,
-                variationId: this.flag.variationId,
-                isReference: !!this.flag.isReference,
-                campaignType: this.flag.campaignType,
-                slug: this.flag.slug
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Flag;
-}());
-export { Flag };
+    }
+    get metadata() {
+        const functionName = 'metadata';
+        if (!this.flag) {
+            logWarn(Flagship.getConfig(), noVisitorMessage, functionName);
+            return FlagMetadata.Empty();
+        }
+        if (this.NotSameType()) {
+            logInfo(Flagship.getConfig(), sprintf(GET_METADATA_CAST_ERROR, this.key), functionName);
+            return FlagMetadata.Empty();
+        }
+        return new FlagMetadata({
+            campaignId: this.flag.campaignId,
+            variationGroupId: this.flag.variationGroupId,
+            variationId: this.flag.variationId,
+            isReference: !!this.flag.isReference,
+            campaignType: this.flag.campaignType,
+            slug: this.flag.slug
+        });
+    }
+}

package/dist/FlagshipContext.d.ts

@@ -1,5 +1,5 @@
-import React, { ReactNode, Dispatch, SetStateAction } from "react";
-import { BucketingDTO, CampaignDTO, FlagDTO, IFlagshipConfig, primitive, Visitor } from "@flagship.io/js-sdk";
+import React, { ReactNode, Dispatch, SetStateAction } from 'react';
+import { BucketingDTO, CampaignDTO, FlagDTO, IFlagshipConfig, primitive, Visitor } from '@flagship.io/js-sdk';
 export interface FsStatus {
     /**
      * Boolean. When true, the SDK is still not ready to render your App otherwise it'll use default modifications.

package/dist/FlagshipContext.js

@@ -1,119 +1,106 @@
-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);
-};
 // 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 },
+import React, { useState, useEffect, createContext, useRef } from 'react';
+import { Flagship, FlagshipStatus } from '@flagship.io/js-sdk';
+import { getModificationsFromCampaigns, logError, useNonInitialEffect } from './utils';
+const initStat = {
+    status: { isLoading: true, isSdkReady: false }
 };
-export var FlagshipContext = createContext({
-    state: __assign({}, initStat),
+export const FlagshipContext = createContext({
+    state: Object.assign({}, initStat)
 });
-export var FlagshipProvider = function (_a) {
-    var children = _a.children, fetchNow = _a.fetchNow, envId = _a.envId, apiKey = _a.apiKey, decisionMode = _a.decisionMode, decisionApiUrl = _a.decisionApiUrl, timeout = _a.timeout, logLevel = _a.logLevel, statusChangedCallback = _a.statusChangedCallback, logManager = _a.logManager, pollingInterval = _a.pollingInterval, visitorData = _a.visitorData, onInitStart = _a.onInitStart, onInitDone = _a.onInitDone, onBucketingSuccess = _a.onBucketingSuccess, onBucketingFail = _a.onBucketingFail, loadingComponent = _a.loadingComponent, onBucketingUpdated = _a.onBucketingUpdated, onUpdate = _a.onUpdate, enableClientCache = _a.enableClientCache, initialBucketing = _a.initialBucketing, initialCampaigns = _a.initialCampaigns, initialModifications = _a.initialModifications, initialFlagsData = _a.initialFlagsData, fetchFlagsOnBucketingUpdated = _a.fetchFlagsOnBucketingUpdated, activateDeduplicationTime = _a.activateDeduplicationTime, hitDeduplicationTime = _a.hitDeduplicationTime, visitorCacheImplementation = _a.visitorCacheImplementation, hitCacheImplementation = _a.hitCacheImplementation, disableCache = _a.disableCache, language = _a.language;
-    var modifications = new Map();
+export const FlagshipProvider = ({ children, fetchNow, envId, apiKey, decisionMode, decisionApiUrl, timeout, logLevel, statusChangedCallback, logManager, pollingInterval, visitorData, onInitStart, onInitDone, onBucketingSuccess, onBucketingFail, loadingComponent, onBucketingUpdated, onUpdate, enableClientCache, initialBucketing, initialCampaigns, initialModifications, initialFlagsData, fetchFlagsOnBucketingUpdated, activateDeduplicationTime, hitDeduplicationTime, visitorCacheImplementation, hitCacheImplementation, disableCache, language }) => {
+    let modifications = new Map();
     if (initialFlagsData && initialFlagsData.forEach) {
-        initialFlagsData.forEach(function (flag) {
+        initialFlagsData.forEach((flag) => {
             modifications.set(flag.key, flag);
         });
     }
     else if (initialModifications && initialModifications.forEach) {
-        initialModifications.forEach(function (modification) {
+        initialModifications.forEach((modification) => {
             modifications.set(modification.key, modification);
         });
     }
     else if (initialCampaigns) {
         modifications = getModificationsFromCampaigns(initialCampaigns);
     }
-    var _b = useState(__assign(__assign({}, initStat), { modifications: modifications })), state = _b[0], setState = _b[1];
-    var _c = useState(), lastModified = _c[0], setLastModified = _c[1];
-    var stateRef = useRef();
+    const [state, setState] = useState(Object.assign(Object.assign({}, initStat), { modifications }));
+    const [lastModified, setLastModified] = useState();
+    const stateRef = useRef();
     stateRef.current = state;
-    useNonInitialEffect(function () {
+    useNonInitialEffect(() => {
         var _a;
         if (fetchFlagsOnBucketingUpdated) {
             (_a = state.visitor) === null || _a === void 0 ? void 0 : _a.fetchFlags();
         }
     }, [lastModified]);
-    useNonInitialEffect(function () {
+    useNonInitialEffect(() => {
         createVisitor(true);
     }, [JSON.stringify(visitorData)]);
-    useEffect(function () {
+    useEffect(() => {
         initSdk();
     }, [envId, apiKey, decisionMode]);
     function initializeState(param) {
-        var newStatus = {
+        const newStatus = {
             isSdkReady: param.isSdkReady,
             isLoading: param.isLoading,
             isVisitorDefined: !!param.fsVisitor,
-            lastRefresh: new Date().toISOString(),
+            lastRefresh: new Date().toISOString()
         };
-        setState(function (currentState) {
+        setState((currentState) => {
             if (!currentState.status.firstInitSuccess) {
                 newStatus.firstInitSuccess = new Date().toISOString();
             }
-            return __assign(__assign({}, currentState), { visitor: param.fsVisitor, modifications: param.fsVisitor.modifications, config: Flagship.getConfig(), status: __assign(__assign({}, currentState.status), newStatus) });
+            return Object.assign(Object.assign({}, currentState), { visitor: param.fsVisitor, modifications: param.fsVisitor.modifications, config: Flagship.getConfig(), status: Object.assign(Object.assign({}, currentState.status), newStatus) });
         });
         return newStatus;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    var onVisitorReady = function (fsVisitor, error) {
+    const onVisitorReady = (fsVisitor, error) => {
         if (error) {
-            logError(Flagship.getConfig(), error.message || error, "onReady");
+            logError(Flagship.getConfig(), error.message || error, 'onReady');
             return;
         }
-        var newStatus = initializeState({
-            fsVisitor: fsVisitor,
+        const newStatus = initializeState({
+            fsVisitor,
             isSdkReady: true,
-            isLoading: false,
+            isLoading: false
         });
         if (onUpdate) {
             onUpdate({
                 fsModifications: fsVisitor.modifications,
                 config: Flagship.getConfig(),
-                status: newStatus,
+                status: newStatus
             });
         }
     };
-    var createVisitor = function (fetchFlags) {
-        if (fetchFlags === void 0) { fetchFlags = false; }
+    const createVisitor = (fetchFlags = false) => {
         if (!visitorData) {
             return;
         }
-        var fsVisitor = Flagship.newVisitor({
+        const fsVisitor = Flagship.newVisitor({
             visitorId: visitorData.id,
             context: visitorData.context,
             isAuthenticated: visitorData.isAuthenticated,
             hasConsented: visitorData.hasConsented,
-            initialCampaigns: initialCampaigns,
-            initialModifications: initialModifications,
-            initialFlagsData: initialFlagsData,
+            initialCampaigns,
+            initialModifications,
+            initialFlagsData
         });
-        fsVisitor === null || fsVisitor === void 0 ? void 0 : fsVisitor.on("ready", function (error) {
+        fsVisitor === null || fsVisitor === void 0 ? void 0 : fsVisitor.on('ready', (error) => {
             onVisitorReady(fsVisitor, error);
         });
         if (!fetchNow && fsVisitor && !fetchFlags) {
             initializeState({
-                fsVisitor: fsVisitor,
+                fsVisitor,
                 isSdkReady: true,
-                isLoading: false,
+                isLoading: false
             });
         }
         if (fetchFlags && !fetchNow) {
             fsVisitor === null || fsVisitor === void 0 ? void 0 : fsVisitor.fetchFlags();
         }
     };
-    var statusChanged = function (status) {
+    const statusChanged = (status) => {
         if (statusChangedCallback) {
             statusChangedCallback(status);
         }
@@ -131,51 +118,51 @@ export var FlagshipProvider = function (_a) {
                 createVisitor();
                 break;
             case FlagshipStatus.NOT_INITIALIZED:
-                setState(function (prev) { return (__assign(__assign({}, prev), { config: Flagship.getConfig() })); });
+                setState((prev) => (Object.assign(Object.assign({}, prev), { config: Flagship.getConfig() })));
                 break;
         }
     };
-    var onBucketingLastModified = function (lastUpdate) {
+    const onBucketingLastModified = (lastUpdate) => {
         if (onBucketingUpdated) {
             onBucketingUpdated(lastUpdate);
         }
         setLastModified(lastUpdate);
     };
-    var initSdk = function () {
+    const initSdk = () => {
         Flagship.start(envId, apiKey, {
-            decisionMode: decisionMode,
-            fetchNow: fetchNow,
-            timeout: timeout,
-            logLevel: logLevel,
+            decisionMode,
+            fetchNow,
+            timeout,
+            logLevel,
             statusChangedCallback: statusChanged,
-            logManager: logManager,
-            pollingInterval: pollingInterval,
-            onBucketingFail: onBucketingFail,
-            onBucketingSuccess: onBucketingSuccess,
-            enableClientCache: enableClientCache,
-            decisionApiUrl: decisionApiUrl,
+            logManager,
+            pollingInterval,
+            onBucketingFail,
+            onBucketingSuccess,
+            enableClientCache,
+            decisionApiUrl,
             onBucketingUpdated: onBucketingLastModified,
-            initialBucketing: initialBucketing,
-            activateDeduplicationTime: activateDeduplicationTime,
-            hitDeduplicationTime: hitDeduplicationTime,
-            visitorCacheImplementation: visitorCacheImplementation,
-            hitCacheImplementation: hitCacheImplementation,
-            disableCache: disableCache,
-            language: language,
+            initialBucketing,
+            activateDeduplicationTime,
+            hitDeduplicationTime,
+            visitorCacheImplementation,
+            hitCacheImplementation,
+            disableCache,
+            language
         });
     };
-    var handleDisplay = function () {
-        var isFirstInit = !state.visitor;
+    const handleDisplay = () => {
+        const isFirstInit = !state.visitor;
         if (state.status.isLoading && loadingComponent && isFirstInit && fetchNow) {
             return React.createElement(React.Fragment, null, loadingComponent);
         }
         return React.createElement(React.Fragment, null, children);
     };
-    return (React.createElement(FlagshipContext.Provider, { value: { state: state, setState: setState } }, handleDisplay()));
+    return (React.createElement(FlagshipContext.Provider, { value: { state, setState } }, handleDisplay()));
 };
 FlagshipProvider.defaultProps = {
     activateDeduplicationTime: 2,
     hitDeduplicationTime: 2,
     fetchNow: true,
-    language: 1,
+    language: 1
 };