feat: support nested object in reflect (#46)

Author: ap0nia

src/LensCore.ts

@@ -65,7 +65,15 @@ export class LensCore<T extends FieldValues> {
 
       return result;
     } else if (this.override) {
-      const overriddenLens: LensCore<T> | undefined = get(this.override, propString);
+      const overriddenLensOrNested = get(this.override, propString);
+
+      let overriddenLens: LensCore<T> | undefined;
+
+      if (typeof overriddenLensOrNested?.reflect === 'function') {
+        overriddenLens = overriddenLensOrNested;
+      } else if (overriddenLensOrNested) {
+        overriddenLens = this.reflect(() => overriddenLensOrNested);
+      }
 
       if (!overriddenLens) {
         const result = new (this.constructor as typeof LensCore)(this.control, nestedPath, this.cache);

src/types/Lens.ts

@@ -45,7 +45,11 @@ export type LensesDictionary<T> = {
   [P in keyof T]: Lens<T[P]>;
 };
 
-export type LensesGetter<T> = LensesDictionary<T> | Lens<T>;
+export type RecursiveLensesDictionary<T> = {
+  [P in keyof T]: Lens<T[P]> | RecursiveLensesDictionary<T[P]>;
+};
+
+export type LensesGetter<T> = RecursiveLensesDictionary<T> | Lens<T>;
 
 export type UnwrapLens<T> = T extends BrowserNativeObject
   ? T

tests/object-reflect.test.ts

@@ -41,7 +41,6 @@ test('non lens fields cannot returned from reflect', () => {
     return lens;
   });
 
-  // @ts-expect-error non lens fields cannot be returned from reflect
   assertType(result.current.reflect((_, l) => ({ b: l.focus('a'), w: 'hello' })));
 });
 
@@ -223,3 +222,139 @@ test('reflected lens handles duplicate key names in different nesting levels', (
 
   expect(reflectedWithDuplicateKeys.focus('nest_id').interop().name).toBe('nest.id');
 });
+
+test('reflected lens with nested objects resolves correct paths', () => {
+  type Input = {
+    password: {
+      password: string;
+      passwordConfirm: string;
+    };
+    usernameNest: {
+      name: string;
+    };
+  };
+
+  type DataLens = {
+    password: {
+      password_base: string;
+      password_confirm: string;
+    };
+    nest2: {
+      names: {
+        name: string;
+      };
+    };
+  };
+
+  const { result } = renderHook(() => {
+    const form = useForm<Input>();
+    const lens = useLens({ control: form.control });
+    return lens;
+  });
+
+  const lens = result.current;
+
+  const reflected: Lens<DataLens> = lens.reflect((_, l) => ({
+    password: {
+      password_base: l.focus('password.password'),
+      password_confirm: l.focus('password.passwordConfirm'),
+    },
+    nest2: {
+      names: l.focus('usernameNest'),
+    },
+  }));
+
+  expect(reflected.focus('password.password_base').interop().name).toBe('password.password');
+  expect(reflected.focus('password.password_confirm').interop().name).toBe('password.passwordConfirm');
+  expect(reflected.focus('nest2.names.name').interop().name).toBe('usernameNest.name');
+});
+
+test('reflected lenses without focus do not append paths', () => {
+  type Input = {
+    a: {
+      b: {
+        c: string;
+      };
+    };
+  };
+
+  type Result = {
+    x: {
+      y: string;
+    };
+  };
+
+  const { result } = renderHook(() => {
+    const form = useForm<Input>();
+    const lens = useLens({ control: form.control });
+    return lens;
+  });
+
+  const lens = result.current;
+
+  const reflected: Lens<Result> = lens.reflect((_, l) => ({
+    x: l.reflect((_, l2) => {
+      return {
+        y: l2.focus('a.b.c'),
+      };
+    }),
+  }));
+
+  expect(reflected.focus('x.y').interop().name).toBe('a.b.c');
+});
+
+test('nested object reflect does not append paths', () => {
+  type Input = {
+    a: {
+      b: {
+        c: string;
+      };
+    };
+  };
+
+  type Result = {
+    x: {
+      y: string;
+    };
+  };
+
+  const { result } = renderHook(() => {
+    const form = useForm<Input>();
+    const lens = useLens({ control: form.control });
+    return lens;
+  });
+
+  const lens = result.current;
+
+  const reflected: Lens<Result> = lens.reflect((_, l) => ({
+    x: {
+      y: l.focus('a.b.c'),
+    },
+  }));
+
+  expect(reflected.focus('x.y').interop().name).toBe('a.b.c');
+});
+
+test('reflect with nested object preserve correct path', () => {
+  const { result } = renderHook(() => {
+    const form = useForm<{ values: { a: string } }>();
+    const lens = useLens({ control: form.control });
+    return lens;
+  });
+
+  const lens = result.current;
+
+  const reflected = lens.focus('values').reflect((_, l) => {
+    return {
+      nested: {
+        deeper: {
+          field: l.focus('a'),
+        },
+      },
+    };
+  });
+
+  expect(reflected.focus('nested').interop().name).toBe('values');
+  expect(reflected.focus('nested.deeper').interop().name).toBe('values');
+  expect(reflected.focus('nested.deeper.field').interop().name).toBe('values.a');
+});