wolves-react-client 1.0.0

package/README.md

@@ -0,0 +1,367 @@
+# Wolves React Client SDK
+
+React SDK for the Wolves A/B Testing & Experimentation Platform. This library provides React hooks and components for easy integration of Wolves into your React applications.
+
+## Features
+
+- 🎣 **React Hooks** - `useExperiment`, `useWolvesClient`, `useWolvesEvent`
+- ⚡ **Fast Initialization** - Async and sync initialization modes with caching
+- 🔄 **Automatic Exposure Logging** - Experiments automatically log exposures
+- 📦 **TypeScript Support** - Full TypeScript type definitions
+- 🌐 **SSR Compatible** - Works with Next.js and other SSR frameworks
+- 🎯 **Zero Config** - Works out of the box with sensible defaults
+
+## Installation
+
+```bash
+npm install wolves-react-client wolves-js-client react
+```
+
+or with yarn:
+
+```bash
+yarn add wolves-react-client wolves-js-client react
+```
+
+## Quick Start
+
+### 1. Wrap your app with WolvesProvider
+
+```tsx
+import { WolvesProvider } from 'wolves-react-client';
+
+function App() {
+  const user = {
+    userID: 'user-123',
+    email: 'user@example.com',
+  };
+
+  return (
+    <WolvesProvider sdkKey="your-sdk-key" user={user}>
+      <YourApp />
+    </WolvesProvider>
+  );
+}
+```
+
+### 2. Use experiments in your components
+
+```tsx
+import { useExperiment } from 'wolves-react-client';
+
+function FeatureComponent() {
+  const experiment = useExperiment('my-experiment');
+  
+  const buttonColor = experiment.get('button_color', 'blue');
+  const buttonText = experiment.get('button_text', 'Click Me');
+
+  return (
+    <button style={{ backgroundColor: buttonColor }}>
+      {buttonText}
+    </button>
+  );
+}
+```
+
+### 3. Log custom events
+
+```tsx
+import { useWolvesEvent } from 'wolves-react-client';
+
+function CheckoutButton() {
+  const { logEvent } = useWolvesEvent();
+
+  const handleCheckout = () => {
+    logEvent('checkout_completed', 99.99, {
+      currency: 'USD',
+      items: '3',
+    });
+  };
+
+  return <button onClick={handleCheckout}>Checkout</button>;
+}
+```
+
+## API Reference
+
+### WolvesProvider
+
+The root component that initializes the Wolves client and provides context to child components.
+
+#### Props
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `sdkKey` | `string` | Yes | Your Wolves SDK key |
+| `user` | `WolvesUser` | Yes | User identification and attributes |
+| `children` | `React.ReactNode` | Yes | Child components |
+| `options` | `WolvesProviderOptions` | No | Configuration options |
+| `waitForInitialization` | `boolean` | No | Wait for init before rendering children |
+| `loadingComponent` | `React.ReactNode` | No | Component to show while loading |
+
+#### Example with Options
+
+```tsx
+<WolvesProvider
+  sdkKey="your-sdk-key"
+  user={{ userID: 'user-123' }}
+  options={{
+    initMode: 'async',
+    onInitialized: (details) => console.log('Initialized:', details),
+    onError: (error) => console.error('Error:', error),
+  }}
+  waitForInitialization={true}
+  loadingComponent={<LoadingSpinner />}
+>
+  <App />
+</WolvesProvider>
+```
+
+### useExperiment
+
+Hook to access experiment configurations and automatically log exposures.
+
+```tsx
+const experiment = useExperiment<T>(experimentName, options?);
+```
+
+#### Parameters
+
+- `experimentName` (string): Name of the experiment
+- `options` (optional):
+  - `skipExposure` (boolean): Skip automatic exposure logging
+  - `defaultValue` (T): Default value if experiment not found
+
+#### Returns
+
+- `value` (T): The experiment configuration value
+- `groupName` (string | null): The assigned group/variant
+- `experimentID` (string): The experiment ID
+- `get<K>(key, defaultValue)`: Get a specific parameter
+- `isLoading` (boolean): Whether client is still loading
+
+#### Example
+
+```tsx
+function MyComponent() {
+  const experiment = useExperiment('button-test', {
+    defaultValue: { color: 'blue', text: 'Click' }
+  });
+
+  if (experiment.isLoading) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <div>
+      <p>Group: {experiment.groupName}</p>
+      <button style={{ color: experiment.get('color', 'blue') }}>
+        {experiment.get('text', 'Click')}
+      </button>
+    </div>
+  );
+}
+```
+
+### useWolvesClient
+
+Hook to access the Wolves client instance and initialization state.
+
+```tsx
+const { client, isInitialized, isLoading, error, updateUser } = useWolvesClient();
+```
+
+#### Returns
+
+- `client` (WolvesClient | null): The client instance
+- `isInitialized` (boolean): Whether initialization completed
+- `isLoading` (boolean): Whether currently loading
+- `initializationDetails` (WolvesUpdateDetails | null): Init details
+- `error` (Error | null): Any initialization error
+- `updateUser` (function): Function to update the current user
+
+### useWolvesEvent
+
+Hook to log custom events.
+
+```tsx
+const { logEvent } = useWolvesEvent();
+```
+
+#### Returns
+
+- `logEvent(eventName, value?, metadata?)`: Function to log events
+  - `eventName` (string): Event name
+  - `value` (string | number, optional): Event value
+  - `metadata` (Record<string, string>, optional): Event metadata
+
+#### Example
+
+```tsx
+function PurchaseButton() {
+  const { logEvent } = useWolvesEvent();
+
+  const handlePurchase = () => {
+    logEvent('purchase', 49.99, {
+      product_id: 'abc123',
+      category: 'electronics'
+    });
+  };
+
+  return <button onClick={handlePurchase}>Buy Now</button>;
+}
+```
+
+### useWolvesInitialization
+
+Hook to monitor initialization status.
+
+```tsx
+const { isLoading, isReady, loadingStatus, error, details } = useWolvesInitialization();
+```
+
+## Initialization Modes
+
+### Async Mode (Default)
+
+Loads from cache first (if available), then fetches from network. Waits for network response before completing initialization.
+
+```tsx
+<WolvesProvider
+  sdkKey="your-sdk-key"
+  user={user}
+  options={{ initMode: 'async' }}
+>
+  <App />
+</WolvesProvider>
+```
+
+### Sync Mode
+
+Immediately loads from cache and starts rendering. Fetches from network in the background to update cache for next session.
+
+```tsx
+<WolvesProvider
+  sdkKey="your-sdk-key"
+  user={user}
+  options={{ 
+    initMode: 'sync',
+    syncOptions: {
+      disableBackgroundCacheRefresh: false
+    }
+  }}
+>
+  <App />
+</WolvesProvider>
+```
+
+## Server-Side Rendering (SSR)
+
+The SDK is SSR-compatible and works with Next.js and other SSR frameworks.
+
+### Next.js App Router Example
+
+```tsx
+// app/layout.tsx
+'use client';
+
+import { WolvesProvider } from 'wolves-react-client';
+
+export default function RootLayout({ children }) {
+  return (
+    <html>
+      <body>
+        <WolvesProvider
+          sdkKey={process.env.NEXT_PUBLIC_WOLVES_SDK_KEY!}
+          user={{ userID: 'user-123' }}
+        >
+          {children}
+        </WolvesProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+### Next.js Pages Router Example
+
+```tsx
+// pages/_app.tsx
+import { WolvesProvider } from 'wolves-react-client';
+
+function MyApp({ Component, pageProps }) {
+  return (
+    <WolvesProvider
+      sdkKey={process.env.NEXT_PUBLIC_WOLVES_SDK_KEY!}
+      user={{ userID: 'user-123' }}
+    >
+      <Component {...pageProps} />
+    </WolvesProvider>
+  );
+}
+
+export default MyApp;
+```
+
+## TypeScript
+
+The SDK is written in TypeScript and provides full type safety.
+
+```tsx
+interface ButtonExperiment {
+  color: string;
+  text: string;
+  size: 'small' | 'medium' | 'large';
+}
+
+function MyButton() {
+  const experiment = useExperiment<ButtonExperiment>('button-test');
+  
+  // Fully typed!
+  const color = experiment.get('color', 'blue');
+  const size = experiment.get('size', 'medium');
+  
+  return <button>{experiment.value.text}</button>;
+}
+```
+
+## Best Practices
+
+1. **Initialize Once**: Place `WolvesProvider` at the root of your app, not in individual components
+2. **Memoize User**: Use `useMemo` for the user object to prevent unnecessary re-initializations
+3. **Handle Loading States**: Check `isLoading` before rendering experiment-dependent UI
+4. **Use Default Values**: Always provide default values for experiment parameters
+5. **Log Meaningful Events**: Use descriptive event names and include relevant metadata
+
+## Troubleshooting
+
+### Provider Error
+
+If you see "useWolvesClient must be used within WolvesProvider", ensure that your component is a child of `WolvesProvider`.
+
+### SSR Errors
+
+The SDK automatically detects SSR environments and skips initialization on the server. Make sure to use `'use client'` directive in Next.js App Router.
+
+### Experiments Not Loading
+
+- Verify your SDK key is correct
+- Check network requests in browser DevTools
+- Ensure the experiment exists in your Wolves dashboard
+- Check for initialization errors using `useWolvesClient().error`
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+
+- `basic-usage/` - Simple React app example
+- `nextjs-ssr/` - Next.js with SSR support
+- `typescript-example/` - TypeScript with full type safety
+
+## License
+
+ISC
+
+## Support
+
+For issues and questions, please open an issue on GitHub.

package/dist/WolvesContext.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { WolvesClient, WolvesUpdateDetails, WolvesUser } from 'wolves-js-client';
+/**
+ * Context value provided to consuming components.
+ */
+export interface WolvesContextValue {
+    /** The WolvesClient instance, null if not yet initialized */
+    client: WolvesClient | null;
+    /** Whether the client has completed initialization */
+    isInitialized: boolean;
+    /** Whether the client is currently initializing */
+    isLoading: boolean;
+    /** Details from the last initialization/update */
+    initializationDetails: WolvesUpdateDetails | null;
+    /** Any error that occurred during initialization */
+    error: Error | null;
+    /** Function to update the current user */
+    updateUser: (user: WolvesUser) => Promise<void>;
+}
+/**
+ * React Context for sharing Wolves client state across the component tree.
+ * Use the useWolvesClient hook to access this context instead of using it directly.
+ */
+export declare const WolvesContext: React.Context<WolvesContextValue | null>;
+//# sourceMappingURL=WolvesContext.d.ts.map

package/dist/WolvesContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WolvesContext.d.ts","sourceRoot":"","sources":["../src/WolvesContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,sDAAsD;IACtD,aAAa,EAAE,OAAO,CAAC;IACvB,mDAAmD;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,kDAAkD;IAClD,qBAAqB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD,oDAAoD;IACpD,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,0CAA0C;IAC1C,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,0CAAuD,CAAC"}

package/dist/WolvesContext.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WolvesContext = void 0;
+const react_1 = __importDefault(require("react"));
+/**
+ * React Context for sharing Wolves client state across the component tree.
+ * Use the useWolvesClient hook to access this context instead of using it directly.
+ */
+exports.WolvesContext = react_1.default.createContext(null);
+exports.WolvesContext.displayName = 'WolvesContext';

package/dist/WolvesProvider.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { WolvesProviderProps } from './types';
+/**
+ * WolvesProvider is the root component for integrating Wolves SDK with React.
+ * It initializes the WolvesClient and provides it to child components via React Context.
+ *
+ * @example
+ * ```tsx
+ * import { WolvesProvider } from 'wolves-react-client';
+ *
+ * function App() {
+ *   return (
+ *     <WolvesProvider
+ *       sdkKey="your-sdk-key"
+ *       user={{ userID: 'user-123' }}
+ *     >
+ *       <YourApp />
+ *     </WolvesProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare const WolvesProvider: React.FC<WolvesProviderProps>;
+//# sourceMappingURL=WolvesProvider.d.ts.map

package/dist/WolvesProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WolvesProvider.d.ts","sourceRoot":"","sources":["../src/WolvesProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAoKxD,CAAC"}

package/dist/WolvesProvider.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WolvesProvider = void 0;
+const react_1 = __importStar(require("react"));
+const wolves_js_client_1 = require("wolves-js-client");
+const WolvesContext_1 = require("./WolvesContext");
+const ssrHelpers_1 = require("./utils/ssrHelpers");
+/**
+ * WolvesProvider is the root component for integrating Wolves SDK with React.
+ * It initializes the WolvesClient and provides it to child components via React Context.
+ *
+ * @example
+ * ```tsx
+ * import { WolvesProvider } from 'wolves-react-client';
+ *
+ * function App() {
+ *   return (
+ *     <WolvesProvider
+ *       sdkKey="your-sdk-key"
+ *       user={{ userID: 'user-123' }}
+ *     >
+ *       <YourApp />
+ *     </WolvesProvider>
+ *   );
+ * }
+ * ```
+ */
+const WolvesProvider = ({ sdkKey, user, children, options = {}, waitForInitialization = false, loadingComponent = null, }) => {
+    const [client, setClient] = (0, react_1.useState)(null);
+    const [isInitialized, setIsInitialized] = (0, react_1.useState)(false);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const [initializationDetails, setInitializationDetails] = (0, react_1.useState)(null);
+    const [error, setError] = (0, react_1.useState)(null);
+    const userRef = (0, react_1.useRef)(user);
+    // Skip initialization on server
+    const shouldInitialize = !(0, ssrHelpers_1.isServer)();
+    // Initialize client on mount
+    (0, react_1.useEffect)(() => {
+        if (!shouldInitialize) {
+            setIsLoading(false);
+            return;
+        }
+        let isMounted = true;
+        const initMode = options.initMode || 'async';
+        const initializeClient = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const newClient = new wolves_js_client_1.WolvesClient(sdkKey, user, options.apiEnv || 'prod');
+                if (initMode === 'async') {
+                    // Async initialization
+                    const details = yield newClient.initializeAsync(options.asyncOptions);
+                    if (!isMounted)
+                        return;
+                    setInitializationDetails(details);
+                    setIsInitialized(true);
+                    setIsLoading(false);
+                    setClient(newClient);
+                    if (options.onInitialized) {
+                        options.onInitialized(details);
+                    }
+                }
+                else {
+                    // Sync initialization
+                    const details = newClient.initializeSync(options.syncOptions);
+                    if (!isMounted)
+                        return;
+                    setInitializationDetails(details);
+                    setIsInitialized(true);
+                    setIsLoading(false);
+                    setClient(newClient);
+                    if (options.onInitialized) {
+                        options.onInitialized(details);
+                    }
+                }
+            }
+            catch (err) {
+                if (!isMounted)
+                    return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                setError(error);
+                setIsLoading(false);
+                if (options.onError) {
+                    options.onError(error);
+                }
+            }
+        });
+        initializeClient();
+        // Cleanup on unmount
+        return () => {
+            isMounted = false;
+            if (client) {
+                client.shutdown().catch((e) => {
+                    console.error('Failed to shutdown Wolves client:', e);
+                });
+            }
+        };
+        // Intentionally only depend on sdkKey and shouldInitialize
+        // User and options changes are handled separately
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sdkKey, shouldInitialize]);
+    // Handle user changes
+    (0, react_1.useEffect)(() => {
+        if (!client || !isInitialized)
+            return;
+        // Check if user actually changed
+        if (JSON.stringify(userRef.current) === JSON.stringify(user)) {
+            return;
+        }
+        userRef.current = user;
+        const updateUser = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const details = yield client.updateUserAsync(user, options.asyncOptions);
+                setInitializationDetails(details);
+                if (options.onInitialized) {
+                    options.onInitialized(details);
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                setError(error);
+                if (options.onError) {
+                    options.onError(error);
+                }
+            }
+        });
+        updateUser();
+        // Intentionally don't include options in deps as we only want to react to user changes
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [user, client, isInitialized]);
+    // Create updateUser function for manual user updates
+    const updateUser = (newUser) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!client) {
+            throw new Error('Wolves client is not initialized');
+        }
+        userRef.current = newUser;
+        const details = yield client.updateUserAsync(newUser, options.asyncOptions);
+        setInitializationDetails(details);
+        if (options.onInitialized) {
+            options.onInitialized(details);
+        }
+    });
+    // Memoize context value to prevent unnecessary re-renders
+    const contextValue = (0, react_1.useMemo)(() => ({
+        client,
+        isInitialized,
+        isLoading,
+        initializationDetails,
+        error,
+        updateUser,
+    }), 
+    // updateUser function is stable (defined outside useEffect)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [client, isInitialized, isLoading, initializationDetails, error]);
+    // Show loading component if waiting for initialization
+    if (waitForInitialization && isLoading && !error) {
+        return react_1.default.createElement(react_1.default.Fragment, null, loadingComponent);
+    }
+    return (react_1.default.createElement(WolvesContext_1.WolvesContext.Provider, { value: contextValue }, children));
+};
+exports.WolvesProvider = WolvesProvider;
+exports.WolvesProvider.displayName = 'WolvesProvider';

