fix: infinite recursion with arrays

Author: airjp73

packages/react/src/test/types.test.tsx

@@ -67,10 +67,11 @@ describe("types", () => {
 
   it("should infer form scope correctly", () => {
     const Component = () => {
-      const scope = {} as any as FormScope<Record<string, number>>;
+      type Node = { value: number; children: Node[] };
+      const scope = {} as any as FormScope<{ tree: Node }>;
       const form = useFormScope(scope);
-      expectTypeOf(form.scope("bob")).toEqualTypeOf<FormScope<number>>();
-      expectTypeOf(form.value("bob")).toEqualTypeOf<number>();
+      expectTypeOf(form.scope("tree.value")).toEqualTypeOf<FormScope<number>>();
+      expectTypeOf(form.value("tree.value")).toEqualTypeOf<number>();
     };
   });
 

packages/set-get/src/types.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, expectTypeOf, it } from "vitest";
+import { describe, expectTypeOf, it } from "vitest";
 import {
   StringToPathTuple,
   ValidStringPaths,
@@ -31,6 +31,26 @@ describe("ValueAtPath type", () => {
     expectTypeOf<res>().toMatchTypeOf<never>();
   });
 
+  it("should work with recursive types", () => {
+    type Node = {
+      value: number;
+      children: Node[];
+    };
+    type Tree = {
+      tree: Node;
+    };
+    expectTypeOf<
+      ValueAtPath<Tree, ["tree", "children", 0, "value"]>
+    >().toMatchTypeOf<number>();
+    expectTypeOf<
+      | "tree.value"
+      | "tree.children"
+      | `tree.children[${number}]`
+      | `tree.children[${number}].value`
+      | `tree.children[${number}].children`
+    >().toMatchTypeOf<ValidStringPaths<Tree>>();
+  });
+
   it("should work with tuples", () => {
     type state = {
       a: {

packages/set-get/src/types.ts

@@ -60,25 +60,27 @@ export type StringToPathTuple<S extends string> = StringToPathTupleImpl<
 
 type Path<Obj, Prefix extends Array<PathKey> = [], AssignableTo = any> =
   | (Obj extends AssignableTo ? Prefix : never)
-  | (Obj extends Primitive
+  | (Prefix["length"] extends 10
       ? never
-      : IsAny<Obj> extends true // prevent infinite recursion when using `any` (usually for generic base types)
+      : Obj extends Primitive
         ? never
-        : Obj extends Array<infer Item>
-          ? Path<Item, [...Prefix, number], AssignableTo>
-          : PathsOfObject<Obj, Prefix, AssignableTo>);
+        : IsAny<Obj> extends true // prevent infinite recursion when using `any` (usually for generic base types)
+          ? never
+          : Obj extends Array<infer Item>
+            ? PathsOfArray<Item, Prefix, AssignableTo>
+            : PathsOfObject<Obj, Prefix, AssignableTo>);
 
-type PathsOfObject<
+type PathsOfArray<
   Obj,
   Prefix extends Array<PathKey>,
   AssignableTo = any,
-> = Prefix["length"] extends 10
-  ? never
-  : {
-      [K in keyof Obj]: K extends PathKey
-        ? Path<Obj[K], [...Prefix, K], AssignableTo>
-        : never;
-    }[keyof Obj];
+> = Path<Obj, [...Prefix, number], AssignableTo>;
+
+type PathsOfObject<Obj, Prefix extends Array<PathKey>, AssignableTo = any> = {
+  [K in keyof Obj]: K extends PathKey
+    ? Path<Obj[K], [...Prefix, K], AssignableTo>
+    : never;
+}[keyof Obj];
 
 export type ValueAtPath<
   Obj,