@flagward/react 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brian Suárez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,196 @@
+# @flagward/react
+
+React SDK for Flagward - Feature Flags as a Service
+
+> Published as `flagward-sdk-react` up to 0.2.0. Same package, same API — it
+> moved into the `@flagward` scope so every SDK in this family shares one
+> namespace the project actually owns. Change the name in your `package.json`
+> and the import; nothing else.
+
+## Installation
+
+```bash
+npm install @flagward/react
+```
+
+## Quick Start
+
+```tsx
+import { FlagwardProvider, useFlag } from "@flagward/react";
+
+function App() {
+  return (
+    <FlagwardProvider apiKey="your-api-key">
+      <Dashboard />
+    </FlagwardProvider>
+  );
+}
+
+function Dashboard() {
+  const { value: showNewUI } = useFlag("show-new-ui");
+
+  return showNewUI ? <NewDashboard /> : <OldDashboard />;
+}
+```
+
+## Module format
+
+This package ships as **ESM only** (`"type": "module"`, with an `exports` map
+pointing at `dist/index.js`). It has no CommonJS build: `require("@flagward/react")`
+fails with a clear `ERR_PACKAGE_PATH_NOT_EXPORTED`/`ERR_REQUIRE_ESM` error
+rather than silently loading broken code. Next.js, Vite, and any other
+bundler-based toolchain resolve ESM packages natively, which covers the
+realistic ways a React SDK gets consumed. If you have a pure CommonJS
+build pipeline with no ESM support, `import()` the package dynamically or
+open an issue.
+
+## How flags are evaluated
+
+This SDK evaluates **locally, in the browser**. On startup it downloads the
+full set of flags and their targeting rules for the environment your API key
+belongs to, then evaluates each flag against the rules on the client. A
+Server-Sent Events (SSE) stream keeps that local copy fresh as flags change on
+the server, without a page reload (see "Losing the network" below for what
+happens when that stream drops).
+
+This has a direct consequence you must know before writing a targeting rule:
+**the rules are visible in the browser.** Anything you put in a rule
+(condition values, user attribute names, percentages, etc.) is downloaded as
+plain JSON to every client and can be read by opening devtools. Do not encode
+secrets, internal identifiers you don't want exposed, or anything
+security-sensitive in a flag's targeting rules — treat them the same way you'd
+treat any other client-side configuration.
+
+## Hooks
+
+### `useFlag(key)`
+
+Evaluates a single flag by key.
+
+```tsx
+const { value, isLoading, error } = useFlag("new-dashboard");
+```
+
+Returns:
+- `value`: `boolean | string | undefined`
+- `isLoading`: `boolean`
+- `error`: `Error | null`
+
+### `useFlags()`
+
+Returns all flags and helper functions.
+
+```tsx
+const { flags, getFlag, isLoading } = useFlags();
+
+const showBanner = getFlag("show-banner");
+```
+
+## Provider
+
+Wrap your app with `FlagwardProvider`:
+
+```tsx
+<FlagwardProvider
+  apiKey="your-api-key"
+  host="http://localhost:8000"  // optional, defaults to localhost:8000
+  context={{ userId: "123" }}   // optional, used to evaluate targeting rules
+  logLevel="warn"               // optional, see Error reporting below
+>
+  {children}
+</FlagwardProvider>
+```
+
+## Losing the network
+
+Flags are read once and evaluated locally, so a client that loses its
+connection keeps working: every flag answers from its last known value.
+
+What it cannot do while disconnected is notice a change. When the browser
+reports the network is back, the SDK re-reads the flags and reopens the update
+stream if the browser had given up on it, so a change made during the outage is
+picked up rather than waiting for the next reload.
+
+A stream that is still open is left alone: replacing a working connection would
+drop events for no reason.
+
+Returning to a backgrounded tab does the same. A machine waking from sleep
+drops its connection without the browser ever reporting the network as gone, so
+`online` never fires and the tab comes back holding whatever it knew before it
+slept. Both signals share one in-flight refresh, so arriving together does not
+produce two.
+
+## Error reporting
+
+The SDK never throws into your application. A rejected API key, an unreachable
+server or an unknown flag all resolve to `undefined`, so your own fallback
+decides what the user sees and the page keeps rendering.
+
+Because none of that surfaces on its own, the SDK reports it to the console
+instead:
+
+```
+[Flagward] The API key was rejected. Check that it matches an environment in
+your Flagward dashboard.
+```
+
+Each distinct problem is reported once per page load, so a component that
+re-renders a hundred times does not produce a hundred lines.
+
+`logLevel` controls how much is reported:
+
+| Value | Reports |
+|-------|---------|
+| `"warn"` (default) | everything: unknown flags, dropped streams, network failures |
+| `"error"` | only what cannot work at all: a missing or rejected API key, a missing provider |
+| `"silent"` | nothing |
+
+## The core
+
+Everything that is not React lives in
+[`@flagward/core`](https://www.npmjs.com/package/@flagward/core) — the client,
+the rule evaluator and the reporting — and is re-exported from this package, so
+installing this one is enough. Reach for the core directly only outside React.
+
+## Standalone Client
+
+Use the client directly without React:
+
+```ts
+import { FlagwardClient } from "@flagward/react";
+
+const client = new FlagwardClient({
+  apiKey: "your-api-key",
+  host: "http://localhost:8000",
+});
+
+await client.init();
+
+// Every flag's configured on/off state, from the local snapshot.
+// Targeting rules are NOT applied here -- there is no user context to
+// apply them against.
+const flags = client.cachedFlags;
+
+// One flag with targeting rules applied against the context you pass.
+// Throws if the key does not exist in this environment.
+const showBanner = client.evaluate("show-banner", { plan: "premium" });
+
+// The same, without context and without throwing: an unknown key reads
+// as undefined and your own fallback decides what happens.
+const maintenance = client.getFlag("maintenance-mode");
+
+// Optional: keep the snapshot fresh via the SSE stream.
+client.connect();
+
+// Close it when you are done -- an open stream holds a connection.
+client.disconnect();
+```
+
+`cachedFlags` and `evaluate` answer different questions. The first says how a
+flag is configured; the second says what it resolves to for a particular user.
+Reaching for `cachedFlags` when you meant `evaluate` silently ignores every
+targeting rule on the flag.
+
+## License
+
+MIT

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+import { FlagwardClient } from "@flagward/core";
+import type { FlagDataMap, UserContext } from "@flagward/core";
+export interface FlagwardContextValue {
+    client: FlagwardClient | null;
+    /** The flag data this render was produced from. */
+    flagsData: FlagDataMap;
+    isLoading: boolean;
+    error: Error | null;
+    context: UserContext;
+}
+export declare const FlagwardContext: import("react").Context<FlagwardContextValue>;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9B,mDAAmD;IACnD,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,WAAW,CAAC;CACtB;AAED,eAAO,MAAM,eAAe,+CAM1B,CAAC"}

package/dist/context.js

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+export const FlagwardContext = createContext({
+    client: null,
+    flagsData: {},
+    isLoading: false,
+    error: null,
+    context: {},
+});
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAatC,MAAM,CAAC,MAAM,eAAe,GAAG,aAAa,CAAuB;IACjE,MAAM,EAAE,IAAI;IACZ,SAAS,EAAE,EAAE;IACb,SAAS,EAAE,KAAK;IAChB,KAAK,EAAE,IAAI;IACX,OAAO,EAAE,EAAE;CACZ,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { FlagwardClient, evaluateFlag, toFlagMap, } from "@flagward/core";
+export type { Condition, Flag, FlagData, FlagDataMap, FlagMap, FlagwardClientOptions, LogLevel, Logger, Rule, UserContext, } from "@flagward/core";
+export { FlagwardProvider } from "./provider.js";
+export type { FlagwardProviderProps } from "./provider.js";
+export { useFlag } from "./useFlag.js";
+export type { UseFlagResult } from "./useFlag.js";
+export { useFlags } from "./useFlags.js";
+export type { UseFlagsResult } from "./useFlags.js";
+export { SDK_VERSION } from "./version.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,cAAc,EACd,YAAY,EACZ,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,SAAS,EACT,IAAI,EACJ,QAAQ,EACR,WAAW,EACX,OAAO,EACP,qBAAqB,EACrB,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,WAAW,GACZ,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG3D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+// The framework-agnostic core, re-exported so a consumer of this package never
+// has to install @flagward/core to reach the client, the evaluator or the types.
+export { FlagwardClient, evaluateFlag, toFlagMap, } from "@flagward/core";
+// Provider
+export { FlagwardProvider } from "./provider.js";
+// Hooks
+export { useFlag } from "./useFlag.js";
+export { useFlags } from "./useFlags.js";
+// The version this adapter registers with
+export { SDK_VERSION } from "./version.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,iFAAiF;AACjF,OAAO,EACL,cAAc,EACd,YAAY,EACZ,SAAS,GACV,MAAM,gBAAgB,CAAC;AAcxB,WAAW;AACX,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGjD,QAAQ;AACR,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,0CAA0C;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/provider.d.ts

@@ -0,0 +1,11 @@
+import type { LogLevel, UserContext } from "@flagward/core";
+export interface FlagwardProviderProps {
+    apiKey: string;
+    host?: string;
+    context?: UserContext;
+    /** How much the SDK reports to the console. Defaults to "warn". */
+    logLevel?: LogLevel;
+    children: React.ReactNode;
+}
+export declare function FlagwardProvider({ apiKey, host, context: userContext, logLevel, children, }: FlagwardProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAe,QAAQ,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAczE,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,MAAM,EACN,IAAI,EACJ,OAAO,EAAE,WAAgB,EACzB,QAAQ,EACR,QAAQ,GACT,EAAE,qBAAqB,+BAsEvB"}

package/dist/provider.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { FlagwardClient } from "@flagward/core";
+import { FlagwardContext } from "./context.js";
+import { SDK_VERSION } from "./version.js";
+/**
+ * How this adapter names itself at registration.
+ *
+ * Not yet one of the server's stored choices, which is why the dashboard shows
+ * it as its own row rather than folding it into JavaScript. It is named here
+ * so that, once the server records adapters, a React application is already
+ * distinguishable from a Vue one without changing what anybody has installed.
+ */
+const SDK_TYPE = "REACT";
+export function FlagwardProvider({ apiKey, host, context: userContext = {}, logLevel, children, }) {
+    const [client] = useState(() => new FlagwardClient({
+        apiKey,
+        host,
+        logLevel,
+        sdkType: SDK_TYPE,
+        sdkVersion: SDK_VERSION,
+    }));
+    // The flag data lives in React state, not in the client's mutable field,
+    // so what a hook renders is what triggered the render.
+    const [flagsData, setFlagsData] = useState({});
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const initClient = async () => {
+            try {
+                await client.init();
+                setFlagsData(client.snapshot);
+            }
+            catch (err) {
+                // Startup failing is never fatal to the host application: the tree
+                // still renders and every flag reads as undefined, so each caller's
+                // own fallback decides what the user sees.
+                client.logger.warn("init-failed", "Could not load flags, so every flag falls back to undefined and " +
+                    "your own defaults apply. The cause is reported above.");
+                setError(err instanceof Error ? err : new Error(String(err)));
+            }
+            finally {
+                // Outside the try on purpose: a startup that failed is exactly when
+                // the stream and the connectivity watcher matter most, and leaving
+                // them behind the success path meant a client that started offline
+                // could never recover.
+                client.connect();
+                setIsLoading(false);
+            }
+        };
+        initClient();
+        const unsubscribe = client.subscribe((snapshot) => {
+            setFlagsData(snapshot);
+            // Flags arriving means the client is talking to the server again. Leaving
+            // a past failure in state would keep every consumer that checks `error`
+            // showing a problem that is over.
+            setError(null);
+        });
+        return () => {
+            unsubscribe();
+            client.destroy();
+        };
+    }, [client]);
+    const value = {
+        client,
+        flagsData,
+        isLoading,
+        error,
+        context: userContext,
+    };
+    return (_jsx(FlagwardContext.Provider, { value: value, children: children }));
+}
+//# sourceMappingURL=provider.js.map