package/dist/hooks/useExperiment.d.ts

@@ -0,0 +1,37 @@
+import { UseExperimentOptions, UseExperimentReturn } from '../types';
+/**
+ * Hook to access experiment configurations and automatically log exposure events.
+ *
+ * This hook retrieves experiment values from the Wolves client and automatically
+ * logs an exposure event (unless skipExposure is true). It handles loading states
+ * and provides default values when experiments are not found.
+ *
+ * @param experimentName - The name of the experiment to retrieve
+ * @param options - Optional configuration
+ * @param options.skipExposure - If true, skip logging exposure event (default: false)
+ * @param options.defaultValue - Default value to return if experiment not found
+ *
+ * @returns Experiment configuration with typed value access
+ *
+ * @example
+ * ```tsx
+ * function MyButton() {
+ *   const experiment = useExperiment('button-test', {
+ *     defaultValue: { color: 'blue', text: 'Click Me' }
+ *   });
+ *
+ *   if (experiment.isLoading) {
+ *     return <button>Loading...</button>;
+ *   }
+ *
+ *   return (
+ *     <button style={{ backgroundColor: experiment.get('color', 'blue') }}>
+ *       {experiment.get('text', 'Click Me')}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useExperiment<T extends Record<string, any> = Record<string, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
+experimentName: string, options?: UseExperimentOptions<T>): UseExperimentReturn<T>;
+//# sourceMappingURL=useExperiment.d.ts.map

package/dist/hooks/useExperiment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExperiment.d.ts","sourceRoot":"","sources":["../../src/hooks/useExperiment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAG,yDAAyD;AAC3I,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAChC,mBAAmB,CAAC,CAAC,CAAC,CAmDxB"}

package/dist/hooks/useExperiment.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExperiment = useExperiment;
+const react_1 = require("react");
+const useWolvesClient_1 = require("./useWolvesClient");
+/**
+ * Hook to access experiment configurations and automatically log exposure events.
+ *
+ * This hook retrieves experiment values from the Wolves client and automatically
+ * logs an exposure event (unless skipExposure is true). It handles loading states
+ * and provides default values when experiments are not found.
+ *
+ * @param experimentName - The name of the experiment to retrieve
+ * @param options - Optional configuration
+ * @param options.skipExposure - If true, skip logging exposure event (default: false)
+ * @param options.defaultValue - Default value to return if experiment not found
+ *
+ * @returns Experiment configuration with typed value access
+ *
+ * @example
+ * ```tsx
+ * function MyButton() {
+ *   const experiment = useExperiment('button-test', {
+ *     defaultValue: { color: 'blue', text: 'Click Me' }
+ *   });
+ *
+ *   if (experiment.isLoading) {
+ *     return <button>Loading...</button>;
+ *   }
+ *
+ *   return (
+ *     <button style={{ backgroundColor: experiment.get('color', 'blue') }}>
+ *       {experiment.get('text', 'Click Me')}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+function useExperiment(// eslint-disable-line @typescript-eslint/no-explicit-any
+experimentName, options) {
+    var _a;
+    const { client, isLoading: clientIsLoading } = (0, useWolvesClient_1.useWolvesClient)();
+    const skipExposure = (_a = options === null || options === void 0 ? void 0 : options.skipExposure) !== null && _a !== void 0 ? _a : false;
+    // Memoize defaultValue to prevent unnecessary re-evaluations
+    const defaultValue = (0, react_1.useMemo)(() => { var _a; return ((_a = options === null || options === void 0 ? void 0 : options.defaultValue) !== null && _a !== void 0 ? _a : {}); }, [options === null || options === void 0 ? void 0 : options.defaultValue]);
+    // Memoize the experiment result to prevent unnecessary re-evaluations
+    const experimentResult = (0, react_1.useMemo)(() => {
+        // Return loading state if client is not ready
+        if (clientIsLoading || !client) {
+            return {
+                value: defaultValue,
+                groupName: null,
+                experimentID: '',
+                get: (key, fallback) => {
+                    if (defaultValue && key in defaultValue) {
+                        return defaultValue[key];
+                    }
+                    return fallback;
+                },
+                isLoading: true,
+            };
+        }
+        // Get experiment from client (automatically logs exposure unless we skip it)
+        let experiment;
+        if (skipExposure) {
+            // TODO: Implement a way to get experiment without logging exposure
+            // For now, we'll use the regular method
+            experiment = client.getExperiment(experimentName);
+        }
+        else {
+            experiment = client.getExperiment(experimentName);
+        }
+        const value = experiment.value || defaultValue;
+        const groupName = experiment.groupName;
+        const experimentID = experiment.experimentID;
+        return {
+            value,
+            groupName,
+            experimentID,
+            get: (key, fallback) => {
+                return experiment.get(key, fallback);
+            },
+            isLoading: false,
+        };
+    }, [client, clientIsLoading, experimentName, skipExposure, defaultValue]);
+    return experimentResult;
+}

package/dist/hooks/useWolvesClient.d.ts

@@ -0,0 +1,30 @@
+import { WolvesContextValue } from '../WolvesContext';
+/**
+ * Hook to access the Wolves client instance and initialization state.
+ *
+ * This hook must be used within a WolvesProvider. It provides access to:
+ * - The WolvesClient instance
+ * - Initialization status (loading, initialized, error)
+ * - Function to manually update the user
+ *
+ * @throws Error if used outside of WolvesProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { client, isInitialized, isLoading, error } = useWolvesClient();
+ *
+ *   if (isLoading) {
+ *     return <div>Loading...</div>;
+ *   }
+ *
+ *   if (error) {
+ *     return <div>Error: {error.message}</div>;
+ *   }
+ *
+ *   return <div>Client ready!</div>;
+ * }
+ * ```
+ */
+export declare function useWolvesClient(): WolvesContextValue;
+//# sourceMappingURL=useWolvesClient.d.ts.map

