@featureflare/react 0.0.24 → 0.0.26

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
-import { FeatureFlareUserPayload, FeatureFlareClient } from '@featureflare/sdk-js';
+import { FeatureFlareBootstrapPayload, FeatureFlarePersistentCacheAdapter, FeatureFlareMetricName, FeatureFlareMetricTags, FeatureFlareUserPayload, FeatureFlareClient, FeatureFlareEvaluationMetadata } from '@featureflare/sdk-js';
 export { FeatureFlareUserPayload } from '@featureflare/sdk-js';
 
 type FeatureFlareEnvironmentKey = 'development' | 'staging' | 'production';
@@ -12,6 +12,20 @@ type FeatureFlareReactConfig = {
     /** Legacy/insecure browser mode: uses /api/v1/eval (no sdkKey). */
     projectKey?: string;
     envKey?: FeatureFlareEnvironmentKey | string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    backoffMs?: number;
+    jitter?: number;
+    cacheTtlMs?: number;
+    staleTtlMs?: number;
+    bootstrap?: FeatureFlareBootstrapPayload;
+    persistentCache?: FeatureFlarePersistentCacheAdapter;
+    onMetric?: (metricName: FeatureFlareMetricName, value: number, tags?: FeatureFlareMetricTags) => void;
+    realtime?: {
+        enabled?: boolean;
+        pollingIntervalMs?: number;
+        ssePath?: string;
+    };
 };
 declare function resolveFeatureFlareBrowserConfig(input?: {
     envKey?: FeatureFlareEnvironmentKey;
@@ -21,11 +35,13 @@ type FeatureFlareContextValue = {
     client: FeatureFlareClient;
     user: FeatureFlareUserPayload;
     setUser: (next: FeatureFlareUserPayload) => void;
-    getFlagsState: (defaultValue: boolean) => FlagsState$1;
+    getFlagsState: (defaultValue: boolean) => FlagsState;
     refreshFlags: (defaultValue: boolean) => void;
     subscribeFlags: (defaultValue: boolean, listener: () => void, options?: FlagsSubscriptionOptions) => () => void;
+    subscribeFlag: (flagKey: string, defaultValue: boolean, listener: () => void, options?: FlagsSubscriptionOptions) => () => void;
+    getFlagDiagnostics: (flagKey: string) => FeatureFlareEvaluationMetadata | null;
 };
-type FlagsState$1 = {
+type FlagsState = {
     flags: Array<{
         key: string;
         value: boolean;
@@ -58,23 +74,27 @@ type BoolFlagsState = {
     loading: boolean;
     errors: Record<string, string>;
 };
-type FlagsState = {
-    flags: Array<{
-        key: string;
-        value: boolean;
-    }>;
-    loading: boolean;
-    error: string | null;
-};
 type UseFlagsOptions = FlagsSubscriptionOptions;
 type UseFlagsInput = UseFlagsOptions & {
     defaultValue?: boolean;
     user?: FeatureFlareUserPayload;
 };
+type FlagDiagnostics = {
+    source: FeatureFlareEvaluationMetadata['source'] | 'unknown';
+    reason: FeatureFlareEvaluationMetadata['reason'] | 'unknown';
+    isStale: boolean;
+    updatedAt?: number;
+    staleAt?: number;
+    expiresAt?: number;
+    latencyMs?: number;
+};
 declare function useFeatureFlareUser(): [FeatureFlareUserPayload, (next: FeatureFlareUserPayload) => void];
+declare function useFlag(flagKey: string, defaultValue?: boolean): BoolFlagState;
 declare function useBoolFlag(flagKey: string, defaultValue?: boolean): BoolFlagState;
-declare function useBoolFlags(flagKeys: string[], defaultValue?: boolean): BoolFlagsState;
+declare function useFlags(flagKeys: string[], defaultValue?: boolean): BoolFlagsState;
 declare function useFlags(input?: UseFlagsInput): FlagsState;
 declare function useFlags(defaultValue?: boolean, options?: UseFlagsOptions): FlagsState;
+declare function useBoolFlags(flagKeys: string[], defaultValue?: boolean): BoolFlagsState;
+declare function useFlagDiagnostics(flagKey: string, defaultValue?: boolean): FlagDiagnostics;
 
-export { type FeatureFlareEnvironmentKey, FeatureFlareProvider, type FeatureFlareReactConfig, type FlagsState$1 as FlagsState, type FlagsSubscriptionOptions, resolveFeatureFlareBrowserConfig, useBoolFlag, useBoolFlags, useFeatureFlareContext, useFeatureFlareUser, useFlags };
+export { type FeatureFlareEnvironmentKey, FeatureFlareProvider, type FeatureFlareReactConfig, type FlagDiagnostics, type FlagsState, type FlagsSubscriptionOptions, resolveFeatureFlareBrowserConfig, useBoolFlag, useBoolFlags, useFeatureFlareContext, useFeatureFlareUser, useFlag, useFlagDiagnostics, useFlags };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
-import { FeatureFlareUserPayload, FeatureFlareClient } from '@featureflare/sdk-js';
+import { FeatureFlareBootstrapPayload, FeatureFlarePersistentCacheAdapter, FeatureFlareMetricName, FeatureFlareMetricTags, FeatureFlareUserPayload, FeatureFlareClient, FeatureFlareEvaluationMetadata } from '@featureflare/sdk-js';
 export { FeatureFlareUserPayload } from '@featureflare/sdk-js';
 
 type FeatureFlareEnvironmentKey = 'development' | 'staging' | 'production';
@@ -12,6 +12,20 @@ type FeatureFlareReactConfig = {
     /** Legacy/insecure browser mode: uses /api/v1/eval (no sdkKey). */
     projectKey?: string;
     envKey?: FeatureFlareEnvironmentKey | string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    backoffMs?: number;
+    jitter?: number;
+    cacheTtlMs?: number;
+    staleTtlMs?: number;
+    bootstrap?: FeatureFlareBootstrapPayload;
+    persistentCache?: FeatureFlarePersistentCacheAdapter;
+    onMetric?: (metricName: FeatureFlareMetricName, value: number, tags?: FeatureFlareMetricTags) => void;
+    realtime?: {
+        enabled?: boolean;
+        pollingIntervalMs?: number;
+        ssePath?: string;
+    };
 };
 declare function resolveFeatureFlareBrowserConfig(input?: {
     envKey?: FeatureFlareEnvironmentKey;
@@ -21,11 +35,13 @@ type FeatureFlareContextValue = {
     client: FeatureFlareClient;
     user: FeatureFlareUserPayload;
     setUser: (next: FeatureFlareUserPayload) => void;
-    getFlagsState: (defaultValue: boolean) => FlagsState$1;
+    getFlagsState: (defaultValue: boolean) => FlagsState;
     refreshFlags: (defaultValue: boolean) => void;
     subscribeFlags: (defaultValue: boolean, listener: () => void, options?: FlagsSubscriptionOptions) => () => void;
+    subscribeFlag: (flagKey: string, defaultValue: boolean, listener: () => void, options?: FlagsSubscriptionOptions) => () => void;
+    getFlagDiagnostics: (flagKey: string) => FeatureFlareEvaluationMetadata | null;
 };
-type FlagsState$1 = {
+type FlagsState = {
     flags: Array<{
         key: string;
         value: boolean;
@@ -58,23 +74,27 @@ type BoolFlagsState = {
     loading: boolean;
     errors: Record<string, string>;
 };
-type FlagsState = {
-    flags: Array<{
-        key: string;
-        value: boolean;
-    }>;
-    loading: boolean;
-    error: string | null;
-};
 type UseFlagsOptions = FlagsSubscriptionOptions;
 type UseFlagsInput = UseFlagsOptions & {
     defaultValue?: boolean;
     user?: FeatureFlareUserPayload;
 };
+type FlagDiagnostics = {
+    source: FeatureFlareEvaluationMetadata['source'] | 'unknown';
+    reason: FeatureFlareEvaluationMetadata['reason'] | 'unknown';
+    isStale: boolean;
+    updatedAt?: number;
+    staleAt?: number;
+    expiresAt?: number;
+    latencyMs?: number;
+};
 declare function useFeatureFlareUser(): [FeatureFlareUserPayload, (next: FeatureFlareUserPayload) => void];
+declare function useFlag(flagKey: string, defaultValue?: boolean): BoolFlagState;
 declare function useBoolFlag(flagKey: string, defaultValue?: boolean): BoolFlagState;
-declare function useBoolFlags(flagKeys: string[], defaultValue?: boolean): BoolFlagsState;
+declare function useFlags(flagKeys: string[], defaultValue?: boolean): BoolFlagsState;
 declare function useFlags(input?: UseFlagsInput): FlagsState;
 declare function useFlags(defaultValue?: boolean, options?: UseFlagsOptions): FlagsState;
+declare function useBoolFlags(flagKeys: string[], defaultValue?: boolean): BoolFlagsState;
+declare function useFlagDiagnostics(flagKey: string, defaultValue?: boolean): FlagDiagnostics;
 
-export { type FeatureFlareEnvironmentKey, FeatureFlareProvider, type FeatureFlareReactConfig, type FlagsState$1 as FlagsState, type FlagsSubscriptionOptions, resolveFeatureFlareBrowserConfig, useBoolFlag, useBoolFlags, useFeatureFlareContext, useFeatureFlareUser, useFlags };
+export { type FeatureFlareEnvironmentKey, FeatureFlareProvider, type FeatureFlareReactConfig, type FlagDiagnostics, type FlagsState, type FlagsSubscriptionOptions, resolveFeatureFlareBrowserConfig, useBoolFlag, useBoolFlags, useFeatureFlareContext, useFeatureFlareUser, useFlag, useFlagDiagnostics, useFlags };

package/dist/index.js

@@ -1,6 +1,8 @@
 // src/provider.tsx
 import React, { createContext, useEffect, useMemo, useRef, useState } from "react";
-import { FeatureFlareClient } from "@featureflare/sdk-js";
+import {
+  FeatureFlareClient
+} from "@featureflare/sdk-js";
 import { jsx } from "react/jsx-runtime";
 function resolveFeatureFlareBrowserConfig(input) {
   const explicitEnv = input?.envKey;
@@ -28,6 +30,29 @@ function normalizeSubscriptionOptions(options) {
     enabled: options?.enabled ?? true
   };
 }
+function flagsToMap(flags) {
+  const map = /* @__PURE__ */ new Map();
+  for (const flag of flags) {
+    map.set(flag.key, flag.value);
+  }
+  return map;
+}
+function diffFlagKeys(prev, next) {
+  const changed = /* @__PURE__ */ new Set();
+  const prevMap = flagsToMap(prev);
+  const nextMap = flagsToMap(next);
+  for (const [key, value] of prevMap.entries()) {
+    if (!nextMap.has(key) || nextMap.get(key) !== value) {
+      changed.add(key);
+    }
+  }
+  for (const [key, value] of nextMap.entries()) {
+    if (!prevMap.has(key) || prevMap.get(key) !== value) {
+      changed.add(key);
+    }
+  }
+  return changed;
+}
 function createFlagsStore(client, getUser) {
   const entries = /* @__PURE__ */ new Map();
   let nextSubscriberId = 1;
@@ -36,10 +61,11 @@ function createFlagsStore(client, getUser) {
     const key = defaultValue ? "1" : "0";
     const existing = entries.get(key);
     if (existing) return existing;
+    const cached = client.getCachedFlags();
     const created = {
       defaultValue,
-      snapshot: { flags: [], loading: true, error: null },
-      listeners: /* @__PURE__ */ new Set(),
+      snapshot: { flags: cached.flags, loading: !cached.hasData, error: null },
+      listeners: /* @__PURE__ */ new Map(),
       subscribers: /* @__PURE__ */ new Map(),
       timer: null,
       inFlight: false
@@ -47,8 +73,12 @@ function createFlagsStore(client, getUser) {
     entries.set(key, created);
     return created;
   };
-  const emit = (entry) => {
-    for (const listener of entry.listeners) listener();
+  const emit = (entry, changedKeys = null) => {
+    for (const { listener, flagKey } of entry.listeners.values()) {
+      if (!flagKey || changedKeys === null || changedKeys.has(flagKey)) {
+        listener();
+      }
+    }
   };
   const getEffectiveOptions = (entry) => {
     const active = [...entry.subscribers.values()].filter((s) => s.enabled);
@@ -94,13 +124,17 @@ function createFlagsStore(client, getUser) {
     if (entry.inFlight) return;
     entry.inFlight = true;
     try {
+      const previousFlags = entry.snapshot.flags;
       const flags = await client.flags(getUser(), defaultValue);
+      const changed = diffFlagKeys(previousFlags, flags);
       entry.snapshot = { flags, loading: false, error: null };
-      emit(entry);
+      if (changed.size > 0 || previousFlags.length === 0) {
+        emit(entry, changed);
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       entry.snapshot = { ...entry.snapshot, loading: false, error: message };
-      emit(entry);
+      emit(entry, null);
     } finally {
       entry.inFlight = false;
       schedule(entry);
@@ -109,14 +143,14 @@ function createFlagsStore(client, getUser) {
   const refreshNow = (defaultValue) => {
     const entry = getEntry(defaultValue);
     entry.snapshot = { ...entry.snapshot, loading: true, error: null };
-    emit(entry);
+    emit(entry, null);
     void refresh(defaultValue, true);
   };
-  const subscribe = (defaultValue, listener, options) => {
+  const subscribe = (defaultValue, listener, options, flagKey) => {
     const entry = getEntry(defaultValue);
     const subscriberId = nextSubscriberId;
     nextSubscriberId += 1;
-    entry.listeners.add(listener);
+    entry.listeners.set(subscriberId, { listener, flagKey });
     entry.subscribers.set(subscriberId, normalizeSubscriptionOptions(options));
     const effective = getEffectiveOptions(entry);
     if (effective.enabled && !entry.inFlight && entry.snapshot.loading) {
@@ -125,7 +159,7 @@ function createFlagsStore(client, getUser) {
       schedule(entry);
     }
     return () => {
-      entry.listeners.delete(listener);
+      entry.listeners.delete(subscriberId);
       entry.subscribers.delete(subscriberId);
       schedule(entry);
     };
@@ -133,7 +167,7 @@ function createFlagsStore(client, getUser) {
   const updateUser = () => {
     for (const entry of entries.values()) {
       entry.snapshot = { ...entry.snapshot, loading: true, error: null };
-      emit(entry);
+      emit(entry, null);
       void refresh(entry.defaultValue);
     }
   };
@@ -145,10 +179,28 @@ function createFlagsStore(client, getUser) {
       void refresh(entry.defaultValue);
     }
   };
+  const unsubscribeClientUpdate = typeof client.on === "function" ? client.on(
+    "update",
+    ({ changedKeys }) => {
+      const changedSet = new Set(changedKeys);
+      for (const entry of entries.values()) {
+        const previous = entry.snapshot.flags;
+        const next = client.getCachedFlags().flags;
+        const diff = diffFlagKeys(previous, next);
+        if (diff.size === 0) continue;
+        const intersects = [...diff].some((key) => changedSet.has(key));
+        if (!intersects && changedSet.size > 0) continue;
+        entry.snapshot = { ...entry.snapshot, flags: next, loading: false, error: null };
+        emit(entry, diff);
+      }
+    }
+  ) : () => {
+  };
   if (typeof document !== "undefined") {
     document.addEventListener("visibilitychange", handleVisibilityChange);
   }
   const dispose = () => {
+    unsubscribeClientUpdate();
     if (typeof document !== "undefined") {
       document.removeEventListener("visibilitychange", handleVisibilityChange);
     }
@@ -167,7 +219,12 @@ function createFlagsStore(client, getUser) {
       return getEntry(defaultValue).snapshot;
     },
     refreshNow,
-    subscribe,
+    subscribeAll(defaultValue, listener, options) {
+      return subscribe(defaultValue, listener, options);
+    },
+    subscribeFlag(flagKey, defaultValue, listener, options) {
+      return subscribe(defaultValue, listener, options, flagKey);
+    },
     updateUser,
     dispose
   };
@@ -186,13 +243,33 @@ function FeatureFlareProvider(props) {
       apiBaseUrl: props.config.apiBaseUrl,
       sdkKey: props.config.sdkKey,
       projectKey: props.config.projectKey,
-      envKey: props.config.envKey
+      envKey: props.config.envKey,
+      timeoutMs: props.config.timeoutMs,
+      maxRetries: props.config.maxRetries,
+      backoffMs: props.config.backoffMs,
+      jitter: props.config.jitter,
+      cacheTtlMs: props.config.cacheTtlMs,
+      staleTtlMs: props.config.staleTtlMs,
+      bootstrap: props.config.bootstrap,
+      persistentCache: props.config.persistentCache,
+      onMetric: props.config.onMetric,
+      realtime: props.config.realtime
     });
   }, [
     props.config.apiBaseUrl,
+    props.config.backoffMs,
+    props.config.bootstrap,
+    props.config.cacheTtlMs,
     props.config.envKey,
+    props.config.jitter,
+    props.config.maxRetries,
+    props.config.onMetric,
+    props.config.persistentCache,
     props.config.projectKey,
-    props.config.sdkKey
+    props.config.realtime,
+    props.config.sdkKey,
+    props.config.staleTtlMs,
+    props.config.timeoutMs
   ]);
   const flagsStore = useMemo(() => createFlagsStore(client, () => userRef.current), [client]);
   useEffect(() => {
@@ -202,8 +279,9 @@ function FeatureFlareProvider(props) {
   useEffect(() => {
     return () => {
       flagsStore.dispose();
+      client.dispose();
     };
-  }, [flagsStore]);
+  }, [client, flagsStore]);
   const value = useMemo(
     () => ({
       client,
@@ -211,7 +289,9 @@ function FeatureFlareProvider(props) {
       setUser,
       getFlagsState: flagsStore.getState,
       refreshFlags: flagsStore.refreshNow,
-      subscribeFlags: flagsStore.subscribe
+      subscribeFlags: flagsStore.subscribeAll,
+      subscribeFlag: (flagKey, defaultValue, listener, options) => flagsStore.subscribeFlag(flagKey, defaultValue, listener, options),
+      getFlagDiagnostics: (flagKey) => client.getFlagDiagnostics(flagKey)
     }),
     [client, flagsStore, setUser, user]
   );
@@ -224,7 +304,7 @@ function useFeatureFlareContext() {
 }
 
 // src/hooks.ts
-import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2, useSyncExternalStore } from "react";
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useSyncExternalStore } from "react";
 var EMPTY_FLAGS_STATE = { flags: [], loading: true, error: null };
 function userFingerprint(user) {
   if (!user) return "";
@@ -235,83 +315,75 @@ function userFingerprint(user) {
     meta: user.meta ?? {}
   });
 }
+function mapFlags(flags) {
+  const values = {};
+  for (const flag of flags) {
+    values[flag.key] = flag.value;
+  }
+  return values;
+}
 function useFeatureFlareUser() {
   const { user, setUser } = useFeatureFlareContext();
   return [user, setUser];
 }
-function useBoolFlag(flagKey, defaultValue = false) {
-  const { client, user } = useFeatureFlareContext();
-  const [state, setState] = useState2({ value: defaultValue, loading: true, error: null });
-  const userId = user.id ?? user.key ?? "";
-  const key = useMemo2(() => `${flagKey}:${userId}`, [flagKey, userId]);
-  const lastKey = useRef2("");
+function useFlag(flagKey, defaultValue = false) {
+  const { subscribeFlag, getFlagsState, refreshFlags } = useFeatureFlareContext();
   useEffect2(() => {
-    let cancelled = false;
-    const nextKey = key;
-    lastKey.current = nextKey;
-    setState((s) => ({ ...s, loading: true, error: null }));
-    (async () => {
-      try {
-        const v = await client.bool(flagKey, user, defaultValue);
-        if (cancelled) return;
-        if (lastKey.current !== nextKey) return;
-        setState({ value: v, loading: false, error: null });
-      } catch (e) {
-        if (cancelled) return;
-        if (lastKey.current !== nextKey) return;
-        const msg = e instanceof Error ? e.message : String(e);
-        setState({ value: defaultValue, loading: false, error: msg });
-      }
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [client, defaultValue, flagKey, key, user]);
-  return state;
+    refreshFlags(defaultValue);
+  }, [defaultValue, refreshFlags]);
+  const subscribe = useMemo2(
+    () => (onStoreChange) => subscribeFlag(flagKey, defaultValue, onStoreChange),
+    [defaultValue, flagKey, subscribeFlag]
+  );
+  const state = useSyncExternalStore(subscribe, () => getFlagsState(defaultValue), () => EMPTY_FLAGS_STATE);
+  const value = state.flags.find((entry) => entry.key === flagKey)?.value ?? defaultValue;
+  return {
+    value,
+    loading: state.loading,
+    error: state.error
+  };
 }
-function useBoolFlags(flagKeys, defaultValue = false) {
-  const { client, user } = useFeatureFlareContext();
-  const sortedKeys = useMemo2(() => [...flagKeys].map((k) => k.trim()).filter(Boolean).sort(), [flagKeys]);
-  const userId = user.id ?? user.key ?? "";
-  const key = useMemo2(() => `${sortedKeys.join(",")}:${userId}`, [sortedKeys, userId]);
-  const [state, setState] = useState2({ values: {}, loading: true, errors: {} });
-  const lastKey = useRef2("");
-  useEffect2(() => {
-    let cancelled = false;
-    const nextKey = key;
-    lastKey.current = nextKey;
-    setState({ values: {}, loading: true, errors: {} });
-    (async () => {
-      const values = {};
-      const errors = {};
-      await Promise.all(
-        sortedKeys.map(async (flagKey) => {
-          try {
-            values[flagKey] = await client.bool(flagKey, user, defaultValue);
-          } catch (e) {
-            values[flagKey] = defaultValue;
-            errors[flagKey] = e instanceof Error ? e.message : String(e);
-          }
-        })
-      );
-      if (cancelled) return;
-      if (lastKey.current !== nextKey) return;
-      setState({ values, loading: false, errors });
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [client, defaultValue, key, sortedKeys, user]);
-  return state;
+function useBoolFlag(flagKey, defaultValue = false) {
+  return useFlag(flagKey, defaultValue);
 }
-function useFlags(defaultValueOrInput = false, options = {}) {
-  const { subscribeFlags, getFlagsState, refreshFlags, setUser } = useFeatureFlareContext();
+function useFlags(defaultValueOrInputOrKeys = false, optionsOrDefaultValue = {}) {
+  const { subscribeFlags, subscribeFlag, getFlagsState, refreshFlags, setUser } = useFeatureFlareContext();
+  if (Array.isArray(defaultValueOrInputOrKeys)) {
+    const keys = [...defaultValueOrInputOrKeys].map((key) => key.trim()).filter(Boolean);
+    const defaultValue2 = typeof optionsOrDefaultValue === "boolean" ? optionsOrDefaultValue : false;
+    useEffect2(() => {
+      refreshFlags(defaultValue2);
+    }, [defaultValue2, refreshFlags]);
+    const subscribe2 = useMemo2(
+      () => (onStoreChange) => {
+        const unsubs = keys.map((key) => subscribeFlag(key, defaultValue2, onStoreChange));
+        return () => {
+          for (const unsub of unsubs) unsub();
+        };
+      },
+      [defaultValue2, keys, subscribeFlag]
+    );
+    const state = useSyncExternalStore(subscribe2, () => getFlagsState(defaultValue2), () => EMPTY_FLAGS_STATE);
+    const values = mapFlags(state.flags);
+    const filtered = {};
+    for (const key of keys) {
+      filtered[key] = values[key] ?? defaultValue2;
+    }
+    return {
+      values: filtered,
+      loading: state.loading,
+      errors: state.error ? { __global: state.error } : {}
+    };
+  }
   const parsed = useMemo2(() => {
-    if (typeof defaultValueOrInput === "boolean") {
-      return { ...options, defaultValue: defaultValueOrInput };
+    if (typeof defaultValueOrInputOrKeys === "boolean") {
+      return {
+        ...typeof optionsOrDefaultValue === "object" && optionsOrDefaultValue !== null ? optionsOrDefaultValue : {},
+        defaultValue: defaultValueOrInputOrKeys
+      };
     }
-    return defaultValueOrInput ?? {};
-  }, [defaultValueOrInput, options]);
+    return defaultValueOrInputOrKeys ?? {};
+  }, [defaultValueOrInputOrKeys, optionsOrDefaultValue]);
   const defaultValue = parsed.defaultValue ?? false;
   const normalizedOptions = useMemo2(
     () => ({
@@ -340,6 +412,30 @@ function useFlags(defaultValueOrInput = false, options = {}) {
   );
   return useSyncExternalStore(subscribe, () => getFlagsState(defaultValue), () => EMPTY_FLAGS_STATE);
 }
+function useBoolFlags(flagKeys, defaultValue = false) {
+  return useFlags(flagKeys, defaultValue);
+}
+function useFlagDiagnostics(flagKey, defaultValue = false) {
+  const { getFlagDiagnostics, subscribeFlag } = useFeatureFlareContext();
+  const subscribe = useMemo2(
+    () => (onStoreChange) => subscribeFlag(flagKey, defaultValue, onStoreChange),
+    [defaultValue, flagKey, subscribeFlag]
+  );
+  const metadata = useSyncExternalStore(
+    subscribe,
+    () => getFlagDiagnostics(flagKey),
+    () => null
+  );
+  return {
+    source: metadata?.source ?? "unknown",
+    reason: metadata?.reason ?? "unknown",
+    isStale: metadata?.isStale ?? false,
+    updatedAt: metadata?.updatedAt,
+    staleAt: metadata?.staleAt,
+    expiresAt: metadata?.expiresAt,
+    latencyMs: metadata?.latencyMs
+  };
+}
 export {
   FeatureFlareProvider,
   resolveFeatureFlareBrowserConfig,
@@ -347,6 +443,8 @@ export {
   useBoolFlags,
   useFeatureFlareContext,
   useFeatureFlareUser,
+  useFlag,
+  useFlagDiagnostics,
   useFlags
 };
 //# sourceMappingURL=index.js.map