package/dist/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,eAAe,EAA6B,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,QAAQ,GAAG,OAAO,CAAC;AAWzB,MAAM,UAAU,gBAAgB,CAAC,EAC/B,MAAM,EACN,IAAI,EACJ,OAAO,EAAE,WAAW,GAAG,EAAE,EACzB,QAAQ,EACR,QAAQ,GACc;IACtB,MAAM,CAAC,MAAM,CAAC,GAAG,QAAQ,CACvB,GAAG,EAAE,CAAC,IAAI,cAAc,CAAC;QACvB,MAAM;QACN,IAAI;QACJ,QAAQ;QACR,OAAO,EAAE,QAAQ;QACjB,UAAU,EAAE,WAAW;KACxB,CAAC,CACH,CAAC;IACF,yEAAyE;IACzE,uDAAuD;IACvD,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAc,EAAE,CAAC,CAAC;IAC5D,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjD,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAe,IAAI,CAAC,CAAC;IAEvD,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,UAAU,GAAG,KAAK,IAAI,EAAE;YAC5B,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;gBACpB,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,mEAAmE;gBACnE,oEAAoE;gBACpE,2CAA2C;gBAC3C,MAAM,CAAC,MAAM,CAAC,IAAI,CAChB,aAAa,EACb,kEAAkE;oBAChE,uDAAuD,CAC1D,CAAC;gBACF,QAAQ,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAChE,CAAC;oBAAS,CAAC;gBACT,oEAAoE;gBACpE,mEAAmE;gBACnE,mEAAmE;gBACnE,uBAAuB;gBACvB,MAAM,CAAC,OAAO,EAAE,CAAC;gBACjB,YAAY,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;QACH,CAAC,CAAC;QAEF,UAAU,EAAE,CAAC;QAEb,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;YAChD,YAAY,CAAC,QAAQ,CAAC,CAAC;YACvB,0EAA0E;YAC1E,wEAAwE;YACxE,kCAAkC;YAClC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC,CAAC,CAAC;QAEH,OAAO,GAAG,EAAE;YACV,WAAW,EAAE,CAAC;YACd,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEb,MAAM,KAAK,GAAyB;QAClC,MAAM;QACN,SAAS;QACT,SAAS;QACT,KAAK;QACL,OAAO,EAAE,WAAW;KACrB,CAAC;IAEF,OAAO,CACL,KAAC,eAAe,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YACnC,QAAQ,GACgB,CAC5B,CAAC;AACJ,CAAC"}

