@khanacademy/wonder-blocks-data 12.0.0 → 13.0.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @khanacademy/wonder-blocks-data
 
+## 13.0.0
+
+### Major Changes
+
+-   65c02cff: Return new no-data state from useCachedEffect when it is not loading and there is no data to return
+
+### Patch Changes
+
+-   Updated dependencies [1920feb8]
+    -   @khanacademy/wonder-blocks-core@6.0.1
+
 ## 12.0.0
 
 ### Major Changes

package/dist/components/data.d.ts

@@ -41,12 +41,12 @@ TData extends ValidCacheData> = {
      * loading state and data or error that gets retrieved from cache or loaded
      * via the request if no cached value is available.
      */
-    children: (result: Result<TData>) => React.ReactNode;
+    children: (result: Result<TData>) => React.ReactElement | null;
 };
 /**
  * This component is the main component of Wonder Blocks Data. With this, data
  * requirements can be placed in a React application in a manner that will
  * support server-side rendering and efficient caching.
  */
-declare const Data: <TData extends ValidCacheData>({ requestId, handler, children, retainResultOnChange, clientBehavior, }: Props<TData>) => React.ReactElement;
+declare const Data: <TData extends ValidCacheData>({ requestId, handler, children, retainResultOnChange, clientBehavior, }: Props<TData>) => React.ReactElement | null;
 export default Data;

package/dist/es/index.js

@@ -162,9 +162,9 @@ class SsrCache {
       this._ssrOnlyCache.purgeAll(realPredicate);
     };
     this.cloneHydratableData = () => {
-      var _cache$DefaultScope;
+      var _ref;
       const cache = this._hydrationCache.clone();
-      return (_cache$DefaultScope = cache[DefaultScope$2]) != null ? _cache$DefaultScope : {};
+      return (_ref = cache[DefaultScope$2]) != null ? _ref : {};
     };
     this._ssrOnlyCache = ssrOnlyCache || new SerializableInMemoryCache();
     this._hydrationCache = hydrationCache || new SerializableInMemoryCache();
@@ -261,7 +261,7 @@ class RequestTracker {
     }
     return _default;
   }