package/dist/hooks/useWolvesClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWolvesClient.d.ts","sourceRoot":"","sources":["../../src/hooks/useWolvesClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,IAAI,kBAAkB,CAWpD"}

package/dist/hooks/useWolvesClient.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWolvesClient = useWolvesClient;
+const react_1 = require("react");
+const WolvesContext_1 = require("../WolvesContext");
+/**
+ * Hook to access the Wolves client instance and initialization state.
+ *
+ * This hook must be used within a WolvesProvider. It provides access to:
+ * - The WolvesClient instance
+ * - Initialization status (loading, initialized, error)
+ * - Function to manually update the user
+ *
+ * @throws Error if used outside of WolvesProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { client, isInitialized, isLoading, error } = useWolvesClient();
+ *
+ *   if (isLoading) {
+ *     return <div>Loading...</div>;
+ *   }
+ *
+ *   if (error) {
+ *     return <div>Error: {error.message}</div>;
+ *   }
+ *
+ *   return <div>Client ready!</div>;
+ * }
+ * ```
+ */
+function useWolvesClient() {
+    const context = (0, react_1.useContext)(WolvesContext_1.WolvesContext);
+    if (context === null) {
+        throw new Error('useWolvesClient must be used within a WolvesProvider. ' +
+            'Wrap your component tree with <WolvesProvider> to use Wolves hooks.');
+    }
+    return context;
+}

