@terreno/ui 0.9.2 → 0.10.0

package/src/table/TableBadge.test.tsx

@@ -1,4 +1,5 @@
 import {describe, expect, it} from "bun:test";
+import {fireEvent} from "@testing-library/react-native";
 import {renderWithTheme} from "../test-utils";
 import {TableBadge} from "./TableBadge";
 
@@ -50,4 +51,39 @@ describe("TableBadge", () => {
     );
     expect(toJSON()).toMatchSnapshot();
   });
+
+  it("renders badge when editing is enabled but options are missing", () => {
+    const {getByText, queryByTestId} = renderWithTheme(<TableBadge isEditing value="Pending" />);
+    expect(getByText("Pending")).toBeTruthy();
+    expect(queryByTestId("ios_picker")).toBeNull();
+  });
+
+  it("updates selected value when select field changes to a non-empty option", () => {
+    const editingOptions = [
+      {label: "Option A", value: "a"},
+      {label: "Option B", value: "b"},
+    ];
+    const {getByTestId} = renderWithTheme(
+      <TableBadge editingOptions={editingOptions} isEditing value="a" />
+    );
+    const picker = getByTestId("ios_picker");
+
+    expect(picker.props.selectedValue).toBe("a");
+    fireEvent(picker, "onValueChange", "b", 2);
+    expect(getByTestId("ios_picker").props.selectedValue).toBe("b");
+  });
+
+  it("clears selected value when select field changes to an empty value", () => {
+    const editingOptions = [
+      {label: "Option A", value: "a"},
+      {label: "Option B", value: "b"},
+    ];
+    const {getByTestId} = renderWithTheme(
+      <TableBadge editingOptions={editingOptions} isEditing value="a" />
+    );
+    const picker = getByTestId("ios_picker");
+
+    fireEvent(picker, "onValueChange", "", 0);
+    expect(getByTestId("ios_picker").props.selectedValue).toBe("");
+  });
 });

package/src/table/TableHeaderCell.tsx

@@ -73,7 +73,7 @@ export const TableHeaderCell = ({
             style={{
               alignItems: "center",
               backgroundColor: theme.surface.primary,
-              borderRadius: theme.radius.rounded as any,
+              borderRadius: theme.radius.rounded,
               height: 16,
               justifyContent: "center",
               width: 16,

package/src/useConsentForms.ts

@@ -19,6 +19,41 @@ export interface ConsentFormPublic {
 
 import {getLocales} from "expo-localization";
 
+interface ConsentFormsResponse {
+  data?: ConsentFormPublic[];
+}
+
+interface ConsentFormsQueryBuilder {
+  query: (options: {
+    onQueryStarted?: (
+      _arg: unknown,
+      helpers: {queryFulfilled: Promise<ConsentFormsResponse>}
+    ) => Promise<void>;
+    providesTags: string[];
+    query: () => string;
+  }) => unknown;
+}
+
+interface ConsentFormsHookState {
+  data?: ConsentFormPublic[] | ConsentFormsResponse;
+  error: unknown;
+  isLoading: boolean;
+  refetch: () => void | Promise<void>;
+}
+
+interface ConsentFormsApiWithTags {
+  injectEndpoints: (options: {
+    endpoints: (build: ConsentFormsQueryBuilder) => {getPendingConsents: unknown};
+    overrideExisting: boolean;
+  }) => {
+    useGetPendingConsentsQuery: () => ConsentFormsHookState;
+  };
+}
+
+interface ConsentFormsApi {
+  enhanceEndpoints: (options: {addTagTypes: string[]}) => ConsentFormsApiWithTags;
+}
+
 export const detectLocale = (): string => {
   // Web
   if (typeof navigator !== "undefined" && navigator.language) {
@@ -38,17 +73,17 @@ export const detectLocale = (): string => {
   return "en";
 };
 
-export const useConsentForms = (api: any, baseUrl?: string) => {
+export const useConsentForms = (api: ConsentFormsApi, baseUrl?: string) => {
   const base = baseUrl || "";
   const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
 
   const enhancedApi = apiWithConsentTags.injectEndpoints({
-    endpoints: (build: any) => ({
+    endpoints: (build) => ({
       getPendingConsents: build.query({
-        async onQueryStarted(_arg: unknown, {queryFulfilled}: {queryFulfilled: Promise<unknown>}) {
+        async onQueryStarted(_arg: unknown, {queryFulfilled}) {
           console.info("[useConsentForms] Fetching pending consent forms");
           try {
-            const result = (await queryFulfilled) as {data?: ConsentFormPublic[]};
+            const result = await queryFulfilled;
             console.info("[useConsentForms] Pending consent forms fetched", {
               count: result?.data?.length ?? 0,
             });

package/src/useConsentHistory.ts

@@ -20,11 +20,35 @@ export interface ConsentHistoryEntry {
   userAgent?: string;
 }
 
-export const useConsentHistory = (api: any, baseUrl?: string) => {
+interface ConsentHistoryResponse {
+  data?: ConsentHistoryEntry[];
+}
+
+interface ConsentHistoryQueryBuilder {
+  query: (options: {providesTags: string[]; query: () => string}) => unknown;
+}
+
+interface ConsentHistoryHookState {
+  data?: ConsentHistoryEntry[] | ConsentHistoryResponse;
+  error: unknown;
+  isLoading: boolean;
+  refetch: () => void | Promise<void>;
+}
+
+interface ConsentHistoryApi {
+  injectEndpoints: (options: {
+    endpoints: (build: ConsentHistoryQueryBuilder) => {getMyConsents: unknown};
+    overrideExisting: boolean;
+  }) => {
+    useGetMyConsentsQuery: () => ConsentHistoryHookState;
+  };
+}
+
+export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
   const base = baseUrl || "";
 
   const enhancedApi = api.injectEndpoints({
-    endpoints: (build: any) => ({
+    endpoints: (build) => ({
       getMyConsents: build.query({
         providesTags: ["MyConsents"],
         query: () => `${base}/consents/my`,

package/src/useSubmitConsent.ts

@@ -6,12 +6,48 @@ export interface SubmitConsentBody {
   signature?: string;
 }
 
-export const useSubmitConsent = (api: any, baseUrl?: string) => {
+interface SubmitConsentMutationResult {
+  unwrap: () => Promise<unknown>;
+}
+
+interface SubmitConsentMutationHookState {
+  error: unknown;
+  isLoading: boolean;
+}
+
+interface SubmitConsentMutationBuilder {
+  mutation: (options: {
+    invalidatesTags: string[];
+    query: (body: SubmitConsentBody) => {
+      body: SubmitConsentBody;
+      method: "POST";
+      url: string;
+    };
+  }) => unknown;
+}
+
+interface SubmitConsentApiWithTags {
+  injectEndpoints: (options: {
+    endpoints: (build: SubmitConsentMutationBuilder) => {submitConsentResponse: unknown};
+    overrideExisting: boolean;
+  }) => {
+    useSubmitConsentResponseMutation: () => [
+      (body: SubmitConsentBody) => SubmitConsentMutationResult,
+      SubmitConsentMutationHookState,
+    ];
+  };
+}
+
+interface SubmitConsentApi {
+  enhanceEndpoints: (options: {addTagTypes: string[]}) => SubmitConsentApiWithTags;
+}
+
+export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
   const base = baseUrl || "";
   const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
 
   const enhancedApi = apiWithConsentTags.injectEndpoints({
-    endpoints: (build: any) => ({
+    endpoints: (build) => ({
       submitConsentResponse: build.mutation({
         invalidatesTags: ["PendingConsents"],
         query: (body: SubmitConsentBody) => ({