@tanstack/form-core 0.23.2 → 0.24.0

package/src/tests/formOptions.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { FormApi, formOptions } from '../index'
-
-describe('formOptions', () => {
-  it('should allow default values to be set', async () => {
-    type Person = {
-      firstName: string
-      lastName: string
-    }
-
-    const formOpts = formOptions<Person>({
-      defaultValues: {
-        firstName: 'FirstName',
-        lastName: 'LastName',
-      },
-    })
-
-    const form = new FormApi({
-      ...formOpts,
-    })
-
-    expect(form.state.values['firstName']).toBe('FirstName')
-    expect(form.state.values['lastName']).toBe('LastName')
-  })
-})

package/src/tests/mutateMergeDeep.spec.ts

@@ -1,32 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { mutateMergeDeep } from '../mergeForm'
-
-describe('mutateMergeDeep', () => {
-  test('Should merge two objects by mutating', () => {
-    const a = { a: 1 }
-    const b = { b: 2 }
-    mutateMergeDeep(a, b)
-    expect(a).toStrictEqual({ a: 1, b: 2 })
-  })
-
-  test('Should merge two objects including overwriting with undefined', () => {
-    const a = { a: 1 }
-    const b = { a: undefined }
-    mutateMergeDeep(a, b)
-    expect(a).toStrictEqual({ a: undefined })
-  })
-
-  test('Should merge two object by merging arrays', () => {
-    const a = { a: [1] }
-    const b = { a: [2] }
-    mutateMergeDeep(a, b)
-    expect(a).toStrictEqual({ a: [1, 2] })
-  })
-
-  test('Should merge two deeply nested objects', () => {
-    const a = { a: { a: 1 } }
-    const b = { a: { b: 2 } }
-    mutateMergeDeep(a, b)
-    expect(a).toStrictEqual({ a: { a: 1, b: 2 } })
-  })
-})

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