package/dist/hooks/useWolvesEvent.d.ts

@@ -0,0 +1,27 @@
+import { UseWolvesEventReturn } from '../types';
+/**
+ * Hook to log custom events to the Wolves platform.
+ *
+ * This hook provides a stable callback function to log events. The callback
+ * function reference remains the same across renders for performance.
+ *
+ * @returns Object containing the logEvent function
+ *
+ * @example
+ * ```tsx
+ * function PurchaseButton() {
+ *   const { logEvent } = useWolvesEvent();
+ *
+ *   const handlePurchase = () => {
+ *     logEvent('purchase_completed', 99.99, {
+ *       product_id: 'abc123',
+ *       category: 'electronics'
+ *     });
+ *   };
+ *
+ *   return <button onClick={handlePurchase}>Buy Now</button>;
+ * }
+ * ```
+ */
+export declare function useWolvesEvent(): UseWolvesEventReturn;
+//# sourceMappingURL=useWolvesEvent.d.ts.map

package/dist/hooks/useWolvesEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWolvesEvent.d.ts","sourceRoot":"","sources":["../../src/hooks/useWolvesEvent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,CAqCrD"}

package/dist/hooks/useWolvesEvent.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWolvesEvent = useWolvesEvent;
+const react_1 = require("react");
+const useWolvesClient_1 = require("./useWolvesClient");
+/**
+ * Hook to log custom events to the Wolves platform.
+ *
+ * This hook provides a stable callback function to log events. The callback
+ * function reference remains the same across renders for performance.
+ *
+ * @returns Object containing the logEvent function
+ *
+ * @example
+ * ```tsx
+ * function PurchaseButton() {
+ *   const { logEvent } = useWolvesEvent();
+ *
+ *   const handlePurchase = () => {
+ *     logEvent('purchase_completed', 99.99, {
+ *       product_id: 'abc123',
+ *       category: 'electronics'
+ *     });
+ *   };
+ *
+ *   return <button onClick={handlePurchase}>Buy Now</button>;
+ * }
+ * ```
+ */
+function useWolvesEvent() {
+    const { client, isInitialized } = (0, useWolvesClient_1.useWolvesClient)();
+    /**
+     * Log a custom event with optional value and metadata.
+     *
+     * @param eventName - Name of the event (e.g., 'purchase', 'click', 'signup')
+     * @param value - Optional numeric or string value associated with the event
+     * @param metadata - Optional key-value metadata for additional context
+     */
+    const logEvent = (0, react_1.useCallback)((eventName, value, metadata) => {
+        if (!client || !isInitialized) {
+            if (process.env.NODE_ENV === 'development') {
+                console.warn(`[Wolves] Cannot log event "${eventName}": Client is not initialized yet.`);
+            }
+            return;
+        }
+        try {
+            client.logEvent(eventName, value, metadata);
+        }
+        catch (error) {
+            if (process.env.NODE_ENV === 'development') {
+                console.error(`[Wolves] Failed to log event "${eventName}":`, error);
+            }
+        }
+    }, [client, isInitialized]);
+    return { logEvent };
+}

