@envive-ai/react-hooks 0.2.10 → 0.3.0

package/src/contexts/systemSettingsContext/__tests__/systemSettingsContext.test.tsx

@@ -1,31 +1,24 @@
-import React from "react";
-import { render, screen, waitFor, act } from "@testing-library/react";
-import { Provider } from "jotai";
-import { useAtomValue } from "jotai";
-import {
-  SystemSettingsContextProvider,
-  defaultGenerationParams,
-} from "../systemSettingsContext";
-import { useSystemSettingsContext } from "src/hooks/SystemSettingsContext/useSystemSettingsContext";
-import { EnviveConfigProvider } from "src/contexts/enviveConfigContext/enviveConfigContext";
-import { baseUrlAtom } from "src/atoms/envive/enviveConfig";
-import { GenerationParams } from "src/application/models";
+import React from 'react';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import { Provider } from 'jotai';
+import { useAtomValue } from 'jotai';
+import { SystemSettingsContextProvider, defaultGenerationParams } from '../systemSettingsContext';
+import { useSystemSettingsContext } from 'src/hooks/SystemSettingsContext/useSystemSettingsContext';
+import { EnviveConfigProvider } from 'src/contexts/enviveConfigContext/enviveConfigContext';
+import { baseUrlAtom } from 'src/atoms/envive/enviveConfig';
+import { GenerationParams } from 'src/application/models';
 
 // Component that uses the useSystemSettingsContext hook
 const MockSystemSettingsComponent: React.FC = () => {
-  const {
-    generationParams,
-    showDebugBar,
-    endpointURL,
-    setGenerationParams,
-  } = useSystemSettingsContext();
+  const { generationParams, showDebugBar, endpointURL, setGenerationParams } =
+    useSystemSettingsContext();
   const [updated, setUpdated] = React.useState(false);
 
   const handleUpdate = () => {
     setGenerationParams({
       stream: false,
       numSuggestions: 5,
-      model: "updated-model",
+      model: 'updated-model',
     });
     setUpdated(true);
   };
@@ -33,20 +26,19 @@ const MockSystemSettingsComponent: React.FC = () => {
   return (
     <div data-testid="system-settings-component">
       <div data-testid="generation-params-stream">
-        {generationParams?.stream?.toString() || "undefined"}
+        {generationParams?.stream?.toString() || 'undefined'}
       </div>
       <div data-testid="generation-params-num-suggestions">
-        {generationParams?.numSuggestions?.toString() || "undefined"}
+        {generationParams?.numSuggestions?.toString() || 'undefined'}
       </div>
-      <div data-testid="generation-params-model">
-        {generationParams?.model || "undefined"}
-      </div>
-      <div data-testid="show-debug-bar">
-        {showDebugBar?.toString() || "undefined"}
-      </div>
-      <div data-testid="endpoint-url">{endpointURL || "not-set"}</div>
+      <div data-testid="generation-params-model">{generationParams?.model || 'undefined'}</div>
+      <div data-testid="show-debug-bar">{showDebugBar?.toString() || 'undefined'}</div>
+      <div data-testid="endpoint-url">{endpointURL || 'not-set'}</div>
       <div data-testid="updated">{updated.toString()}</div>
-      <button data-testid="update-params-btn" onClick={handleUpdate}>
+      <button
+        data-testid="update-params-btn"
+        onClick={handleUpdate}
+      >
         Update Params
       </button>
     </div>
@@ -56,7 +48,7 @@ const MockSystemSettingsComponent: React.FC = () => {
 // Component that reads baseUrlAtom
 const BaseUrlReaderComponent: React.FC = () => {
   const baseUrl = useAtomValue(baseUrlAtom);
-  return <div data-testid="base-url">{baseUrl || "not-set"}</div>;
+  return <div data-testid="base-url">{baseUrl || 'not-set'}</div>;
 };
 
 // Wrapper component to ensure providers are in correct order
@@ -65,7 +57,7 @@ const TestWrapper: React.FC<{
   generationParams?: GenerationParams;
   showDebugBar?: boolean;
   baseUrl?: string;
-}> = ({ children, generationParams, showDebugBar, baseUrl = "https://test-api.example.com" }) => {
+}> = ({ children, generationParams, showDebugBar, baseUrl = 'https://test-api.example.com' }) => {
   return (
     <Provider>
       <EnviveConfigProvider
@@ -85,7 +77,7 @@ const TestWrapper: React.FC<{
   );
 };
 
-describe("SystemSettingsContextProvider", () => {
+describe('SystemSettingsContextProvider', () => {
   const originalLocation = window.location;
 
   beforeEach(() => {
@@ -99,27 +91,25 @@ describe("SystemSettingsContextProvider", () => {
     (window as any).location = originalLocation;
   });
 
-  describe("useSystemSettingsContext Hook Integration", () => {
-    it("should provide context through useSystemSettingsContext hook", async () => {
+  describe('useSystemSettingsContext Hook Integration', () => {
+    it('should provide context through useSystemSettingsContext hook', async () => {
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("system-settings-component")).toBeInTheDocument();
+        expect(screen.getByTestId('system-settings-component')).toBeInTheDocument();
       });
 
       // Check default values
-      expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("true");
-      expect(screen.getByTestId("generation-params-num-suggestions")).toHaveTextContent("3");
+      expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('true');
+      expect(screen.getByTestId('generation-params-num-suggestions')).toHaveTextContent('3');
     });
 
-    it("should throw error when used outside of SystemSettingsContextProvider", () => {
-      const consoleSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
+    it('should throw error when used outside of SystemSettingsContextProvider', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       const TestComponent: React.FC = () => {
         try {
@@ -133,198 +123,199 @@ describe("SystemSettingsContextProvider", () => {
       render(
         <Provider>
           <TestComponent />
-        </Provider>
+        </Provider>,
       );
 
-      expect(screen.getByTestId("error")).toHaveTextContent(
-        "useSystemSettingsContext must be used within a SystemSettingsContextProvider"
+      expect(screen.getByTestId('error')).toHaveTextContent(
+        'useSystemSettingsContext must be used within a SystemSettingsContextProvider',
       );
 
       consoleSpy.mockRestore();
     });
   });
 
-  describe("generationParams Initialization", () => {
-    it("should use default generationParams when not provided", async () => {
+  describe('generationParams Initialization', () => {
+    it('should use default generationParams when not provided', async () => {
       // Note: defaultGenerationParams is created at module load time,
       // so window.location changes in tests won't affect it
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("true");
+        expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('true');
       });
 
-      expect(screen.getByTestId("generation-params-num-suggestions")).toHaveTextContent("3");
+      expect(screen.getByTestId('generation-params-num-suggestions')).toHaveTextContent('3');
       // Model will be whatever was in the URL when the module loaded, or undefined
-      expect(screen.getByTestId("generation-params-model")).toBeInTheDocument();
+      expect(screen.getByTestId('generation-params-model')).toBeInTheDocument();
     });
 
-    it("should use provided generationParams prop", async () => {
+    it('should use provided generationParams prop', async () => {
       const customParams: GenerationParams = {
         stream: false,
         numSuggestions: 5,
-        model: "custom-model",
+        model: 'custom-model',
       };
 
       render(
         <TestWrapper generationParams={customParams}>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("false");
+        expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('false');
       });
 
-      expect(screen.getByTestId("generation-params-num-suggestions")).toHaveTextContent("5");
-      expect(screen.getByTestId("generation-params-model")).toHaveTextContent("custom-model");
+      expect(screen.getByTestId('generation-params-num-suggestions')).toHaveTextContent('5');
+      expect(screen.getByTestId('generation-params-model')).toHaveTextContent('custom-model');
     });
 
-    it("should use defaultGenerationParams model from URL at module load", async () => {
+    it('should use defaultGenerationParams model from URL at module load', async () => {
       // Note: defaultGenerationParams.model is set at module load time
       // This test verifies that the default is used when generationParams prop is not provided
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("true");
+        expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('true');
       });
 
       // Model will be whatever was in defaultGenerationParams (set at module load)
-      expect(screen.getByTestId("generation-params-model")).toBeInTheDocument();
+      expect(screen.getByTestId('generation-params-model')).toBeInTheDocument();
     });
 
-    it("should handle defaultGenerationParams with undefined model", async () => {
+    it('should handle defaultGenerationParams with undefined model', async () => {
       // Note: defaultGenerationParams is created at module load time
       // This test verifies the component works even if model is undefined
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("true");
+        expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('true');
       });
 
       // Model may be undefined if not in URL at module load time
-      expect(screen.getByTestId("generation-params-model")).toBeInTheDocument();
+      expect(screen.getByTestId('generation-params-model')).toBeInTheDocument();
     });
   });
 
-  describe("showDebugBar Prop", () => {
-    it("should pass showDebugBar prop to context", async () => {
+  describe('showDebugBar Prop', () => {
+    it('should pass showDebugBar prop to context', async () => {
       render(
         <TestWrapper showDebugBar={true}>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("show-debug-bar")).toHaveTextContent("true");
+        expect(screen.getByTestId('show-debug-bar')).toHaveTextContent('true');
       });
     });
 
-    it("should pass false showDebugBar prop to context", async () => {
+    it('should pass false showDebugBar prop to context', async () => {
       render(
         <TestWrapper showDebugBar={false}>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("show-debug-bar")).toHaveTextContent("false");
+        expect(screen.getByTestId('show-debug-bar')).toHaveTextContent('false');
       });
     });
 
-    it("should be undefined when showDebugBar is not provided", async () => {
+    it('should be undefined when showDebugBar is not provided', async () => {
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("show-debug-bar")).toHaveTextContent("undefined");
+        expect(screen.getByTestId('show-debug-bar')).toHaveTextContent('undefined');
       });
     });
   });
 
-  describe("endpointURL from baseUrlAtom", () => {
-    it("should read endpointURL from baseUrlAtom", async () => {
+  describe('endpointURL from baseUrlAtom', () => {
+    it('should read endpointURL from baseUrlAtom', async () => {
       render(
         <TestWrapper baseUrl="https://custom-api.example.com">
           <MockSystemSettingsComponent />
           <BaseUrlReaderComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("endpoint-url")).toHaveTextContent(
-          "https://custom-api.example.com"
+        expect(screen.getByTestId('endpoint-url')).toHaveTextContent(
+          'https://custom-api.example.com',
         );
       });
 
-      expect(screen.getByTestId("base-url")).toHaveTextContent(
-        "https://custom-api.example.com"
-      );
+      expect(screen.getByTestId('base-url')).toHaveTextContent('https://custom-api.example.com');
     });
 
-    it("should use default baseUrl when not provided", async () => {
+    it('should use default baseUrl when not provided', async () => {
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
           <BaseUrlReaderComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        const endpointUrl = screen.getByTestId("endpoint-url").textContent;
+        const endpointUrl = screen.getByTestId('endpoint-url').textContent;
         expect(endpointUrl).toBeTruthy();
-        expect(endpointUrl).not.toBe("not-set");
+        expect(endpointUrl).not.toBe('not-set');
       });
     });
   });
 
-  describe("setGenerationParams Function", () => {
-    it("should update generationParams when setGenerationParams is called", async () => {
+  describe('setGenerationParams Function', () => {
+    it('should update generationParams when setGenerationParams is called', async () => {
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("true");
+        expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('true');
       });
 
       await act(async () => {
-        screen.getByTestId("update-params-btn").click();
+        screen.getByTestId('update-params-btn').click();
       });
 
       // Note: The useMemo depends on generationParams prop, not params state
       // So the context value may not update immediately, but params state will update
       await waitFor(() => {
-        expect(screen.getByTestId("updated")).toHaveTextContent("true");
+        expect(screen.getByTestId('updated')).toHaveTextContent('true');
       });
 
       // The component reads from context, which may not update due to useMemo dependencies
       // But the state update should trigger a re-render
-      await waitFor(() => {
-        const streamValue = screen.getByTestId("generation-params-stream").textContent;
-        // State should update even if context doesn't
-        expect(streamValue).toBeDefined();
-      }, { timeout: 2000 });
+      await waitFor(
+        () => {
+          const streamValue = screen.getByTestId('generation-params-stream').textContent;
+          // State should update even if context doesn't
+          expect(streamValue).toBeDefined();
+        },
+        { timeout: 2000 },
+      );
     });
 
-    it("should allow partial updates to generationParams", async () => {
+    it('should allow partial updates to generationParams', async () => {
       const PartialUpdateComponent: React.FC = () => {
         const { setGenerationParams, generationParams } = useSystemSettingsContext();
         const [updated, setUpdated] = React.useState(false);
@@ -335,23 +326,27 @@ describe("SystemSettingsContextProvider", () => {
         }, [generationParams]);
 
         const handlePartialUpdate = () => {
-          setGenerationParams((prev) => ({
-            ...prev,
-            stream: false,
-          } as GenerationParams));
+          setGenerationParams(
+            prev =>
+              ({
+                ...prev,
+                stream: false,
+              }) as GenerationParams,
+          );
           setUpdated(true);
         };
 
         return (
           <div data-testid="partial-update-component">
-            <div data-testid="current-stream">
-              {localParams?.stream?.toString() || "undefined"}
-            </div>
+            <div data-testid="current-stream">{localParams?.stream?.toString() || 'undefined'}</div>
             <div data-testid="current-num-suggestions">
-              {localParams?.numSuggestions?.toString() || "undefined"}
+              {localParams?.numSuggestions?.toString() || 'undefined'}
             </div>
             <div data-testid="updated">{updated.toString()}</div>
-            <button data-testid="partial-update-btn" onClick={handlePartialUpdate}>
+            <button
+              data-testid="partial-update-btn"
+              onClick={handlePartialUpdate}
+            >
               Partial Update
             </button>
           </div>
@@ -361,32 +356,35 @@ describe("SystemSettingsContextProvider", () => {
       render(
         <TestWrapper>
           <PartialUpdateComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("current-stream")).toHaveTextContent("true");
+        expect(screen.getByTestId('current-stream')).toHaveTextContent('true');
       });
 
       await act(async () => {
-        screen.getByTestId("partial-update-btn").click();
+        screen.getByTestId('partial-update-btn').click();
       });
 
       await waitFor(() => {
-        expect(screen.getByTestId("updated")).toHaveTextContent("true");
+        expect(screen.getByTestId('updated')).toHaveTextContent('true');
       });
 
       // Note: Due to useMemo dependencies, context may not update immediately
       // But the setGenerationParams function should work
-      await waitFor(() => {
-        const streamValue = screen.getByTestId("current-stream").textContent;
-        expect(streamValue).toBeDefined();
-      }, { timeout: 2000 });
+      await waitFor(
+        () => {
+          const streamValue = screen.getByTestId('current-stream').textContent;
+          expect(streamValue).toBeDefined();
+        },
+        { timeout: 2000 },
+      );
     });
   });
 
-  describe("Context Value Memoization", () => {
-    it("should maintain stable context value references", async () => {
+  describe('Context Value Memoization', () => {
+    it('should maintain stable context value references', async () => {
       let contextValue1: any;
       let contextValue2: any;
 
@@ -406,7 +404,7 @@ describe("SystemSettingsContextProvider", () => {
         <TestWrapper>
           <Component1 />
           <Component2 />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
@@ -420,7 +418,7 @@ describe("SystemSettingsContextProvider", () => {
       });
     });
 
-    it("should update context value when dependencies change", async () => {
+    it('should update context value when dependencies change', async () => {
       let contextValue1: any;
       let contextValue2: any;
 
@@ -440,7 +438,7 @@ describe("SystemSettingsContextProvider", () => {
         <TestWrapper showDebugBar={false}>
           <Component1 />
           <Component2 />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
@@ -454,7 +452,7 @@ describe("SystemSettingsContextProvider", () => {
         <TestWrapper showDebugBar={true}>
           <Component1 />
           <Component2 />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
@@ -465,33 +463,33 @@ describe("SystemSettingsContextProvider", () => {
     });
   });
 
-  describe("defaultGenerationParams", () => {
-    it("should export defaultGenerationParams", () => {
+  describe('defaultGenerationParams', () => {
+    it('should export defaultGenerationParams', () => {
       expect(defaultGenerationParams).toBeDefined();
       expect(defaultGenerationParams.stream).toBe(true);
       expect(defaultGenerationParams.numSuggestions).toBe(3);
     });
 
-    it("should use defaultGenerationParams when generationParams prop is not provided", async () => {
+    it('should use defaultGenerationParams when generationParams prop is not provided', async () => {
       // Note: defaultGenerationParams is created at module load time
       render(
         <TestWrapper>
           <MockSystemSettingsComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("generation-params-stream")).toHaveTextContent("true");
-        expect(screen.getByTestId("generation-params-num-suggestions")).toHaveTextContent("3");
+        expect(screen.getByTestId('generation-params-stream')).toHaveTextContent('true');
+        expect(screen.getByTestId('generation-params-num-suggestions')).toHaveTextContent('3');
       });
 
       // Model will be whatever was in defaultGenerationParams (set at module load)
-      expect(screen.getByTestId("generation-params-model")).toBeInTheDocument();
+      expect(screen.getByTestId('generation-params-model')).toBeInTheDocument();
     });
   });
 
-  describe("URL Query Parameter Parsing", () => {
-    it("should verify defaultGenerationParams uses getChatModelName at module load", () => {
+  describe('URL Query Parameter Parsing', () => {
+    it('should verify defaultGenerationParams uses getChatModelName at module load', () => {
       // Note: defaultGenerationParams.model is set at module load time via getChatModelName()
       // This test verifies that the defaultGenerationParams has the expected structure
       expect(defaultGenerationParams).toBeDefined();
@@ -499,8 +497,7 @@ describe("SystemSettingsContextProvider", () => {
       expect(defaultGenerationParams.numSuggestions).toBe(3);
       // Model will be whatever was in the URL when the module loaded, or undefined
       // We just verify the structure is correct
-      expect(defaultGenerationParams).toHaveProperty("model");
+      expect(defaultGenerationParams).toHaveProperty('model');
     });
   });
 });
-

package/src/contexts/systemSettingsContext/index.ts

@@ -1 +1 @@
-export * from "./systemSettingsContext";
+export * from './systemSettingsContext';

package/src/contexts/systemSettingsContext/systemSettingsContext.tsx

@@ -1,14 +1,7 @@
-import { useAtomValue } from "jotai";
-import {
-  Dispatch,
-  ReactNode,
-  SetStateAction,
-  createContext,
-  useMemo,
-  useState,
-} from "react";
-import { GenerationParams } from "src/application/models";
-import { baseUrlAtom } from "src/atoms/envive/enviveConfig";
+import { useAtomValue } from 'jotai';
+import { Dispatch, ReactNode, SetStateAction, createContext, useMemo, useState } from 'react';
+import { GenerationParams } from 'src/application/models';
+import { baseUrlAtom } from 'src/atoms/envive/enviveConfig';
 
 // TODO: Refactor this to a common service that handles query params (and spiffy variables all together)
 const getChatModelName = () => {
@@ -37,9 +30,7 @@ interface SystemSettingsContextProviderProps {
   showDebugBar?: boolean;
 }
 
-const SystemSettingsContext = createContext<
-  SystemSettingsContextParams | undefined
->(undefined);
+const SystemSettingsContext = createContext<SystemSettingsContextParams | undefined>(undefined);
 
 const SystemSettingsContextProvider = ({
   children,
@@ -47,7 +38,7 @@ const SystemSettingsContextProvider = ({
   showDebugBar,
 }: SystemSettingsContextProviderProps) => {
   const [params, setParams] = useState<GenerationParams | undefined>(
-    () => generationParams ?? defaultGenerationParams
+    () => generationParams ?? defaultGenerationParams,
   );
   const endpointURL = useAtomValue(baseUrlAtom);
   const settingsContextValues = useMemo(
@@ -57,7 +48,7 @@ const SystemSettingsContextProvider = ({
       setGenerationParams: setParams,
       endpointURL,
     }),
-    [generationParams, endpointURL, showDebugBar]
+    [generationParams, endpointURL, showDebugBar],
   );
 
   return (
@@ -67,8 +58,4 @@ const SystemSettingsContextProvider = ({
   );
 };
 
-export {
-  SystemSettingsContextProvider,
-  SystemSettingsContext,
-  defaultGenerationParams,
-};
+export { SystemSettingsContextProvider, SystemSettingsContext, defaultGenerationParams };