refactor(@remix-run/react): rename UseDataFunctionReturn to `Serial…

…izeFrom`

since the type can be used without `useLoaderData` or `useActionData` and just returns the JSON
serialized data from a loader or action

packages/remix-react/__tests__/hook-types-test.tsx

@@ -1,78 +1,81 @@
-import type { TypedResponse, UseDataFunctionReturn } from "../serialize";
+import type { TypedResponse } from "../serialize";
+import type { useLoaderData } from "../components";
 
 function isEqual<A, B>(
   arg: A extends B ? (B extends A ? true : false) : false
 ): void {}
 
+type LoaderData<T> = ReturnType<typeof useLoaderData<T>>
+
 describe("useLoaderData", () => {
   it("supports plain data type", () => {
     type AppData = { hello: string };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, { hello: string }>(true);
   });
 
   it("supports plain Response", () => {
     type Loader = (args: any) => Response;
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, any>(true);
   });
 
   it("infers type regardless of redirect", () => {
     type Loader = (
       args: any
     ) => TypedResponse<{ id: string }> | TypedResponse<never>;
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, { id: string }>(true);
   });
 
   it("supports Response-returning loader", () => {
     type Loader = (args: any) => TypedResponse<{ hello: string }>;
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, { hello: string }>(true);
   });
 
   it("supports async Response-returning loader", () => {
     type Loader = (args: any) => Promise<TypedResponse<{ hello: string }>>;
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, { hello: string }>(true);
   });
 
   it("supports data-returning loader", () => {
     type Loader = (args: any) => { hello: string };
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, { hello: string }>(true);
   });
 
   it("supports async data-returning loader", () => {
     type Loader = (args: any) => Promise<{ hello: string }>;
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, { hello: string }>(true);
   });
 });
 
 describe("type serializer", () => {
   it("converts Date to string", () => {
     type AppData = { hello: Date };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, { hello: string }>(true);
   });
 
   it("supports custom toJSON", () => {
     type AppData = { toJSON(): { data: string[] } };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, { data: string[] }>(true);
   });
 
   it("supports recursion", () => {
     type AppData = { dob: Date; parent: AppData };
     type SerializedAppData = { dob: string; parent: SerializedAppData };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, SerializedAppData>(true);
   });
 
   it("supports tuples and arrays", () => {
     type AppData = { arr: Date[]; tuple: [string, number, Date]; empty: [] };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<
       response,
       { arr: string[]; tuple: [string, number, string]; empty: [] }
@@ -81,13 +84,13 @@ describe("type serializer", () => {
 
   it("transforms unserializables to null in arrays", () => {
     type AppData = [Function, symbol, undefined];
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, [null, null, null]>(true);
   });
 
   it("transforms unserializables to never in objects", () => {
     type AppData = { arg1: Function; arg2: symbol; arg3: undefined };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, {}>(true);
   });
 
@@ -97,7 +100,7 @@ describe("type serializer", () => {
       speak: () => string;
     }
     type Loader = (args: any) => TypedResponse<Test>;
-    type response = UseDataFunctionReturn<Loader>;
+    type response = LoaderData<Loader>;
     isEqual<response, { arg: string }>(true);
   });
 
@@ -107,7 +110,7 @@ describe("type serializer", () => {
       arg2: number | undefined;
       arg3: undefined;
     };
-    type response = UseDataFunctionReturn<AppData>;
+    type response = LoaderData<AppData>;
     isEqual<response, { arg1: string; arg2?: number }>(true);
   });
 });

packages/remix-react/components.tsx

@@ -55,7 +55,7 @@ import type {
   Fetcher,
   Submission,
 } from "./transition";
-import type { UseDataFunctionReturn } from "./serialize";
+import type { SerializeFrom } from "./serialize";
 
 ////////////////////////////////////////////////////////////////////////////////
 // RemixEntry
@@ -1361,7 +1361,7 @@ export function useMatches(): RouteMatch[] {
  *
  * @see https://remix.run/api/remix#useloaderdata
  */
-export function useLoaderData<T = AppData>(): UseDataFunctionReturn<T> {
+export function useLoaderData<T = AppData>(): SerializeFrom<T> {
   return useRemixRouteContext().data;
 }
 
@@ -1370,9 +1370,7 @@ export function useLoaderData<T = AppData>(): UseDataFunctionReturn<T> {
  *
  * @see https://remix.run/api/remix#useactiondata
  */
-export function useActionData<T = AppData>():
-  | UseDataFunctionReturn<T>
-  | undefined {
+export function useActionData<T = AppData>(): SerializeFrom<T> | undefined {
   let { id: routeId } = useRemixRouteContext();
   let { transitionManager } = useRemixEntryContext();
   let { actionData } = transitionManager.getState();

packages/remix-react/serialize.ts

@@ -62,11 +62,10 @@ export type TypedResponse<T extends unknown = unknown> = Response & {
 
 type ArbitraryFunction = (...args: any[]) => unknown;
 
-export type UseDataFunctionReturn<T extends AppData | ArbitraryFunction> =
-  Serialize<
-    T extends (...args: any[]) => infer Output
-      ? Awaited<Output> extends TypedResponse<infer U>
-        ? U
-        : Awaited<Output>
-      : Awaited<T>
-  >;
+export type SerializeFrom<T extends AppData | ArbitraryFunction> = Serialize<
+  T extends (...args: any[]) => infer Output
+    ? Awaited<Output> extends TypedResponse<infer U>
+      ? U
+      : Awaited<Output>
+    : Awaited<T>
+>;