@coframe/sdk 1.1.23 → 1.1.25

package/dist/pkg/server.cjs.js

@@ -48,6 +48,75 @@ async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext,
     }
 }
 
+async function requestFeatureFlags(options) {
+    var _a, _b;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), (_a = options.requestTimeoutMs) !== null && _a !== void 0 ? _a : 3000);
+    try {
+        const response = await fetch(`${(_b = options.edgeUrl) !== null && _b !== void 0 ? _b : "https://edge.cofra.me"}/api/v1/flags?v=1`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${options.apiKey}`,
+            },
+            body: JSON.stringify({
+                projectId: options.projectId,
+                userToken: options.userToken,
+                ...(options.selector ? { selector: options.selector } : {}),
+                ...(options.currentUrl ? { currentUrl: options.currentUrl } : {}),
+                ...(options.languages ? { languages: options.languages } : {}),
+                ...(options.browserPlatform
+                    ? { browserPlatform: options.browserPlatform }
+                    : {}),
+                ...(options.userVisitCount !== undefined
+                    ? { userVisitCount: options.userVisitCount }
+                    : {}),
+                ...(options.userContext ? { userContext: options.userContext } : {}),
+                ...(options.country ? { country: options.country } : {}),
+                ...(options.device ? { device: options.device } : {}),
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return undefined;
+        return (await response.json());
+    }
+    catch (_c) {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function evaluateFlags(options) {
+    return requestFeatureFlags(options);
+}
+async function getFeatureFlagResult(key, options) {
+    const response = await requestFeatureFlags({
+        ...options,
+        selector: { names: [key] },
+    });
+    return response === null || response === void 0 ? void 0 : response.flags[key];
+}
+async function getFeatureFlag(key, options) {
+    var _a;
+    const result = await getFeatureFlagResult(key, options);
+    if (!result)
+        return undefined;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+async function isFeatureEnabled(key, options) {
+    var _a, _b;
+    return ((_b = (_a = (await getFeatureFlagResult(key, options))) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : options.defaultValue);
+}
+async function getFeatureFlagPayload(key, options) {
+    var _a;
+    const result = await getFeatureFlagResult(key, options);
+    if (!result)
+        return undefined;
+    return 'payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null;
+}
+const getRemoteConfig = getFeatureFlagPayload;
 function getRequestReferrer(headers) {
     const get = headers.get;
     if (typeof get === 'function') {
@@ -124,4 +193,10 @@ async function getProjectData(options) {
     return null;
 }
 
+exports.evaluateFlags = evaluateFlags;
+exports.getFeatureFlag = getFeatureFlag;
+exports.getFeatureFlagPayload = getFeatureFlagPayload;
+exports.getFeatureFlagResult = getFeatureFlagResult;
 exports.getProjectData = getProjectData;
+exports.getRemoteConfig = getRemoteConfig;
+exports.isFeatureEnabled = isFeatureEnabled;

package/dist/pkg/server.esm.mjs

@@ -46,6 +46,75 @@ async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext,
     }
 }
 
+async function requestFeatureFlags(options) {
+    var _a, _b;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), (_a = options.requestTimeoutMs) !== null && _a !== void 0 ? _a : 3000);
+    try {
+        const response = await fetch(`${(_b = options.edgeUrl) !== null && _b !== void 0 ? _b : "https://edge.cofra.me"}/api/v1/flags?v=1`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${options.apiKey}`,
+            },
+            body: JSON.stringify({
+                projectId: options.projectId,
+                userToken: options.userToken,
+                ...(options.selector ? { selector: options.selector } : {}),
+                ...(options.currentUrl ? { currentUrl: options.currentUrl } : {}),
+                ...(options.languages ? { languages: options.languages } : {}),
+                ...(options.browserPlatform
+                    ? { browserPlatform: options.browserPlatform }
+                    : {}),
+                ...(options.userVisitCount !== undefined
+                    ? { userVisitCount: options.userVisitCount }
+                    : {}),
+                ...(options.userContext ? { userContext: options.userContext } : {}),
+                ...(options.country ? { country: options.country } : {}),
+                ...(options.device ? { device: options.device } : {}),
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return undefined;
+        return (await response.json());
+    }
+    catch (_c) {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function evaluateFlags(options) {
+    return requestFeatureFlags(options);
+}
+async function getFeatureFlagResult(key, options) {
+    const response = await requestFeatureFlags({
+        ...options,
+        selector: { names: [key] },
+    });
+    return response === null || response === void 0 ? void 0 : response.flags[key];
+}
+async function getFeatureFlag(key, options) {
+    var _a;
+    const result = await getFeatureFlagResult(key, options);
+    if (!result)
+        return undefined;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+async function isFeatureEnabled(key, options) {
+    var _a, _b;
+    return ((_b = (_a = (await getFeatureFlagResult(key, options))) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : options.defaultValue);
+}
+async function getFeatureFlagPayload(key, options) {
+    var _a;
+    const result = await getFeatureFlagResult(key, options);
+    if (!result)
+        return undefined;
+    return 'payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null;
+}
+const getRemoteConfig = getFeatureFlagPayload;
 function getRequestReferrer(headers) {
     const get = headers.get;
     if (typeof get === 'function') {
@@ -122,4 +191,4 @@ async function getProjectData(options) {
     return null;
 }
 
-export { getProjectData };
+export { evaluateFlags, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getProjectData, getRemoteConfig, isFeatureEnabled };

package/dist/pkg/types/feature-flags.d.ts

@@ -0,0 +1,75 @@
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type FeatureFlagValue = boolean | string;
+type FeatureFlagReason = 'inactive' | 'remote_config' | 'condition_match' | 'no_matching_condition' | 'missing_user_token';
+interface FeatureFlagResult {
+    key: string;
+    enabled: boolean;
+    reason: FeatureFlagReason;
+    metadata: {
+        version: number;
+    };
+    variant?: string;
+    payload?: JsonValue;
+}
+interface FeatureFlagsResponse {
+    flags: Record<string, FeatureFlagResult>;
+    errorsWhileComputingFlags: boolean;
+    requestId: string;
+    snapshotVersion: number;
+}
+interface FeatureFlagSelector {
+    names?: string[];
+    groups?: string[];
+}
+interface FeatureFlagsConfig {
+    selector?: FeatureFlagSelector;
+    requestTimeoutMs?: number;
+    cacheTtlMs?: number;
+}
+
+type FeatureFlagsCallback = (flags: Record<string, FeatureFlagResult>, metadata: {
+    errorsWhileComputingFlags: boolean;
+    snapshotVersion: number;
+}) => void;
+declare function reloadFeatureFlags(): Promise<void>;
+declare function onFeatureFlags(callback: FeatureFlagsCallback): () => void;
+declare function getFeatureFlagResult(key: string): FeatureFlagResult | undefined;
+declare function getFeatureFlag(key: string): FeatureFlagValue | undefined;
+declare function isFeatureEnabled(key: string, options?: {
+    defaultValue?: boolean;
+}): boolean | undefined;
+declare function getFeatureFlagPayload(key: string): JsonValue | null | undefined;
+declare const getRemoteConfig: typeof getFeatureFlagPayload;
+
+interface FeatureFlagsInitOptions extends FeatureFlagsConfig {
+    projectId: string;
+    userToken?: string;
+    userContext?: Record<string, unknown>;
+    consent?: boolean;
+    reloadOnSpaNavigation?: boolean;
+}
+declare function initFeatureFlags(options: FeatureFlagsInitOptions): Promise<void>;
+declare function setUserToken(userToken: string): void;
+declare function reset(): string;
+declare function setConsent(enabled: boolean): void;
+declare function getUserToken(): string | undefined;
+
+declare const featureFlags: {
+    init: typeof initFeatureFlags;
+    setUserToken: typeof setUserToken;
+    reset: typeof reset;
+    setConsent: typeof setConsent;
+    getUserToken: typeof getUserToken;
+    getFeatureFlag: typeof getFeatureFlag;
+    getFeatureFlagPayload: typeof getFeatureFlagPayload;
+    getFeatureFlagResult: typeof getFeatureFlagResult;
+    getRemoteConfig: typeof getFeatureFlagPayload;
+    isFeatureEnabled: typeof isFeatureEnabled;
+    onFeatureFlags: typeof onFeatureFlags;
+    reloadFeatureFlags: typeof reloadFeatureFlags;
+};
+
+export { featureFlags, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getRemoteConfig, getUserToken, initFeatureFlags, isFeatureEnabled, onFeatureFlags, reloadFeatureFlags, reset, setConsent, setUserToken };
+export type { FeatureFlagResult, FeatureFlagSelector, FeatureFlagValue, FeatureFlagsConfig, FeatureFlagsInitOptions, FeatureFlagsResponse, JsonValue };

package/dist/pkg/types/react.d.ts

@@ -1,6 +1,22 @@
 import React, { ReactNode } from 'react';
 export { init, onLog, onTreatmentApplied, setConsent, setFeatureFlag, setPageHydrated, setUserToken, trackConversion } from '@coframe/sdk';
 
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type FeatureFlagValue = boolean | string;
+type FeatureFlagReason = 'inactive' | 'remote_config' | 'condition_match' | 'no_matching_condition' | 'missing_user_token';
+interface FeatureFlagResult {
+    key: string;
+    enabled: boolean;
+    reason: FeatureFlagReason;
+    metadata: {
+        version: number;
+    };
+    variant?: string;
+    payload?: JsonValue;
+}
+
 interface UniversalSelector {
     t: string;
     fingerprint?: string;
@@ -312,6 +328,11 @@ declare function CoframeProvider({ projectConfig, projectData, onTreatmentApplie
 declare function useCoframeTreatments(): TreatmentData[] | null;
 declare function useCoframeTreatment(experimentId: string): TreatmentData | undefined;
 declare function useCoframeVariant(experimentId: string): string | undefined;
+declare function useFeatureFlagResult(key: string): FeatureFlagResult | undefined;
+declare function useFeatureFlagVariantKey(key: string): FeatureFlagValue | undefined;
+declare const useFeatureFlag: typeof useFeatureFlagVariantKey;
+declare function useFeatureFlagEnabled(key: string): boolean | undefined;
+declare function useFeatureFlagPayload(key: string): JsonValue | null | undefined;
 
-export { CoframeProvider, useCoframeTreatment, useCoframeTreatments, useCoframeVariant };
+export { CoframeProvider, useCoframeTreatment, useCoframeTreatments, useCoframeVariant, useFeatureFlag, useFeatureFlagEnabled, useFeatureFlagPayload, useFeatureFlagResult, useFeatureFlagVariantKey };
 export type { CoframeProviderProps };

package/dist/pkg/types/server.d.ts

@@ -217,6 +217,32 @@ type PersonalizationHeaders = {
     'x-bot-reason': BotReason;
 };
 
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type FeatureFlagValue = boolean | string;
+type FeatureFlagReason = 'inactive' | 'remote_config' | 'condition_match' | 'no_matching_condition' | 'missing_user_token';
+interface FeatureFlagResult {
+    key: string;
+    enabled: boolean;
+    reason: FeatureFlagReason;
+    metadata: {
+        version: number;
+    };
+    variant?: string;
+    payload?: JsonValue;
+}
+interface FeatureFlagsResponse {
+    flags: Record<string, FeatureFlagResult>;
+    errorsWhileComputingFlags: boolean;
+    requestId: string;
+    snapshotVersion: number;
+}
+interface FeatureFlagSelector {
+    names?: string[];
+    groups?: string[];
+}
+
 interface GetProjectDataOptions {
     projectId: string;
     currentUrl: string;
@@ -232,7 +258,30 @@ interface CoframeProjectPayload {
     personalizationHeaders?: PersonalizationHeaders;
     antiflickerCSS?: string;
 }
+interface EvaluateFlagsOptions {
+    apiKey: string;
+    projectId: string;
+    userToken?: string;
+    selector?: FeatureFlagSelector;
+    requestTimeoutMs?: number;
+    edgeUrl?: string;
+    currentUrl?: string;
+    languages?: string[];
+    browserPlatform?: string;
+    userVisitCount?: number;
+    userContext?: Record<string, unknown>;
+    country?: string;
+    device?: 'desktop' | 'mobile';
+}
+declare function evaluateFlags(options: EvaluateFlagsOptions): Promise<FeatureFlagsResponse | undefined>;
+declare function getFeatureFlagResult(key: string, options: Omit<EvaluateFlagsOptions, 'selector'>): Promise<FeatureFlagResult | undefined>;
+declare function getFeatureFlag(key: string, options: Omit<EvaluateFlagsOptions, 'selector'>): Promise<FeatureFlagValue | undefined>;
+declare function isFeatureEnabled(key: string, options: Omit<EvaluateFlagsOptions, 'selector'> & {
+    defaultValue?: boolean;
+}): Promise<boolean | undefined>;
+declare function getFeatureFlagPayload(key: string, options: Omit<EvaluateFlagsOptions, 'selector'>): Promise<JsonValue | null | undefined>;
+declare const getRemoteConfig: typeof getFeatureFlagPayload;
 declare function getProjectData(options: GetProjectDataOptions): Promise<CoframeProjectPayload | null>;
 
-export { getProjectData };
-export type { CoframeProjectPayload, GetProjectDataOptions };
+export { evaluateFlags, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getProjectData, getRemoteConfig, isFeatureEnabled };
+export type { CoframeProjectPayload, EvaluateFlagsOptions, GetProjectDataOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coframe/sdk",
-  "version": "1.1.23",
+  "version": "1.1.25",
   "description": "Coframe optimizes your website using generative AI to deliver maximum impact to your audience and allow your site to improve itself as you sleep. Learn more at coframe.com.",
   "main": "dist/pkg/cf.cjs.js",
   "module": "dist/pkg/cf.esm.mjs",
@@ -16,6 +16,11 @@
       "require": "./dist/pkg/server.cjs.js",
       "types": "./dist/pkg/types/server.d.ts"
     },
+    "./feature-flags": {
+      "import": "./dist/pkg/feature-flags.esm.mjs",
+      "require": "./dist/pkg/feature-flags.cjs.js",
+      "types": "./dist/pkg/types/feature-flags.d.ts"
+    },
     "./react": {
       "import": "./dist/pkg/react.esm.mjs",
       "require": "./dist/pkg/react.cjs.js",
@@ -131,4 +136,4 @@
     "ua-parser-js": "^2.0.10"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
-}
+}