@terreno/ui 0.12.2 → 0.13.3

package/src/__snapshots__/SelectField.test.tsx.snap

@@ -51,7 +51,6 @@ exports[`SelectField renders correctly with default props 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -341,7 +340,6 @@ exports[`SelectField renders with title 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -616,7 +614,6 @@ exports[`SelectField renders with selected value 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -891,7 +888,6 @@ exports[`SelectField renders with custom placeholder 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -1166,7 +1162,6 @@ exports[`SelectField renders disabled state 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -1443,7 +1438,6 @@ exports[`SelectField renders with requireValue (no clear option) 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",

package/src/__snapshots__/TerrenoProvider.test.tsx.snap

@@ -27,15 +27,8 @@ exports[`TerrenoProvider renders correctly with default props 1`] = `
       },
     ],
     "props": {
-      "collapsable": false,
-      "pointerEvents": "box-none",
-      "style": [
-        {
-          "flex": 1,
-        },
-        undefined,
-      ],
-      "testID": undefined,
+      "style": undefined,
+      "testID": "portal-host",
     },
     "type": "View",
   },
@@ -123,15 +116,8 @@ exports[`TerrenoProvider renders with openAPISpecUrl 1`] = `
       },
     ],
     "props": {
-      "collapsable": false,
-      "pointerEvents": "box-none",
-      "style": [
-        {
-          "flex": 1,
-        },
-        undefined,
-      ],
-      "testID": undefined,
+      "style": undefined,
+      "testID": "portal-host",
     },
     "type": "View",
   },

package/src/__snapshots__/TimezonePicker.test.tsx.snap

