@getflaggy/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,80 @@
+/** Possible types a flag value can take */
+type FlagValue = boolean | string | number | Record<string, unknown>;
+/** Evaluation context sent to the server */
+type FlaggyContext = Record<string, unknown>;
+/** A single evaluated flag result from the server */
+interface EvaluatedFlag {
+    flag_key: string;
+    value: FlagValue;
+    match: boolean;
+    reason: string;
+}
+/** Response from POST /api/v1/evaluate */
+interface EvaluateResponse {
+    flag_key: string;
+    value: FlagValue;
+    match: boolean;
+    reason: string;
+}
+/** Response from POST /api/v1/evaluate/batch */
+interface BatchEvaluateResponse {
+    results: EvaluatedFlag[];
+}
+/** SSE event data for flag changes */
+interface FlagChangeEvent {
+    type: 'flag_updated' | 'flag_deleted' | 'flag_created';
+    key: string;
+}
+/** Configuration for FlaggyClient */
+interface FlaggyClientOptions {
+    serverUrl: string;
+    apiKey: string;
+    context?: FlaggyContext;
+    /** Whether to open an SSE connection for live updates. Default: true */
+    enableStreaming?: boolean;
+    /** Initial retry delay for SSE reconnection in ms. Default: 1000 */
+    sseRetryDelay?: number;
+    /** Max retry delay for SSE reconnection in ms. Default: 30000 */
+    sseMaxRetryDelay?: number;
+}
+/** Listener for flag value changes */
+type FlagChangeListener = (key: string, value: FlagValue) => void;
+/** Listener for readiness state */
+type ReadyListener = () => void;
+/** Listener for errors */
+type ErrorListener = (error: Error) => void;
+
+type EventMap = {
+    change: FlagChangeListener;
+    ready: ReadyListener;
+    error: ErrorListener;
+};
+declare class FlaggyClient {
+    private readonly serverUrl;
+    private readonly apiKey;
+    private readonly enableStreaming;
+    private readonly sseRetryDelay;
+    private readonly sseMaxRetryDelay;
+    private context;
+    private cache;
+    private _ready;
+    private _error;
+    private sseManager;
+    private contextAbortController;
+    private listeners;
+    constructor(options: FlaggyClientOptions);
+    get ready(): boolean;
+    get error(): Error | null;
+    initialize(): Promise<void>;
+    getFlag<T extends FlagValue>(key: string, defaultValue: T): T;
+    setContext(context: FlaggyContext): Promise<void>;
+    on<E extends keyof EventMap>(event: E, listener: EventMap[E]): () => void;
+    destroy(): void;
+    private startSSE;
+    private handleSSEEvent;
+    private applyBatchResult;
+    private emit;
+    private fetchApi;
+}
+
+export { type BatchEvaluateResponse, type ErrorListener, type EvaluateResponse, type EvaluatedFlag, type FlagChangeEvent, type FlagChangeListener, type FlagValue, FlaggyClient, type FlaggyClientOptions, type FlaggyContext, type ReadyListener };

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+/** Possible types a flag value can take */
+type FlagValue = boolean | string | number | Record<string, unknown>;
+/** Evaluation context sent to the server */
+type FlaggyContext = Record<string, unknown>;
+/** A single evaluated flag result from the server */
+interface EvaluatedFlag {
+    flag_key: string;
+    value: FlagValue;
+    match: boolean;
+    reason: string;
+}
+/** Response from POST /api/v1/evaluate */
+interface EvaluateResponse {
+    flag_key: string;
+    value: FlagValue;
+    match: boolean;
+    reason: string;
+}
+/** Response from POST /api/v1/evaluate/batch */
+interface BatchEvaluateResponse {
+    results: EvaluatedFlag[];
+}
+/** SSE event data for flag changes */
+interface FlagChangeEvent {
+    type: 'flag_updated' | 'flag_deleted' | 'flag_created';
+    key: string;
+}
+/** Configuration for FlaggyClient */
+interface FlaggyClientOptions {
+    serverUrl: string;
+    apiKey: string;
+    context?: FlaggyContext;
+    /** Whether to open an SSE connection for live updates. Default: true */
+    enableStreaming?: boolean;
+    /** Initial retry delay for SSE reconnection in ms. Default: 1000 */
+    sseRetryDelay?: number;
+    /** Max retry delay for SSE reconnection in ms. Default: 30000 */
+    sseMaxRetryDelay?: number;
+}
+/** Listener for flag value changes */
+type FlagChangeListener = (key: string, value: FlagValue) => void;
+/** Listener for readiness state */
+type ReadyListener = () => void;
+/** Listener for errors */
+type ErrorListener = (error: Error) => void;
+
+type EventMap = {
+    change: FlagChangeListener;
+    ready: ReadyListener;
+    error: ErrorListener;
+};
+declare class FlaggyClient {
+    private readonly serverUrl;
+    private readonly apiKey;
+    private readonly enableStreaming;
+    private readonly sseRetryDelay;
+    private readonly sseMaxRetryDelay;
+    private context;
+    private cache;
+    private _ready;
+    private _error;
+    private sseManager;
+    private contextAbortController;
+    private listeners;
+    constructor(options: FlaggyClientOptions);
+    get ready(): boolean;
+    get error(): Error | null;
+    initialize(): Promise<void>;
+    getFlag<T extends FlagValue>(key: string, defaultValue: T): T;
+    setContext(context: FlaggyContext): Promise<void>;
+    on<E extends keyof EventMap>(event: E, listener: EventMap[E]): () => void;
+    destroy(): void;
+    private startSSE;
+    private handleSSEEvent;
+    private applyBatchResult;
+    private emit;
+    private fetchApi;
+}
+
+export { type BatchEvaluateResponse, type ErrorListener, type EvaluateResponse, type EvaluatedFlag, type FlagChangeEvent, type FlagChangeListener, type FlagValue, FlaggyClient, type FlaggyClientOptions, type FlaggyContext, type ReadyListener };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import {
+  FlaggyClient
+} from "./chunk-HBGNXCEV.mjs";
+export {
+  FlaggyClient
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/react.cjs

@@ -0,0 +1,397 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  FlaggyProvider: () => FlaggyProvider,
+  useFlag: () => useFlag,
+  useFlaggy: () => useFlaggy
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/FlaggyProvider.tsx
+var import_react2 = require("react");
+
+// src/sse.ts
+var SSEManager = class {
+  constructor(options) {
+    this.abortController = null;
+    this.retryCount = 0;
+    this.retryTimeout = null;
+    this.destroyed = false;
+    this.url = options.url;
+    this.apiKey = options.apiKey;
+    this.onEvent = options.onEvent;
+    this.onError = options.onError;
+    this.retryDelay = options.retryDelay ?? 1e3;
+    this.maxRetryDelay = options.maxRetryDelay ?? 3e4;
+  }
+  connect() {
+    if (this.destroyed) return;
+    this.abortController = new AbortController();
+    fetch(this.url, {
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        Accept: "text/event-stream"
+      },
+      signal: this.abortController.signal
+    }).then((response) => {
+      if (!response.ok) {
+        throw new Error(`SSE connection failed: ${response.status}`);
+      }
+      if (!response.body) {
+        throw new Error("SSE response has no body");
+      }
+      this.retryCount = 0;
+      this.readStream(response.body);
+    }).catch((err) => {
+      if (this.destroyed) return;
+      if (err instanceof Error && err.name === "AbortError") return;
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      this.reconnect();
+    });
+  }
+  destroy() {
+    this.destroyed = true;
+    this.abortController?.abort();
+    this.abortController = null;
+    if (this.retryTimeout) {
+      clearTimeout(this.retryTimeout);
+      this.retryTimeout = null;
+    }
+  }
+  async readStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "";
+    let currentData = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("event:")) {
+            currentEvent = line.slice(6).trim();
+          } else if (line.startsWith("data:")) {
+            currentData = line.slice(5).trim();
+          } else if (line === "") {
+            if (currentData) {
+              this.handleEvent(currentEvent, currentData);
+            }
+            currentEvent = "";
+            currentData = "";
+          }
+        }
+      }
+    } catch (err) {
+      if (this.destroyed) return;
+      if (err instanceof Error && err.name === "AbortError") return;
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      reader.releaseLock();
+    }
+    if (!this.destroyed) {
+      this.reconnect();
+    }
+  }
+  handleEvent(eventType, data) {
+    try {
+      const parsed = JSON.parse(data);
+      if (eventType && !parsed.type) {
+        parsed.type = eventType;
+      }
+      this.onEvent(parsed);
+    } catch {
+    }
+  }
+  reconnect() {
+    if (this.destroyed) return;
+    const delay = this.getBackoffDelay();
+    this.retryCount++;
+    this.retryTimeout = setTimeout(() => {
+      this.retryTimeout = null;
+      this.connect();
+    }, delay);
+  }
+  getBackoffDelay() {
+    const delay = this.retryDelay * Math.pow(2, this.retryCount);
+    const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+    return Math.min(delay + jitter, this.maxRetryDelay);
+  }
+};
+
+// src/client.ts
+var FlaggyClient = class {
+  constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this._ready = false;
+    this._error = null;
+    this.sseManager = null;
+    this.contextAbortController = null;
+    this.listeners = {
+      change: /* @__PURE__ */ new Set(),
+      ready: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ new Set()
+    };
+    this.serverUrl = options.serverUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.context = options.context ?? {};
+    this.enableStreaming = options.enableStreaming ?? true;
+    this.sseRetryDelay = options.sseRetryDelay ?? 1e3;
+    this.sseMaxRetryDelay = options.sseMaxRetryDelay ?? 3e4;
+  }
+  get ready() {
+    return this._ready;
+  }
+  get error() {
+    return this._error;
+  }
+  async initialize() {
+    try {
+      const response = await this.fetchApi(
+        "/api/v1/evaluate/batch",
+        { context: this.context }
+      );
+      this.applyBatchResult(response);
+      this._ready = true;
+      this.emit("ready");
+    } catch (err) {
+      this._error = err instanceof Error ? err : new Error(String(err));
+      this.emit("error", this._error);
+    }
+    if (this.enableStreaming) {
+      this.startSSE();
+    }
+  }
+  getFlag(key, defaultValue) {
+    if (!this._ready || !this.cache.has(key)) {
+      return defaultValue;
+    }
+    return this.cache.get(key);
+  }
+  async setContext(context) {
+    this.context = context;
+    this.contextAbortController?.abort();
+    const controller = new AbortController();
+    this.contextAbortController = controller;
+    try {
+      const response = await this.fetchApi(
+        "/api/v1/evaluate/batch",
+        { context },
+        controller.signal
+      );
+      if (controller.signal.aborted) return;
+      this.applyBatchResult(response);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") return;
+      this._error = err instanceof Error ? err : new Error(String(err));
+      this.emit("error", this._error);
+    }
+  }
+  on(event, listener) {
+    this.listeners[event].add(listener);
+    return () => {
+      this.listeners[event].delete(listener);
+    };
+  }
+  destroy() {
+    this.sseManager?.destroy();
+    this.sseManager = null;
+    this.contextAbortController?.abort();
+    this.contextAbortController = null;
+    this.listeners.change.clear();
+    this.listeners.ready.clear();
+    this.listeners.error.clear();
+  }
+  startSSE() {
+    this.sseManager = new SSEManager({
+      url: `${this.serverUrl}/api/v1/stream`,
+      apiKey: this.apiKey,
+      onEvent: (event) => this.handleSSEEvent(event),
+      onError: (err) => this.emit("error", err),
+      retryDelay: this.sseRetryDelay,
+      maxRetryDelay: this.sseMaxRetryDelay
+    });
+    this.sseManager.connect();
+  }
+  async handleSSEEvent(event) {
+    if (event.type === "flag_deleted") {
+      if (this.cache.has(event.key)) {
+        this.cache.delete(event.key);
+        this.emit("change", event.key, void 0);
+      }
+      return;
+    }
+    try {
+      const response = await this.fetchApi(
+        "/api/v1/evaluate",
+        { flag_key: event.key, context: this.context }
+      );
+      const oldValue = this.cache.get(event.key);
+      this.cache.set(event.key, response.value);
+      if (oldValue !== response.value) {
+        this.emit("change", event.key, response.value);
+      }
+    } catch {
+    }
+  }
+  applyBatchResult(response) {
+    const newCache = /* @__PURE__ */ new Map();
+    for (const flag of response.results) {
+      newCache.set(flag.flag_key, flag.value);
+    }
+    for (const [key, newValue] of newCache) {
+      const oldValue = this.cache.get(key);
+      if (oldValue !== newValue) {
+        this.emit("change", key, newValue);
+      }
+    }
+    for (const key of this.cache.keys()) {
+      if (!newCache.has(key)) {
+        this.emit("change", key, void 0);
+      }
+    }
+    this.cache = newCache;
+  }
+  emit(event, ...args) {
+    if (event === "change") {
+      for (const listener of this.listeners.change) {
+        listener(args[0], args[1]);
+      }
+    } else if (event === "ready") {
+      for (const listener of this.listeners.ready) {
+        listener();
+      }
+    } else if (event === "error") {
+      for (const listener of this.listeners.error) {
+        listener(args[0]);
+      }
+    }
+  }
+  async fetchApi(path, body, signal) {
+    const response = await fetch(`${this.serverUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`Flaggy API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+};
+
+// src/react/context.ts
+var import_react = require("react");
+var FlaggyReactContext = (0, import_react.createContext)(null);
+
+// src/react/FlaggyProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function FlaggyProvider({
+  serverUrl,
+  apiKey,
+  context,
+  enableStreaming,
+  onError,
+  children
+}) {
+  const clientRef = (0, import_react2.useRef)(null);
+  const [ready, setReady] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [, setVersion] = (0, import_react2.useState)(0);
+  (0, import_react2.useEffect)(() => {
+    const client = new FlaggyClient({
+      serverUrl,
+      apiKey,
+      context,
+      enableStreaming
+    });
+    clientRef.current = client;
+    setReady(false);
+    setError(null);
+    const unsubReady = client.on("ready", () => setReady(true));
+    const unsubError = client.on("error", (err) => {
+      setError(err);
+      onError?.(err);
+    });
+    const unsubChange = client.on("change", () => {
+      setVersion((v) => v + 1);
+    });
+    client.initialize();
+    return () => {
+      unsubReady();
+      unsubError();
+      unsubChange();
+      client.destroy();
+      clientRef.current = null;
+    };
+  }, [serverUrl, apiKey]);
+  const contextKey = context ? JSON.stringify(context) : "";
+  (0, import_react2.useEffect)(() => {
+    if (clientRef.current && context && clientRef.current.ready) {
+      clientRef.current.setContext(context);
+    }
+  }, [contextKey]);
+  const value = (0, import_react2.useMemo)(
+    () => clientRef.current ? { client: clientRef.current, ready, error } : null,
+    [ready, error]
+  );
+  if (!value) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FlaggyReactContext.Provider, { value, children });
+}
+
+// src/react/useFlag.ts
+var import_react3 = require("react");
+function useFlag(key, defaultValue) {
+  const ctx = (0, import_react3.useContext)(FlaggyReactContext);
+  if (!ctx) {
+    return defaultValue;
+  }
+  return ctx.client.getFlag(key, defaultValue);
+}
+
+// src/react/useFlaggy.ts
+var import_react4 = require("react");
+function useFlaggy() {
+  const ctx = (0, import_react4.useContext)(FlaggyReactContext);
+  if (!ctx) {
+    throw new Error("[flaggy] useFlaggy() must be used within a <FlaggyProvider>.");
+  }
+  return {
+    client: ctx.client,
+    ready: ctx.ready,
+    error: ctx.error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlaggyProvider,
+  useFlag,
+  useFlaggy
+});
+//# sourceMappingURL=react.cjs.map