@@ -1,171 +0,0 @@
-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 deep partial object nesting like so:
- */
-type NestedPartialSupport = DeepKeys<{ meta?: { mainUser?: User } }>
-assertType<
-  | 'meta'
-  | 'meta.mainUser'
-  | 'meta.mainUser.name'
-  | 'meta.mainUser.id'
-  | 'meta.mainUser.age'
->(0 as never as NestedPartialSupport)
-
-/**
- * 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 NestedNullableKeys = DeepValue<
-  {
-    meta: { mainUser: 'hello' } | null
-  },
-  'meta.mainUser'
->
-assertType<'hello' | null>(0 as never as NestedNullableKeys)
-
-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 NestedTupleBroadExample = DeepValue<
-  { topUsers: User[] },
-  `topUsers[${number}].age`
->
-assertType<number>(0 as never as NestedTupleBroadExample)
-
-type DeeplyNestedTupleBroadExample = DeepValue<
-  { nested: { topUsers: User[] } },
-  `nested.topUsers[${number}].age`
->
-assertType<number>(0 as never as DeeplyNestedTupleBroadExample)
-
-type SimpleArrayExample = DeepValue<User[], `[${number}]`>
-assertType<User>(0 as never as SimpleArrayExample)
-
-type SimpleNestedArrayExample = DeepValue<User[], `[${number}].age`>
-assertType<number>(0 as never as SimpleNestedArrayExample)
-
-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
-}
-
-type FormDefinition = {
-  nested: {
-    people: User[]
-  }
-}
-
-type FormDefinitionValue = DeepValue<
-  FormDefinition,
-  `nested.people[${number}].name`
->
-
-assertType<string>(0 as never as FormDefinitionValue)
-
-type DoubleDeepArray = DeepValue<
-  {
-    people: {
-      parents: {
-        name: string
-        age: number
-      }[]
-    }[]
-  },
-  `people[${0}].parents[${0}].name`
->
-
-assertType<string>(0 as never as DoubleDeepArray)

package/src/tests/utils.spec.ts

@@ -1,131 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { deleteBy, getBy, makePathArray, setBy } from '../utils'
-
-describe('getBy', () => {
-  const structure = {
-    name: 'Marc',
-    kids: [
-      { name: 'Stephen', age: 10, hobbies: ['soccer', 'reading'] },
-      { name: 'Taylor', age: 15, hobbies: ['swimming', 'gaming'] },
-    ],
-    mother: {
-      name: 'Lisa',
-    },
-  }
-
-  it('should get subfields by path', () => {
-    expect(getBy(structure, 'name')).toBe(structure.name)
-    expect(getBy(structure, 'mother.name')).toBe(structure.mother.name)
-  })
-
-  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)
-  })
-
-  it('should get nested array subfields by path', () => {
-    expect(getBy(structure, 'kids[0].hobbies[0]')).toBe(
-      structure.kids[0]!.hobbies[0],
-    )
-    expect(getBy(structure, 'kids[0].hobbies[1]')).toBe(
-      structure.kids[0]!.hobbies[1],
-    )
-  })
-})
-
-describe('setBy', () => {
-  const structure = {
-    name: 'Marc',
-    kids: [
-      { name: 'Stephen', age: 10, hobbies: ['soccer', 'reading'] },
-      { name: 'Taylor', age: 15, hobbies: ['swimming', 'gaming'] },
-    ],
-    mother: {
-      name: 'Lisa',
-    },
-  }
-
-  it('should set subfields by path', () => {
-    expect(setBy(structure, 'name', 'Lisa').name).toBe('Lisa')
-    expect(setBy(structure, 'mother.name', 'Tina').mother.name).toBe('Tina')
-  })
-
-  it('should set array subfields by path', () => {
-    expect(setBy(structure, 'kids[0].name', 'Taylor').kids[0].name).toBe(
-      'Taylor',
-    )
-    expect(setBy(structure, 'kids[0].age', 20).kids[0].age).toBe(20)
-  })
-
-  it('should set nested array subfields by path', () => {
-    expect(
-      setBy(structure, 'kids[0].hobbies[0]', 'swimming').kids[0].hobbies[0],
-    ).toBe('swimming')
-    expect(
-      setBy(structure, 'kids[0].hobbies[1]', 'gaming').kids[0].hobbies[1],
-    ).toBe('gaming')
-  })
-})
-
-describe('deleteBy', () => {
-  const structure = {
-    name: 'Marc',
-    kids: [
-      { name: 'Stephen', age: 10, hobbies: ['soccer', 'reading'] },
-      { name: 'Taylor', age: 15, hobbies: ['swimming', 'gaming'] },
-    ],
-    mother: {
-      name: 'Lisa',
-    },
-  }
-
-  it('should delete subfields by path', () => {
-    expect(deleteBy(structure, 'name').name).not.toBeDefined()
-    expect(deleteBy(structure, 'mother.name').mother.name).not.toBeDefined()
-  })
-
-  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()
-  })
-
-  it('should delete nested array subfields by path', () => {
-    expect(deleteBy(structure, 'kids[0].hobbies[0]').kids[0].hobbies[0]).toBe(
-      'reading',
-    )
-    expect(
-      deleteBy(structure, 'kids[0].hobbies[1]').kids[0].hobbies[1],
-    ).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)
-  })
-})
-
-describe('makePathArray', () => {
-  it('should convert dot notation to array', () => {
-    expect(makePathArray('name')).toEqual(['name'])
-    expect(makePathArray('mother.name')).toEqual(['mother', 'name'])
-    expect(makePathArray('kids[0].name')).toEqual(['kids', 0, 'name'])
-    expect(makePathArray('kids[0].name[1]')).toEqual(['kids', 0, 'name', 1])
-    expect(makePathArray('kids[0].name[1].age')).toEqual([
-      'kids',
-      0,
-      'name',
-      1,
-      'age',
-    ])
-    expect(makePathArray('kids[0].name[1].age[2]')).toEqual([
-      'kids',
-      0,
-      'name',
-      1,
-      'age',
-      2,
-    ])
-  })
-})

package/src/tests/utils.ts

@@ -1,5 +0,0 @@
-export function sleep(timeout: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout)
-  })
-}