package/dist/hooks/useWolvesInitialization.d.ts

@@ -0,0 +1,43 @@
+import { LoadingStatus, WolvesUpdateDetails } from 'wolves-js-client';
+/**
+ * Return type for useWolvesInitialization hook
+ */
+export interface UseWolvesInitializationReturn {
+    /** Whether the client is currently loading/initializing */
+    isLoading: boolean;
+    /** Whether the client is ready for use */
+    isReady: boolean;
+    /** The current loading status */
+    loadingStatus: LoadingStatus;
+    /** Any error that occurred during initialization */
+    error: Error | null;
+    /** Details from the initialization process */
+    details: WolvesUpdateDetails | null;
+}
+/**
+ * Hook to monitor the initialization status of the Wolves client.
+ *
+ * This hook provides detailed information about the client's initialization
+ * state, which is useful for displaying loading screens or handling errors.
+ *
+ * @returns Object containing initialization status information
+ *
+ * @example
+ * ```tsx
+ * function InitializationStatus() {
+ *   const { isLoading, isReady, loadingStatus, error } = useWolvesInitialization();
+ *
+ *   if (error) {
+ *     return <div>Error: {error.message}</div>;
+ *   }
+ *
+ *   if (isLoading) {
+ *     return <div>Loading experiments... ({loadingStatus})</div>;
+ *   }
+ *
+ *   return <div>Ready! Experiments loaded.</div>;
+ * }
+ * ```
+ */
+export declare function useWolvesInitialization(): UseWolvesInitializationReturn;
+//# sourceMappingURL=useWolvesInitialization.d.ts.map

