@flagship.io/react-sdk 4.0.0-alpha.1 → 4.0.0-alpha.2

package/dist/src/FlagshipProvider.js

@@ -0,0 +1,154 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+// eslint-disable-next-line no-use-before-define
+import { useState, useRef, useEffect } from 'react';
+import Flagship, { DecisionMode, FSSdkStatus } from '@flagship.io/js-sdk';
+import { FlagshipContext, initStat } from './FlagshipContext';
+import { INTERNAL_EVENTS } from './internalType';
+import { version as SDK_VERSION } from './sdkVersion';
+import { useNonInitialEffect, logError, extractFlagsMap } from './utils';
+export function FlagshipProvider({ children, envId, apiKey, decisionMode = DecisionMode.DECISION_API, visitorData, loadingComponent, onSdkStatusChanged, onBucketingUpdated, initialCampaigns, initialFlagsData, fetchFlagsOnBucketingUpdated, hitDeduplicationTime = 2, fetchNow = true, language = 1, sdkVersion = SDK_VERSION, onFetchFlagsStatusChanged, shouldSaveInstance, ...props }) {
+    const flags = extractFlagsMap(initialFlagsData, initialCampaigns);
+    const [state, setState] = useState({
+        ...initStat,
+        flags,
+        hasVisitorData: !!visitorData
+    });
+    const [lastModified, setLastModified] = useState();
+    const stateRef = useRef();
+    stateRef.current = state;
+    // #region functions
+    const onBucketingLastModified = (lastUpdate) => {
+        if (onBucketingUpdated) {
+            onBucketingUpdated(lastUpdate);
+        }
+        setLastModified(lastUpdate);
+    };
+    const statusChanged = (status) => {
+        if (onSdkStatusChanged) {
+            onSdkStatusChanged(status);
+        }
+        switch (status) {
+            case FSSdkStatus.SDK_PANIC:
+            case FSSdkStatus.SDK_INITIALIZED:
+                createVisitor();
+                break;
+            case FSSdkStatus.SDK_NOT_INITIALIZED:
+                setState((prev) => ({
+                    ...prev,
+                    config: Flagship.getConfig(),
+                    isInitializing: false
+                }));
+                break;
+        }
+    };
+    const initSdk = () => {
+        Flagship.start(envId, apiKey, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            decisionMode: decisionMode,
+            fetchNow,
+            onSdkStatusChanged: statusChanged,
+            onBucketingUpdated: onBucketingLastModified,
+            hitDeduplicationTime,
+            language,
+            sdkVersion,
+            ...props
+        });
+    };
+    function initializeState(param) {
+        setState((currentState) => ({
+            ...currentState,
+            visitor: param.fsVisitor,
+            config: Flagship.getConfig(),
+            isInitializing: false,
+            hasVisitorData: !!visitorData
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const onVisitorReady = (fsVisitor, error) => {
+        if (error) {
+            logError(Flagship.getConfig(), error.message || error, 'onReady');
+        }
+        initializeState({ fsVisitor });
+    };
+    const createVisitor = () => {
+        if (!visitorData) {
+            return;
+        }
+        const fsVisitor = Flagship.newVisitor({
+            visitorId: visitorData.id,
+            context: visitorData.context,
+            isAuthenticated: visitorData.isAuthenticated,
+            hasConsented: visitorData.hasConsented,
+            initialCampaigns,
+            initialFlagsData,
+            onFetchFlagsStatusChanged,
+            shouldSaveInstance
+        });
+        fsVisitor?.on('ready', (error) => {
+            onVisitorReady(fsVisitor, error);
+        });
+        if (!fetchNow) {
+            initializeState({ fsVisitor });
+        }
+    };
+    function updateVisitor() {
+        if (!visitorData) {
+            return;
+        }
+        if (!state.visitor ||
+            (state.visitor.visitorId !== visitorData.id &&
+                (!visitorData.isAuthenticated || (visitorData.isAuthenticated && state.visitor.anonymousId)))) {
+            createVisitor();
+            return;
+        }
+        if (visitorData.hasConsented !== state.visitor.hasConsented) {
+            state.visitor.setConsent(visitorData.hasConsented ?? true);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        state.visitor.updateContext(visitorData.context);
+        if (!state.visitor.anonymousId && visitorData.isAuthenticated) {
+            state.visitor.authenticate(visitorData.id);
+        }
+        if (state.visitor.anonymousId && !visitorData.isAuthenticated) {
+            state.visitor.unauthenticate();
+        }
+        state.visitor.fetchFlags();
+    }
+    // #endregion
+    useNonInitialEffect(() => {
+        if (fetchFlagsOnBucketingUpdated) {
+            state.visitor?.fetchFlags();
+        }
+    }, [lastModified]);
+    useNonInitialEffect(() => {
+        updateVisitor();
+    }, [JSON.stringify(visitorData)]);
+    useEffect(() => {
+        initSdk();
+    }, [envId, apiKey, decisionMode]);
+    const handleDisplay = () => {
+        const isFirstInit = !state.visitor;
+        if (state.isInitializing &&
+            loadingComponent &&
+            isFirstInit &&
+            fetchNow) {
+            return _jsx(_Fragment, { children: loadingComponent });
+        }
+        return _jsx(_Fragment, { children: children });
+    };
+    useEffect(() => {
+        window.addEventListener(INTERNAL_EVENTS.FsTriggerRendering, onVariationsForced);
+        return () => window.removeEventListener(INTERNAL_EVENTS.FsTriggerRendering, onVariationsForced);
+    }, [state.config?.isQAModeEnabled]);
+    const onVariationsForced = (e) => {
+        const { detail } = e;
+        if (detail.forcedReFetchFlags) {
+            stateRef.current?.visitor?.fetchFlags();
+        }
+        else {
+            setState(state => ({ ...state, toggleForcedVariations: !state.toggleForcedVariations }));
+        }
+    };
+    return (_jsx(FlagshipContext.Provider, { value: { state, setState }, children: handleDisplay() }));
+}

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
-import { FlagshipProvider } from './FlagshipContext';
-export * from './FlagshipContext';
+import { FlagshipProvider } from './FlagshipProvider';
 export * from '@flagship.io/js-sdk';
 export * from './FlagshipHooks';
+export * from './type';
+export { FlagshipProvider } from './FlagshipProvider';
 export default FlagshipProvider;

package/dist/src/index.js

@@ -1,5 +1,6 @@
-import { FlagshipProvider } from './FlagshipContext';
-export * from './FlagshipContext';
+import { FlagshipProvider } from './FlagshipProvider';
 export * from '@flagship.io/js-sdk';
 export * from './FlagshipHooks';
+export * from './type';
+export { FlagshipProvider } from './FlagshipProvider';
 export default FlagshipProvider;

package/dist/src/sdkVersion.d.ts

@@ -1 +1 @@
-export declare const version = "4.0.0-alpha.1";
+export declare const version = "4.0.0-alpha.2";

package/dist/src/sdkVersion.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '4.0.0-alpha.1';
+export const version = '4.0.0-alpha.2';

package/dist/src/type.d.ts

@@ -0,0 +1,158 @@
+import { Dispatch, ReactNode, SetStateAction } from 'react';
+import { Visitor, IFlagshipConfig, FlagDTO, CampaignDTO, primitive, BucketingDTO, FetchFlagsStatus, FSSdkStatus, IHit, IFSFlag, IFSFlagCollection, SerializedFlagMetadata } from '@flagship.io/js-sdk';
+export interface FsContextState {
+    visitor?: Visitor;
+    config?: IFlagshipConfig;
+    flags?: Map<string, FlagDTO>;
+    initialCampaigns?: CampaignDTO[];
+    initialFlags?: Map<string, FlagDTO> | FlagDTO[];
+    isInitializing: boolean;
+    hasVisitorData?: boolean;
+    toggleForcedVariations?: boolean;
+}
+export type VisitorData = {
+    id?: string;
+    context?: Record<string, primitive>;
+    isAuthenticated?: boolean;
+    hasConsented: boolean;
+};
+export interface FsContext {
+    state: FsContextState;
+    setState?: Dispatch<SetStateAction<FsContextState>>;
+}
+/**
+ * Props for the FlagshipProvider component.
+ */
+export interface FlagshipProviderProps extends IFlagshipConfig {
+    /**
+     * This is the data to identify the current visitor using your app.
+     */
+    visitorData: VisitorData | null;
+    /**
+     * The environment ID for your Flagship project.
+     */
+    envId: string;
+    /**
+     * The API key for your Flagship project.
+     */
+    apiKey: string;
+    /**
+     * This component will be rendered when Flagship is loading at first initialization only.
+     * By default, the value is undefined. It means it will display your app and it might
+     * display default modifications value for a very short moment.
+     */
+    loadingComponent?: ReactNode;
+    /**
+     * The child components to be rendered within the FlagshipProvider.
+     */
+    children?: ReactNode;
+    /**
+     * This is an object of the data received when fetching bucketing endpoint.
+     * Providing this prop will make bucketing ready to use and the first polling will immediately check for an update.
+     * If the shape of an element is not correct, an error log will give the reason why.
+     */
+    initialBucketing?: BucketingDTO;
+    /**
+     * An array of initial campaigns to be used by the SDK.
+     */
+    initialCampaigns?: CampaignDTO[];
+    /**
+     * This is a set of flag data provided to avoid the SDK to have an empty cache during the first initialization.
+     */
+    initialFlagsData?: SerializedFlagMetadata[];
+    /**
+     * If true, it'll automatically call fetchFlags when the bucketing file has updated.
+     */
+    fetchFlagsOnBucketingUpdated?: boolean;
+    /**
+     * Callback function that will be called when the fetch flags status changes.
+     *
+     * @param newStatus - The new status of the flags fetch.
+     * @param reason - The reason for the status change.
+     */
+    onFetchFlagsStatusChanged?: ({ status, reason }: FetchFlagsStatus) => void;
+    /**
+     * If true, the newly created visitor instance won't be saved and will simply be returned. Otherwise, the newly created visitor instance will be returned and saved into the Flagship.
+     *
+     * Note: By default, it is false on server-side and true on client-side.
+     */
+    shouldSaveInstance?: boolean;
+}
+/**
+ * Represents the output of the `useFlagship` hook.
+ */
+export type UseFlagshipOutput = {
+    /**
+     * The visitor ID.
+     */
+    visitorId?: string;
+    /**
+     * The anonymous ID.
+     */
+    anonymousId?: string | null;
+    /**
+     * The visitor context.
+     */
+    context?: Record<string, primitive>;
+    /**
+     * Indicates whether the visitor has consented for protected data usage.
+     */
+    hasConsented?: boolean;
+    /**
+     * Sets whether the visitor has consented for protected data usage.
+     * @param hasConsented - True if the visitor has consented, false otherwise.
+     */
+    setConsent: (hasConsented: boolean) => void;
+    readonly sdkStatus: FSSdkStatus;
+    readonly fetchStatus?: FetchFlagsStatus;
+    /**
+     * Updates the visitor context values, matching the given keys, used for targeting.
+     * A new context value associated with this key will be created if there is no previous matching value.
+     * Context keys must be strings, and value types must be one of the following: number, boolean, string.
+     * @param context - A collection of keys and values.
+     */
+    updateContext(context: Record<string, primitive>): void;
+    /**
+     * Clears the actual visitor context.
+     */
+    clearContext(): void;
+    /**
+     * Authenticates an anonymous visitor.
+     * @param visitorId - The visitor ID.
+     */
+    authenticate(visitorId: string): void;
+    /**
+     * Changes an authenticated visitor to an anonymous visitor.
+     */
+    unauthenticate(): void;
+    /**
+     * Sends a hit or multiple hits to the Flagship server.
+     * @param hit - The hit or array of hits to send.
+     */
+    sendHits(hit: IHit): Promise<void>;
+    sendHits(hits: IHit[]): Promise<void>;
+    sendHits(hits: IHit | IHit[]): Promise<void>;
+    /**
+     * Return a [Flag](#flag-class)  object by its key.
+     *  If no flag matches the given key, an empty flag will be returned.
+     * Call exists() to check if the flag has been found.
+     * @param key - The flag key.
+     * @param defaultValue - The default value.
+     * @returns The flag object.
+     */
+    getFlag(key: string): IFSFlag;
+    /**
+     * Invokes the `decision API` or refers to the `bucketing file` to refresh all campaign flags based on the visitor's context.
+     */
+    fetchFlags: () => Promise<void>;
+    /**
+     * Batches and sends all hits that are in the pool before the application is closed.
+     * @returns A promise that resolves when all hits are sent.
+     */
+    close(): Promise<void>;
+    /**
+    * Returns a collection of all flags fetched for the visitor.
+    * @returns An IFSFlagCollection object.
+    */
+    getFlags(): IFSFlagCollection;
+};

package/dist/src/type.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils.d.ts

@@ -1,10 +1,14 @@
-import { CampaignDTO, IFlagshipConfig, Modification } from '@flagship.io/js-sdk';
 import { EffectCallback, DependencyList } from 'react';
+import { CampaignDTO, FlagDTO, IFlagshipConfig, SerializedFlagMetadata } from '@flagship.io/js-sdk';
 export declare function logError(config: IFlagshipConfig | undefined, message: string, tag: string): void;
 export declare function logInfo(config: IFlagshipConfig | undefined, message: string, tag: string): void;
 export declare function logWarn(config: IFlagshipConfig | undefined, message: string, tag: string): void;
-export declare const getModificationsFromCampaigns: (campaigns: Array<CampaignDTO>) => Map<string, Modification>;
+export declare const getFlagsFromCampaigns: (campaigns: Array<CampaignDTO>) => Map<string, FlagDTO>;
 export declare function uuidV4(): string;
 export declare function useNonInitialEffect(effect: EffectCallback, deps?: DependencyList): void;
 export declare function hasSameType(flagValue: unknown, defaultValue: unknown): boolean;
 export declare function sprintf(format: string, ...value: any[]): string;
+export declare function hexToValue(hex: string, config: IFlagshipConfig): {
+    v: unknown;
+} | null;
+export declare function extractFlagsMap(initialFlagsData?: SerializedFlagMetadata[], initialCampaigns?: CampaignDTO[]): Map<string, FlagDTO>;

package/dist/src/utils.js

@@ -1,46 +1,49 @@
 'use client';
-import { LogLevel } from '@flagship.io/js-sdk';
 import { useEffect, useRef } from 'react';
+import Flagship, { LogLevel } from '@flagship.io/js-sdk';
 export function logError(config, message, tag) {
-    if (!config ||
-        !config.logManager ||
-        typeof config.logManager.error !== 'function' ||
-        !config.logLevel ||
-        config.logLevel < LogLevel.ERROR) {
+    if (!config || !config.logLevel || config.logLevel < LogLevel.ERROR) {
         return;
     }
-    config.logManager.error(message, tag);
+    if (typeof config.onLog === 'function') {
+        config.onLog(LogLevel.ERROR, tag, message);
+    }
+    if (config.logManager && typeof config.logManager.error === 'function') {
+        config.logManager.error(message, tag);
+    }
 }
 export function logInfo(config, message, tag) {
-    if (!config ||
-        !config.logManager ||
-        typeof config.logManager.info !== 'function' ||
-        !config.logLevel ||
-        config.logLevel < LogLevel.INFO) {
+    if (!config || !config.logLevel || config.logLevel < LogLevel.INFO) {
         return;
     }
-    config.logManager.info(message, tag);
+    if (typeof config.onLog === 'function') {
+        config.onLog(LogLevel.INFO, tag, message);
+    }
+    if (config.logManager && typeof config.logManager.info === 'function') {
+        config.logManager.info(message, tag);
+    }
 }
 export function logWarn(config, message, tag) {
-    if (!config ||
-        !config.logManager ||
-        typeof config.logManager.warning !== 'function' ||
-        !config.logLevel ||
-        config.logLevel < LogLevel.WARNING) {
+    if (!config || !config.logLevel || config.logLevel < LogLevel.WARNING) {
         return;
     }
-    config.logManager.warning(message, tag);
+    if (typeof config.onLog === 'function') {
+        config.onLog(LogLevel.WARNING, tag, message);
+    }
+    if (config.logManager && typeof config.logManager.warning === 'function') {
+        config.logManager.warning(message, tag);
+    }
 }
-export const getModificationsFromCampaigns = (campaigns) => {
-    const modifications = new Map();
+export const getFlagsFromCampaigns = (campaigns) => {
+    const flags = new Map();
     if (!campaigns || !Array.isArray(campaigns)) {
-        return modifications;
+        return flags;
     }
     campaigns.forEach((campaign) => {
         const object = campaign.variation.modifications.value;
         for (const key in object) {
             const value = object[key];
-            modifications.set(key, {
+            flags.set(key, {
                 key,
                 campaignId: campaign.id,
                 campaignName: campaign.name || '',
@@ -49,11 +52,12 @@ export const getModificationsFromCampaigns = (campaigns) => {
                 variationId: campaign.variation.id,
                 variationName: campaign.variation.name || '',
                 isReference: campaign.variation.reference,
+                slug: campaign.slug || '',
                 value
             });
         }
     });
-    return modifications;
+    return flags;
 };
 export function uuidV4() {
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (char) {
@@ -93,3 +97,52 @@ export function sprintf(format, ...value) {
     }
     return formatted;
 }
+export function hexToValue(hex, config) {
+    if (typeof hex !== 'string') {
+        logError(config, `Invalid hex string: ${hex}`, 'hexToValue');
+        return null;
+    }
+    let jsonString = '';
+    for (let i = 0; i < hex.length; i += 2) {
+        const hexChar = hex.slice(i, i + 2);
+        const charCode = parseInt(hexChar, 16);
+        if (isNaN(charCode)) {
+            logError(config, `Invalid hex character: ${hexChar}`, 'hexToValue');
+            return null;
+        }
+        jsonString += String.fromCharCode(charCode);
+    }
+    try {
+        const value = JSON.parse(jsonString);
+        return value;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        logError(config, `Error while parsing JSON: ${error?.message}`, 'hexToValue');
+        return null;
+    }
+}
+export function extractFlagsMap(initialFlagsData, initialCampaigns) {
+    let flags = new Map();
+    if (Array.isArray(initialFlagsData)) {
+        initialFlagsData.forEach((flag) => {
+            flags.set(flag.key, {
+                key: flag.key,
+                campaignId: flag.campaignId,
+                campaignName: flag.campaignName,
+                variationGroupId: flag.variationGroupId,
+                variationGroupName: flag.variationGroupName,
+                variationId: flag.variationId,
+                variationName: flag.variationName,
+                isReference: flag.isReference,
+                campaignType: flag.campaignType,
+                slug: flag.slug,
+                value: hexToValue(flag.hex, Flagship.getConfig())?.v
+            });
+        });
+    }
+    else if (initialCampaigns) {
+        flags = getFlagsFromCampaigns(initialCampaigns);
+    }
+    return flags;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flagship.io/react-sdk",
   "sideEffects": false,
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.2",
   "license": "Apache-2.0",
   "description": "Flagship REACT SDK",
   "main": "dist/index.node.js",
@@ -20,7 +20,7 @@
     "react-native": "./dist/src/index.js"
   },
   "dependencies": {
-    "@flagship.io/js-sdk": "^4.0.0-alpha.1",
+    "@flagship.io/js-sdk": "^4.0.0-alpha.2",
     "encoding": "^0.1.13"
   },
   "peerDependencies": {
@@ -38,49 +38,52 @@
     "sdk"
   ],
   "devDependencies": {
-    "@babel/cli": "^7.14.6",
-    "@babel/core": "^7.14.6",
-    "@babel/preset-env": "^7.14.7",
-    "@babel/preset-react": "^7.14.5",
-    "@babel/preset-typescript": "^7.14.5",
-    "@testing-library/jest-dom": "^5.11.4",
-    "@testing-library/react": "^11.1.0",
-    "@testing-library/react-hooks": "^7.0.1",
-    "@testing-library/user-event": "^12.1.10",
-    "@types/jest": "^26.0.15",
-    "@types/node": "^12.0.0",
-    "@types/react": "^17.0.0",
-    "@types/react-dom": "^17.0.0",
-    "@typescript-eslint/eslint-plugin": "^4.32.0",
-    "@typescript-eslint/parser": "^4.32.0",
-    "babel-loader": "^8.2.2",
+    "@babel/cli": "^7.24.1",
+    "@babel/core": "^7.24.3",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/preset-env": "^7.24.3",
+    "@babel/preset-react": "^7.24.1",
+    "@babel/preset-typescript": "^7.24.1",
+    "@testing-library/jest-dom": "^6.4.2",
+    "@testing-library/react": "^14.2.2",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.30",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "@typescript-eslint/eslint-plugin": "^7.4.0",
+    "@typescript-eslint/parser": "^7.4.0",
+    "babel-loader": "^9.1.3",
     "babel-plugin-add-module-exports": "^1.0.4",
-    "eslint": "^7.32.0",
-    "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.24.2",
+    "core-js": "^3.36.1",
+    "eslint": "^8.57.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.1.0",
-    "eslint-plugin-react": "^7.26.0",
-    "genversion": "^3.1.1",
-    "jest": "^29.5.0",
-    "jest-environment-jsdom": "^29.5.0",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
-    "react-test-renderer": "^17.0.2",
-    "regenerator-runtime": "^0.13.9",
-    "terser-webpack-plugin": "^5.2.4",
-    "ts-jest": "^29.1.0",
-    "ts-loader": "^9.2.3",
-    "typescript": "^5.0.4",
-    "webpack": "^5.82.0",
-    "webpack-cli": "^5.1.0",
-    "webpack-merge": "^5.8.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-react": "^7.34.1",
+    "genversion": "^3.2.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-test-renderer": "^18.2.0",
+    "regenerator-runtime": "^0.14.1",
+    "terser-webpack-plugin": "^5.3.10",
+    "ts-jest": "^29.1.2",
+    "ts-loader": "^9.5.1",
+    "typescript": "^5.4.3",
+    "webpack": "^5.91.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-merge": "^5.10.0",
     "webpack-node-externals": "^3.0.0"
   },
   "scripts": {
     "dev": "tsc --watch",
     "test": "jest",
-    "lint": "eslint . --ext .tsx",
+    "lint": "eslint src --ext .tsx",
     "clean": "rm -rf dist && mkdir dist",
     "generate:version": "genversion --es6 src/sdkVersion.ts",
     "build:esm": "BABEL_ENV=esm babel src --extensions '.ts,.tsx' --out-dir dist/esm --copy-files",

package/dist/src/Flag.d.ts

@@ -1,13 +0,0 @@
-import { FlagDTO, IFlag, IFlagMetadata } from '@flagship.io/js-sdk';
-export declare class Flag<T> implements IFlag<T> {
-    private defaultValue;
-    private key;
-    private flag?;
-    constructor(defaultValue: T, key: string, flagsData: Map<string, FlagDTO> | undefined);
-    private NotSameType;
-    getValue(): T;
-    exists(): boolean;
-    userExposed(): Promise<void>;
-    visitorExposed(): Promise<void>;
-    get metadata(): IFlagMetadata;
-}