Skip to content
Source
Sign inSign up
TanStack/form
Open History to see the last commit

detailSnapshot.ts

424 lines11.4 KB

1import { getBy, isStandardSchema } from '@tanstack/form-core/internals'
2import { compareFieldPaths } from '../utils'
3import type {
4 AnyInternalFieldApi,
5 AnyInternalValidatorInstance,
6 FieldWatchingListenerFields,
7 FieldWatchingValidatorFields,
8 InternalFieldState,
9 ValidationSourceErrorMap,
10} from '@tanstack/form-core/internals'
11import type { ValidationIssue } from '@tanstack/form-core'
12import type {
13 DevtoolsFieldDetail,
14 DevtoolsFieldError,
15 DevtoolsFieldErrorSource,
16 DevtoolsFieldRelation,
17 DevtoolsFieldRelationCause,
18 DevtoolsFieldRelationKind,
19 DevtoolsFieldRelations,
20 DevtoolsFieldValidatorType,
21 FieldDetailSubscriptionDescriptor,
22 FieldErrorPayloadMode,
23} from '../../eventClientTypes'
24import type { FieldId } from '../../types/branded'
25import type { FieldIdentityController } from './identity'
26​
27function getValidatorType(
28 validator: { run: unknown } | null | undefined,
29): DevtoolsFieldValidatorType {
30 return validator && isStandardSchema(validator.run as never)
31 ? 'schema'
32 : 'callback'
34​
35function projectError(
36 error: ValidationIssue,
37 mode: FieldErrorPayloadMode,
38): { message: string } {
39 if (mode === 'messages') {
40 return { message: error.message }
41 }
42​
43 return error
45​
46function appendValidatorErrors({
47 destination,
48 errorMap,
49 validatorInstances,
50 getSource,
51 mode,
52}: {
53 destination: Array<DevtoolsFieldError>
54 errorMap: ValidationSourceErrorMap | null
55 validatorInstances: ReadonlyArray<AnyInternalValidatorInstance> | null
56 getSource: (
57 validatorIndex: number,
58 sourceEvent: string,
59 ) => DevtoolsFieldErrorSource
60 mode: FieldErrorPayloadMode
61}): void {
62 validatorInstances?.forEach((validatorInstance, validatorIndex) => {
63 const errorState = errorMap?.get(validatorInstance)
64 if (!errorState) return
65​
66 const { errors, sourceEvent } = errorState
67 const source = getSource(validatorIndex, sourceEvent)
68​
69 for (const error of errors) {
70 destination.push({
71 error: projectError(error, mode),
72 source,
73 sourceEvent,
74 })
75 }
76 })
78​
79export function getDevtoolsFieldErrors(
80 field: AnyInternalFieldApi,
81 state: InternalFieldState,
82 mode: FieldErrorPayloadMode,
83): Array<DevtoolsFieldError> {
84 // Keep this traversal aligned with getErrorsFromBaseMeta in form-core so
85 // these entries have the same order as field.state.meta.original.errors.
86 const errors: Array<DevtoolsFieldError> = []
87 const meta = state.meta
88​
89 appendValidatorErrors({
90 destination: errors,
91 errorMap: meta._validationSourceErrors,
92 validatorInstances: field._validatorInstances,
93 mode,
94 getSource: (validatorIndex) => ({
95 scope: 'field',
96 validatorIndex,
97 validatorType: getValidatorType(
98 field._validatorInstances?.[validatorIndex]?.definition,
99 ),
100 }),
101 })
102​
103 if (meta._validationSourceErrors) {
104 const containingGroup = field._getFormGroup()
105​
106 appendValidatorErrors({
107 destination: errors,
108 errorMap: meta._validationSourceErrors,
109 validatorInstances: containingGroup?._validatorInstances ?? null,
110 mode,
111 getSource: (validatorIndex) => ({
112 scope: 'formGroup',
113 formGroupPath: containingGroup
114 ? String(containingGroup.name)
115 : '(unknown form group)',
116 validatorIndex,
117 validatorType: getValidatorType(
118 containingGroup?._validatorInstances?.[validatorIndex]?.definition,
119 ),
120 }),
121 })
122 }
123​
124 appendValidatorErrors({
125 destination: errors,
126 errorMap: meta._validationSourceErrors,
127 validatorInstances: field.form._validatorInstances,
128 mode,
129 getSource: (validatorIndex) => ({
130 scope: 'form',
131 validatorIndex,
132 validatorType: getValidatorType(
133 field.form._validatorInstances?.[validatorIndex]?.definition,
134 ),
135 }),
136 })
137​
138 const onSubmitErrorState = meta._validationSourceErrors?.get(
139 field.form._onSubmitSource,
140 )
141 if (onSubmitErrorState) {
142 const { errors: submitErrors, sourceEvent } = onSubmitErrorState
143 for (const error of submitErrors) {
144 errors.push({
145 error: projectError(error, mode),
146 source: { scope: 'onSubmit', validatorType: 'callback' },
147 sourceEvent,
148 })
149 }
150 }
151​
152 return errors
154​
155function getDevtoolsFieldState(
156 field: AnyInternalFieldApi,
157 state: InternalFieldState,
158 descriptor: FieldDetailSubscriptionDescriptor,
159): DevtoolsFieldDetail['state'] {
160 const meta = state.meta
161 const originalErrors = getDevtoolsFieldErrors(
162 field,
163 state,
164 descriptor.settings.errorPayloadMode,
165 )
166​
167 return {
168 ...(descriptor.settings.includeValues ? { value: state.value } : {}),
169 meta: {
170 isTouched: meta.isTouched,
171 isDirty: meta.isDirty,
172 isPristine: meta.isPristine,
173 isDefaultValue: meta.isDefaultValue,
174 isBlurred: meta.isBlurred,
175 isValidating: meta.isValidating,
176 isSelfTouched: meta.isSelfTouched,
177 isSelfDirty: meta.isSelfDirty,
178 isSelfValidating: meta.isSelfValidating,
179 isSelfValid: meta.isSelfValid,
180 isValid: meta.isValid,
181 isInvalid: meta.isInvalid,
182 subfields: { ...meta.subfields },
183 errors: meta.errors.length > 0 ? originalErrors : [],
184 original: {
185 errors: originalErrors,
186 isValid: meta.original.isValid,
187 isInvalid: meta.original.isInvalid,
188 },
189 },
190 }
192​
193interface FieldRelationAccumulator {
194 fieldId: FieldId
195 path: string
196 causes: Array<DevtoolsFieldRelationCause>
198​
199function getRelationCause(
200 kind: DevtoolsFieldRelationKind,
201 itemIndex: number,
202 configuredPath: string | undefined,
203 currentPath: string,
204): DevtoolsFieldRelationCause {
205 return {
206 kind,
207 itemIndex,
208 ...(configuredPath && configuredPath !== currentPath
209 ? { configuredPath }
210 : {}),
211 }
213​
214function addRelation(
215 relations: Map<FieldId, FieldRelationAccumulator>,
216 field: AnyInternalFieldApi,
217 cause: DevtoolsFieldRelationCause,
218 identity: Pick<FieldIdentityController, 'getFieldId'>,
219): void {
220 if (field._isKilled) return
221​
222 const fieldId = identity.getFieldId(field)
223 const existing = relations.get(fieldId)
224 if (existing) {
225 existing.causes.push(cause)
226 return
227 }
228​
229 relations.set(fieldId, {
230 fieldId,
231 path: field.name,
232 causes: [cause],
233 })
235​
236function addListenerListensToRelations(
237 relations: Map<FieldId, FieldRelationAccumulator>,
238 field: AnyInternalFieldApi,
239 identity: Pick<FieldIdentityController, 'getFieldId'>,
240): void {
241 field._listenerInstances?.forEach((listenerInstance, itemIndex) => {
242 listenerInstance.resolvedWatchFields?.forEach(
243 (sourceField, configuredPath) => {
244 addRelation(
245 relations,
246 sourceField,
247 getRelationCause(
248 'listener',
249 itemIndex,
250 configuredPath,
251 sourceField.name,
252 ),
253 identity,
254 )
255 },
256 )
257 })
259​
260function addListenerListenedToByRelations(
261 relations: Map<FieldId, FieldRelationAccumulator>,
262 sourceField: AnyInternalFieldApi,
263 watchingFields: FieldWatchingListenerFields | null,
264 identity: Pick<FieldIdentityController, 'getFieldId'>,
265): void {
266 watchingFields?.forEach((listenerInstances, watchingField) => {
267 if (watchingField._isKilled) return
268​
269 for (const listenerInstance of listenerInstances) {
270 const itemIndex =
271 watchingField._listenerInstances?.indexOf(listenerInstance) ?? -1
272 if (itemIndex < 0) continue
273​
274 let configuredPath: string | undefined
275 listenerInstance.resolvedWatchFields?.forEach((field, path) => {
276 if (field === sourceField) configuredPath = path
277 })
278 addRelation(
279 relations,
280 watchingField,
281 getRelationCause(
282 'listener',
283 itemIndex,
284 configuredPath,
285 sourceField.name,
286 ),
287 identity,
288 )
289 }
290 })
292​
293function addValidatorListensToRelations(
294 relations: Map<FieldId, FieldRelationAccumulator>,
295 field: AnyInternalFieldApi,
296 identity: Pick<FieldIdentityController, 'getFieldId'>,
297): void {
298 field._validatorInstances?.forEach((validatorInstance, itemIndex) => {
299 validatorInstance.resolvedWatchFields?.forEach(
300 (sourceField, configuredPath) => {
301 addRelation(
302 relations,
303 sourceField,
304 getRelationCause(
305 'validator',
306 itemIndex,
307 configuredPath,
308 sourceField.name,
309 ),
310 identity,
311 )
312 },
313 )
314 })
316​
317function addValidatorListenedToByRelations(
318 relations: Map<FieldId, FieldRelationAccumulator>,
319 sourceField: AnyInternalFieldApi,
320 watchingFields: FieldWatchingValidatorFields | null,
321 identity: Pick<FieldIdentityController, 'getFieldId'>,
322): void {
323 watchingFields?.forEach((validatorInstances, watchingField) => {
324 if (watchingField._isKilled) return
325​
326 for (const validatorInstance of validatorInstances) {
327 const itemIndex =
328 watchingField._validatorInstances?.indexOf(validatorInstance) ?? -1
329 if (itemIndex < 0) continue
330​
331 let configuredPath: string | undefined
332 validatorInstance.resolvedWatchFields?.forEach((field, path) => {
333 if (field === sourceField) configuredPath = path
334 })
335 addRelation(
336 relations,
337 watchingField,
338 getRelationCause(
339 'validator',
340 itemIndex,
341 configuredPath,
342 sourceField.name,
343 ),
344 identity,
345 )
346 }
347 })
349​
350function compareRelationCauses(
351 left: DevtoolsFieldRelationCause,
352 right: DevtoolsFieldRelationCause,
353): number {
354 if (left.kind !== right.kind) return left.kind === 'listener' ? -1 : 1
355 if (left.itemIndex !== right.itemIndex) {
356 return left.itemIndex - right.itemIndex
357 }
358 return (left.configuredPath ?? '').localeCompare(right.configuredPath ?? '')
360​
361function finalizeRelations(
362 relations: Map<FieldId, FieldRelationAccumulator>,
363): Array<DevtoolsFieldRelation> {
364 return Array.from(relations.values())
365 .sort((left, right) => {
366 const pathOrder = compareFieldPaths(left.path, right.path)
367 return (
368 pathOrder || String(left.fieldId).localeCompare(String(right.fieldId))
369 )
370 })
371 .map(({ fieldId, causes }) => ({
372 fieldId,
373 causes: causes.sort(compareRelationCauses),
374 }))
376​
377function getDevtoolsFieldRelations(
378 field: AnyInternalFieldApi,
379 identity: Pick<FieldIdentityController, 'getFieldId'>,
380): DevtoolsFieldRelations {
381 const listensTo = new Map<FieldId, FieldRelationAccumulator>()
382 const listenedToBy = new Map<FieldId, FieldRelationAccumulator>()
383​
384 addListenerListensToRelations(listensTo, field, identity)
385 addValidatorListensToRelations(listensTo, field, identity)
386 addListenerListenedToByRelations(
387 listenedToBy,
388 field,
389 field._watchingListenerFields,
390 identity,
391 )
392 addValidatorListenedToByRelations(
393 listenedToBy,
394 field,
395 field._watchingValidatorFields,
396 identity,
397 )
398​
399 return {
400 directChildCount: field._children.reduce(
401 (count, child) => count + (child._isKilled ? 0 : 1),
402 0,
403 ),
404 listensTo: finalizeRelations(listensTo),
405 listenedToBy: finalizeRelations(listenedToBy),
406 }
408​
409export function getDevtoolsFieldDetail(
410 field: AnyInternalFieldApi,
411 descriptor: FieldDetailSubscriptionDescriptor,
412 identity: Pick<FieldIdentityController, 'getFieldId'>,
413): DevtoolsFieldDetail {
414 const state = field.atom.get()
415​
416 return {
417 ...descriptor,
418 state: getDevtoolsFieldState(field, state, descriptor),
419 relations: getDevtoolsFieldRelations(field, identity),
420 ...(descriptor.settings.includeValues
421 ? { defaultValue: getBy(field.form.defaultValues, field.name) }
422 : {}),
423 }