@terreno/ui 0.14.0 → 0.14.1

package/src/table/TableRow.test.tsx

@@ -1,5 +1,7 @@
-import {describe, expect, it} from "bun:test";
+import {describe, expect, it, type mock} from "bun:test";
+import {act} from "@testing-library/react-native";
 
+import {IconButton} from "../IconButton";
 import {Text} from "../Text";
 import {renderWithTheme} from "../test-utils";
 import {Table} from "./Table";
@@ -113,4 +115,32 @@ describe("TableRow", () => {
     // Snapshot captures the blank placeholder cell for the row without drawer contents
     expect(toJSON()).toMatchSnapshot();
   });
+
+  it("toggles drawer contents when the expand button is pressed", () => {
+    const iconButtonMock = IconButton as unknown as ReturnType<typeof mock>;
+    iconButtonMock.mockClear();
+
+    const {queryByText} = renderWithTheme(
+      <Table columns={[100]}>
+        <TableHeader>
+          <TableHeaderCell index={0} title="Name" />
+        </TableHeader>
+        <TableRow drawerContents={<Text>Hidden content</Text>}>
+          <TableText value="Row" />
+        </TableRow>
+      </Table>
+    );
+
+    expect(queryByText("Hidden content")).toBeNull();
+
+    act(() => {
+      iconButtonMock.mock.calls[iconButtonMock.mock.calls.length - 1][0].onClick();
+    });
+    expect(queryByText("Hidden content")).toBeTruthy();
+
+    act(() => {
+      iconButtonMock.mock.calls[iconButtonMock.mock.calls.length - 1][0].onClick();
+    });
+    expect(queryByText("Hidden content")).toBeNull();
+  });
 });

package/src/table/__snapshots__/TableHeaderCell.test.tsx.snap

@@ -1544,6 +1544,8 @@ exports[`TableHeaderCell renders sortable header with sort indicator when sorted
                                       "$$typeof": Symbol(react.test.json),
                                       "children": null,
                                       "props": {
+                                        "onPointerEnter": [Function: AsyncFunction],
+                                        "onPointerLeave": [Function: AsyncFunction],
                                         "style": {
                                           "alignItems": "center",
                                           "backgroundColor": "#0E9DCD",

package/src/table/tableContext.tsx

@@ -45,7 +45,7 @@ export const TableContextProvider = ({
   );
 };
 
-export function useTableContext(): TableContextType {
+export const useTableContext = (): TableContextType => {
   const {
     columns,
     hasDrawerContents,
@@ -64,4 +64,4 @@ export function useTableContext(): TableContextType {
     sortColumn,
     stickyHeader,
   };
-}
+};

package/src/useStoredState.test.tsx

@@ -140,4 +140,51 @@ describe("useStoredState", () => {
     expect(result.current[0]).toBe("initial value");
     expect(result.current[2]).toBe(true);
   });
+
+  it("should handle the outer catch when fetchData rejects unexpectedly", async () => {
+    const originalConsoleError = console.error;
+    console.error = mock((...args: unknown[]) => {
+      const msg = String(args[0]);
+      if (msg.includes("Error reading data from AsyncStorage")) {
+        throw new Error("unexpected failure in error handler");
+      }
+    });
+
+    getItemMock = mock(() => Promise.reject(new Error("Storage read failure")));
+    Unifier.storage.getItem = getItemMock;
+
+    const {result} = renderHook(() => useStoredState("testKey", "fallback"));
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(result.current[2]).toBe(false);
+    console.error = originalConsoleError;
+  });
+
+  it("should not update state in outer catch if unmounted", async () => {
+    const originalConsoleError = console.error;
+    console.error = mock((...args: unknown[]) => {
+      const msg = String(args[0]);
+      if (msg.includes("Error reading data from AsyncStorage")) {
+        throw new Error("force outer catch");
+      }
+    });
+
+    getItemMock = mock(() => Promise.reject(new Error("fail")));
+    Unifier.storage.getItem = getItemMock;
+
+    const {result, unmount} = renderHook(() => useStoredState("testKey", "init"));
+
+    unmount();
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(result.current[0]).toBe("init");
+    expect(result.current[2]).toBe(true);
+    console.error = originalConsoleError;
+  });
 });