package/dist/react.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react/index.ts","../src/react/FlaggyProvider.tsx","../src/sse.ts","../src/client.ts","../src/react/context.ts","../src/react/useFlag.ts","../src/react/useFlaggy.ts"],"sourcesContent":["export { FlaggyProvider } from './FlaggyProvider';\nexport type { FlaggyProviderProps } from './FlaggyProvider';\nexport { useFlag } from './useFlag';\nexport { useFlaggy } from './useFlaggy';\nexport type { FlaggyContext as FlaggyEvalContext, FlagValue } from '../types';\n","import { useEffect, useRef, useState, useMemo, type ReactNode } from 'react';\nimport { FlaggyClient } from '../client';\nimport { FlaggyReactContext } from './context';\nimport type { FlaggyContext } from '../types';\n\nexport interface FlaggyProviderProps {\n  serverUrl: string;\n  apiKey: string;\n  context?: FlaggyContext;\n  enableStreaming?: boolean;\n  /** Called when an error occurs (init failure, SSE error, etc.) */\n  onError?: (error: Error) => void;\n  children: ReactNode;\n}\n\nexport function FlaggyProvider({\n  serverUrl,\n  apiKey,\n  context,\n  enableStreaming,\n  onError,\n  children,\n}: FlaggyProviderProps) {\n  const clientRef = useRef<FlaggyClient | null>(null);\n  const [ready, setReady] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n  const [, setVersion] = useState(0);\n\n  // Create and initialize client when serverUrl or apiKey change\n  useEffect(() => {\n    const client = new FlaggyClient({\n      serverUrl,\n      apiKey,\n      context,\n      enableStreaming,\n    });\n    clientRef.current = client;\n    setReady(false);\n    setError(null);\n\n    const unsubReady = client.on('ready', () => setReady(true));\n    const unsubError = client.on('error', (err) => {\n      setError(err);\n      onError?.(err);\n    });\n    const unsubChange = client.on('change', () => {\n      setVersion((v) => v + 1);\n    });\n\n    client.initialize();\n\n    return () => {\n      unsubReady();\n      unsubError();\n      unsubChange();\n      client.destroy();\n      clientRef.current = null;\n    };\n  }, [serverUrl, apiKey]);\n\n  // Update context when it changes (deep comparison via JSON.stringify)\n  const contextKey = context ? JSON.stringify(context) : '';\n  useEffect(() => {\n    if (clientRef.current && context && clientRef.current.ready) {\n      clientRef.current.setContext(context);\n    }\n  }, [contextKey]);\n\n  const value = useMemo(\n    () =>\n      clientRef.current\n        ? { client: clientRef.current, ready, error }\n        : null,\n    [ready, error],\n  );\n\n  if (!value) return null;\n\n  return (\n    <FlaggyReactContext.Provider value={value}>\n      {children}\n    </FlaggyReactContext.Provider>\n  );\n}\n","import type { FlagChangeEvent } from './types';\n\nexport interface SSEManagerOptions {\n  url: string;\n  apiKey: string;\n  onEvent: (event: FlagChangeEvent) => void;\n  onError: (error: Error) => void;\n  retryDelay?: number;\n  maxRetryDelay?: number;\n}\n\nexport class SSEManager {\n  private abortController: AbortController | null = null;\n  private retryCount = 0;\n  private retryTimeout: ReturnType<typeof setTimeout> | null = null;\n  private destroyed = false;\n\n  private readonly url: string;\n  private readonly apiKey: string;\n  private readonly onEvent: (event: FlagChangeEvent) => void;\n  private readonly onError: (error: Error) => void;\n  private readonly retryDelay: number;\n  private readonly maxRetryDelay: number;\n\n  constructor(options: SSEManagerOptions) {\n    this.url = options.url;\n    this.apiKey = options.apiKey;\n    this.onEvent = options.onEvent;\n    this.onError = options.onError;\n    this.retryDelay = options.retryDelay ?? 1000;\n    this.maxRetryDelay = options.maxRetryDelay ?? 30_000;\n  }\n\n  connect(): void {\n    if (this.destroyed) return;\n\n    this.abortController = new AbortController();\n\n    fetch(this.url, {\n      headers: {\n        Authorization: `Bearer ${this.apiKey}`,\n        Accept: 'text/event-stream',\n      },\n      signal: this.abortController.signal,\n    })\n      .then((response) => {\n        if (!response.ok) {\n          throw new Error(`SSE connection failed: ${response.status}`);\n        }\n        if (!response.body) {\n          throw new Error('SSE response has no body');\n        }\n\n        this.retryCount = 0;\n        this.readStream(response.body);\n      })\n      .catch((err: unknown) => {\n        if (this.destroyed) return;\n        if (err instanceof Error && err.name === 'AbortError') return;\n\n        this.onError(err instanceof Error ? err : new Error(String(err)));\n        this.reconnect();\n      });\n  }\n\n  destroy(): void {\n    this.destroyed = true;\n    this.abortController?.abort();\n    this.abortController = null;\n    if (this.retryTimeout) {\n      clearTimeout(this.retryTimeout);\n      this.retryTimeout = null;\n    }\n  }\n\n  private async readStream(body: ReadableStream<Uint8Array>): Promise<void> {\n    const reader = body.getReader();\n    const decoder = new TextDecoder();\n    let buffer = '';\n    let currentEvent = '';\n    let currentData = '';\n\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) break;\n\n        buffer += decoder.decode(value, { stream: true });\n\n        const lines = buffer.split('\\n');\n        // Keep the last incomplete line in the buffer\n        buffer = lines.pop() ?? '';\n\n        for (const line of lines) {\n          if (line.startsWith('event:')) {\n            currentEvent = line.slice(6).trim();\n          } else if (line.startsWith('data:')) {\n            currentData = line.slice(5).trim();\n          } else if (line === '') {\n            // Empty line = end of event\n            if (currentData) {\n              this.handleEvent(currentEvent, currentData);\n            }\n            currentEvent = '';\n            currentData = '';\n          }\n        }\n      }\n    } catch (err: unknown) {\n      if (this.destroyed) return;\n      if (err instanceof Error && err.name === 'AbortError') return;\n\n      this.onError(err instanceof Error ? err : new Error(String(err)));\n    } finally {\n      reader.releaseLock();\n    }\n\n    // Stream ended — reconnect if not destroyed\n    if (!this.destroyed) {\n      this.reconnect();\n    }\n  }\n\n  private handleEvent(eventType: string, data: string): void {\n    try {\n      const parsed = JSON.parse(data) as FlagChangeEvent;\n      // Use the event type from the SSE field if present, otherwise from data\n      if (eventType && !parsed.type) {\n        parsed.type = eventType as FlagChangeEvent['type'];\n      }\n      this.onEvent(parsed);\n    } catch {\n      // Malformed event data, skip\n    }\n  }\n\n  private reconnect(): void {\n    if (this.destroyed) return;\n\n    const delay = this.getBackoffDelay();\n    this.retryCount++;\n    this.retryTimeout = setTimeout(() => {\n      this.retryTimeout = null;\n      this.connect();\n    }, delay);\n  }\n\n  private getBackoffDelay(): number {\n    const delay = this.retryDelay * Math.pow(2, this.retryCount);\n    const jitter = delay * 0.25 * (Math.random() * 2 - 1);\n    return Math.min(delay + jitter, this.maxRetryDelay);\n  }\n}\n","import { SSEManager } from './sse';\nimport type {\n  FlagValue,\n  FlaggyContext,\n  FlaggyClientOptions,\n  EvaluateResponse,\n  BatchEvaluateResponse,\n  FlagChangeEvent,\n  FlagChangeListener,\n  ReadyListener,\n  ErrorListener,\n} from './types';\n\ntype EventMap = {\n  change: FlagChangeListener;\n  ready: ReadyListener;\n  error: ErrorListener;\n};\n\nexport class FlaggyClient {\n  private readonly serverUrl: string;\n  private readonly apiKey: string;\n  private readonly enableStreaming: boolean;\n  private readonly sseRetryDelay: number;\n  private readonly sseMaxRetryDelay: number;\n\n  private context: FlaggyContext;\n  private cache = new Map<string, FlagValue>();\n  private _ready = false;\n  private _error: Error | null = null;\n  private sseManager: SSEManager | null = null;\n  private contextAbortController: AbortController | null = null;\n\n  private listeners: {\n    change: Set<FlagChangeListener>;\n    ready: Set<ReadyListener>;\n    error: Set<ErrorListener>;\n  } = {\n    change: new Set(),\n    ready: new Set(),\n    error: new Set(),\n  };\n\n  constructor(options: FlaggyClientOptions) {\n    this.serverUrl = options.serverUrl.replace(/\\/$/, '');\n    this.apiKey = options.apiKey;\n    this.context = options.context ?? {};\n    this.enableStreaming = options.enableStreaming ?? true;\n    this.sseRetryDelay = options.sseRetryDelay ?? 1000;\n    this.sseMaxRetryDelay = options.sseMaxRetryDelay ?? 30_000;\n  }\n\n  get ready(): boolean {\n    return this._ready;\n  }\n\n  get error(): Error | null {\n    return this._error;\n  }\n\n  async initialize(): Promise<void> {\n    try {\n      const response = await this.fetchApi<BatchEvaluateResponse>(\n        '/api/v1/evaluate/batch',\n        { context: this.context },\n      );\n      this.applyBatchResult(response);\n      this._ready = true;\n      this.emit('ready');\n    } catch (err: unknown) {\n      this._error = err instanceof Error ? err : new Error(String(err));\n      this.emit('error', this._error);\n    }\n\n    if (this.enableStreaming) {\n      this.startSSE();\n    }\n  }\n\n  getFlag<T extends FlagValue>(key: string, defaultValue: T): T {\n    if (!this._ready || !this.cache.has(key)) {\n      return defaultValue;\n    }\n    return this.cache.get(key) as T;\n  }\n\n  async setContext(context: FlaggyContext): Promise<void> {\n    this.context = context;\n    this.contextAbortController?.abort();\n    const controller = new AbortController();\n    this.contextAbortController = controller;\n\n    try {\n      const response = await this.fetchApi<BatchEvaluateResponse>(\n        '/api/v1/evaluate/batch',\n        { context },\n        controller.signal,\n      );\n      if (controller.signal.aborted) return;\n      this.applyBatchResult(response);\n    } catch (err: unknown) {\n      if (err instanceof Error && err.name === 'AbortError') return;\n      this._error = err instanceof Error ? err : new Error(String(err));\n      this.emit('error', this._error);\n    }\n  }\n\n  on<E extends keyof EventMap>(event: E, listener: EventMap[E]): () => void {\n    (this.listeners[event] as Set<EventMap[E]>).add(listener);\n    return () => {\n      (this.listeners[event] as Set<EventMap[E]>).delete(listener);\n    };\n  }\n\n  destroy(): void {\n    this.sseManager?.destroy();\n    this.sseManager = null;\n    this.contextAbortController?.abort();\n    this.contextAbortController = null;\n    this.listeners.change.clear();\n    this.listeners.ready.clear();\n    this.listeners.error.clear();\n  }\n\n  private startSSE(): void {\n    this.sseManager = new SSEManager({\n      url: `${this.serverUrl}/api/v1/stream`,\n      apiKey: this.apiKey,\n      onEvent: (event) => this.handleSSEEvent(event),\n      onError: (err) => this.emit('error', err),\n      retryDelay: this.sseRetryDelay,\n      maxRetryDelay: this.sseMaxRetryDelay,\n    });\n    this.sseManager.connect();\n  }\n\n  private async handleSSEEvent(event: FlagChangeEvent): Promise<void> {\n    if (event.type === 'flag_deleted') {\n      if (this.cache.has(event.key)) {\n        this.cache.delete(event.key);\n        this.emit('change', event.key, undefined as unknown as FlagValue);\n      }\n      return;\n    }\n\n    // flag_updated or flag_created — re-evaluate this flag\n    try {\n      const response = await this.fetchApi<EvaluateResponse>(\n        '/api/v1/evaluate',\n        { flag_key: event.key, context: this.context },\n      );\n      const oldValue = this.cache.get(event.key);\n      this.cache.set(event.key, response.value);\n      if (oldValue !== response.value) {\n        this.emit('change', event.key, response.value);\n      }\n    } catch {\n      // Failed to re-evaluate, keep previous cached value\n    }\n  }\n\n  private applyBatchResult(response: BatchEvaluateResponse): void {\n    const newCache = new Map<string, FlagValue>();\n    for (const flag of response.results) {\n      newCache.set(flag.flag_key, flag.value);\n    }\n\n    // Emit changes for any values that differ\n    for (const [key, newValue] of newCache) {\n      const oldValue = this.cache.get(key);\n      if (oldValue !== newValue) {\n        this.emit('change', key, newValue);\n      }\n    }\n\n    // Emit changes for keys that were removed\n    for (const key of this.cache.keys()) {\n      if (!newCache.has(key)) {\n        this.emit('change', key, undefined as unknown as FlagValue);\n      }\n    }\n\n    this.cache = newCache;\n  }\n\n  private emit(event: 'change', key: string, value: FlagValue): void;\n  private emit(event: 'ready'): void;\n  private emit(event: 'error', error: Error): void;\n  private emit(event: keyof EventMap, ...args: unknown[]): void {\n    if (event === 'change') {\n      for (const listener of this.listeners.change) {\n        listener(args[0] as string, args[1] as FlagValue);\n      }\n    } else if (event === 'ready') {\n      for (const listener of this.listeners.ready) {\n        listener();\n      }\n    } else if (event === 'error') {\n      for (const listener of this.listeners.error) {\n        listener(args[0] as Error);\n      }\n    }\n  }\n\n  private async fetchApi<T>(\n    path: string,\n    body: unknown,\n    signal?: AbortSignal,\n  ): Promise<T> {\n    const response = await fetch(`${this.serverUrl}${path}`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        Authorization: `Bearer ${this.apiKey}`,\n      },\n      body: JSON.stringify(body),\n      signal,\n    });\n    if (!response.ok) {\n      throw new Error(`Flaggy API error: ${response.status} ${response.statusText}`);\n    }\n    return response.json() as Promise<T>;\n  }\n}\n","import { createContext } from 'react';\nimport type { FlaggyClient } from '../client';\n\nexport interface FlaggyContextValue {\n  client: FlaggyClient;\n  ready: boolean;\n  error: Error | null;\n}\n\nexport const FlaggyReactContext = createContext<FlaggyContextValue | null>(null);\n","import { useContext } from 'react';\nimport { FlaggyReactContext } from './context';\nimport type { FlagValue } from '../types';\n\nexport function useFlag<T extends FlagValue>(key: string, defaultValue: T): T {\n  const ctx = useContext(FlaggyReactContext);\n\n  if (!ctx) {\n    return defaultValue;\n  }\n\n  return ctx.client.getFlag(key, defaultValue);\n}\n","import { useContext } from 'react';\nimport { FlaggyReactContext } from './context';\n\nexport function useFlaggy() {\n  const ctx = useContext(FlaggyReactContext);\n\n  if (!ctx) {\n    throw new Error('[flaggy] useFlaggy() must be used within a <FlaggyProvider>.');\n  }\n\n  return {\n    client: ctx.client,\n    ready: ctx.ready,\n    error: ctx.error,\n  };\n}\n"],"mappings":"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","names":["import_react","import_react","import_react"]}

package/dist/react.d.cts

@@ -0,0 +1,24 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { FlaggyContext, FlagValue, FlaggyClient } from './index.cjs';
+
+interface FlaggyProviderProps {
+    serverUrl: string;
+    apiKey: string;
+    context?: FlaggyContext;
+    enableStreaming?: boolean;
+    /** Called when an error occurs (init failure, SSE error, etc.) */
+    onError?: (error: Error) => void;
+    children: ReactNode;
+}
+declare function FlaggyProvider({ serverUrl, apiKey, context, enableStreaming, onError, children, }: FlaggyProviderProps): react_jsx_runtime.JSX.Element | null;
+
+declare function useFlag<T extends FlagValue>(key: string, defaultValue: T): T;
+
+declare function useFlaggy(): {
+    client: FlaggyClient;
+    ready: boolean;
+    error: Error | null;
+};
+
+export { FlagValue, FlaggyContext as FlaggyEvalContext, FlaggyProvider, type FlaggyProviderProps, useFlag, useFlaggy };

package/dist/react.d.ts

@@ -0,0 +1,24 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { FlaggyContext, FlagValue, FlaggyClient } from './index.js';
+
+interface FlaggyProviderProps {
+    serverUrl: string;
+    apiKey: string;
+    context?: FlaggyContext;
+    enableStreaming?: boolean;
+    /** Called when an error occurs (init failure, SSE error, etc.) */
+    onError?: (error: Error) => void;
+    children: ReactNode;
+}
+declare function FlaggyProvider({ serverUrl, apiKey, context, enableStreaming, onError, children, }: FlaggyProviderProps): react_jsx_runtime.JSX.Element | null;
+
+declare function useFlag<T extends FlagValue>(key: string, defaultValue: T): T;
+
+declare function useFlaggy(): {
+    client: FlaggyClient;
+    ready: boolean;
+    error: Error | null;
+};
+
+export { FlagValue, FlaggyContext as FlaggyEvalContext, FlaggyProvider, type FlaggyProviderProps, useFlag, useFlaggy };