@tanstack/form-core 0.13.6 → 0.14.0

package/src/FormApi.ts

@@ -8,7 +8,8 @@ import {
   isNonEmptyArray,
   setBy,
 } from './utils'
-import type { DeepKeys, DeepValue, Updater } from './utils'
+import type { Updater } from './utils'
+import type { DeepKeys, DeepValue } from './util-types'
 import type { FieldApi, FieldMeta } from './FieldApi'
 import type {
   ValidationCause,
@@ -104,15 +105,12 @@ export type FieldInfo<
   TFormData,
   TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
 > = {
-  instances: Record<
-    string,
-    FieldApi<
-      TFormData,
-      any,
-      Validator<unknown, unknown> | undefined,
-      TFormValidator
-    >
-  >
+  instance: FieldApi<
+    TFormData,
+    any,
+    Validator<unknown, unknown> | undefined,
+    TFormValidator
+  > | null
   validationMetaMap: Record<ValidationErrorMapKeys, ValidationMeta | undefined>
 }
 
@@ -314,7 +312,9 @@ export class FormApi<
           Object.assign(
             {},
             this.state as any,
+
             shouldUpdateState ? options.defaultState : {},
+
             shouldUpdateValues
               ? {
                   values: options.defaultValues,
@@ -340,17 +340,17 @@ export class FormApi<
       void (
         Object.values(this.fieldInfo) as FieldInfo<any, TFormValidator>[]
       ).forEach((field) => {
-        Object.values(field.instances).forEach((instance) => {
-          // Validate the field
-          fieldValidationPromises.push(
-            Promise.resolve().then(() => instance.validate(cause)),
-          )
-          // If any fields are not touched
-          if (!instance.state.meta.isTouched) {
-            // Mark them as touched
-            instance.setMeta((prev) => ({ ...prev, isTouched: true }))
-          }
-        })
+        if (!field.instance) return
+        const fieldInstance = field.instance
+        // Validate the field
+        fieldValidationPromises.push(
+          Promise.resolve().then(() => fieldInstance.validate(cause)),
+        )
+        // If any fields are not touched
+        if (!field.instance.state.meta.isTouched) {
+          // Mark them as touched
+          field.instance.setMeta((prev) => ({ ...prev, isTouched: true }))
+        }
       })
     })
 
@@ -587,7 +587,7 @@ export class FormApi<
   ): FieldInfo<TFormData, TFormValidator> => {
     // eslint-disable-next-line  @typescript-eslint/no-unnecessary-condition
     return (this.fieldInfo[field] ||= {
-      instances: {},
+      instance: null,
       validationMetaMap: {
         onChange: undefined,
         onBlur: undefined,
@@ -645,6 +645,7 @@ export class FormApi<
 
       return newState
     })
+    delete this.fieldInfo[field]
   }
 
   pushFieldValue = <TField extends DeepKeys<TFormData>>(

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './FormApi'
 export * from './FieldApi'
 export * from './utils'
+export * from './util-types'
 export * from './types'
 export * from './mergeForm'

package/src/tests/FieldApi.spec.ts

@@ -1,4 +1,4 @@
-import { expect, vitest } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 import { FormApi } from '../FormApi'
 import { FieldApi } from '../FieldApi'
@@ -154,26 +154,6 @@ describe('field api', () => {
     expect(field.getValue()).toStrictEqual(['two', 'one'])
   })
 
-  it('should get a subfield properly', () => {
-    const form = new FormApi({
-      defaultValues: {
-        names: {
-          first: 'one',
-          second: 'two',
-        },
-      },
-    })
-
-    const field = new FieldApi({
-      form,
-      name: 'names',
-    })
-
-    const subfield = field.getSubField('first')
-
-    expect(subfield.getValue()).toBe('one')
-  })
-
   it('should not throw errors when no meta info is stored on a field and a form re-renders', async () => {
     const form = new FormApi({
       defaultValues: {
@@ -602,7 +582,7 @@ describe('field api', () => {
 
     const unmount = field.mount()
     unmount()
-    expect(form.getFieldInfo(field.name).instances[field.uid]).toBeDefined()
+    expect(form.getFieldInfo(field.name).instance).toBeDefined()
     expect(form.getFieldInfo(field.name)).toBeDefined()
   })
 
@@ -619,13 +599,13 @@ describe('field api', () => {
     })
 
     const unmount = field.mount()
-    const callback = vitest.fn()
+    const callback = vi.fn()
     const subscription = form.store.subscribe(callback)
     unmount()
     const info = form.getFieldInfo(field.name)
     subscription()
-    expect(info.instances[field.uid]).toBeUndefined()
-    expect(Object.keys(info.instances).length).toBe(0)
+    expect(info.instance).toBeNull()
+    expect(Object.keys(info.instance ?? {}).length).toBe(0)
 
     // Check that form store has been updated
     expect(callback).toHaveBeenCalledOnce()

package/src/tests/FieldApi.test-d.ts

@@ -1,4 +1,4 @@
-import { assertType } from 'vitest'
+import { assertType, it } from 'vitest'
 import { FormApi } from '../FormApi'
 import { FieldApi } from '../FieldApi'
 

package/src/tests/FormApi.spec.ts

@@ -1,4 +1,4 @@
-import { expect } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 import { FormApi } from '../FormApi'
 import { FieldApi } from '../FieldApi'
@@ -272,7 +272,7 @@ describe('form api', () => {
 
     const fieldInArray = new FieldApi({
       form,
-      name: `employees.${0}.firstName`,
+      name: `employees[0].firstName`,
       defaultValue: 'Darcy',
     })
     fieldInArray.mount()
@@ -300,11 +300,11 @@ describe('form api', () => {
 
     const fieldInArray = new FieldApi({
       form,
-      name: `employees.${0}.firstName`,
+      name: `employees[0].firstName`,
       defaultValue: 'Darcy',
     })
     fieldInArray.mount()
-    form.deleteField(`employees.${0}.firstName`)
+    form.deleteField(`employees[0].firstName`)
     expect(field.state.value.length).toBe(1)
     expect(Object.keys(field.state.value[0]!).length).toBe(0)
   })

package/src/tests/mutateMergeDeep.spec.ts

@@ -1,4 +1,4 @@
-import { describe } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { mutateMergeDeep } from '../mergeForm'
 
 describe('mutateMergeDeep', () => {

package/src/tests/util-types.test-d.ts

@@ -0,0 +1,106 @@
+import { assertType } from 'vitest'
+import type { DeepKeys, DeepValue } from '../util-types'
+
+/**
+ * Properly recognizes that `0` is not an object and should not have subkeys
+ */
+type TupleSupport = DeepKeys<{ topUsers: [User, 0, User] }>
+assertType<
+  | 'topUsers'
+  | 'topUsers[0]'
+  | 'topUsers[0].name'
+  | 'topUsers[0].id'
+  | 'topUsers[0].age'
+  | 'topUsers[1]'
+  | 'topUsers[2]'
+  | 'topUsers[2].name'
+  | 'topUsers[2].id'
+  | 'topUsers[2].age'
+>(0 as never as TupleSupport)
+
+/**
+ * Properly recognizes that a normal number index won't cut it and should be `[number]` prefixed instead
+ */
+type ArraySupport = DeepKeys<{ users: User[] }>
+assertType<
+  | 'users'
+  | `users[${number}].name`
+  | `users[${number}].id`
+  | `users[${number}].age`
+>(0 as never as ArraySupport)
+
+/**
+ * Properly handles deep object nesting like so:
+ */
+type NestedSupport = DeepKeys<{ meta: { mainUser: User } }>
+assertType<
+  | 'meta'
+  | 'meta.mainUser'
+  | 'meta.mainUser.name'
+  | 'meta.mainUser.id'
+  | 'meta.mainUser.age'
+>(0 as never as NestedSupport)
+
+/**
+ * Properly handles `object` edgecase nesting like so:
+ */
+type ObjectNestedEdgecase = DeepKeys<{ meta: { mainUser: object } }>
+assertType<'meta' | 'meta.mainUser' | `meta.mainUser.${string}`>(
+  0 as never as ObjectNestedEdgecase,
+)
+
+/**
+ * Properly handles `object` edgecase like so:
+ */
+type ObjectEdgecase = DeepKeys<object>
+assertType<string>(0 as never as ObjectEdgecase)
+
+/**
+ * Properly handles `object` edgecase nesting like so:
+ */
+type UnknownNestedEdgecase = DeepKeys<{ meta: { mainUser: unknown } }>
+assertType<'meta' | 'meta.mainUser' | `meta.mainUser.${string}`>(
+  0 as never as UnknownNestedEdgecase,
+)
+
+/**
+ * Properly handles `object` edgecase like so:
+ */
+type UnknownEdgecase = DeepKeys<unknown>
+assertType<string>(0 as never as UnknownEdgecase)
+
+type NestedKeysExample = DeepValue<
+  { meta: { mainUser: User } },
+  'meta.mainUser.age'
+>
+assertType<number>(0 as never as NestedKeysExample)
+
+type NestedArrayExample = DeepValue<{ users: User[] }, 'users[0].age'>
+assertType<number>(0 as never as NestedArrayExample)
+
+type NestedLooseArrayExample = DeepValue<{ users: User[] }, 'users[number].age'>
+assertType<number>(0 as never as NestedLooseArrayExample)
+
+type NestedTupleExample = DeepValue<
+  { topUsers: [User, 0, User] },
+  'topUsers[0].age'
+>
+assertType<number>(0 as never as NestedTupleExample)
+
+type NestedTupleItemExample = DeepValue<
+  { topUsers: [User, 0, User] },
+  'topUsers[1]'
+>
+assertType<0>(0 as never as NestedTupleItemExample)
+
+type ArrayExample = DeepValue<[1, 2, 3], '[1]'>
+assertType<2>(0 as never as ArrayExample)
+
+type NonNestedObjExample = DeepValue<{ a: 1 }, 'a'>
+assertType<1>(0 as never as NonNestedObjExample)
+
+interface User {
+  name: string
+  id: string
+  age: number
+}

package/src/tests/utils.spec.ts

@@ -19,8 +19,8 @@ describe('getBy', () => {
   })
 
   it('should get array subfields by path', () => {
-    expect(getBy(structure, 'kids.0.name')).toBe(structure.kids[0]!.name)
-    expect(getBy(structure, 'kids.0.age')).toBe(structure.kids[0]!.age)
+    expect(getBy(structure, 'kids[0].name')).toBe(structure.kids[0]!.name)
+    expect(getBy(structure, 'kids[0].age')).toBe(structure.kids[0]!.age)
   })
 })
 
@@ -42,10 +42,10 @@ describe('setBy', () => {
   })
 
   it('should set array subfields by path', () => {
-    expect(setBy(structure, 'kids.0.name', 'Taylor').kids[0].name).toBe(
+    expect(setBy(structure, 'kids[0].name', 'Taylor').kids[0].name).toBe(
       'Taylor',
     )
-    expect(setBy(structure, 'kids.0.age', 20).kids[0].age).toBe(20)
+    expect(setBy(structure, 'kids[0].age', 20).kids[0].age).toBe(20)
   })
 })
 
@@ -67,14 +67,14 @@ describe('deleteBy', () => {
   })
 
   it('should delete array subfields by path', () => {
-    expect(deleteBy(structure, 'kids.0.name').kids[0].name).not.toBeDefined()
-    expect(deleteBy(structure, 'kids.0.age').kids[0].age).not.toBeDefined()
+    expect(deleteBy(structure, 'kids[0].name').kids[0].name).not.toBeDefined()
+    expect(deleteBy(structure, 'kids[0].age').kids[0].age).not.toBeDefined()
   })
 
   it('should delete non-existent paths like a noop', () => {
     expect(deleteBy(structure, 'nonexistent')).toEqual(structure)
     expect(deleteBy(structure, 'nonexistent.nonexistent')).toEqual(structure)
-    expect(deleteBy(structure, 'kids.3.name')).toEqual(structure)
-    expect(deleteBy(structure, 'nonexistent.3.nonexistent')).toEqual(structure)
+    expect(deleteBy(structure, 'kids[3].name')).toEqual(structure)
+    expect(deleteBy(structure, 'nonexistent[3].nonexistent')).toEqual(structure)
   })
 })

package/src/util-types.ts

@@ -0,0 +1,99 @@
+export type RequiredByKey<T, K extends keyof T> = Omit<T, K> &
+  Required<Pick<T, K>>
+
+type Narrowable = string | number | bigint | boolean
+
+type NarrowRaw<A> =
+  | (A extends [] ? [] : never)
+  | (A extends Narrowable ? A : never)
+  | {
+      [K in keyof A]: A[K] extends Function ? A[K] : NarrowRaw<A[K]>
+    }
+
+export type Narrow<A> = Try<A, [], NarrowRaw<A>>
+
+type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch
+
+// Hack to get TypeScript to show simplified types in error messages
+export type Pretty<T> = { [K in keyof T]: T[K] } & {}
+
+type ComputeRange<
+  N extends number,
+  Result extends Array<unknown> = [],
+> = Result['length'] extends N
+  ? Result
+  : ComputeRange<N, [...Result, Result['length']]>
+type Index40 = ComputeRange<40>[number]
+
+// Is this type a tuple?
+type IsTuple<T> = T extends readonly any[] & { length: infer Length }
+  ? Length extends Index40
+    ? T
+    : never
+  : never
+
+// If this type is a tuple, what indices are allowed?
+type AllowedIndexes<
+  Tuple extends ReadonlyArray<any>,
+  Keys extends number = never,
+> = Tuple extends readonly []
+  ? Keys
+  : Tuple extends readonly [infer _, ...infer Tail]
+    ? AllowedIndexes<Tail, Keys | Tail['length']>
+    : Keys
+
+type PrefixArrayAccessor<T extends any[], TDepth extends any[]> = {
+  [K in keyof T]: `[${number}]${DeepKeys<T[K], TDepth>}`
+}[number]
+
+type PrefixTupleAccessor<
+  T extends any[],
+  TIndex extends number,
+  TDepth extends any[],
+> = {
+  [K in TIndex]: `[${K}]` | `[${K}]${DeepKeys<T[K], TDepth>}`
+}[TIndex]
+
+type PrefixObjectAccessor<T extends object, TDepth extends any[]> = {
+  [K in keyof T]: K extends string | number
+    ?
+        | PrefixFromDepth<K, TDepth>
+        | `${PrefixFromDepth<K, TDepth>}${DeepKeys<T[K], [TDepth]>}`
+    : never
+}[keyof T]
+
+export type DeepKeys<T, TDepth extends any[] = []> = TDepth['length'] extends 5
+  ? never
+  : unknown extends T
+    ? PrefixFromDepth<string, TDepth>
+    : object extends T
+      ? PrefixFromDepth<string, TDepth>
+      : T extends readonly any[] & IsTuple<T>
+        ? PrefixTupleAccessor<T, AllowedIndexes<T>, TDepth>
+        : T extends any[]
+          ? PrefixArrayAccessor<T, [...TDepth, any]>
+          : T extends Date
+            ? never
+            : T extends object
+              ? PrefixObjectAccessor<T, TDepth>
+              : never
+
+type PrefixFromDepth<
+  T extends string | number,
+  TDepth extends any[],
+> = TDepth['length'] extends 0 ? T : `.${T}`
+
+export type DeepValue<TValue, TAccessor> = TValue extends Record<
+  string | number,
+  any
+>
+  ? TAccessor extends `${infer TBefore}[${infer TBrackets}].${infer TAfter}`
+    ? DeepValue<TValue[TBefore][TBrackets], TAfter>
+    : TAccessor extends `[${infer TBrackets}]`
+      ? DeepValue<TValue, TBrackets>
+      : TAccessor extends `${infer TBefore}[${infer TBrackets}]`
+        ? DeepValue<TValue[TBefore], TBrackets>
+        : TAccessor extends `${infer TBefore}.${infer TAfter}`
+          ? DeepValue<TValue[TBefore], TAfter>
+          : TValue[TAccessor & string]
+  : never

package/src/utils.ts

@@ -1,4 +1,4 @@
-import type { ValidationCause, Validator } from './types'
+import type { ValidationCause } from './types'
 import type { FormValidators } from './FormApi'
 import type { FieldValidators } from './FieldApi'
 
@@ -267,75 +267,3 @@ export function getSyncValidatorArray<T>(
       return [changeValidator, serverValidator] as never
   }
 }
-
-export type RequiredByKey<T, K extends keyof T> = Omit<T, K> &
-  Required<Pick<T, K>>
-
-type ComputeRange<
-  N extends number,
-  Result extends Array<unknown> = [],
-> = Result['length'] extends N
-  ? Result
-  : ComputeRange<N, [...Result, Result['length']]>
-type Index40 = ComputeRange<40>[number]
-
-// Is this type a tuple?
-type IsTuple<T> = T extends readonly any[] & { length: infer Length }
-  ? Length extends Index40
-    ? T
-    : never
-  : never
-
-// If this type is a tuple, what indices are allowed?
-type AllowedIndexes<
-  Tuple extends ReadonlyArray<any>,
-  Keys extends number = never,
-> = Tuple extends readonly []
-  ? Keys
-  : Tuple extends readonly [infer _, ...infer Tail]
-    ? AllowedIndexes<Tail, Keys | Tail['length']>
-    : Keys
-
-export type DeepKeys<T, TDepth extends any[] = []> = TDepth['length'] extends 5
-  ? never
-  : unknown extends T
-    ? string
-    : T extends readonly any[] & IsTuple<T>
-      ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth>
-      : T extends any[]
-        ? DeepKeysPrefix<T, number, TDepth>
-        : T extends Date
-          ? never
-          : T extends object
-            ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth>
-            : never
-
-type DeepKeysPrefix<
-  T,
-  TPrefix,
-  TDepth extends any[],
-> = TPrefix extends keyof T & (number | string)
-  ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}`
-  : never
-
-export type DeepValue<T, TProp> = T extends Record<string | number, any>
-  ? TProp extends `${infer TBranch}.${infer TDeepProp}`
-    ? DeepValue<T[TBranch], TDeepProp>
-    : T[TProp & string]
-  : never
-
-type Narrowable = string | number | bigint | boolean
-
-type NarrowRaw<A> =
-  | (A extends [] ? [] : never)
-  | (A extends Narrowable ? A : never)
-  | {
-      [K in keyof A]: A[K] extends Function ? A[K] : NarrowRaw<A[K]>
-    }
-
-export type Narrow<A> = Try<A, [], NarrowRaw<A>>
-
-type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch
-
-// Hack to get TypeScript to show simplified types in error messages
-export type Pretty<T> = { [K in keyof T]: T[K] } & {}