package/dist/useFlag.d.ts

@@ -0,0 +1,9 @@
+import type { UserContext } from "@flagward/core";
+export interface UseFlagResult {
+    /** The flag's value, or undefined while loading or if it does not exist. */
+    value: boolean | undefined;
+    isLoading: boolean;
+    error: Error | null;
+}
+export declare function useFlag(key: string, flagContext?: UserContext): UseFlagResult;
+//# sourceMappingURL=useFlag.d.ts.map

package/dist/useFlag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlag.d.ts","sourceRoot":"","sources":["../src/useFlag.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,KAAK,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,aAAa,CAmC7E"}

package/dist/useFlag.js

@@ -0,0 +1,30 @@
+import { useContext } from "react";
+import { FlagwardContext } from "./context.js";
+import { createLogger, evaluateFlag } from "@flagward/core";
+export function useFlag(key, flagContext) {
+    const context = useContext(FlagwardContext);
+    const logger = context.client?.logger ?? createLogger();
+    // Merge provider context with flag-specific context
+    const mergedContext = { ...context.context, ...flagContext };
+    let value;
+    if (!context.client) {
+        logger.error("no-provider", `useFlag("${key}") was called outside FlagwardProvider, so it can only ` +
+            "return undefined. Wrap the tree in <FlagwardProvider>.");
+    }
+    else if (!context.isLoading) {
+        // Evaluated against the data this render was produced from, so the value
+        // shown and the update that caused it can never disagree.
+        value = evaluateFlag(context.flagsData[key], mergedContext);
+        if (value === undefined) {
+            logger.warn(`unknown-flag:${key}`, `Flag "${key}" is not in this environment, so it reads as undefined. ` +
+                "Check the key, and that the flag exists in the environment this " +
+                "API key belongs to.");
+        }
+    }
+    return {
+        value,
+        isLoading: context.isLoading,
+        error: context.error,
+    };
+}
+//# sourceMappingURL=useFlag.js.map

