@coframe/sdk 1.1.23 → 1.1.24

package/dist/pkg/feature-flags.esm.mjs

@@ -0,0 +1,609 @@
+function getBrowserHostname() {
+    return window.location.hostname;
+}
+function getDocumentCookie() {
+    try {
+        return document.cookie;
+    }
+    catch (_error) {
+        return '';
+    }
+}
+function setDocumentCookie(cookie) {
+    document.cookie = cookie;
+}
+
+const USER_TOKEN_COOKIE_KEY = 'coframe.user.token';
+const VISIT_COUNT_COOKIE_KEY = 'coframe.cvc';
+const COOKIE_DAYS = 400;
+function getGlobalScope() {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+}
+const generateUUID = () => {
+    var _a;
+    const cryptoObject = (_a = getGlobalScope()) === null || _a === void 0 ? void 0 : _a.crypto;
+    if (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID)
+        return cryptoObject.randomUUID();
+    return `${1e7}${ -1e3}${ -4e3}${ -8e3}${ -1e11}`.replace(/[018]/g, (c) => {
+        var _a, _b;
+        const randomValue = (_b = (_a = cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues) === null || _a === void 0 ? void 0 : _a.call(cryptoObject, new Uint8Array(1))[0]) !== null && _b !== void 0 ? _b : 0;
+        return (c ^
+            (randomValue & (15 >> (c / 4)))).toString(16);
+    });
+};
+const getCookie = (name) => {
+    const cookieStr = getDocumentCookie();
+    const regex = new RegExp(`(?:^| )${name}=([^;]*)`, 'g');
+    let match = null;
+    let lastValue = '';
+    while (true) {
+        match = regex.exec(cookieStr);
+        if (match === null)
+            break;
+        lastValue = match[1];
+    }
+    return lastValue;
+};
+let isCookiesEnabled = false;
+const setCookiesEnabled = (allowed) => {
+    isCookiesEnabled = allowed;
+};
+const setCookie = (name, value, logger) => {
+    if (!isCookiesEnabled) {
+        return;
+    }
+    const expirationDate = new Date();
+    expirationDate.setTime(expirationDate.getTime() + 24 * 60 * 60 * 1000 * COOKIE_DAYS);
+    const expires = expirationDate.toUTCString();
+    const setCookieForDomain = (domain) => {
+        const cookie = domain
+            ? `${name}=${value};path=/;domain=${domain};expires=${expires};secure`
+            : `${name}=${value};path=/;expires=${expires};secure`;
+        setDocumentCookie(cookie);
+    };
+    const hostname = getBrowserHostname();
+    if (hostname === 'localhost') {
+        setCookieForDomain();
+    }
+    else {
+        const domainParts = hostname.split('.');
+        for (let i = domainParts.length - 2; i >= 0; i--) {
+            let domain = `${domainParts.slice(i).join('.')}`;
+            if (i !== 0) {
+                domain = `.${domain}`;
+            }
+            setCookieForDomain(domain);
+        }
+    }
+    if (getCookie(name) !== value) ;
+};
+const getOrGenerateUserToken = () => {
+    let uuid = getCookie(USER_TOKEN_COOKIE_KEY);
+    if (!uuid) {
+        uuid = generateUUID();
+    }
+    return uuid;
+};
+const setUserTokenCookie = (uuid, logger) => {
+    setCookie(USER_TOKEN_COOKIE_KEY, uuid);
+};
+
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
+const CACHE_PREFIX = 'coframe.featureFlags.';
+let config;
+let projectId;
+let userToken;
+let userContext;
+let response;
+let responseContextKey;
+let inFlight;
+let inFlightContextKey;
+let requestGeneration = 0;
+const listeners = [];
+function storageKey(projectId) {
+    return `${CACHE_PREFIX}${projectId}`;
+}
+function readCache(projectId, expectedFingerprint) {
+    if (!isCookiesEnabled || typeof window === 'undefined')
+        return undefined;
+    try {
+        const value = window.localStorage.getItem(storageKey(projectId));
+        if (!value)
+            return undefined;
+        const parsed = JSON.parse(value);
+        if (!Object.prototype.hasOwnProperty.call(parsed, 'fingerprint')) {
+            window.localStorage.removeItem(storageKey(projectId));
+            return undefined;
+        }
+        if (typeof parsed.loadedAt !== 'number' ||
+            parsed.fingerprint !== expectedFingerprint ||
+            !parsed.response ||
+            typeof parsed.response.flags !== 'object') {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function getEvaluationContext() {
+    var _a, _b;
+    const visitCountCookie = getCookie(VISIT_COUNT_COOKIE_KEY);
+    const visitCount = /^[1-9]\d{0,14}$/.test(visitCountCookie)
+        ? Number(visitCountCookie)
+        : undefined;
+    return {
+        currentUrl: window.location.href,
+        languages: Array.from((_a = navigator.languages) !== null && _a !== void 0 ? _a : [navigator.language]),
+        browserPlatform: navigator.platform ||
+            ((_b = navigator.userAgentData) === null || _b === void 0 ? void 0 : _b.platform) ||
+            '',
+        ...(visitCount !== undefined ? { userVisitCount: visitCount } : {}),
+        ...(userContext ? { userContext } : {}),
+    };
+}
+function getContextKey(context) {
+    return JSON.stringify({
+        selector: (config === null || config === void 0 ? void 0 : config.selector)
+            ? {
+                names: config.selector.names
+                    ? [...config.selector.names].sort()
+                    : null,
+                groups: config.selector.groups
+                    ? [...config.selector.groups].sort()
+                    : null,
+            }
+            : null,
+        context,
+    });
+}
+async function getCacheFingerprint(currentUserToken, contextKey) {
+    var _a;
+    if (!isCookiesEnabled || !((_a = globalThis.crypto) === null || _a === void 0 ? void 0 : _a.subtle))
+        return undefined;
+    try {
+        const bytes = new TextEncoder().encode(JSON.stringify([currentUserToken, contextKey]));
+        const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+        return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+    }
+    catch (_b) {
+        return undefined;
+    }
+}
+function writeCache(projectId, value) {
+    if (!isCookiesEnabled || typeof window === 'undefined')
+        return;
+    try {
+        window.localStorage.setItem(storageKey(projectId), JSON.stringify(value));
+    }
+    catch (_a) {
+    }
+}
+function notify() {
+    if (!response)
+        return;
+    const metadata = {
+        errorsWhileComputingFlags: response.errorsWhileComputingFlags,
+        snapshotVersion: response.snapshotVersion,
+    };
+    for (const listener of listeners.slice()) {
+        try {
+            listener(response.flags, metadata);
+        }
+        catch (_a) {
+        }
+    }
+}
+function notifyCleared() {
+    for (const listener of listeners.slice()) {
+        try {
+            listener({}, { errorsWhileComputingFlags: false, snapshotVersion: 0 });
+        }
+        catch (_a) {
+        }
+    }
+}
+async function fetchFeatureFlags(context) {
+    var _a;
+    if (!config || !projectId)
+        throw new Error('Feature Flags are not configured');
+    const controller = new AbortController();
+    const timeout = window.setTimeout(() => controller.abort(), (_a = config.requestTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS);
+    try {
+        const result = await fetch(`${"https://edge.cofra.me"}/api/v1/flags?v=1`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                projectId,
+                userToken,
+                ...(config.selector ? { selector: config.selector } : {}),
+                ...context,
+            }),
+            signal: controller.signal,
+        });
+        if (!result.ok)
+            throw new Error(`Feature Flags request failed (${result.status})`);
+        return (await result.json());
+    }
+    finally {
+        window.clearTimeout(timeout);
+    }
+}
+async function initializeFeatureFlags(nextConfig, nextProjectId, nextUserToken, nextUserContext) {
+    var _a;
+    if (!nextConfig)
+        return;
+    config = nextConfig;
+    projectId = nextProjectId;
+    userToken = nextUserToken;
+    userContext = nextUserContext;
+    requestGeneration += 1;
+    inFlight = undefined;
+    inFlightContextKey = undefined;
+    response = undefined;
+    responseContextKey = undefined;
+    const initializationGeneration = requestGeneration;
+    const initialContextKey = getContextKey(getEvaluationContext());
+    const loading = reloadFeatureFlags();
+    const initialFingerprint = await getCacheFingerprint(nextUserToken, initialContextKey);
+    if (initializationGeneration === requestGeneration && !response) {
+        const initialCache = initialFingerprint
+            ? readCache(nextProjectId, initialFingerprint)
+            : undefined;
+        const ttl = (_a = nextConfig.cacheTtlMs) !== null && _a !== void 0 ? _a : DEFAULT_CACHE_TTL_MS;
+        if (initialCache && Date.now() - initialCache.loadedAt <= ttl) {
+            response = initialCache.response;
+            responseContextKey = initialContextKey;
+            notify();
+        }
+    }
+    await loading;
+}
+function reloadFeatureFlags() {
+    if (!config)
+        return Promise.resolve();
+    const currentProjectId = projectId;
+    if (!currentProjectId)
+        return Promise.resolve();
+    const requestUserToken = userToken !== null && userToken !== void 0 ? userToken : '';
+    const requestContext = getEvaluationContext();
+    const requestContextKey = getContextKey(requestContext);
+    if (inFlight && inFlightContextKey === requestContextKey)
+        return inFlight;
+    if (response && responseContextKey !== requestContextKey) {
+        response = undefined;
+        responseContextKey = undefined;
+        notifyCleared();
+    }
+    if (inFlight)
+        requestGeneration += 1;
+    const generation = requestGeneration;
+    const fingerprintPromise = getCacheFingerprint(requestUserToken, requestContextKey);
+    let trackedRequest;
+    trackedRequest = fetchFeatureFlags(requestContext)
+        .then(async (nextResponse) => {
+        if (generation !== requestGeneration)
+            return;
+        response = nextResponse;
+        responseContextKey = requestContextKey;
+        notify();
+        const fingerprint = await fingerprintPromise;
+        if (generation !== requestGeneration || !fingerprint)
+            return;
+        const cache = {
+            fingerprint,
+            loadedAt: Date.now(),
+            response: nextResponse,
+        };
+        writeCache(currentProjectId, cache);
+    })
+        .catch(async () => {
+        if (generation !== requestGeneration)
+            return;
+        const fingerprint = await fingerprintPromise;
+        if (generation !== requestGeneration || !fingerprint)
+            return;
+        const fallbackCache = readCache(currentProjectId, fingerprint);
+        if (!response && fallbackCache) {
+            response = fallbackCache.response;
+            responseContextKey = requestContextKey;
+            notify();
+        }
+    })
+        .finally(() => {
+        if (inFlight === trackedRequest) {
+            inFlight = undefined;
+            inFlightContextKey = undefined;
+        }
+    });
+    inFlight = trackedRequest;
+    inFlightContextKey = requestContextKey;
+    return trackedRequest;
+}
+function updateFeatureFlagUserToken(nextUserToken) {
+    if (nextUserToken === userToken)
+        return;
+    userToken = nextUserToken;
+    requestGeneration += 1;
+    inFlight = undefined;
+    inFlightContextKey = undefined;
+    response = undefined;
+    responseContextKey = undefined;
+    notifyCleared();
+    void reloadFeatureFlags();
+}
+function onFeatureFlags(callback) {
+    listeners.push(callback);
+    if (response) {
+        try {
+            callback(response.flags, {
+                errorsWhileComputingFlags: response.errorsWhileComputingFlags,
+                snapshotVersion: response.snapshotVersion,
+            });
+        }
+        catch (_a) {
+        }
+    }
+    return () => {
+        const index = listeners.indexOf(callback);
+        if (index !== -1)
+            listeners.splice(index, 1);
+    };
+}
+function getFeatureFlagResult(key) {
+    return response === null || response === void 0 ? void 0 : response.flags[key];
+}
+function getFeatureFlag(key) {
+    var _a;
+    const result = getFeatureFlagResult(key);
+    if (!result)
+        return undefined;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+function isFeatureEnabled(key, options) {
+    var _a, _b;
+    return (_b = (_a = getFeatureFlagResult(key)) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : options === null || options === void 0 ? void 0 : options.defaultValue;
+}
+function getFeatureFlagPayload(key) {
+    var _a;
+    const result = getFeatureFlagResult(key);
+    if (!result)
+        return undefined;
+    return 'payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null;
+}
+const getRemoteConfig = getFeatureFlagPayload;
+
+function observeFeatureFlagUrlChanges(onUrlChange) {
+    let lastUrl = window.location.href;
+    const tryReload = () => {
+        const currentUrl = window.location.href;
+        if (currentUrl === lastUrl)
+            return;
+        const previousUrl = lastUrl;
+        lastUrl = currentUrl;
+        onUrlChange(currentUrl, previousUrl);
+    };
+    window.addEventListener('popstate', tryReload);
+    window.addEventListener('hashchange', tryReload);
+    const patchHistoryMethod = (method) => {
+        const original = window.history[method];
+        window.history[method] = function (...args) {
+            const result = original.apply(this, args);
+            setTimeout(tryReload, 0);
+            return result;
+        };
+    };
+    patchHistoryMethod('pushState');
+    patchHistoryMethod('replaceState');
+}
+
+const QueueName = {
+    CFQ: 'CFQ'};
+
+function ensureQueueExists(queueName = QueueName.CFQ) {
+    var _a;
+    const descriptor = Object.getOwnPropertyDescriptor(window, queueName);
+    if (descriptor === null || descriptor === void 0 ? void 0 : descriptor.get) {
+        return window[queueName];
+    }
+    const queue = (_a = window[queueName]) !== null && _a !== void 0 ? _a : [];
+    Object.defineProperty(window, queueName, {
+        get() {
+            return queue;
+        },
+        set(val) {
+            if (val !== queue) {
+                console.warn(`[Coframe] Attempt to reassign ${queueName} queue — assignment ignored. Use .push() instead.`);
+            }
+        },
+        configurable: false,
+    });
+    return queue;
+}
+function __ensureQueuePushListenerHooked(queueName = QueueName.CFQ) {
+    const queue = ensureQueueExists(queueName);
+    if (queue.__cfqHooked) {
+        return queue;
+    }
+    queue.__cfqHooked = true;
+    queue.__cfqListeners = [];
+    const originalPush = queue.push.bind(queue);
+    queue.push = (...items) => {
+        const len = originalPush(...items);
+        const listeners = queue.__cfqListeners;
+        for (let i = 0; i < items.length; i++) {
+            const cmd = items[i];
+            const snapshot = listeners.slice();
+            for (let j = 0; j < snapshot.length; j++) {
+                const l = snapshot[j];
+                if (l.predicate(cmd))
+                    l.callback(cmd);
+            }
+        }
+        return len;
+    };
+    return queue;
+}
+function __addListener(predicate, callback, queueName = QueueName.CFQ) {
+    const queue = __ensureQueuePushListenerHooked(queueName);
+    const entry = { predicate, callback };
+    queue.__cfqListeners.push(entry);
+    let active = true;
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        const arr = queue.__cfqListeners;
+        const idx = arr.indexOf(entry);
+        if (idx !== -1)
+            arr.splice(idx, 1);
+    };
+}
+function findLastCmd(predicate, queueName = QueueName.CFQ) {
+    const queue = ensureQueueExists(queueName);
+    for (let i = queue.length - 1; i >= 0; i--) {
+        if (predicate(queue[i])) {
+            return queue[i];
+        }
+    }
+    return undefined;
+}
+function subscribeToCmd(predicate, callback, queueName = QueueName.CFQ) {
+    return __addListener(predicate, callback, queueName);
+}
+
+function push(cmd) {
+    if (typeof window === 'undefined')
+        return;
+    window.CFQ = window.CFQ || [];
+    window.CFQ.push(cmd);
+}
+function setConsent$1(enabled) {
+    push({ cookiesEnabled: enabled });
+}
+
+let currentUserToken;
+let spaNavigationInstalled = false;
+let identitySubscriptionInstalled = false;
+let consentSubscriptionInstalled = false;
+function requireIdentity(userToken) {
+    const normalized = userToken.trim();
+    if (!normalized)
+        throw new Error('Feature Flag userToken must not be empty');
+    return normalized;
+}
+function persistIdentity() {
+    if (isCookiesEnabled && currentUserToken) {
+        setUserTokenCookie(currentUserToken);
+    }
+}
+function applyConsent(enabled) {
+    setCookiesEnabled(enabled);
+    if (enabled)
+        persistIdentity();
+}
+function installSpaNavigationReload() {
+    if (spaNavigationInstalled || typeof window === 'undefined')
+        return;
+    spaNavigationInstalled = true;
+    observeFeatureFlagUrlChanges(() => {
+        void reloadFeatureFlags();
+    });
+}
+function getQueuedUserToken() {
+    const command = findLastCmd((cmd) => typeof cmd.setUserToken === 'string' && !!cmd.setUserToken);
+    return command === null || command === void 0 ? void 0 : command.setUserToken;
+}
+function getQueuedConsent() {
+    const command = findLastCmd((cmd) => typeof cmd.cookiesEnabled === 'boolean');
+    return command === null || command === void 0 ? void 0 : command.cookiesEnabled;
+}
+function installIdentitySync() {
+    if (identitySubscriptionInstalled || typeof window === 'undefined')
+        return;
+    identitySubscriptionInstalled = true;
+    subscribeToCmd((cmd) => typeof cmd.setUserToken === 'string' && !!cmd.setUserToken, (cmd) => {
+        if (!cmd.setUserToken)
+            return;
+        const nextUserToken = requireIdentity(cmd.setUserToken);
+        if (nextUserToken === currentUserToken)
+            return;
+        currentUserToken = nextUserToken;
+        persistIdentity();
+        updateFeatureFlagUserToken(nextUserToken);
+    });
+}
+function installConsentSync() {
+    if (consentSubscriptionInstalled || typeof window === 'undefined')
+        return;
+    consentSubscriptionInstalled = true;
+    subscribeToCmd((cmd) => typeof cmd.cookiesEnabled === 'boolean', (cmd) => applyConsent(!!cmd.cookiesEnabled));
+}
+function initFeatureFlags(options) {
+    const queuedConsent = getQueuedConsent();
+    installConsentSync();
+    const queuedUserToken = options.userToken ? undefined : getQueuedUserToken();
+    currentUserToken = options.userToken
+        ? requireIdentity(options.userToken)
+        : queuedUserToken
+            ? requireIdentity(queuedUserToken)
+            : getOrGenerateUserToken();
+    installIdentitySync();
+    if (options.consent !== undefined) {
+        setConsent$1(options.consent);
+    }
+    else if (queuedConsent !== undefined) {
+        applyConsent(queuedConsent);
+    }
+    else {
+        persistIdentity();
+    }
+    if (options.reloadOnSpaNavigation !== false) {
+        installSpaNavigationReload();
+    }
+    const { selector, requestTimeoutMs, cacheTtlMs } = options;
+    return initializeFeatureFlags({ selector, requestTimeoutMs, cacheTtlMs }, options.projectId, currentUserToken, options.userContext);
+}
+function setUserToken(userToken) {
+    currentUserToken = requireIdentity(userToken);
+    persistIdentity();
+    updateFeatureFlagUserToken(currentUserToken);
+}
+function reset() {
+    currentUserToken = generateUUID();
+    persistIdentity();
+    updateFeatureFlagUserToken(currentUserToken);
+    return currentUserToken;
+}
+function setConsent(enabled) {
+    setConsent$1(enabled);
+}
+function getUserToken() {
+    return currentUserToken;
+}
+const featureFlags = {
+    init: initFeatureFlags,
+    setUserToken,
+    reset,
+    setConsent,
+    getUserToken,
+    getFeatureFlag,
+    getFeatureFlagPayload,
+    getFeatureFlagResult,
+    getRemoteConfig,
+    isFeatureEnabled,
+    onFeatureFlags,
+    reloadFeatureFlags,
+};
+
+export { featureFlags, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getRemoteConfig, getUserToken, initFeatureFlags, isFeatureEnabled, onFeatureFlags, reloadFeatureFlags, reset, setConsent, setUserToken };

package/dist/pkg/react.cjs.js

@@ -2,9 +2,12 @@
 'use strict';
 
 var sdk = require('@coframe/sdk');
+var featureFlags = require('@coframe/sdk/feature-flags');
 var React = require('react');
 
-const CoframeContext = React.createContext({ treatments: null });
+const CoframeContext = React.createContext({
+    treatments: null,
+});
 function CoframeProvider({ projectConfig, projectData, onTreatmentApplied: onTreatmentAppliedProp, onTreatmentAppliedBulk: onTreatmentAppliedBulkProp, onTreatmentAppliedBulkV2, onTreatmentAppliedBulkV2WithoutConsent, onLog: onLogProp, children, }) {
     const [treatments, setTreatments] = React.useState(null);
     React.useEffect(() => {
@@ -59,6 +62,33 @@ function useCoframeVariant(experimentId) {
     var _a;
     return (_a = useCoframeTreatment(experimentId)) === null || _a === void 0 ? void 0 : _a.variantId;
 }
+function useFeatureFlagResult(key) {
+    const [result, setResult] = React.useState(() => featureFlags.getFeatureFlagResult(key));
+    React.useEffect(() => {
+        setResult(featureFlags.getFeatureFlagResult(key));
+        return featureFlags.onFeatureFlags(() => setResult(featureFlags.getFeatureFlagResult(key)));
+    }, [key]);
+    return result;
+}
+function useFeatureFlagVariantKey(key) {
+    var _a;
+    const result = useFeatureFlagResult(key);
+    if (!result)
+        return undefined;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+const useFeatureFlag = useFeatureFlagVariantKey;
+function useFeatureFlagEnabled(key) {
+    var _a;
+    return (_a = useFeatureFlagResult(key)) === null || _a === void 0 ? void 0 : _a.enabled;
+}
+function useFeatureFlagPayload(key) {
+    var _a;
+    const result = useFeatureFlagResult(key);
+    if (!result)
+        return undefined;
+    return 'payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null;
+}
 
 Object.defineProperty(exports, "init", {
   enumerable: true,
@@ -96,3 +126,8 @@ exports.CoframeProvider = CoframeProvider;
 exports.useCoframeTreatment = useCoframeTreatment;
 exports.useCoframeTreatments = useCoframeTreatments;
 exports.useCoframeVariant = useCoframeVariant;
+exports.useFeatureFlag = useFeatureFlag;
+exports.useFeatureFlagEnabled = useFeatureFlagEnabled;
+exports.useFeatureFlagPayload = useFeatureFlagPayload;
+exports.useFeatureFlagResult = useFeatureFlagResult;
+exports.useFeatureFlagVariantKey = useFeatureFlagVariantKey;

package/dist/pkg/react.esm.mjs

@@ -1,9 +1,12 @@
 'use client';
 import { init, onTreatmentApplied, onLog } from '@coframe/sdk';
 export { init, onLog, onTreatmentApplied, setConsent, setFeatureFlag, setPageHydrated, setUserToken, trackConversion } from '@coframe/sdk';
+import { getFeatureFlagResult, onFeatureFlags } from '@coframe/sdk/feature-flags';
 import React, { createContext, useState, useEffect, useContext } from 'react';
 
-const CoframeContext = createContext({ treatments: null });
+const CoframeContext = createContext({
+    treatments: null,
+});
 function CoframeProvider({ projectConfig, projectData, onTreatmentApplied: onTreatmentAppliedProp, onTreatmentAppliedBulk: onTreatmentAppliedBulkProp, onTreatmentAppliedBulkV2, onTreatmentAppliedBulkV2WithoutConsent, onLog: onLogProp, children, }) {
     const [treatments, setTreatments] = useState(null);
     useEffect(() => {
@@ -58,5 +61,32 @@ function useCoframeVariant(experimentId) {
     var _a;
     return (_a = useCoframeTreatment(experimentId)) === null || _a === void 0 ? void 0 : _a.variantId;
 }
+function useFeatureFlagResult(key) {
+    const [result, setResult] = useState(() => getFeatureFlagResult(key));
+    useEffect(() => {
+        setResult(getFeatureFlagResult(key));
+        return onFeatureFlags(() => setResult(getFeatureFlagResult(key)));
+    }, [key]);
+    return result;
+}
+function useFeatureFlagVariantKey(key) {
+    var _a;
+    const result = useFeatureFlagResult(key);
+    if (!result)
+        return undefined;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+const useFeatureFlag = useFeatureFlagVariantKey;
+function useFeatureFlagEnabled(key) {
+    var _a;
+    return (_a = useFeatureFlagResult(key)) === null || _a === void 0 ? void 0 : _a.enabled;
+}
+function useFeatureFlagPayload(key) {
+    var _a;
+    const result = useFeatureFlagResult(key);
+    if (!result)
+        return undefined;
+    return 'payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null;
+}
 
-export { CoframeProvider, useCoframeTreatment, useCoframeTreatments, useCoframeVariant };
+export { CoframeProvider, useCoframeTreatment, useCoframeTreatments, useCoframeVariant, useFeatureFlag, useFeatureFlagEnabled, useFeatureFlagPayload, useFeatureFlagResult, useFeatureFlagVariantKey };