-  constructor(responseCache = undefined) {
+  constructor(responseCache) {
     this._trackedRequests = {};
     this._responseCache = void 0;
     this._requestFulfillment = void 0;
@@ -379,11 +379,15 @@ class TrackData extends React.Component {
 const loadingStatus = Object.freeze({
   status: "loading"
 });
+const noDataStatus = Object.freeze({
+  status: "no-data"
+});
 const abortedStatus = Object.freeze({
   status: "aborted"
 });
 const Status = Object.freeze({
   loading: () => loadingStatus,
+  noData: () => noDataStatus,
   aborted: () => abortedStatus,
   success: data => ({
     status: "success",
@@ -527,8 +531,8 @@ const useCachedEffect = (requestId, handler, options = {}) => {
       currentRequestRef.current = null;
     };
   }, [shouldFetch, fetchRequest]);
-  const lastResultAgnosticOfIdRef = React.useRef(Status.loading());
-  const loadingResult = retainResultOnChange ? lastResultAgnosticOfIdRef.current : Status.loading();
+  const lastResultAgnosticOfIdRef = React.useRef(Status.noData());
+  const loadingResult = retainResultOnChange ? lastResultAgnosticOfIdRef.current : shouldFetch ? Status.loading() : Status.noData();
   const result = (_ref = fetchPolicy === FetchPolicy.NetworkOnly ? networkResultRef.current : mostRecentResult) != null ? _ref : loadingResult;
   lastResultAgnosticOfIdRef.current = result;
   return [result, fetchRequest];
@@ -841,7 +845,7 @@ const useGql = (context = {}) => {
       context = {}
     } = options;
     const finalContext = mergeGqlContext(defaultContext, context);
-    return fetch(operation, variables, finalContext).then(getGqlDataFromResponse);
+    return fetch(operation, variables, finalContext).then(response => getGqlDataFromResponse(response));
   }, [gqlRouterContext]);
   return gqlFetch;
 };

package/dist/hooks/use-gql.d.ts

@@ -1,4 +1,7 @@
 import type { GqlContext, GqlOperation, GqlFetchOptions } from "../util/gql-types";
+interface GqlFetchFn<TContext extends GqlContext> {
+    <TData, TVariables extends Record<any, any>>(operation: GqlOperation<TData, TVariables>, options?: GqlFetchOptions<TVariables, TContext>): Promise<TData>;
+}
 /**
  * Hook to obtain a gqlFetch function for performing GraphQL requests.
  *
@@ -9,4 +12,5 @@ import type { GqlContext, GqlOperation, GqlFetchOptions } from "../util/gql-type
  * Values in the partial context given to the returned fetch function will
  * only be included if they have a value other than undefined.
  */
-export declare const useGql: <TContext extends GqlContext>(context?: Partial<TContext>) => <TData, TVariables extends Record<any, any>>(operation: GqlOperation<TData, TVariables>, options?: GqlFetchOptions<TVariables, TContext> | undefined) => Promise<TData>;
+export declare const useGql: <TContext extends GqlContext>(context?: Partial<TContext>) => GqlFetchFn<TContext>;
+export {};

package/dist/index.js

@@ -185,9 +185,9 @@ class SsrCache {
       this._ssrOnlyCache.purgeAll(realPredicate);
     };
     this.cloneHydratableData = () => {
-      var _cache$DefaultScope;
+      var _ref;
       const cache = this._hydrationCache.clone();
-      return (_cache$DefaultScope = cache[DefaultScope$2]) != null ? _cache$DefaultScope : {};
+      return (_ref = cache[DefaultScope$2]) != null ? _ref : {};
     };
     this._ssrOnlyCache = ssrOnlyCache || new SerializableInMemoryCache();
     this._hydrationCache = hydrationCache || new SerializableInMemoryCache();
@@ -284,7 +284,7 @@ class RequestTracker {
     }
     return _default;
   }
-  constructor(responseCache = undefined) {
+  constructor(responseCache) {
     this._trackedRequests = {};
     this._responseCache = void 0;
     this._requestFulfillment = void 0;
@@ -402,11 +402,15 @@ class TrackData extends React__namespace.Component {
 const loadingStatus = Object.freeze({
   status: "loading"
 });
+const noDataStatus = Object.freeze({
+  status: "no-data"
+});
 const abortedStatus = Object.freeze({
   status: "aborted"
 });
 const Status = Object.freeze({
   loading: () => loadingStatus,
+  noData: () => noDataStatus,
   aborted: () => abortedStatus,
   success: data => ({
     status: "success",
@@ -550,8 +554,8 @@ const useCachedEffect = (requestId, handler, options = {}) => {
       currentRequestRef.current = null;
     };
   }, [shouldFetch, fetchRequest]);
-  const lastResultAgnosticOfIdRef = React__namespace.useRef(Status.loading());
-  const loadingResult = retainResultOnChange ? lastResultAgnosticOfIdRef.current : Status.loading();
+  const lastResultAgnosticOfIdRef = React__namespace.useRef(Status.noData());
+  const loadingResult = retainResultOnChange ? lastResultAgnosticOfIdRef.current : shouldFetch ? Status.loading() : Status.noData();
   const result = (_ref = fetchPolicy === FetchPolicy.NetworkOnly ? networkResultRef.current : mostRecentResult) != null ? _ref : loadingResult;
   lastResultAgnosticOfIdRef.current = result;
   return [result, fetchRequest];
@@ -864,7 +868,7 @@ const useGql = (context = {}) => {
       context = {}
     } = options;
     const finalContext = mergeGqlContext(defaultContext, context);
-    return fetch(operation, variables, finalContext).then(getGqlDataFromResponse);
+    return fetch(operation, variables, finalContext).then(response => getGqlDataFromResponse(response));
   }, [gqlRouterContext]);
   return gqlFetch;
 };

package/dist/util/status.d.ts

@@ -4,7 +4,8 @@ import type { Result, ValidCacheData } from "./types";
  */
 export declare const Status: Readonly<{
     loading: <TData extends ValidCacheData = ValidCacheData>() => Result<TData>;
-    aborted: <TData_1 extends ValidCacheData = ValidCacheData>() => Result<TData_1>;
-    success: <TData_2 extends ValidCacheData>(data: TData_2) => Result<TData_2>;
-    error: <TData_3 extends ValidCacheData = ValidCacheData>(error: Error) => Result<TData_3>;
+    noData: <TData_1 extends ValidCacheData = ValidCacheData>() => Result<TData_1>;
+    aborted: <TData_2 extends ValidCacheData = ValidCacheData>() => Result<TData_2>;
+    success: <TData_3 extends ValidCacheData>(data: TData_3) => Result<TData_3>;
+    error: <TData_4 extends ValidCacheData = ValidCacheData>(error: Error) => Result<TData_4>;
 }>;

package/dist/util/types.d.ts

@@ -34,6 +34,8 @@ export type ValidCacheData = string | boolean | number | Record<any, any> | Arra
  */
 export type Result<TData extends ValidCacheData> = {
     status: "loading";
+} | {
+    status: "no-data";
 } | {
     status: "success";
     data: TData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanacademy/wonder-blocks-data",
-  "version": "12.0.0",
+  "version": "13.0.0",
   "design": "v1",
   "publishConfig": {
     "access": "public"
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.6",
-    "@khanacademy/wonder-blocks-core": "^6.0.0"
+    "@khanacademy/wonder-blocks-core": "^6.0.1"
   },
   "peerDependencies": {
     "@khanacademy/wonder-stuff-core": "^1.2.2",

package/src/components/__tests__/data.test.tsx

@@ -47,7 +47,7 @@ describe("Data", () => {
 
             it("should make request for data on construction", async () => {
                 // Arrange
-                const response = Promise.resolve("data");
+                const response: any = Promise.resolve("data");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 const fakeChildrenFn = jest.fn(() => null);
 
@@ -57,7 +57,6 @@ describe("Data", () => {
                         {fakeChildrenFn}
                     </Data>,
                 );
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
                 await act(() => response);
 
                 // Assert
@@ -66,7 +65,7 @@ describe("Data", () => {
 
             it("should initially render children with loading", async () => {
                 // Arrange
-                const response = Promise.resolve("data");
+                const response: any = Promise.resolve("data");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 const fakeChildrenFn = jest.fn(() => null);
 
@@ -76,7 +75,6 @@ describe("Data", () => {
                         {fakeChildrenFn}
                     </Data>,
                 );
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
                 await act(() => response);
 
                 // Assert
@@ -272,7 +270,7 @@ describe("Data", () => {
 
             it("should ignore resolution of pending handler fulfillment when id changes", async () => {
                 // Arrange
-                const oldRequest = Promise.resolve("OLD DATA");
+                const oldRequest: any = Promise.resolve("OLD DATA");
                 const oldHandler = jest
                     .fn()
                     .mockReturnValueOnce(oldRequest)
@@ -294,7 +292,6 @@ describe("Data", () => {
                         {fakeChildrenFn}
                     </Data>,
                 );
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
                 await act(() => oldRequest);
 
                 // Assert
@@ -343,14 +340,13 @@ describe("Data", () => {
 
             it("should ignore catastrophic request fulfillment when id changes", async () => {
                 // Arrange
-                const catastrophe = Promise.resolve({
+                const catastrophe: any = Promise.resolve({
                     status: "error",
                     error: new Error("CATASTROPHE!"),
                 });
                 jest.spyOn(
                     RequestFulfillment.Default,
                     "fulfill",
-                    // @ts-expect-error [FEI-5019] - TS2345 - Argument of type 'Promise<{ status: string; error: Error; }>' is not assignable to parameter of type 'Promise<Result<ValidCacheData>>'.
                 ).mockReturnValueOnce(catastrophe);
                 const oldHandler = jest.fn().mockResolvedValue("OLD DATA");
 
@@ -367,7 +363,6 @@ describe("Data", () => {
                     </Data>,
                 );
                 await act(() =>
-                    // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
                     catastrophe.catch(() => {
                         /* ignore */
                     }),
@@ -428,8 +423,8 @@ describe("Data", () => {
 
             it("should retain old data while reloading if retainResultOnChange is true", async () => {
                 // Arrange
-                const response1 = Promise.resolve("data1");
-                const response2 = Promise.resolve("data2");
+                const response1: any = Promise.resolve("data1");
+                const response2: any = Promise.resolve("data2");
                 const fakeHandler1 = () => response1;
                 const fakeHandler2 = () => response2;
                 const fakeChildrenFn = jest.fn(() => null);
@@ -445,7 +440,6 @@ describe("Data", () => {
                     </Data>,
                 );
                 fakeChildrenFn.mockClear();
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
                 await act(() => response1);
                 wrapper.rerender(
                     <Data
@@ -456,7 +450,6 @@ describe("Data", () => {
                         {fakeChildrenFn}
                     </Data>,
                 );
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
                 await act(() => response2);
 
                 // Assert

package/src/components/data.ts

@@ -48,7 +48,7 @@ type Props<
      * loading state and data or error that gets retrieved from cache or loaded
      * via the request if no cached value is available.
      */
-    children: (result: Result<TData>) => React.ReactNode;
+    children: (result: Result<TData>) => React.ReactElement | null;
 };
 
 /**
@@ -62,13 +62,11 @@ const Data = <TData extends ValidCacheData>({
     children,
     retainResultOnChange = false,
     clientBehavior = WhenClientSide.ExecuteWhenNoSuccessResult,
-}: Props<TData>): React.ReactElement => {
+}: Props<TData>): React.ReactElement | null => {
     const result = useHydratableEffect(requestId, handler, {
         retainResultOnChange,
         clientBehavior,
     });
-    // @ts-expect-error: React TS types don't allow functional components to return
-    // ReactNodes even though React itself does.
     return children(result);
 };
 

package/src/hooks/__tests__/use-cached-effect.test.tsx

@@ -22,8 +22,9 @@ jest.mock("../use-request-interception");
 jest.mock("../use-shared-cache");
 
 const allPolicies = Array.from(values(FetchPolicy));
-const allPoliciesBut = (policy: typeof FetchPolicy[keyof typeof FetchPolicy]) =>
-    allPolicies.filter((p: any) => p !== policy);
+const allPoliciesBut = (
+    ...policies: Array<typeof FetchPolicy[keyof typeof FetchPolicy]>
+) => allPolicies.filter((p: any) => !policies.includes(p));
 
 describe("#useCachedEffect", () => {
     beforeEach(() => {
@@ -116,7 +117,7 @@ describe("#useCachedEffect", () => {
             },
         );
 
-        describe.each(allPolicies)(
+        describe.each(allPoliciesBut(FetchPolicy.CacheOnly))(
             "with FetchPolicy.%s without cached result",
             (fetchPolicy: any) => {
                 it("should return a loading result", () => {
@@ -138,6 +139,27 @@ describe("#useCachedEffect", () => {
             },
         );
 
+        describe("with FetchPolicy.CacheOnly without cached result", () => {
+            it("should return a no-data result", () => {
+                // Arrange
+                const fakeHandler = jest.fn();
+
+                // Act
+                const {
+                    result: {
+                        current: [result],
+                    },
+                } = serverRenderHook(() =>
+                    useCachedEffect("ID", fakeHandler, {
+                        fetchPolicy: FetchPolicy.CacheOnly,
+                    }),
+                );
+
+                // Assert
+                expect(result).toStrictEqual(Status.noData());
+            });
+        });
+
         describe.each(allPoliciesBut(FetchPolicy.NetworkOnly))(
             "with FetchPolicy.%s with cached result",
             (fetchPolicy: any) => {
@@ -232,7 +254,7 @@ describe("#useCachedEffect", () => {
             "should provide function that causes refetch with FetchPolicy.%s",
             async (fetchPolicy: any) => {
                 // Arrange
-                const response = Promise.resolve("DATA1");
+                const response: any = Promise.resolve("DATA1");
                 const fakeHandler = jest.fn().mockReturnValue(response);
 
                 // Act
@@ -244,11 +266,9 @@ describe("#useCachedEffect", () => {
                     useCachedEffect("ID", fakeHandler, {fetchPolicy}),
                 );
                 fakeHandler.mockClear();
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await act((): Promise<unknown> => response);
+                await act(() => response);
                 act(refetch);
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await act((): Promise<unknown> => response);
+                await act(() => response);
 
                 // Assert
                 expect(fakeHandler).toHaveBeenCalledTimes(1);
@@ -426,7 +446,7 @@ describe("#useCachedEffect", () => {
 
         it("should ignore inflight request if requestId changes", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const response2 = Promise.resolve("DATA2");
             const fakeHandler = jest
                 .fn()
@@ -449,7 +469,7 @@ describe("#useCachedEffect", () => {
 
         it("should return result of fulfilled request for current requestId", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const response2 = Promise.resolve("DATA2");
             const fakeHandler = jest
                 .fn()
@@ -485,7 +505,7 @@ describe("#useCachedEffect", () => {
 
         it("should ignore result of inflight request if skip changes", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const fakeHandler = jest.fn().mockReturnValueOnce(response1);
 
             // Act
@@ -496,8 +516,7 @@ describe("#useCachedEffect", () => {
                 },
             );
             rerender({skip: true});
-            // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-            await act((): Promise<unknown> => response1);
+            await act(() => response1);
 
             // Assert
             expect(result.all).not.toContainEqual(Status.success("DATA1"));
@@ -505,7 +524,7 @@ describe("#useCachedEffect", () => {
 
         it("should not ignore result of inflight request if handler changes", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const response2 = Promise.resolve("DATA2");
             const fakeHandler1 = jest.fn().mockReturnValueOnce(response1);
             const fakeHandler2 = jest.fn().mockReturnValueOnce(response2);
@@ -526,7 +545,7 @@ describe("#useCachedEffect", () => {
 
         it("should not ignore inflight request if options (other than skip) change", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const fakeHandler = jest.fn().mockReturnValueOnce(response1);
 
             // Act
@@ -537,13 +556,11 @@ describe("#useCachedEffect", () => {
                 },
             );
             rerender({
-                // @ts-expect-error [FEI-5019] - TS2322 - Type '{ scope: string; }' is not assignable to type 'undefined'.
                 options: {
                     scope: "BLAH!",
                 },
-            });
-            // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-            await act((): Promise<unknown> => response1);
+            } as any);
+            await act(() => response1);
 
             // Assert
             expect(result.current[0]).toStrictEqual(Status.success("DATA1"));
@@ -551,7 +568,7 @@ describe("#useCachedEffect", () => {
 
         it("should return previous result when requestId changes and retainResultOnChange is true", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const response2 = Promise.resolve("DATA2");
             const fakeHandler = jest
                 .fn()
@@ -572,8 +589,7 @@ describe("#useCachedEffect", () => {
                     initialProps: {requestId: "ID"},
                 },
             );
-            // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-            await act((): Promise<unknown> => response1);
+            await act(() => response1);
             rerender({requestId: "ID2"});
             const [result] = hookResult.current;
             await waitForNextUpdate();
@@ -584,7 +600,7 @@ describe("#useCachedEffect", () => {
 
         it("should return loading status when requestId changes and retainResultOnChange is false", async () => {
             // Arrange
-            const response1 = Promise.resolve("DATA1");
+            const response1: any = Promise.resolve("DATA1");
             const response2 = new Promise(() => {
                 /*pending*/
             });
@@ -603,19 +619,47 @@ describe("#useCachedEffect", () => {
                     initialProps: {requestId: "ID"},
                 },
             );
-            // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-            await act((): Promise<unknown> => response1);
+            await act(() => response1);
             rerender({requestId: "ID2"});
 
             // Assert
             expect(result.current[0]).toStrictEqual(Status.loading());
         });
 
+        it("should return no-data status when requestId changes, retainResultOnChange is false, and skip is true", async () => {
+            // Arrange
+            const response1: any = Promise.resolve("DATA1");
+            const response2 = new Promise(() => {
+                /*pending*/
+            });
+            const fakeHandler = jest
+                .fn()
+                .mockReturnValueOnce(response1)
+                .mockReturnValueOnce(response2);
+
+            // Act
+            const {rerender, result} = clientRenderHook(
+                ({requestId}: any) =>
+                    useCachedEffect(requestId, fakeHandler, {
+                        retainResultOnChange: false,
+                        skip: true,
+                    }),
+                {
+                    initialProps: {requestId: "ID"},
+                },
+            );
+            await act(() => response1);
+            rerender({requestId: "ID2"});
+
+            // Assert
+            expect(result.current[0]).toStrictEqual(Status.noData());
+        });
+
         it.each(allPoliciesBut(FetchPolicy.CacheOnly))(
             "should trigger render when request is fulfilled and onResultChanged is undefined for FetchPolicy.%s",
             async (fetchPolicy: any) => {
                 // Arrange
-                const response = Promise.resolve("DATA");
+                const response: any = Promise.resolve("DATA");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 let renderCount = 0;
                 const Component = React.memo(() => {
@@ -626,8 +670,7 @@ describe("#useCachedEffect", () => {
 
                 // Act
                 render(<Component />);
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await reactAct((): Promise<unknown> => response);
+                await reactAct(() => response);
 
                 // Assert
                 expect(renderCount).toBe(2);
@@ -638,7 +681,7 @@ describe("#useCachedEffect", () => {
             "should trigger render once per inflight request being fulfilled and onResultChanged is undefined for FetchPolicy.%s",
             async (fetchPolicy: any) => {
                 // Arrange
-                const response = Promise.resolve("DATA");
+                const response: any = Promise.resolve("DATA");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 let renderCount = 0;
                 const Component = React.memo(() => {
@@ -657,8 +700,7 @@ describe("#useCachedEffect", () => {
 
                 // Act
                 render(<Component />);
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await reactAct((): Promise<unknown> => response);
+                await reactAct(() => response);
 
                 // Assert
                 expect(renderCount).toBe(2);
@@ -669,7 +711,7 @@ describe("#useCachedEffect", () => {
             "should not trigger render when request is fulfilled and onResultChanged is defined for FetchPolicy.%s",
             async (fetchPolicy: any) => {
                 // Arrange
-                const response = Promise.resolve("DATA");
+                const response: any = Promise.resolve("DATA");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 let renderCount = 0;
                 const Component = React.memo(() => {
@@ -683,8 +725,7 @@ describe("#useCachedEffect", () => {
 
                 // Act
                 render(<Component />);
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await reactAct((): Promise<unknown> => response);
+                await reactAct(() => response);
 
                 // Assert
                 expect(renderCount).toBe(1);
@@ -695,7 +736,7 @@ describe("#useCachedEffect", () => {
             "should call onResultChanged when request is fulfilled and onResultChanged is defined for FetchPolicy.%s",
             async (fetchPolicy: any) => {
                 // Arrange
-                const response = Promise.resolve("DATA");
+                const response: any = Promise.resolve("DATA");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 const onResultChanged = jest.fn();
 
@@ -706,8 +747,7 @@ describe("#useCachedEffect", () => {
                         fetchPolicy,
                     }),
                 );
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await act((): Promise<unknown> => response);
+                await act(() => response);
 
                 // Assert
                 expect(onResultChanged).toHaveBeenCalledWith(
@@ -720,7 +760,7 @@ describe("#useCachedEffect", () => {
             "should call onResultChanged once per inflight request being fulfilled and onResultChanged is defined for FetchPolicy.%s",
             async (fetchPolicy: any) => {
                 // Arrange
-                const response = Promise.resolve("DATA");
+                const response: any = Promise.resolve("DATA");
                 const fakeHandler = jest.fn().mockReturnValue(response);
                 const onResultChanged = jest.fn();
 
@@ -739,8 +779,7 @@ describe("#useCachedEffect", () => {
                 act(refetch);
                 act(refetch);
                 act(refetch);
-                // @ts-expect-error [FEI-5019] - TS2769 - No overload matches this call.
-                await act((): Promise<unknown> => response);
+                await act(() => response);
 
                 // Assert
                 expect(onResultChanged).toHaveBeenCalledTimes(1);

package/src/hooks/__tests__/use-gql-router-context.test.tsx

@@ -123,8 +123,7 @@ describe("#useGqlRouterContext", () => {
             },
         );
         const result1 = wrapper.result.current;
-        // @ts-expect-error [FEI-5019] - TS2741 - Property 'fiz' is missing in type '{}' but required in type '{ fiz: string; }'.
-        wrapper.rerender({overrides: {}});
+        wrapper.rerender({overrides: {} as any});
         const result2 = wrapper.result.current;
 
         // Assert

package/src/hooks/__tests__/use-hydratable-effect.test.ts

@@ -562,10 +562,9 @@ describe("#useHydratableEffect", () => {
                 },
             );
             rerender({
-                // @ts-expect-error [FEI-5019] - TS2322 - Type '{ scope: string; }' is not assignable to type 'undefined'.
                 options: {
                     scope: "BLAH!",
-                },
+                } as any,
             });
 
             await act((): Promise<any> => response1);