@@ -66,7 +66,6 @@ exports[`TimezonePicker renders correctly with default props 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -381,7 +380,6 @@ exports[`TimezonePicker hides title when hideTitle is true 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -711,7 +709,6 @@ exports[`TimezonePicker renders with selected timezone 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -1041,7 +1038,6 @@ exports[`TimezonePicker renders USA timezones by default 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -1371,7 +1367,6 @@ exports[`TimezonePicker renders with short timezone labels 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",
@@ -1701,7 +1696,6 @@ exports[`TimezonePicker calls onChange when timezone is selected 1`] = `
             },
           ],
           "props": {
-            "activeOpacity": 1,
             "onPress": [Function],
             "style": {
               "alignItems": "center",

package/src/bunSetup.ts

@@ -530,6 +530,28 @@ mock.module("react-native-signature-canvas", () => ({
   Signature: mock(() => null),
 }));
 
+// Mock react-signature-canvas (web). The real module references `window` at
+// import time, which doesn't exist under bun test.
+mock.module("react-signature-canvas", () => {
+  const SignatureCanvasMock = React.forwardRef(
+    ({backgroundColor}: {backgroundColor?: string}, _ref) =>
+      React.createElement("View", {style: {backgroundColor}, testID: "signature-canvas"})
+  );
+  return {__esModule: true, default: SignatureCanvasMock};
+});
+
+// Mock react-native-portalize. The real `Host` wraps children in an extra View
+// whose presence makes snapshots brittle, and individual tests already mock
+// this to render inline; hoisting the mock to setup keeps test ordering from
+// leaking different shapes into other test files. Shape matches the per-file
+// mock used by Tooltip.test.tsx so the two don't disagree.
+mock.module("react-native-portalize", () => ({
+  Host: ({children}: MockComponentProps) =>
+    React.createElement("View", {style: undefined, testID: "portal-host"}, children),
+  Portal: ({children}: MockComponentProps) =>
+    React.createElement("View", {style: undefined, testID: "portal"}, children),
+}));
+
 // Mock IconButton component
 mock.module("./IconButton", () => ({
   IconButton: mock(() => null),

package/src/polyfill.d.ts

@@ -6,6 +6,6 @@
 //   }
 
 //   interface Object {
-//     values<T>(obj: any): T[];
+//     values<T>(obj: object): T[];
 //   }
 // }

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

@@ -485,7 +485,6 @@ exports[`TableBadge renders select field when editing 1`] = `
                 },
               ],
               "props": {
-                "activeOpacity": 1,
                 "onPress": [Function],
                 "style": {
                   "alignItems": "center",

package/src/useConsentForms.test.ts

@@ -149,4 +149,29 @@ describe("useConsentForms", () => {
     const {result} = renderHook(() => useConsentForms(api as unknown as ConsentFormsApi));
     expect(result.current.error).toBe("error");
   });
+
+  it("injects the pending-consents endpoint only once per (api, baseUrl)", () => {
+    let injectCallCount = 0;
+    const refetch = mock(() => {});
+    const useGetPendingConsentsQuery = mock(() => ({
+      data: undefined,
+      error: undefined,
+      isLoading: false,
+      refetch,
+    }));
+    const api = {
+      enhanceEndpoints: () => ({
+        injectEndpoints: () => {
+          injectCallCount += 1;
+          return {useGetPendingConsentsQuery};
+        },
+      }),
+    };
+    const {rerender} = renderHook(() => useConsentForms(api as unknown as ConsentFormsApi));
+    rerender(undefined);
+    rerender(undefined);
+    // The hook reuses the cached enhanced api after the first render so the
+    // dev-mode RTK warning about re-injecting endpoints never fires.
+    expect(injectCallCount).toBe(1);
+  });
 });

package/src/useConsentForms.ts

@@ -41,13 +41,15 @@ interface ConsentFormsHookState {
   refetch: () => void | Promise<void>;
 }
 
+interface ConsentFormsEnhancedApi {
+  useGetPendingConsentsQuery: () => ConsentFormsHookState;
+}
+
 interface ConsentFormsApiWithTags {
   injectEndpoints: (options: {
     endpoints: (build: ConsentFormsQueryBuilder) => {getPendingConsents: unknown};
     overrideExisting: boolean;
-  }) => {
-    useGetPendingConsentsQuery: () => ConsentFormsHookState;
-  };
+  }) => ConsentFormsEnhancedApi;
 }
 
 interface ConsentFormsApi {
@@ -73,11 +75,27 @@ export const detectLocale = (): string => {
   return "en";
 };
 
-export const useConsentForms = (api: ConsentFormsApi, baseUrl?: string) => {
-  const base = baseUrl || "";
-  const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
+/**
+ * Cache the enhanced api per (api, baseUrl). `injectEndpoints` logs a console
+ * error in development whenever an endpoint with the same name is re-injected
+ * (with `overrideExisting: false`), so calling it on every render of every
+ * consumer would flood the console. WeakMap-by-api lets the GC reclaim entries
+ * when the api object is unreachable.
+ */
+const enhancedApiCache = new WeakMap<ConsentFormsApi, Map<string, ConsentFormsEnhancedApi>>();
 
-  const enhancedApi = apiWithConsentTags.injectEndpoints({
+const getEnhancedApi = (api: ConsentFormsApi, base: string): ConsentFormsEnhancedApi => {
+  let byBase = enhancedApiCache.get(api);
+  if (!byBase) {
+    byBase = new Map();
+    enhancedApiCache.set(api, byBase);
+  }
+  const cached = byBase.get(base);
+  if (cached) {
+    return cached;
+  }
+  const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
+  const enhanced = apiWithConsentTags.injectEndpoints({
     endpoints: (build) => ({
       getPendingConsents: build.query({
         async onQueryStarted(_arg: unknown, {queryFulfilled}) {
@@ -97,6 +115,13 @@ export const useConsentForms = (api: ConsentFormsApi, baseUrl?: string) => {
     }),
     overrideExisting: false,
   });
+  byBase.set(base, enhanced);
+  return enhanced;
+};
+
+export const useConsentForms = (api: ConsentFormsApi, baseUrl?: string) => {
+  const base = baseUrl || "";
+  const enhancedApi = getEnhancedApi(api, base);
 
   const {data, isLoading, error, refetch} = enhancedApi.useGetPendingConsentsQuery();
   const forms: ConsentFormPublic[] = Array.isArray(data) ? data : (data?.data ?? []);

package/src/useConsentHistory.test.ts

@@ -0,0 +1,99 @@
+import {describe, expect, it, mock} from "bun:test";
+import {renderHook} from "@testing-library/react-native";
+
+import type {ConsentHistoryEntry} from "./useConsentHistory";
+import {useConsentHistory} from "./useConsentHistory";
+
+type ConsentHistoryApi = Parameters<typeof useConsentHistory>[0];
+
+interface MockQueryDef {
+  query: () => string;
+  providesTags: string[];
+}
+
+interface MockInjectOpts {
+  endpoints: (build: {query: (def: MockQueryDef) => string}) => Record<string, unknown>;
+}
+
+describe("useConsentHistory", () => {
+  const buildApi = (queryResult: {data?: unknown; error?: unknown; isLoading?: boolean}) => {
+    const refetch = mock(() => {});
+    const useGetMyConsentsQuery = mock(() => ({
+      data: queryResult.data,
+      error: queryResult.error,
+      isLoading: queryResult.isLoading ?? false,
+      refetch,
+    }));
+    const api = {
+      injectEndpoints: mock((opts: MockInjectOpts) => {
+        const build = {
+          query: mock((def: MockQueryDef) => {
+            // Exercise the URL builder so the closure captures `base`
+            const url = def.query();
+            expect(url).toContain("/consents/my");
+            return "my-consents-query";
+          }),
+        };
+        opts.endpoints(build);
+        return {useGetMyConsentsQuery};
+      }),
+    };
+    return {api, refetch};
+  };
+
+  it("returns an array of entries when response is an array", () => {
+    const {api} = buildApi({
+      data: [{_id: "1", agreed: true} as unknown as ConsentHistoryEntry],
+    });
+    const {result} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    expect(Array.isArray(result.current.entries)).toBe(true);
+    expect(result.current.entries).toHaveLength(1);
+  });
+
+  it("unwraps .data property when response is object shape", () => {
+    const {api} = buildApi({
+      data: {data: [{_id: "2", agreed: false} as unknown as ConsentHistoryEntry]},
+    });
+    const {result} = renderHook(() =>
+      useConsentHistory(api as unknown as ConsentHistoryApi, "/api")
+    );
+    expect(Array.isArray(result.current.entries)).toBe(true);
+    expect(result.current.entries).toHaveLength(1);
+  });
+
+  it("returns empty array when no data is present", () => {
+    const {api} = buildApi({data: undefined, isLoading: true});
+    const {result} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    expect(result.current.entries).toEqual([]);
+    expect(result.current.isLoading).toBe(true);
+  });
+
+  it("surfaces error from the query hook", () => {
+    const {api} = buildApi({data: undefined, error: "boom"});
+    const {result} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    expect(result.current.error).toBe("boom");
+  });
+
+  it("injects the my-consents endpoint only once per (api, baseUrl)", () => {
+    let injectCallCount = 0;
+    const refetch = mock(() => {});
+    const useGetMyConsentsQuery = mock(() => ({
+      data: undefined,
+      error: undefined,
+      isLoading: false,
+      refetch,
+    }));
+    const api = {
+      injectEndpoints: () => {
+        injectCallCount += 1;
+        return {useGetMyConsentsQuery};
+      },
+    };
+    const {rerender} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    rerender(undefined);
+    rerender(undefined);
+    // The hook reuses the cached enhanced api after the first render so the
+    // dev-mode RTK warning about re-injecting endpoints never fires.
+    expect(injectCallCount).toBe(1);
+  });
+});

package/src/useConsentHistory.ts

@@ -35,19 +35,37 @@ interface ConsentHistoryHookState {
   refetch: () => void | Promise<void>;
 }
 
+interface ConsentHistoryEnhancedApi {
+  useGetMyConsentsQuery: () => ConsentHistoryHookState;
+}
+
 interface ConsentHistoryApi {
   injectEndpoints: (options: {
     endpoints: (build: ConsentHistoryQueryBuilder) => {getMyConsents: unknown};
     overrideExisting: boolean;
-  }) => {
-    useGetMyConsentsQuery: () => ConsentHistoryHookState;
-  };
+  }) => ConsentHistoryEnhancedApi;
 }
 
-export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
-  const base = baseUrl || "";
+/**
+ * Cache the enhanced api per (api, baseUrl). `injectEndpoints` logs a console
+ * error in development whenever an endpoint with the same name is re-injected
+ * (with `overrideExisting: false`), so calling it on every render of every
+ * consumer would flood the console. WeakMap-by-api lets the GC reclaim entries
+ * when the api object is unreachable.
+ */
+const enhancedApiCache = new WeakMap<ConsentHistoryApi, Map<string, ConsentHistoryEnhancedApi>>();
 
-  const enhancedApi = api.injectEndpoints({
+const getEnhancedApi = (api: ConsentHistoryApi, base: string): ConsentHistoryEnhancedApi => {
+  let byBase = enhancedApiCache.get(api);
+  if (!byBase) {
+    byBase = new Map();
+    enhancedApiCache.set(api, byBase);
+  }
+  const cached = byBase.get(base);
+  if (cached) {
+    return cached;
+  }
+  const enhanced = api.injectEndpoints({
     endpoints: (build) => ({
       getMyConsents: build.query({
         providesTags: ["MyConsents"],
@@ -56,6 +74,13 @@ export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
     }),
     overrideExisting: false,
   });
+  byBase.set(base, enhanced);
+  return enhanced;
+};
+
+export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
+  const base = baseUrl || "";
+  const enhancedApi = getEnhancedApi(api, base);
 
   const {data, isLoading, error, refetch} = enhancedApi.useGetMyConsentsQuery();
   const entries: ConsentHistoryEntry[] = Array.isArray(data) ? data : (data?.data ?? []);

package/src/useSubmitConsent.test.ts

@@ -72,4 +72,28 @@ describe("useSubmitConsent", () => {
     const {result} = renderHook(() => useSubmitConsent(api as unknown as SubmitConsentApi));
     expect(result.current.submit).toBeDefined();
   });
+
+  it("injects the submit endpoint only once per (api, baseUrl)", () => {
+    let injectCallCount = 0;
+    const unwrap = mock(async () => ({}));
+    const submitMutation = mock(() => ({unwrap}));
+    const useSubmitConsentResponseMutation = mock(() => [
+      submitMutation,
+      {error: undefined, isLoading: false},
+    ]);
+    const api = {
+      enhanceEndpoints: () => ({
+        injectEndpoints: () => {
+          injectCallCount += 1;
+          return {useSubmitConsentResponseMutation};
+        },
+      }),
+    };
+    const {rerender} = renderHook(() => useSubmitConsent(api as unknown as SubmitConsentApi));
+    rerender(undefined);
+    rerender(undefined);
+    // The hook reuses the cached enhanced api after the first render so the
+    // dev-mode RTK warning about re-injecting endpoints never fires.
+    expect(injectCallCount).toBe(1);
+  });
 });

package/src/useSubmitConsent.ts

@@ -26,27 +26,45 @@ interface SubmitConsentMutationBuilder {
   }) => unknown;
 }
 
+interface SubmitConsentEnhancedApi {
+  useSubmitConsentResponseMutation: () => [
+    (body: SubmitConsentBody) => SubmitConsentMutationResult,
+    SubmitConsentMutationHookState,
+  ];
+}
+
 interface SubmitConsentApiWithTags {
   injectEndpoints: (options: {
     endpoints: (build: SubmitConsentMutationBuilder) => {submitConsentResponse: unknown};
     overrideExisting: boolean;
-  }) => {
-    useSubmitConsentResponseMutation: () => [
-      (body: SubmitConsentBody) => SubmitConsentMutationResult,
-      SubmitConsentMutationHookState,
-    ];
-  };
+  }) => SubmitConsentEnhancedApi;
 }
 
 interface SubmitConsentApi {
   enhanceEndpoints: (options: {addTagTypes: string[]}) => SubmitConsentApiWithTags;
 }
 
-export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
-  const base = baseUrl || "";
-  const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
+/**
+ * Cache the enhanced api per (api, baseUrl). `injectEndpoints` logs a console
+ * error in development whenever an endpoint with the same name is re-injected
+ * (with `overrideExisting: false`), so calling it on every render of every
+ * consumer would flood the console. WeakMap-by-api lets the GC reclaim entries
+ * when the api object is unreachable.
+ */
+const enhancedApiCache = new WeakMap<SubmitConsentApi, Map<string, SubmitConsentEnhancedApi>>();
 
-  const enhancedApi = apiWithConsentTags.injectEndpoints({
+const getEnhancedApi = (api: SubmitConsentApi, base: string): SubmitConsentEnhancedApi => {
+  let byBase = enhancedApiCache.get(api);
+  if (!byBase) {
+    byBase = new Map();
+    enhancedApiCache.set(api, byBase);
+  }
+  const cached = byBase.get(base);
+  if (cached) {
+    return cached;
+  }
+  const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
+  const enhanced = apiWithConsentTags.injectEndpoints({
     endpoints: (build) => ({
       submitConsentResponse: build.mutation({
         invalidatesTags: ["PendingConsents"],
@@ -59,6 +77,13 @@ export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
     }),
     overrideExisting: false,
   });
+  byBase.set(base, enhanced);
+  return enhanced;
+};
+
+export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
+  const base = baseUrl || "";
+  const enhancedApi = getEnhancedApi(api, base);
 
   const [submitMutation, {isLoading: isSubmitting, error}] =
     enhancedApi.useSubmitConsentResponseMutation();