@ops-ai/react-router-toggly 1.0.0

package/dist/client.cjs

@@ -0,0 +1,832 @@
+'use strict';
+
+var togglyHooksTypes = require('@ops-ai/toggly-hooks-types');
+require('@ops-ai/toggly-eval');
+var react = require('react');
+var togglyLocalGates = require('@ops-ai/toggly-local-gates');
+var jsxRuntime = require('react/jsx-runtime');
+var reactRouter = require('react-router');
+
+// src/core/index.ts
+
+// src/core/types.ts
+var TogglyError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "TogglyError";
+  }
+};
+var TogglyNetworkError = class extends TogglyError {
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR", cause);
+    this.name = "TogglyNetworkError";
+  }
+};
+var TogglyConfigError = class extends TogglyError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "TogglyConfigError";
+  }
+};
+var TogglyTimeoutError = class extends TogglyError {
+  constructor(message) {
+    super(message, "TIMEOUT_ERROR");
+    this.name = "TogglyTimeoutError";
+  }
+};
+var DEFAULT_CONFIG = {
+  baseUrl: "https://definitions.toggly.io",
+  environment: "Production",
+  timeout: 1e4,
+  debug: false,
+  evaluationMode: "remote"
+};
+function mergeConfig(config) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+}
+function buildDefinitionsUrl(config, context) {
+  const { baseUrl, appKey, environment, groups, claims, evaluationMode } = mergeConfig(config);
+  if (!appKey) {
+    throw new Error("appKey is required");
+  }
+  const mode = evaluationMode ?? "remote";
+  const pathSegment = mode === "local" ? "definitions-signed" : "evaluated-signed";
+  const url = new URL(`${baseUrl}/${pathSegment}/${appKey}/${environment}`);
+  if (mode === "local") {
+    return url.toString();
+  }
+  const fromParam = typeof context === "string" ? { identity: context } : context;
+  togglyHooksTypes.appendEvaluationContext(
+    url,
+    {
+      identity: fromParam?.identity,
+      groups: fromParam?.groups ?? groups,
+      claims: fromParam?.claims ?? claims
+    },
+    "evaluated"
+  );
+  return url.toString();
+}
+function isFeatureEnabled(flags, featureKey, defaultValue = false, entityContext) {
+  if (!flags || Object.keys(flags).length === 0) {
+    return defaultValue;
+  }
+  const value = flags[featureKey];
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return togglyHooksTypes.resolveEvaluatedDefinition(value, entityContext);
+}
+function createLogger(debug) {
+  return {
+    debug: (...args) => {
+      if (debug) {
+        console.debug("[Toggly]", ...args);
+      }
+    },
+    info: (...args) => {
+      if (debug) {
+        console.info("[Toggly]", ...args);
+      }
+    },
+    warn: (...args) => {
+      console.warn("[Toggly]", ...args);
+    },
+    error: (...args) => {
+      console.error("[Toggly]", ...args);
+    }
+  };
+}
+async function fetchWithTimeout(url, options = {}, timeout = 1e4) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    return response;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/core/constants.ts
+var STORAGE_KEYS = {
+  /** Identity cookie/storage key */
+  IDENTITY: "toggly_identity",
+  /** Feature flags cache key */
+  FLAGS: "toggly_flags",
+  /** Config cache key */
+  CONFIG: "toggly_config",
+  /** Last fetch timestamp key */
+  LAST_FETCH: "toggly_last_fetch"
+};
+var HEADERS = {
+  /** Identity header */
+  IDENTITY: "x-toggly-identity",
+  /** Feature flags header */
+  FLAGS: "x-toggly-flags",
+  /** Cache control */
+  CACHE_CONTROL: "cache-control"
+};
+var TOGGLY_LOADER_KEY = "__toggly";
+
+// src/client/sdk-identity.ts
+var SDK_ID = "react-router";
+var SDK_VERSION = "1.0.0";
+function appendSdkQueryParams(params) {
+  params.set("sdk", SDK_ID);
+  params.set("sdkVersion", SDK_VERSION);
+}
+var TogglyContext = react.createContext(void 0);
+function TogglyProvider({
+  children,
+  serverContext,
+  config,
+  enableRefresh = false,
+  refreshInterval = 6e4,
+  onFlagsChange
+}) {
+  const mergedConfig = react.useMemo(
+    () => config ? mergeConfig(config) : void 0,
+    [config]
+  );
+  const logger = react.useMemo(
+    () => createLogger(mergedConfig?.debug ?? false),
+    [mergedConfig?.debug]
+  );
+  const [flags, setFlags] = react.useState(
+    serverContext?.flags ?? mergedConfig?.featureDefaults ?? {}
+  );
+  const [identity, setIdentity] = react.useState(
+    serverContext ? serverContext.identity : mergedConfig?.identity
+  );
+  const [isReady, setIsReady] = react.useState(!!serverContext);
+  const [hooks, setHooks] = react.useState([]);
+  const [localGatesRevision, setLocalGatesRevision] = react.useState(0);
+  const localGatesRef = react.useRef(mergedConfig?.localGates ?? []);
+  const localGateIndexRef = react.useRef(
+    togglyLocalGates.buildFlagGateIndex(localGatesRef.current)
+  );
+  const localGatesListenersRef = react.useRef(/* @__PURE__ */ new Set());
+  const getEffectiveFlag = react.useCallback(
+    (featureKey, defaultValue = false, entityContext) => {
+      const remote = isFeatureEnabled(
+        flags,
+        featureKey,
+        defaultValue,
+        entityContext
+      );
+      return togglyLocalGates.applyLocalGate(
+        remote,
+        featureKey,
+        localGatesRef.current,
+        localGateIndexRef.current
+      );
+    },
+    [flags, localGatesRevision]
+  );
+  const registerContext2 = react.useCallback(
+    (kind, mapper) => {
+      togglyHooksTypes.registerContext(kind, mapper);
+    },
+    []
+  );
+  const setLocalGates = react.useCallback((gates) => {
+    localGatesRef.current = [...gates];
+    localGateIndexRef.current = togglyLocalGates.buildFlagGateIndex(localGatesRef.current);
+  }, []);
+  const notifyLocalGatesChanged = react.useCallback(() => {
+    setLocalGatesRevision((revision) => revision + 1);
+    localGatesListenersRef.current.forEach((listener) => {
+      try {
+        listener();
+      } catch (error) {
+        logger.error("Local gate listener error:", error);
+      }
+    });
+  }, [logger]);
+  const subscribeLocalGatesChanged = react.useCallback(
+    (listener) => {
+      localGatesListenersRef.current.add(listener);
+      return () => {
+        localGatesListenersRef.current.delete(listener);
+      };
+    },
+    []
+  );
+  react.useEffect(() => {
+    if (mergedConfig?.localGates) {
+      setLocalGates(mergedConfig.localGates);
+    }
+  }, [mergedConfig?.localGates, setLocalGates]);
+  const executeAfterRefresh = react.useCallback(
+    async (newFlags) => {
+      for (const hook of hooks) {
+        if (hook.afterRefresh) {
+          try {
+            await hook.afterRefresh(newFlags);
+          } catch (error) {
+            logger.error(
+              `Error in hook "${hook.getMetadata().name}.afterRefresh":`,
+              error
+            );
+          }
+        }
+      }
+    },
+    [hooks, logger]
+  );
+  const fetchFlags = react.useCallback(
+    async (userIdentity) => {
+      if (!mergedConfig?.appKey) {
+        logger.debug("No appKey, using current flags.");
+        return flags;
+      }
+      try {
+        const url = buildDefinitionsUrl(mergedConfig, userIdentity);
+        logger.debug(`Fetching flags from: ${url}`);
+        const response = await fetchWithTimeout(url, {}, mergedConfig.timeout);
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const payload = await response.json();
+        const newFlags = payload && typeof payload === "object" ? payload : {};
+        logger.debug(`Fetched ${Object.keys(newFlags).length} flags.`);
+        return newFlags;
+      } catch (error) {
+        logger.warn("Failed to fetch flags:", error);
+        return flags;
+      }
+    },
+    [mergedConfig, flags, logger]
+  );
+  const updateFlags = react.useCallback(
+    async (newFlags) => {
+      setFlags(newFlags);
+      await executeAfterRefresh(newFlags);
+      onFlagsChange?.(newFlags);
+    },
+    [executeAfterRefresh, onFlagsChange]
+  );
+  const isEnabled = react.useCallback(
+    (featureKey, defaultValue = false, entity, kind) => {
+      return getEffectiveFlag(
+        featureKey,
+        defaultValue,
+        togglyHooksTypes.normalizeEntityContext(entity, kind)
+      );
+    },
+    [getEffectiveFlag]
+  );
+  const isDisabled = react.useCallback(
+    (featureKey, defaultValue = true, entity, kind) => {
+      return !isEnabled(featureKey, !defaultValue, entity, kind);
+    },
+    [isEnabled]
+  );
+  const evaluateGate = react.useCallback(
+    (featureKeys, requirement = "all", negate = false, entity, kind) => {
+      if (featureKeys.length === 0) {
+        return !negate;
+      }
+      const entityContext = togglyHooksTypes.normalizeEntityContext(entity, kind);
+      let result;
+      if (requirement === "any") {
+        result = featureKeys.some(
+          (key) => getEffectiveFlag(key, false, entityContext)
+        );
+      } else {
+        result = featureKeys.every(
+          (key) => getEffectiveFlag(key, false, entityContext)
+        );
+      }
+      return negate ? !result : result;
+    },
+    [getEffectiveFlag]
+  );
+  const identify = react.useCallback(
+    async (newIdentity, _context) => {
+      logger.debug(`Identifying user: ${newIdentity}`);
+      for (const hook of hooks) {
+        if (hook.beforeIdentify) {
+          try {
+            await hook.beforeIdentify(newIdentity);
+          } catch (error) {
+            logger.error(
+              `Error in hook "${hook.getMetadata().name}.beforeIdentify":`,
+              error
+            );
+          }
+        }
+      }
+      setIdentity(newIdentity);
+      const newFlags = await fetchFlags(newIdentity);
+      await updateFlags(newFlags);
+      for (let i = hooks.length - 1; i >= 0; i--) {
+        const hook = hooks[i];
+        if (hook.afterIdentify) {
+          try {
+            await hook.afterIdentify(newIdentity, void 0);
+          } catch (error) {
+            logger.error(
+              `Error in hook "${hook.getMetadata().name}.afterIdentify":`,
+              error
+            );
+          }
+        }
+      }
+      setIsReady(true);
+    },
+    [hooks, fetchFlags, updateFlags, logger]
+  );
+  const reset = react.useCallback(async () => {
+    logger.debug("Resetting identity");
+    setIdentity(void 0);
+    const newFlags = await fetchFlags();
+    await updateFlags(newFlags);
+  }, [fetchFlags, updateFlags, logger]);
+  const refresh = react.useCallback(async () => {
+    logger.debug("Refreshing flags");
+    const newFlags = await fetchFlags(identity);
+    await updateFlags(newFlags);
+  }, [identity, fetchFlags, updateFlags, logger]);
+  const addHook = react.useCallback(
+    (hook) => {
+      setHooks((currentHooks) => {
+        const metadata = hook.getMetadata();
+        const exists = currentHooks.find(
+          (h) => h.getMetadata().name === metadata.name
+        );
+        if (exists) {
+          logger.warn(`Hook "${metadata.name}" already registered. Skipping.`);
+          return currentHooks;
+        }
+        logger.debug(`Hook "${metadata.name}" registered.`);
+        return [...currentHooks, hook];
+      });
+    },
+    [logger]
+  );
+  const removeHook = react.useCallback(
+    (name) => {
+      let removed = false;
+      setHooks((currentHooks) => {
+        const index = currentHooks.findIndex(
+          (h) => h.getMetadata().name === name
+        );
+        if (index > -1) {
+          logger.debug(`Hook "${name}" removed.`);
+          removed = true;
+          return [
+            ...currentHooks.slice(0, index),
+            ...currentHooks.slice(index + 1)
+          ];
+        }
+        return currentHooks;
+      });
+      return removed;
+    },
+    [logger]
+  );
+  const wsRef = react.useRef(null);
+  const wsReconnectTimerRef = react.useRef(null);
+  const wsConnectedRef = react.useRef(false);
+  const lastFallbackRefreshRef = react.useRef(0);
+  const FALLBACK_REFRESH_INTERVAL = 20 * 60 * 1e3;
+  const WS_RECONNECT_DELAY = 5e3;
+  const refreshRef = react.useRef(refresh);
+  react.useEffect(() => {
+    refreshRef.current = refresh;
+  }, [refresh]);
+  react.useEffect(() => {
+    if (!enableRefresh || !mergedConfig?.appKey) {
+      return;
+    }
+    logger.debug(`Setting up refresh interval: ${refreshInterval}ms`);
+    const intervalId = setInterval(() => {
+      if (wsConnectedRef.current) {
+        const now = Date.now();
+        if (now - lastFallbackRefreshRef.current < FALLBACK_REFRESH_INTERVAL) {
+          return;
+        }
+        lastFallbackRefreshRef.current = now;
+      }
+      refresh();
+    }, refreshInterval);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [enableRefresh, refreshInterval, refresh, mergedConfig?.appKey, logger]);
+  react.useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (!mergedConfig?.appKey || !mergedConfig?.baseUrl) {
+      return;
+    }
+    if (typeof WebSocket === "undefined") {
+      return;
+    }
+    function buildWebSocketUrl() {
+      const baseUrl = mergedConfig.baseUrl;
+      const wsUrl = baseUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+      const params = new URLSearchParams();
+      appendSdkQueryParams(params);
+      const query = params.toString();
+      return `${wsUrl.replace(/\/$/, "")}/${mergedConfig.appKey}/ws${query ? `?${query}` : ""}`;
+    }
+    function connect() {
+      if (wsRef.current) {
+        return;
+      }
+      const wsUrl = buildWebSocketUrl();
+      logger.debug(`WebSocket connecting to: ${wsUrl}`);
+      try {
+        const socket = new WebSocket(wsUrl);
+        wsRef.current = socket;
+        socket.onopen = () => {
+          wsConnectedRef.current = true;
+          lastFallbackRefreshRef.current = Date.now();
+          logger.debug("WebSocket connected");
+        };
+        socket.onmessage = (event) => {
+          const text = typeof event.data === "string" ? event.data : "";
+          try {
+            const msg = JSON.parse(text);
+            if (msg.type === "ping") {
+              return;
+            }
+            if (msg.type === "flags-updated" || msg.type === "update") {
+              logger.debug("WebSocket: definitions updated, refreshing");
+              refreshRef.current();
+            }
+          } catch {
+            if (text === "update" || text === "flags-updated") {
+              refreshRef.current();
+            }
+          }
+        };
+        socket.onclose = () => {
+          wsConnectedRef.current = false;
+          wsRef.current = null;
+          logger.debug("WebSocket disconnected, reconnecting in 5s");
+          scheduleReconnect();
+        };
+        socket.onerror = () => {
+          logger.warn("WebSocket error");
+        };
+      } catch (error) {
+        logger.warn("Failed to create WebSocket:", error);
+        wsRef.current = null;
+        scheduleReconnect();
+      }
+    }
+    function scheduleReconnect() {
+      if (wsReconnectTimerRef.current) {
+        return;
+      }
+      wsReconnectTimerRef.current = setTimeout(() => {
+        wsReconnectTimerRef.current = null;
+        connect();
+      }, WS_RECONNECT_DELAY);
+    }
+    connect();
+    return () => {
+      if (wsReconnectTimerRef.current) {
+        clearTimeout(wsReconnectTimerRef.current);
+        wsReconnectTimerRef.current = null;
+      }
+      if (wsRef.current) {
+        wsRef.current.onclose = null;
+        wsRef.current.onerror = null;
+        wsRef.current.onmessage = null;
+        wsRef.current.onopen = null;
+        wsRef.current.close();
+        wsRef.current = null;
+        wsConnectedRef.current = false;
+      }
+    };
+  }, [mergedConfig?.appKey, mergedConfig?.baseUrl, logger]);
+  react.useEffect(() => {
+    if (!serverContext && mergedConfig?.appKey) {
+      logger.debug("No server context, initializing client-side");
+      fetchFlags(identity).then((newFlags) => {
+        setFlags(newFlags);
+        setIsReady(true);
+      });
+    }
+  }, []);
+  const contextValue = react.useMemo(
+    () => ({
+      flags,
+      isReady,
+      identity,
+      isEnabled,
+      isDisabled,
+      evaluateGate,
+      registerContext: registerContext2,
+      identify,
+      reset,
+      refresh,
+      addHook,
+      removeHook,
+      setLocalGates,
+      notifyLocalGatesChanged,
+      subscribeLocalGatesChanged
+    }),
+    [
+      flags,
+      isReady,
+      identity,
+      isEnabled,
+      isDisabled,
+      evaluateGate,
+      registerContext2,
+      identify,
+      reset,
+      refresh,
+      addHook,
+      removeHook,
+      setLocalGates,
+      notifyLocalGatesChanged,
+      subscribeLocalGatesChanged
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TogglyContext.Provider, { value: contextValue, children });
+}
+function useTogglyContext() {
+  const context = react.useContext(TogglyContext);
+  if (!context) {
+    throw new Error("useTogglyContext must be used within a TogglyProvider");
+  }
+  return context;
+}
+function useToggly() {
+  return useTogglyContext();
+}
+function useFeature(featureKey, defaultValue = false, entity, kind) {
+  const { isEnabled } = useTogglyContext();
+  return isEnabled(featureKey, defaultValue, entity, kind);
+}
+function useFeatureDisabled(featureKey, defaultValue = true, entity, kind) {
+  const { isDisabled } = useTogglyContext();
+  return isDisabled(featureKey, defaultValue, entity, kind);
+}
+function useFeatureGate(featureKeys, requirement = "all", negate = false, entity, kind) {
+  const { evaluateGate } = useTogglyContext();
+  return evaluateGate(featureKeys, requirement, negate, entity, kind);
+}
+function useFeatureFlags() {
+  const { flags } = useTogglyContext();
+  return flags;
+}
+function useFeatures(featureKeys, defaultValue = false) {
+  const { isEnabled } = useTogglyContext();
+  return react.useMemo(() => {
+    const result = {};
+    for (const key of featureKeys) {
+      result[key] = isEnabled(key, defaultValue);
+    }
+    return result;
+  }, [featureKeys, isEnabled, defaultValue]);
+}
+function useFeatureCallback(featureKey, enabledCallback, disabledCallback, defaultValue = false) {
+  const enabled = useFeature(featureKey, defaultValue);
+  return enabled ? enabledCallback() : disabledCallback();
+}
+function useFeatureValue(featureKey, enabledValue, disabledValue, defaultValue = false) {
+  const enabled = useFeature(featureKey, defaultValue);
+  return enabled ? enabledValue : disabledValue;
+}
+function useFeatureChange(featureKey, _onChange) {
+  const enabled = useFeature(featureKey);
+  return enabled;
+}
+function useIdentity() {
+  const { identity, identify, reset } = useTogglyContext();
+  return {
+    identity,
+    identify,
+    reset
+  };
+}
+function useTogglyReady() {
+  const { isReady } = useTogglyContext();
+  return isReady;
+}
+function useRefreshFlags() {
+  const { refresh } = useTogglyContext();
+  return refresh;
+}
+function useFeatureRender(featureKey, enabled, disabled, defaultValue = false) {
+  const isEnabled = useFeature(featureKey, defaultValue);
+  return isEnabled ? enabled : disabled;
+}
+function useABTest(featureKey, variantA, variantB, defaultVariant = "A") {
+  const enabled = useFeature(featureKey, defaultVariant === "B");
+  return enabled ? variantB : variantA;
+}
+function useFeatureWithLoading(featureKey, defaultValue = false) {
+  const { isReady, isEnabled } = useTogglyContext();
+  return {
+    enabled: isEnabled(featureKey, defaultValue),
+    isLoading: !isReady
+  };
+}
+function Feature({
+  featureKey,
+  featureKeys,
+  requirement = "all",
+  negate = false,
+  defaultValue = false,
+  children,
+  render,
+  context,
+  contextKind
+}) {
+  const keys = featureKeys ?? (featureKey ? [featureKey] : []);
+  const singleEnabled = useFeature(keys[0] ?? "", defaultValue, context, contextKind);
+  const gateEnabled = useFeatureGate(keys, requirement, false, context, contextKind);
+  let enabled;
+  if (keys.length === 0) {
+    enabled = defaultValue;
+  } else if (keys.length === 1) {
+    enabled = singleEnabled;
+  } else {
+    enabled = gateEnabled;
+  }
+  if (negate) {
+    enabled = !enabled;
+  }
+  if (render) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: render(enabled) });
+  }
+  return enabled ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) : null;
+}
+function FeatureEnabled({
+  featureKey,
+  defaultValue = false,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Feature, { featureKey, defaultValue, children });
+}
+function FeatureDisabled({
+  featureKey,
+  defaultValue = true,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(Feature, { featureKey, defaultValue: !defaultValue, negate: true, children });
+}
+function FeatureSwitch({
+  featureKey,
+  defaultValue = false,
+  enabled,
+  disabled
+}) {
+  const isEnabled = useFeature(featureKey, defaultValue);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: isEnabled ? enabled : disabled });
+}
+function FeatureGate({
+  featureKeys,
+  requirement = "all",
+  negate = false,
+  children,
+  context,
+  contextKind
+}) {
+  const enabled = useFeatureGate(featureKeys, requirement, negate, context, contextKind);
+  return enabled ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) : null;
+}
+function RouterTogglyProvider({
+  children,
+  routeId,
+  fallbackContext,
+  config,
+  ...props
+}) {
+  let serverContext;
+  try {
+    if (routeId) {
+      const routeData = reactRouter.useRouteLoaderData(routeId);
+      serverContext = routeData?.[TOGGLY_LOADER_KEY];
+    } else {
+      const loaderData = reactRouter.useLoaderData();
+      serverContext = loaderData?.[TOGGLY_LOADER_KEY];
+    }
+  } catch {
+    serverContext = fallbackContext;
+  }
+  serverContext = serverContext ?? fallbackContext;
+  const mergedConfig = config ?? (serverContext ? {
+    appKey: serverContext.appKey,
+    environment: serverContext.environment
+  } : void 0);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    TogglyProvider,
+    {
+      serverContext,
+      config: mergedConfig,
+      ...props,
+      children
+    }
+  );
+}
+function useTogglyLoaderData() {
+  const loaderData = reactRouter.useLoaderData();
+  return {
+    data: loaderData,
+    toggly: loaderData[TOGGLY_LOADER_KEY]
+  };
+}
+function useTogglyRouteLoaderData(routeId) {
+  const routeData = reactRouter.useRouteLoaderData(routeId);
+  return {
+    data: routeData,
+    toggly: routeData?.[TOGGLY_LOADER_KEY]
+  };
+}
+function extractServerContext(loaderData) {
+  return loaderData[TOGGLY_LOADER_KEY];
+}
+function hasTogglyContext(loaderData) {
+  const data = loaderData;
+  return TOGGLY_LOADER_KEY in data && data[TOGGLY_LOADER_KEY] !== void 0;
+}
+function TogglyScript({
+  serverContext,
+  nonce
+}) {
+  if (!serverContext) {
+    return null;
+  }
+  const script = `window.__TOGGLY_DATA__=${togglyHooksTypes.serializeJsonForInlineScript(serverContext)};`;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "script",
+    {
+      nonce,
+      dangerouslySetInnerHTML: { __html: script },
+      suppressHydrationWarning: true
+    }
+  );
+}
+function getWindowTogglyData() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.__TOGGLY_DATA__;
+}
+
+Object.defineProperty(exports, "normalizeEntityContext", {
+  enumerable: true,
+  get: function () { return togglyHooksTypes.normalizeEntityContext; }
+});
+Object.defineProperty(exports, "registerContext", {
+  enumerable: true,
+  get: function () { return togglyHooksTypes.registerContext; }
+});
+exports.Feature = Feature;
+exports.FeatureDisabled = FeatureDisabled;
+exports.FeatureEnabled = FeatureEnabled;
+exports.FeatureGate = FeatureGate;
+exports.FeatureSwitch = FeatureSwitch;
+exports.HEADERS = HEADERS;
+exports.RouterTogglyProvider = RouterTogglyProvider;
+exports.STORAGE_KEYS = STORAGE_KEYS;
+exports.TOGGLY_LOADER_KEY = TOGGLY_LOADER_KEY;
+exports.TogglyConfigError = TogglyConfigError;
+exports.TogglyContext = TogglyContext;
+exports.TogglyError = TogglyError;
+exports.TogglyNetworkError = TogglyNetworkError;
+exports.TogglyProvider = TogglyProvider;
+exports.TogglyScript = TogglyScript;
+exports.TogglyTimeoutError = TogglyTimeoutError;
+exports.extractServerContext = extractServerContext;
+exports.getWindowTogglyData = getWindowTogglyData;
+exports.hasTogglyContext = hasTogglyContext;
+exports.useABTest = useABTest;
+exports.useFeature = useFeature;
+exports.useFeatureCallback = useFeatureCallback;
+exports.useFeatureChange = useFeatureChange;
+exports.useFeatureDisabled = useFeatureDisabled;
+exports.useFeatureFlags = useFeatureFlags;
+exports.useFeatureGate = useFeatureGate;
+exports.useFeatureRender = useFeatureRender;
+exports.useFeatureValue = useFeatureValue;
+exports.useFeatureWithLoading = useFeatureWithLoading;
+exports.useFeatures = useFeatures;
+exports.useIdentity = useIdentity;
+exports.useRefreshFlags = useRefreshFlags;
+exports.useToggly = useToggly;
+exports.useTogglyContext = useTogglyContext;
+exports.useTogglyLoaderData = useTogglyLoaderData;
+exports.useTogglyReady = useTogglyReady;
+exports.useTogglyRouteLoaderData = useTogglyRouteLoaderData;
+//# sourceMappingURL=client.cjs.map
+//# sourceMappingURL=client.cjs.map