@envive-ai/react-hooks 0.2.10 → 0.3.0

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

@@ -1,17 +1,13 @@
-import React from "react";
-import { render, screen, waitFor, act } from "@testing-library/react";
-import {
-  LocalStorageProvider,
-  useLocalStorage,
-  LocalStorageKeys,
-} from "../localStorageContext";
-import Logger from "src/application/logging/logger";
-import { LocalStorageEventListener } from "src/application/models/localStorageEventListener";
+import React from 'react';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import { LocalStorageProvider, useLocalStorage, LocalStorageKeys } from '../localStorageContext';
+import Logger from 'src/application/logging/logger';
+import { LocalStorageEventListener } from 'src/application/models/localStorageEventListener';
 
 // Mock the Logger to avoid console output in tests
-vi.spyOn(Logger, "logDebug").mockImplementation(() => {});
-vi.spyOn(Logger, "logWarn").mockImplementation(() => {});
-vi.spyOn(Logger, "logError").mockImplementation(() => {});
+vi.spyOn(Logger, 'logDebug').mockImplementation(() => {});
+vi.spyOn(Logger, 'logWarn').mockImplementation(() => {});
+vi.spyOn(Logger, 'logError').mockImplementation(() => {});
 
 // Component that uses the useLocalStorage hook
 const MockLocalStorageComponent: React.FC = () => {
@@ -31,7 +27,7 @@ const MockLocalStorageComponent: React.FC = () => {
 
   React.useEffect(() => {
     // Test getItem
-    const value = getItem("test-key");
+    const value = getItem('test-key');
     setTestValue(value);
 
     // Test getSpiffyOnFeatureFlag
@@ -40,7 +36,7 @@ const MockLocalStorageComponent: React.FC = () => {
 
     // Test attachListener
     const listener: LocalStorageEventListener = {
-      storageKey: "test-listener-key",
+      storageKey: 'test-listener-key',
       listener: () => {
         setEventReceived(true);
       },
@@ -55,14 +51,14 @@ const MockLocalStorageComponent: React.FC = () => {
   return (
     <div data-testid="local-storage-component">
       <div data-testid="is-available">{isAvailable.toString()}</div>
-      <div data-testid="test-value">{testValue || "null"}</div>
-      <div data-testid="spiffy-on-value">{spiffyOnValue || "null"}</div>
+      <div data-testid="test-value">{testValue || 'null'}</div>
+      <div data-testid="spiffy-on-value">{spiffyOnValue || 'null'}</div>
       <div data-testid="event-received">{eventReceived.toString()}</div>
       <button
         data-testid="set-item-btn"
         onClick={() => {
-          setItem("test-key", "test-value");
-          setTestValue(getItem("test-key"));
+          setItem('test-key', 'test-value');
+          setTestValue(getItem('test-key'));
         }}
       >
         Set Item
@@ -88,7 +84,7 @@ const MockLocalStorageComponent: React.FC = () => {
       <button
         data-testid="trigger-event-btn"
         onClick={() => {
-          setItem("test-listener-key", "event-value");
+          setItem('test-listener-key', 'event-value');
         }}
       >
         Trigger Event
@@ -97,35 +93,33 @@ const MockLocalStorageComponent: React.FC = () => {
   );
 };
 
-describe("LocalStorageProvider", () => {
+describe('LocalStorageProvider', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     // Clear localStorage before each test
-    if (typeof localStorage !== "undefined") {
+    if (typeof localStorage !== 'undefined') {
       localStorage.clear();
     }
   });
 
-  describe("useLocalStorage Hook Integration", () => {
-    it("should provide localStorage context through useLocalStorage hook", async () => {
+  describe('useLocalStorage Hook Integration', () => {
+    it('should provide localStorage context through useLocalStorage hook', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
 
       // Verify all context methods are accessible
-      expect(screen.getByTestId("local-storage-component")).toBeInTheDocument();
+      expect(screen.getByTestId('local-storage-component')).toBeInTheDocument();
     });
 
-    it("should throw error when used outside of LocalStorageProvider", () => {
-      const consoleSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
+    it('should throw error when used outside of LocalStorageProvider', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       const TestComponent: React.FC = () => {
         try {
@@ -138,30 +132,30 @@ describe("LocalStorageProvider", () => {
 
       render(<TestComponent />);
 
-      expect(screen.getByTestId("error")).toHaveTextContent(
-        "useLocalStorage must be used within a LocalStorageProvider"
+      expect(screen.getByTestId('error')).toHaveTextContent(
+        'useLocalStorage must be used within a LocalStorageProvider',
       );
 
       consoleSpy.mockRestore();
     });
   });
 
-  describe("isAvailable State", () => {
-    it("should be true when localStorage is available", async () => {
+  describe('isAvailable State', () => {
+    it('should be true when localStorage is available', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
     });
 
-    it("should be false when localStorage is not available", async () => {
+    it('should be false when localStorage is not available', async () => {
       const originalLocalStorage = window.localStorage;
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: undefined,
         writable: true,
         configurable: true,
@@ -170,25 +164,25 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("false");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('false');
       });
 
       // Restore localStorage
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: originalLocalStorage,
         writable: true,
         configurable: true,
       });
     });
 
-    it("should log error when localStorage is not available", async () => {
-      const logErrorSpy = vi.spyOn(Logger, "logError");
+    it('should log error when localStorage is not available', async () => {
+      const logErrorSpy = vi.spyOn(Logger, 'logError');
       const originalLocalStorage = window.localStorage;
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: undefined,
         writable: true,
         configurable: true,
@@ -197,18 +191,15 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <div>Test</div>
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(logErrorSpy).toHaveBeenCalledWith(
-          "localStorage is not available",
-          undefined
-        );
+        expect(logErrorSpy).toHaveBeenCalledWith('localStorage is not available', undefined);
       });
 
       // Restore localStorage
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: originalLocalStorage,
         writable: true,
         configurable: true,
@@ -216,71 +207,71 @@ describe("LocalStorageProvider", () => {
     });
   });
 
-  describe("setItem and getItem", () => {
-    it("should set and get items from localStorage", async () => {
+  describe('setItem and getItem', () => {
+    it('should set and get items from localStorage', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
 
       await act(async () => {
-        screen.getByTestId("set-item-btn").click();
+        screen.getByTestId('set-item-btn').click();
       });
 
       await waitFor(() => {
-        expect(screen.getByTestId("test-value")).toHaveTextContent("test-value");
+        expect(screen.getByTestId('test-value')).toHaveTextContent('test-value');
       });
 
       // Verify it's actually in localStorage
-      expect(localStorage.getItem("test-key")).toBe("test-value");
+      expect(localStorage.getItem('test-key')).toBe('test-value');
     });
 
     it("should return null when item doesn't exist", async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("test-value")).toHaveTextContent("null");
+        expect(screen.getByTestId('test-value')).toHaveTextContent('null');
       });
     });
 
-    it("should dispatch storage event when setItem is called", async () => {
+    it('should dispatch storage event when setItem is called', async () => {
       const eventHandler = vi.fn();
-      window.addEventListener("storage", eventHandler);
+      window.addEventListener('storage', eventHandler);
 
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
 
       await act(async () => {
-        screen.getByTestId("set-item-btn").click();
+        screen.getByTestId('set-item-btn').click();
       });
 
       await waitFor(() => {
         expect(eventHandler).toHaveBeenCalled();
         const event = eventHandler.mock.calls[0][0] as StorageEvent;
-        expect(event.key).toBe("test-key");
-        expect(event.newValue).toBe("test-value");
+        expect(event.key).toBe('test-key');
+        expect(event.newValue).toBe('test-value');
       });
 
-      window.removeEventListener("storage", eventHandler);
+      window.removeEventListener('storage', eventHandler);
     });
 
-    it("should not set item when localStorage is not available", async () => {
+    it('should not set item when localStorage is not available', async () => {
       const originalLocalStorage = window.localStorage;
       const mockLocalStorage = {
         setItem: vi.fn(),
@@ -291,7 +282,7 @@ describe("LocalStorageProvider", () => {
         length: 0,
       };
 
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: undefined,
         writable: true,
         configurable: true,
@@ -300,7 +291,7 @@ describe("LocalStorageProvider", () => {
       const TestComponent: React.FC = () => {
         const { setItem } = useLocalStorage();
         React.useEffect(() => {
-          setItem("test-key", "test-value");
+          setItem('test-key', 'test-value');
         }, [setItem]);
         return <div>Test</div>;
       };
@@ -308,7 +299,7 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
@@ -317,16 +308,16 @@ describe("LocalStorageProvider", () => {
       });
 
       // Restore localStorage
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: originalLocalStorage,
         writable: true,
         configurable: true,
       });
     });
 
-    it("should not get item when localStorage is not available", async () => {
+    it('should not get item when localStorage is not available', async () => {
       const originalLocalStorage = window.localStorage;
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: undefined,
         writable: true,
         configurable: true,
@@ -334,22 +325,22 @@ describe("LocalStorageProvider", () => {
 
       const TestComponent: React.FC = () => {
         const { getItem } = useLocalStorage();
-        const value = getItem("test-key");
-        return <div data-testid="value">{value || "null"}</div>;
+        const value = getItem('test-key');
+        return <div data-testid="value">{value || 'null'}</div>;
       };
 
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("value")).toHaveTextContent("null");
+        expect(screen.getByTestId('value')).toHaveTextContent('null');
       });
 
       // Restore localStorage
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: originalLocalStorage,
         writable: true,
         configurable: true,
@@ -357,61 +348,56 @@ describe("LocalStorageProvider", () => {
     });
   });
 
-  describe("setSpiffyOnFeatureFlag and getSpiffyOnFeatureFlag", () => {
-    it("should set SpiffyOn feature flag to true", async () => {
+  describe('setSpiffyOnFeatureFlag and getSpiffyOnFeatureFlag', () => {
+    it('should set SpiffyOn feature flag to true', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
 
       await act(async () => {
-        screen.getByTestId("set-spiffy-on-true-btn").click();
+        screen.getByTestId('set-spiffy-on-true-btn').click();
       });
 
       await waitFor(() => {
-        expect(screen.getByTestId("spiffy-on-value")).toHaveTextContent("true");
+        expect(screen.getByTestId('spiffy-on-value')).toHaveTextContent('true');
       });
 
       // Verify it's actually in localStorage
-      expect(localStorage.getItem(LocalStorageKeys.SpiffyOnOverride)).toBe(
-        "true"
-      );
+      expect(localStorage.getItem(LocalStorageKeys.SpiffyOnOverride)).toBe('true');
     });
 
-    it("should set SpiffyOn feature flag to false", async () => {
+    it('should set SpiffyOn feature flag to false', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
 
       await act(async () => {
-        screen.getByTestId("set-spiffy-on-false-btn").click();
+        screen.getByTestId('set-spiffy-on-false-btn').click();
       });
 
       await waitFor(() => {
-        expect(screen.getByTestId("spiffy-on-value")).toHaveTextContent("false");
+        expect(screen.getByTestId('spiffy-on-value')).toHaveTextContent('false');
       });
 
       // Verify it's actually in localStorage
-      expect(localStorage.getItem(LocalStorageKeys.SpiffyOnOverride)).toBe(
-        "false"
-      );
+      expect(localStorage.getItem(LocalStorageKeys.SpiffyOnOverride)).toBe('false');
     });
 
-    it("should not set feature flag when value is null", async () => {
+    it('should not set feature flag when value is null', async () => {
       const TestComponent: React.FC = () => {
-        const { setSpiffyOnFeatureFlag, getSpiffyOnFeatureFlag } =
-          useLocalStorage();
+        const { setSpiffyOnFeatureFlag, getSpiffyOnFeatureFlag } = useLocalStorage();
         React.useEffect(() => {
           setSpiffyOnFeatureFlag(null);
           const value = getSpiffyOnFeatureFlag();
@@ -423,7 +409,7 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
@@ -432,21 +418,21 @@ describe("LocalStorageProvider", () => {
       });
     });
 
-    it("should return null when feature flag is not set", async () => {
+    it('should return null when feature flag is not set', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("spiffy-on-value")).toHaveTextContent("null");
+        expect(screen.getByTestId('spiffy-on-value')).toHaveTextContent('null');
       });
     });
 
-    it("should not set feature flag when localStorage is not available", async () => {
+    it('should not set feature flag when localStorage is not available', async () => {
       const originalLocalStorage = window.localStorage;
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: undefined,
         writable: true,
         configurable: true,
@@ -463,16 +449,16 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
         // Should not throw, just return early
-        expect(screen.getByTestId("is-available")).toHaveTextContent("false");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('false');
       });
 
       // Restore localStorage
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: originalLocalStorage,
         writable: true,
         configurable: true,
@@ -480,31 +466,34 @@ describe("LocalStorageProvider", () => {
     });
   });
 
-  describe("attachListener and detachListener", () => {
-    it("should attach and trigger storage event listener", async () => {
+  describe('attachListener and detachListener', () => {
+    it('should attach and trigger storage event listener', async () => {
       render(
         <LocalStorageProvider>
           <MockLocalStorageComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-available")).toHaveTextContent("true");
+        expect(screen.getByTestId('is-available')).toHaveTextContent('true');
       });
 
       // Wait a bit to ensure listener is attached
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      await new Promise(resolve => setTimeout(resolve, 50));
 
       await act(async () => {
-        screen.getByTestId("trigger-event-btn").click();
+        screen.getByTestId('trigger-event-btn').click();
       });
 
-      await waitFor(() => {
-        expect(screen.getByTestId("event-received")).toHaveTextContent("true");
-      }, { timeout: 2000 });
+      await waitFor(
+        () => {
+          expect(screen.getByTestId('event-received')).toHaveTextContent('true');
+        },
+        { timeout: 2000 },
+      );
     });
 
-    it("should only trigger listener for matching storage key", async () => {
+    it('should only trigger listener for matching storage key', async () => {
       const listener1 = vi.fn();
       const listener2 = vi.fn();
 
@@ -514,11 +503,11 @@ describe("LocalStorageProvider", () => {
 
         React.useEffect(() => {
           const listenerObj1: LocalStorageEventListener = {
-            storageKey: "key1",
+            storageKey: 'key1',
             listener: listener1,
           };
           const listenerObj2: LocalStorageEventListener = {
-            storageKey: "key2",
+            storageKey: 'key2',
             listener: listener2,
           };
           attachListener(listenerObj1);
@@ -535,7 +524,7 @@ describe("LocalStorageProvider", () => {
           if (ready) {
             // Set item for key1 after listeners are attached
             setTimeout(() => {
-              setItem("key1", "value1");
+              setItem('key1', 'value1');
             }, 50);
           }
         }, [ready, setItem]);
@@ -546,21 +535,24 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("ready")).toHaveTextContent("true");
+        expect(screen.getByTestId('ready')).toHaveTextContent('true');
       });
 
-      await waitFor(() => {
-        expect(listener1).toHaveBeenCalled();
-        expect(listener2).not.toHaveBeenCalled();
-      }, { timeout: 2000 });
+      await waitFor(
+        () => {
+          expect(listener1).toHaveBeenCalled();
+          expect(listener2).not.toHaveBeenCalled();
+        },
+        { timeout: 2000 },
+      );
     });
 
-    it("should log debug message when storage event is received", async () => {
-      const logDebugSpy = vi.spyOn(Logger, "logDebug");
+    it('should log debug message when storage event is received', async () => {
+      const logDebugSpy = vi.spyOn(Logger, 'logDebug');
 
       const TestComponent: React.FC = () => {
         const { attachListener, setItem, detachListener } = useLocalStorage();
@@ -568,7 +560,7 @@ describe("LocalStorageProvider", () => {
 
         React.useEffect(() => {
           const listener: LocalStorageEventListener = {
-            storageKey: "test-key",
+            storageKey: 'test-key',
             listener: () => {},
           };
           attachListener(listener);
@@ -583,7 +575,7 @@ describe("LocalStorageProvider", () => {
           if (ready) {
             // Set item after listener is attached
             setTimeout(() => {
-              setItem("test-key", "test-value");
+              setItem('test-key', 'test-value');
             }, 50);
           }
         }, [ready, setItem]);
@@ -594,22 +586,25 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("ready")).toHaveTextContent("true");
+        expect(screen.getByTestId('ready')).toHaveTextContent('true');
       });
 
-      await waitFor(() => {
-        expect(logDebugSpy).toHaveBeenCalledWith(
-          "[spiffy-ai] Storage event key=test-key, value=",
-          "test-value"
-        );
-      }, { timeout: 2000 });
+      await waitFor(
+        () => {
+          expect(logDebugSpy).toHaveBeenCalledWith(
+            '[spiffy-ai] Storage event key=test-key, value=',
+            'test-value',
+          );
+        },
+        { timeout: 2000 },
+      );
     });
 
-    it("should attach and detach listeners without errors", async () => {
+    it('should attach and detach listeners without errors', async () => {
       const listener = vi.fn();
 
       const TestComponent: React.FC = () => {
@@ -618,7 +613,7 @@ describe("LocalStorageProvider", () => {
 
         React.useEffect(() => {
           const listenerObj: LocalStorageEventListener = {
-            storageKey: "test-key",
+            storageKey: 'test-key',
             listener,
           };
           attachListener(listenerObj);
@@ -635,22 +630,22 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("attached")).toHaveTextContent("true");
+        expect(screen.getByTestId('attached')).toHaveTextContent('true');
       });
 
       // Verify methods can be called without errors
-      expect(screen.getByTestId("attached")).toBeInTheDocument();
+      expect(screen.getByTestId('attached')).toBeInTheDocument();
     });
 
-    it("should not attach listener when localStorage is not available", async () => {
+    it('should not attach listener when localStorage is not available', async () => {
       const originalLocalStorage = window.localStorage;
-      const addEventListenerSpy = vi.spyOn(window, "addEventListener");
+      const addEventListenerSpy = vi.spyOn(window, 'addEventListener');
 
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: undefined,
         writable: true,
         configurable: true,
@@ -660,7 +655,7 @@ describe("LocalStorageProvider", () => {
         const { attachListener } = useLocalStorage();
         React.useEffect(() => {
           attachListener({
-            storageKey: "test-key",
+            storageKey: 'test-key',
             listener: () => {},
           });
         }, [attachListener]);
@@ -670,13 +665,13 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
         // addEventListener should not be called for storage events
         const storageCalls = addEventListenerSpy.mock.calls.filter(
-          (call: any) => call[0] === "storage"
+          (call: any) => call[0] === 'storage',
         );
         expect(storageCalls.length).toBe(0);
       });
@@ -684,14 +679,14 @@ describe("LocalStorageProvider", () => {
       addEventListenerSpy.mockRestore();
 
       // Restore localStorage
-      Object.defineProperty(window, "localStorage", {
+      Object.defineProperty(window, 'localStorage', {
         value: originalLocalStorage,
         writable: true,
         configurable: true,
       });
     });
 
-    it("should allow attaching and detaching multiple listeners", async () => {
+    it('should allow attaching and detaching multiple listeners', async () => {
       const listener1 = vi.fn();
       const listener2 = vi.fn();
 
@@ -701,11 +696,11 @@ describe("LocalStorageProvider", () => {
 
         React.useEffect(() => {
           const listenerObj1: LocalStorageEventListener = {
-            storageKey: "key1",
+            storageKey: 'key1',
             listener: listener1,
           };
           const listenerObj2: LocalStorageEventListener = {
-            storageKey: "key2",
+            storageKey: 'key2',
             listener: listener2,
           };
 
@@ -727,20 +722,20 @@ describe("LocalStorageProvider", () => {
       render(
         <LocalStorageProvider>
           <TestComponent />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("ready")).toHaveTextContent("true");
+        expect(screen.getByTestId('ready')).toHaveTextContent('true');
       });
 
       // Verify methods can be called without errors
-      expect(screen.getByTestId("ready")).toBeInTheDocument();
+      expect(screen.getByTestId('ready')).toBeInTheDocument();
     });
   });
 
-  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;
 
@@ -760,7 +755,7 @@ describe("LocalStorageProvider", () => {
         <LocalStorageProvider>
           <Component1 />
           <Component2 />
-        </LocalStorageProvider>
+        </LocalStorageProvider>,
       );
 
       await waitFor(() => {
@@ -772,4 +767,3 @@ describe("LocalStorageProvider", () => {
     });
   });
 });
-