package/dist/hooks/useWolvesInitialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWolvesInitialization.d.ts","sourceRoot":"","sources":["../../src/hooks/useWolvesInitialization.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,2DAA2D;IAC3D,SAAS,EAAE,OAAO,CAAC;IACnB,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,iCAAiC;IACjC,aAAa,EAAE,aAAa,CAAC;IAC7B,oDAAoD;IACpD,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,8CAA8C;IAC9C,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,uBAAuB,IAAI,6BAA6B,CA8BvE"}

package/dist/hooks/useWolvesInitialization.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWolvesInitialization = useWolvesInitialization;
+const react_1 = require("react");
+const useWolvesClient_1 = require("./useWolvesClient");
+/**
+ * Hook to monitor the initialization status of the Wolves client.
+ *
+ * This hook provides detailed information about the client's initialization
+ * state, which is useful for displaying loading screens or handling errors.
+ *
+ * @returns Object containing initialization status information
+ *
+ * @example
+ * ```tsx
+ * function InitializationStatus() {
+ *   const { isLoading, isReady, loadingStatus, error } = useWolvesInitialization();
+ *
+ *   if (error) {
+ *     return <div>Error: {error.message}</div>;
+ *   }
+ *
+ *   if (isLoading) {
+ *     return <div>Loading experiments... ({loadingStatus})</div>;
+ *   }
+ *
+ *   return <div>Ready! Experiments loaded.</div>;
+ * }
+ * ```
+ */
+function useWolvesInitialization() {
+    const { client, isInitialized, isLoading, initializationDetails, error } = (0, useWolvesClient_1.useWolvesClient)();
+    // Determine the loading status from the client
+    const loadingStatus = (0, react_1.useMemo)(() => {
+        if (!client) {
+            return 'Uninitialized';
+        }
+        try {
+            return client.getLoadingStatus();
+        }
+        catch (_a) {
+            // Fallback if method doesn't exist or errors
+            if (isInitialized) {
+                return 'Ready';
+            }
+            if (isLoading) {
+                return 'Loading';
+            }
+            return 'Uninitialized';
+        }
+    }, [client, isInitialized, isLoading]);
+    return {
+        isLoading,
+        isReady: isInitialized && !isLoading,
+        loadingStatus,
+        error,
+        details: initializationDetails,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Main entry point for the Wolves React SDK
+ */
+export { WolvesProvider } from './WolvesProvider';
+export { WolvesContext } from './WolvesContext';
+export type { WolvesContextValue } from './WolvesContext';
+export { useWolvesClient } from './hooks/useWolvesClient';
+export { useExperiment } from './hooks/useExperiment';
+export { useWolvesEvent } from './hooks/useWolvesEvent';
+export { useWolvesInitialization } from './hooks/useWolvesInitialization';
+export type { UseWolvesInitializationReturn } from './hooks/useWolvesInitialization';
+export type { WolvesUser, WolvesUpdateDetails, LoadingStatus, AsyncUpdateOptions, SyncUpdateOptions, } from 'wolves-js-client';
+export type { WolvesProviderProps, WolvesProviderOptions, UseExperimentOptions, UseExperimentReturn, UseWolvesEventReturn, InitMode, } from './types';
+export { isBrowser, isServer } from './utils/ssrHelpers';
+//# 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":"AAAA;;GAEG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAG1D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,YAAY,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAGrF,YAAY,EACV,UAAU,EACV,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,QAAQ,GACT,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Main entry point for the Wolves React SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isServer = exports.isBrowser = exports.useWolvesInitialization = exports.useWolvesEvent = exports.useExperiment = exports.useWolvesClient = exports.WolvesContext = exports.WolvesProvider = void 0;
+// Provider component
+var WolvesProvider_1 = require("./WolvesProvider");
+Object.defineProperty(exports, "WolvesProvider", { enumerable: true, get: function () { return WolvesProvider_1.WolvesProvider; } });
+// Context (for advanced use cases)
+var WolvesContext_1 = require("./WolvesContext");
+Object.defineProperty(exports, "WolvesContext", { enumerable: true, get: function () { return WolvesContext_1.WolvesContext; } });
+// Hooks
+var useWolvesClient_1 = require("./hooks/useWolvesClient");
+Object.defineProperty(exports, "useWolvesClient", { enumerable: true, get: function () { return useWolvesClient_1.useWolvesClient; } });
+var useExperiment_1 = require("./hooks/useExperiment");
+Object.defineProperty(exports, "useExperiment", { enumerable: true, get: function () { return useExperiment_1.useExperiment; } });
+var useWolvesEvent_1 = require("./hooks/useWolvesEvent");
+Object.defineProperty(exports, "useWolvesEvent", { enumerable: true, get: function () { return useWolvesEvent_1.useWolvesEvent; } });
+var useWolvesInitialization_1 = require("./hooks/useWolvesInitialization");
+Object.defineProperty(exports, "useWolvesInitialization", { enumerable: true, get: function () { return useWolvesInitialization_1.useWolvesInitialization; } });
+// SSR utilities
+var ssrHelpers_1 = require("./utils/ssrHelpers");
+Object.defineProperty(exports, "isBrowser", { enumerable: true, get: function () { return ssrHelpers_1.isBrowser; } });
+Object.defineProperty(exports, "isServer", { enumerable: true, get: function () { return ssrHelpers_1.isServer; } });

package/dist/types/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Type definitions for Wolves React SDK
+ */
+import { WolvesUser, WolvesUpdateDetails, AsyncUpdateOptions, SyncUpdateOptions } from 'wolves-js-client';
+import React from 'react';
+/**
+ * Initialization mode for the Wolves client
+ */
+export type InitMode = 'async' | 'sync';
+/**
+ * Options for configuring WolvesProvider behavior
+ */
+export interface WolvesProviderOptions {
+    /** Initialization mode: 'async' (default) or 'sync' */
+    initMode?: InitMode;
+    /** API environment: 'local', 'dev', or 'prod' (default) */
+    apiEnv?: 'local' | 'dev' | 'prod';
+    /** Options for async initialization */
+    asyncOptions?: AsyncUpdateOptions;
+    /** Options for sync initialization */
+    syncOptions?: SyncUpdateOptions;
+    /** Callback invoked when initialization completes */
+    onInitialized?: (details: WolvesUpdateDetails) => void;
+    /** Callback invoked when an error occurs */
+    onError?: (error: Error) => void;
+}
+/**
+ * Props for the WolvesProvider component
+ */
+export interface WolvesProviderProps {
+    /** SDK key for authenticating with Wolves API */
+    sdkKey: string;
+    /** User object containing user identification and attributes */
+    user: WolvesUser;
+    /** Child components that will have access to Wolves context */
+    children: React.ReactNode;
+    /** Optional configuration options */
+    options?: WolvesProviderOptions;
+    /** Whether to wait for initialization before rendering children */
+    waitForInitialization?: boolean;
+    /** Component to display while waiting for initialization */
+    loadingComponent?: React.ReactNode;
+}
+/**
+ * Options for the useExperiment hook
+ */
+export interface UseExperimentOptions<T = Record<string, any>> {
+    /** Whether to skip logging exposure events */
+    skipExposure?: boolean;
+    /** Default value to return if experiment is not found */
+    defaultValue?: T;
+}
+/**
+ * Return type for the useExperiment hook
+ */
+export interface UseExperimentReturn<T = Record<string, any>> {
+    /** The experiment configuration value */
+    value: T;
+    /** The group/variant name assigned to the user */
+    groupName: string | null;
+    /** The experiment ID */
+    experimentID: string;
+    /** Get a specific parameter from the experiment with a default fallback */
+    get: <K extends keyof T>(key: K, defaultValue: T[K]) => T[K];
+    /** Whether the client is still loading */
+    isLoading: boolean;
+}
+/**
+ * Return type for the useWolvesEvent hook
+ */
+export interface UseWolvesEventReturn {
+    /** Function to log a custom event */
+    logEvent: (eventName: string, value?: string | number, metadata?: Record<string, string>) => void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1G,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uDAAuD;IACvD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IAClC,uCAAuC;IACvC,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,sCAAsC;IACtC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,qDAAqD;IACrD,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACvD,4CAA4C;IAC5C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,IAAI,EAAE,UAAU,CAAC;IACjB,+DAA+D;IAC/D,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,qCAAqC;IACrC,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,mEAAmE;IACnE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC3D,8CAA8C;IAC9C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yDAAyD;IACzD,YAAY,CAAC,EAAE,CAAC,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC1D,yCAAyC;IACzC,KAAK,EAAE,CAAC,CAAC;IACT,kDAAkD;IAClD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,wBAAwB;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,GAAG,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,0CAA0C;IAC1C,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qCAAqC;IACrC,QAAQ,EAAE,CACR,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC9B,IAAI,CAAC;CACX"}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for Wolves React SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/ssrHelpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Server-Side Rendering (SSR) helper utilities
+ */
+/**
+ * Checks if the code is running in a browser environment.
+ * Returns false on the server (Node.js).
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Checks if the code is running in a server environment.
+ * Returns true on the server (Node.js).
+ */
+export declare function isServer(): boolean;
+//# sourceMappingURL=ssrHelpers.d.ts.map

package/dist/utils/ssrHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrHelpers.d.ts","sourceRoot":"","sources":["../../src/utils/ssrHelpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED;;;GAGG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAElC"}

package/dist/utils/ssrHelpers.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Server-Side Rendering (SSR) helper utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = isBrowser;
+exports.isServer = isServer;
+/**
+ * Checks if the code is running in a browser environment.
+ * Returns false on the server (Node.js).
+ */
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+}
+/**
+ * Checks if the code is running in a server environment.
+ * Returns true on the server (Node.js).
+ */
+function isServer() {
+    return !isBrowser();
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "wolves-react-client",
+  "version": "1.0.0",
+  "description": "React SDK for Wolves A/B Testing Platform",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "wolves",
+    "ab-testing",
+    "experiment",
+    "sdk",
+    "react",
+    "hooks"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts,.tsx",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "wolves-js-client": "^1.0.6"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.1.5",
+    "@testing-library/react": "^14.0.0",
+    "@types/jest": "^29.0.0",
+    "@types/react": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "eslint-plugin-react": "^7.33.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "jest": "^29.0.0",
+    "jest-environment-jsdom": "^29.0.0",
+    "prettier": "^3.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0",
+    "wolves-js-client": "^1.0.6"
+  },
+  "author": "",
+  "license": "ISC"
+}