@tanstack/form-core 0.13.7 → 0.16.0

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'
@@ -46,6 +46,8 @@ describe('field api', () => {
     expect(field.getMeta()).toEqual({
       isTouched: false,
       isValidating: false,
+      isPristine: true,
+      isDirty: false,
       touchedErrors: [],
       errors: [],
       errorMap: {},
@@ -57,12 +59,14 @@ describe('field api', () => {
     const field = new FieldApi({
       form,
       name: 'name',
-      defaultMeta: { isTouched: true },
+      defaultMeta: { isTouched: true, isDirty: true, isPristine: false },
     })
 
     expect(field.getMeta()).toEqual({
       isTouched: true,
       isValidating: false,
+      isDirty: true,
+      isPristine: false,
       touchedErrors: [],
       errors: [],
       errorMap: {},
@@ -154,26 +158,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: {
@@ -619,7 +603,7 @@ 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)

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'
@@ -21,6 +21,8 @@ describe('form api', () => {
       errorMap: {},
       isSubmitting: false,
       isTouched: false,
+      isPristine: true,
+      isDirty: false,
       isValid: true,
       isValidating: false,
       submissionAttempts: 0,
@@ -55,6 +57,8 @@ describe('form api', () => {
       isSubmitted: false,
       isSubmitting: false,
       isTouched: false,
+      isPristine: true,
+      isDirty: false,
       isValid: true,
       isValidating: false,
       submissionAttempts: 0,
@@ -87,6 +91,8 @@ describe('form api', () => {
       isSubmitted: false,
       isSubmitting: false,
       isTouched: false,
+      isPristine: true,
+      isDirty: false,
       isValid: true,
       isValidating: false,
       submissionAttempts: 30,
@@ -130,6 +136,8 @@ describe('form api', () => {
       isSubmitted: false,
       isSubmitting: false,
       isTouched: false,
+      isPristine: true,
+      isDirty: false,
       isValid: true,
       isValidating: false,
       submissionAttempts: 300,
@@ -170,6 +178,8 @@ describe('form api', () => {
       isSubmitted: false,
       isSubmitting: false,
       isTouched: false,
+      isPristine: true,
+      isDirty: false,
       isValid: true,
       isValidating: false,
       submissionAttempts: 0,
@@ -204,6 +214,40 @@ describe('form api', () => {
     expect(form.getFieldValue('name')).toEqual('other')
   })
 
+  it("should be dirty after a field's value has been set", () => {
+    const form = new FormApi({
+      defaultValues: {
+        name: 'test',
+      },
+    })
+    form.mount()
+
+    form.setFieldValue('name', 'other', { touch: true })
+
+    expect(form.state.isDirty).toBe(true)
+    expect(form.state.isPristine).toBe(false)
+  })
+
+  it('should be clean again after being reset from a dirty state', () => {
+    const form = new FormApi({
+      defaultValues: {
+        name: 'test',
+      },
+    })
+    form.mount()
+
+    form.setFieldMeta('name', (meta) => ({
+      ...meta,
+      isDirty: true,
+      isPristine: false,
+    }))
+
+    form.reset()
+
+    expect(form.state.isDirty).toBe(false)
+    expect(form.state.isPristine).toBe(true)
+  })
+
   it("should push an array field's value", () => {
     const form = new FormApi({
       defaultValues: {
@@ -272,7 +316,7 @@ describe('form api', () => {
 
     const fieldInArray = new FieldApi({
       form,
-      name: `employees.${0}.firstName`,
+      name: `employees[0].firstName`,
       defaultValue: 'Darcy',
     })
     fieldInArray.mount()
@@ -300,11 +344,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] } & {}