package/dist/useFlag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlag.js","sourceRoot":"","sources":["../src/useFlag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAU5D,MAAM,UAAU,OAAO,CAAC,GAAW,EAAE,WAAyB;IAC5D,MAAM,OAAO,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,MAAM,IAAI,YAAY,EAAE,CAAC;IAExD,oDAAoD;IACpD,MAAM,aAAa,GAAG,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,GAAG,WAAW,EAAE,CAAC;IAE7D,IAAI,KAA0B,CAAC;IAE/B,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,KAAK,CACV,aAAa,EACb,YAAY,GAAG,yDAAyD;YACtE,wDAAwD,CAC3D,CAAC;IACJ,CAAC;SAAM,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QAC9B,yEAAyE;QACzE,0DAA0D;QAC1D,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAC;QAE5D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,CAAC,IAAI,CACT,gBAAgB,GAAG,EAAE,EACrB,SAAS,GAAG,0DAA0D;gBACpE,kEAAkE;gBAClE,qBAAqB,CACxB,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO;QACL,KAAK;QACL,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;KACrB,CAAC;AACJ,CAAC"}

package/dist/useFlags.d.ts

@@ -0,0 +1,9 @@
+import type { FlagMap, UserContext } from "@flagward/core";
+export interface UseFlagsResult {
+    flags: FlagMap;
+    isLoading: boolean;
+    error: Error | null;
+    getFlag: (key: string, flagContext?: UserContext) => boolean | undefined;
+}
+export declare function useFlags(): UseFlagsResult;
+//# sourceMappingURL=useFlags.d.ts.map

