@barricador/react-client 0.2.0 → 0.3.0

package/dist/BarricadorProvider.d.ts

@@ -5,6 +5,7 @@ export interface BarricadorProviderProps {
     user: UserContext;
     baseUrl?: string;
     streaming?: boolean;
+    pollIntervalMs?: number;
     telemetry?: boolean;
     flushIntervalMs?: number;
     /** Optionally gate children until the first evaluation completes. */
@@ -17,4 +18,4 @@ export interface BarricadorProviderProps {
  * render immediately and flags resolve to their fallbacks until the first eval lands (unless a
  * `fallback` node is provided to gate on readiness).
  */
-export declare function BarricadorProvider({ clientKey, user, baseUrl, streaming, telemetry, flushIntervalMs, fallback, children, }: BarricadorProviderProps): import("react").JSX.Element;
+export declare function BarricadorProvider({ clientKey, user, baseUrl, streaming, pollIntervalMs, telemetry, flushIntervalMs, fallback, children, }: BarricadorProviderProps): import("react").JSX.Element;

package/dist/BarricadorProvider.js

@@ -8,7 +8,7 @@ import { BarricadorStore } from "./store";
  * render immediately and flags resolve to their fallbacks until the first eval lands (unless a
  * `fallback` node is provided to gate on readiness).
  */
-export function BarricadorProvider({ clientKey, user, baseUrl, streaming, telemetry, flushIntervalMs, fallback, children, }) {
+export function BarricadorProvider({ clientKey, user, baseUrl, streaming, pollIntervalMs, telemetry, flushIntervalMs, fallback, children, }) {
     const storeRef = useRef(null);
     if (storeRef.current === null) {
         storeRef.current = new BarricadorStore({
@@ -16,6 +16,7 @@ export function BarricadorProvider({ clientKey, user, baseUrl, streaming, teleme
             user,
             baseUrl,
             streaming,
+            pollIntervalMs,
             telemetry,
             flushIntervalMs,
         });

package/dist/store.d.ts

@@ -17,6 +17,7 @@ export declare class BarricadorStore {
     private readonly streaming;
     private readonly telemetry;
     private readonly flushIntervalMs;
+    private readonly pollIntervalMs;
     private values;
     private status;
     /** Per-key listeners so a component only re-renders when *its* flag changes. */
@@ -25,7 +26,10 @@ export declare class BarricadorStore {
     private readonly evalCounts;
     private eventSource;
     private flushTimer;
+    private pollTimer;
     private closed;
+    /** Avoid spamming the console on every reconnect/refresh failure. */
+    private warnedEvalFailure;
     constructor(options: BarricadorClientOptions);
     start(): Promise<void>;
     /** Re-post the user context and swap in the freshly evaluated values. */

package/dist/store.js

@@ -18,7 +18,10 @@ export class BarricadorStore {
         this.evalCounts = new Map();
         this.eventSource = null;
         this.flushTimer = null;
+        this.pollTimer = null;
         this.closed = false;
+        /** Avoid spamming the console on every reconnect/refresh failure. */
+        this.warnedEvalFailure = false;
         if (!options.clientKey)
             throw new Error("clientKey is required");
         if (!options.user?.key)
@@ -26,14 +29,22 @@ export class BarricadorStore {
         this.clientKey = options.clientKey;
         this.user = options.user;
         this.baseUrl = (options.baseUrl ?? "https://app.barricador.com").replace(/\/$/, "");
-        this.streaming = options.streaming ?? true;
+        // Polling by default. An open EventSource is billed as continuous backend instance time, and a
+        // browser SDK opens one per tab — so streaming every session made idle users cost as much as
+        // active ones. Opt in with `streaming` where sub-second propagation matters.
+        this.streaming = options.streaming ?? false;
         this.telemetry = options.telemetry ?? true;
         this.flushIntervalMs = options.flushIntervalMs ?? 30000;
+        this.pollIntervalMs = options.pollIntervalMs ?? 30000;
     }
     async start() {
         await this.refresh();
-        if (this.streaming)
+        if (this.streaming) {
             this.connectStream();
+        }
+        else if (typeof setInterval !== "undefined") {
+            this.pollTimer = setInterval(() => void this.refresh(), this.pollIntervalMs);
+        }
         if (this.telemetry && typeof setInterval !== "undefined") {
             this.flushTimer = setInterval(() => void this.flush(), this.flushIntervalMs);
         }
@@ -54,9 +65,23 @@ export class BarricadorStore {
             const body = (await res.json());
             this.applyValues(body.values ?? {});
             this.setStatus("ready");
+            this.warnedEvalFailure = false;
         }
-        catch {
+        catch (err) {
             // Network/eval failure: keep last values; hooks fall back to defaults. Never throw.
+            // CORS preflight rejection (origin not on BARRICADOR_CORS_ORIGINS) surfaces as a
+            // TypeError/"Failed to fetch" with no response — identical to a missing key from the
+            // caller's perspective — so surface a one-shot console hint.
+            if (!this.warnedEvalFailure && typeof console !== "undefined") {
+                this.warnedEvalFailure = true;
+                const origin = typeof globalThis !== "undefined" && "location" in globalThis
+                    ? String(globalThis.location?.origin ?? "")
+                    : "";
+                console.warn(`[barricador] flag eval failed (${err instanceof Error ? err.message : String(err)}). ` +
+                    `Flags will use their fallback defaults. If this is a browser app, confirm that ` +
+                    `${origin || "this page's Origin"} is listed in BARRICADOR_CORS_ORIGINS on the ` +
+                    `Barricador backend (CORS preflight 403 looks like a network failure here).`);
+            }
             this.setStatus(this.status === "initializing" ? "offline" : this.status);
         }
     }
@@ -154,6 +179,8 @@ export class BarricadorStore {
         this.closed = true;
         if (this.flushTimer)
             clearInterval(this.flushTimer);
+        if (this.pollTimer)
+            clearInterval(this.pollTimer);
         this.eventSource?.close();
         void this.flush();
     }

package/dist/types.d.ts

@@ -14,7 +14,14 @@ export interface BarricadorClientOptions {
     user: UserContext;
     baseUrl?: string;
     /** Enable the live SSE connection (default true). */
+    /**
+     * Hold an EventSource open for near-instant flag propagation. Defaults to false: a held-open
+     * stream is billed as continuous backend instance time, per browser tab. When false the store
+     * re-evaluates every `pollIntervalMs`.
+     */
     streaming?: boolean;
+    /** How often to re-evaluate flags when `streaming` is false. Default 30000ms. */
+    pollIntervalMs?: number;
     /** Enable async telemetry flushing (default true). */
     telemetry?: boolean;
     /** Telemetry flush cadence in ms (default 30000). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barricador/react-client",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Barricador client-side React SDK (pre-evaluated context model, SSE sync, telemetry)",
   "type": "module",
   "main": "dist/index.js",