package/dist/useFlags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlags.d.ts","sourceRoot":"","sources":["../src/useFlags.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,KAAK,OAAO,GAAG,SAAS,CAAC;CAC1E;AAED,wBAAgB,QAAQ,IAAI,cAAc,CAkCzC"}

package/dist/useFlags.js

@@ -0,0 +1,28 @@
+import { useContext } from "react";
+import { FlagwardContext } from "./context.js";
+import { createLogger, evaluateFlag, toFlagMap } from "@flagward/core";
+export function useFlags() {
+    const context = useContext(FlagwardContext);
+    const logger = context.client?.logger ?? createLogger();
+    if (!context.client) {
+        logger.error("no-provider", "useFlags() was called outside FlagwardProvider, so it can only return " +
+            "an empty set. Wrap the tree in <FlagwardProvider>.");
+    }
+    const getFlag = (key, flagContext) => {
+        const mergedContext = { ...context.context, ...flagContext };
+        const value = evaluateFlag(context.flagsData[key], mergedContext);
+        if (value === undefined) {
+            logger.warn(`unknown-flag:${key}`, `Flag "${key}" is not in this environment, so it reads as undefined. ` +
+                "Check the key, and that the flag exists in the environment this " +
+                "API key belongs to.");
+        }
+        return value;
+    };
+    return {
+        flags: toFlagMap(context.flagsData, context.context),
+        isLoading: context.isLoading,
+        error: context.error,
+        getFlag,
+    };
+}
+//# sourceMappingURL=useFlags.js.map

package/dist/useFlags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlags.js","sourceRoot":"","sources":["../src/useFlags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAUvE,MAAM,UAAU,QAAQ;IACtB,MAAM,OAAO,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,MAAM,IAAI,YAAY,EAAE,CAAC;IAExD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,KAAK,CACV,aAAa,EACb,wEAAwE;YACtE,oDAAoD,CACvD,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,CAAC,GAAW,EAAE,WAAyB,EAAuB,EAAE;QAC9E,MAAM,aAAa,GAAG,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,GAAG,WAAW,EAAE,CAAC;QAC7D,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAC;QAElE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,CAAC,IAAI,CACT,gBAAgB,GAAG,EAAE,EACrB,SAAS,GAAG,0DAA0D;gBACpE,kEAAkE;gBAClE,qBAAqB,CACxB,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,OAAO;QACL,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC;QACpD,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The version this package reports when it registers with the server.
+ *
+ * GENERATED by scripts/sync-version.mjs from package.json. Do not edit: the
+ * next build overwrites it, and a test fails if the two disagree.
+ */
+export declare const SDK_VERSION = "0.2.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,UAAU,CAAC"}

package/dist/version.js

@@ -0,0 +1,8 @@
+/**
+ * The version this package reports when it registers with the server.
+ *
+ * GENERATED by scripts/sync-version.mjs from package.json. Do not edit: the
+ * next build overwrites it, and a test fails if the two disagree.
+ */
+export const SDK_VERSION = "0.2.0";
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@flagward/react",
+  "version": "0.2.0",
+  "description": "React SDK for Flagward - Feature Flags as a Service",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "node ../../scripts/sync-version.mjs",
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "prepublishOnly": "npm run build --prefix ../core && npm run lint && npm run test:run && npm run build"
+  },
+  "keywords": [
+    "feature-flags",
+    "flags",
+    "react",
+    "sdk",
+    "flagward"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/basb7/flagward-sdk-js.git",
+    "directory": "packages/react"
+  },
+  "homepage": "https://github.com/basb7/flagward-sdk-js/tree/main/packages/react#readme",
+  "bugs": {
+    "url": "https://github.com/basb7/flagward-sdk-js/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@flagward/core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.0.0",
+    "@testing-library/react": "^16.0.0",
+    "@types/node": "^22.20.1",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^6.1.0",
+    "jsdom": "^25.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}