@formvk/schema 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,497 @@
1
+ import type { ArrayField, Field, ObjectField, VoidField } from '@formvk/core'
2
+
3
+ import type { ExpressionProps, ISchema, SchemaExpression, SchemaPatch, SchemaReactions } from './types'
4
+
5
+ /**
6
+ * 三个独立的组件 props map,泛型顺序与运行时分类通道一致:
7
+ * - F:数据字段组件(string / number 等,也是动态组件的默认分类)
8
+ * - V:无值组件(void 字段、object 字段、decorator)
9
+ * - A:数组组件(array 字段)
10
+ */
11
+ export type FragmentPropsMap = Record<string, any>
12
+
13
+ export interface FragmentOptions<
14
+ V extends FragmentPropsMap = {},
15
+ DefaultDecorator extends AnyComponent<V> = AnyComponent<V>,
16
+ > {
17
+ patches?: SchemaPatchInput | SchemaPatchInput[]
18
+ /** 动态组件中按 void 处理的组件名,其余未声明组件按 field 处理 */
19
+ voidComponentNames?: string[]
20
+ /** 动态组件中按 array 处理的组件名 */
21
+ arrayComponentNames?: string[]
22
+ /**
23
+ * 默认装饰器:string 字段声明了 title 且未显式设置 decorator 时自动补上。
24
+ * 与 formily-pro 的 defaultDecoratorPatch 语义一致,object / void / array 不生效。
25
+ * 指定 createFragment 的第五个泛型后,decoratorProps 会按该装饰器收窄。
26
+ */
27
+ defaultDecorator?: DefaultDecorator
28
+ }
29
+
30
+ /** 支持 `{ pre: true, patch }` 形式的 patch,pre 会提前执行 */
31
+ export type SchemaPatchInput = SchemaPatch | { pre?: boolean; patch: SchemaPatch }
32
+
33
+ type ComponentName<Map> = [Map] extends [never] ? never : keyof Map & string
34
+
35
+ /**
36
+ * 组件入参通用形态:分类 map 中已声明的组件名 | 任意字符串组件名 | 组件引用(函数或对象组件)。
37
+ * field / void / array 组件与 decorator 的取值约束共用本类型,分类语义由传入的 F / V / A map 承载。
38
+ * 注意:object 成员不校验组件具体形状(跨 Vue 选项式 / 函数组件的宽松约束),非组件对象也能通过类型检查,
39
+ * 其合法性最终交给渲染层 h() 兜底。
40
+ */
41
+ export type AnyComponent<Map extends FragmentPropsMap> =
42
+ | ComponentName<Map>
43
+ | (string & {})
44
+ | ((...args: any[]) => any)
45
+ | object
46
+
47
+ /**
48
+ * 从组件类型提取 props;Vue 从 `$props`、类组件从构造函数首参、函数组件从入参提取。
49
+ * 无法识别组件形状时退回 `Record<string, unknown>`:保持对象可赋值、但不再放行任意属性运算(any 会污染下游)。
50
+ * 与 vue 包 ComponentProps 的差异:vue 侧只服务 Vue 组件,识别失败退化为 never(严格);
51
+ * 本类型需兼容跨框架的任意组件引用,识别失败只能退化为宽松 record。
52
+ */
53
+ export type TPropsOfComponent<Component> = Component extends abstract new (...args: any) => { $props: infer Props }
54
+ ? Props
55
+ : Component extends abstract new (props: infer Props, ...args: any[]) => any
56
+ ? Props
57
+ : Component extends (props: infer Props, ...args: any[]) => any
58
+ ? Props
59
+ : Record<string, unknown>
60
+
61
+ type TComponentProps<Map, Component> = [Component] extends [never]
62
+ ? Record<string, unknown>
63
+ : Component extends string
64
+ ? [Map] extends [never]
65
+ ? Record<string, unknown>
66
+ : Component extends keyof Map
67
+ ? Map[Component]
68
+ : Record<string, unknown>
69
+ : TPropsOfComponent<Component>
70
+
71
+ /** 四类 Schema 统一重写的 ISchema 键:节点类型、组件/装饰器引用及其 props、reactions;各 Schema 再按结构追加自身专有键 */
72
+ type SchemaOverrideKeys = 'type' | 'component' | 'componentProps' | 'decorator' | 'decoratorProps' | 'reactions'
73
+
74
+ /**
75
+ * 结构化的 creator 约束。
76
+ * 这里刻意不写成 `SchemaCreator<any>`,避免调用处把 Value 泛型从上下文中推导成 any。
77
+ */
78
+ export type SchemaCreatorLike = ((patches?: SchemaPatchInput | SchemaPatchInput[]) => ISchema) & {
79
+ _$types$_: any[]
80
+ }
81
+
82
+ /** properties 输入:creator / 已展开 ISchema / 空值 */
83
+ export type SchemaPropertiesInput = Record<string, SchemaCreatorLike | ISchema | null | undefined>
84
+
85
+ /**
86
+ * 校验 properties 的取值。
87
+ * 参数类型使用 `Properties & ValidateSchemaProperties<Properties>`,
88
+ * 既保留 creator 的 Value 推导,又能约束非法取值。
89
+ */
90
+ export type ValidateSchemaProperties<P> = {
91
+ [K in keyof P]: P[K] extends SchemaCreatorLike | ISchema | null | undefined ? P[K] : never
92
+ }
93
+
94
+ /**
95
+ * 父级声明类型的 properties 上下文。
96
+ * - Record 中声明的 key 会收敛子级 creator 的值类型与 reactions 的 `$record`
97
+ * - 未在 Record 中声明的 key 只允许 void 字段,用于布局等不产生值的节点
98
+ * - 子级未显式声明 Scope 时自动继承父级 Scope
99
+ *
100
+ * 这里刻意使用非 homomorphic 的映射类型(`Extract<keyof IRecord, string | number>`),
101
+ * 避免 TS 从子级 creator 反向推断父级 Record,保证显式声明的类型优先。
102
+ */
103
+ export type SchemaPropertiesContext<
104
+ IRecord extends object = any,
105
+ Scope extends object = {},
106
+ IValues extends object = any,
107
+ > =
108
+ | {
109
+ [K in Extract<keyof IRecord, string | number>]?:
110
+ | SchemaCreator<IRecord[K], Scope, IRecord, IValues>
111
+ | ISchema
112
+ | null
113
+ | undefined
114
+ }
115
+ | {
116
+ [key: string]: VoidSchemaCreator<IRecord, Scope, IValues> | ISchema | null | undefined
117
+ }
118
+
119
+ /**
120
+ * 显式 overload 的调用守卫:第一个类型参数默认 never,未显式提供时参数类型为 never,
121
+ * 使调用落到后面的推断 overload;显式提供泛型时还原为真实入参类型。
122
+ */
123
+ type ExplicitTypeArgGuard<T, Context> = [T] extends [never] ? never : Context
124
+
125
+ export interface SchemaCreator<Value = any, IScope = any, IRecord extends object = any, IValues = any> {
126
+ (patches?: SchemaPatchInput | SchemaPatchInput[]): ISchema
127
+ /** 仅用于类型标记,请勿使用 */
128
+ _$types$_: [Value, IRecord, IScope, IValues]
129
+ }
130
+
131
+ export interface VoidSchemaCreator<IRecord extends object = any, IScope = any, IValues = any> {
132
+ (patches?: SchemaPatchInput | SchemaPatchInput[]): ISchema
133
+ /** 仅用于类型标记,请勿使用 */
134
+ _$types$_: [IRecord, IScope, IValues]
135
+ }
136
+
137
+ export type SchemaPropertiesValues<P extends Record<string, any>> = {
138
+ [K in keyof P]?: P[K] extends SchemaCreator<infer Value, any, any, any> ? Value : any
139
+ }
140
+
141
+ export type FieldSchema<
142
+ F extends FragmentPropsMap,
143
+ V extends FragmentPropsMap,
144
+ Component extends AnyComponent<F> = ComponentName<F>,
145
+ Decorator extends AnyComponent<V> = ComponentName<V>,
146
+ Value = any,
147
+ IRecord extends object = any,
148
+ Scope extends object = {},
149
+ IValues extends object = any,
150
+ > = Omit<ISchema, SchemaOverrideKeys> & {
151
+ component?: Component | SchemaExpression
152
+ componentProps?: ExpressionProps<TComponentProps<F, Component>>
153
+ decorator?: Decorator | SchemaExpression
154
+ decoratorProps?: ExpressionProps<TComponentProps<V, Decorator>>
155
+ reactions?: SchemaReactions<
156
+ Field<Value, TComponentProps<F, Component>, TComponentProps<V, Decorator>, IRecord>,
157
+ Scope,
158
+ IRecord,
159
+ IValues
160
+ >
161
+ }
162
+
163
+ export type ObjectSchema<
164
+ V extends FragmentPropsMap,
165
+ Component extends AnyComponent<V> = ComponentName<V>,
166
+ Decorator extends AnyComponent<V> = ComponentName<V>,
167
+ Value extends object = any,
168
+ IRecord extends object = any,
169
+ Scope extends object = {},
170
+ IValues extends object = any,
171
+ > = Omit<ISchema, SchemaOverrideKeys | 'properties'> & {
172
+ component?: Component | SchemaExpression
173
+ componentProps?: ExpressionProps<TComponentProps<V, Component>>
174
+ decorator?: Decorator | SchemaExpression
175
+ decoratorProps?: ExpressionProps<TComponentProps<V, Decorator>>
176
+ properties?: SchemaPropertiesInput
177
+ reactions?: SchemaReactions<
178
+ ObjectField<Value, TComponentProps<V, Component>, TComponentProps<V, Decorator>, IRecord>,
179
+ Scope,
180
+ IRecord,
181
+ IValues
182
+ >
183
+ }
184
+
185
+ export type ArraySchema<
186
+ A extends FragmentPropsMap,
187
+ V extends FragmentPropsMap,
188
+ Component extends AnyComponent<A> = ComponentName<A>,
189
+ Decorator extends AnyComponent<V> = ComponentName<V>,
190
+ Value extends any[] = any[],
191
+ IRecord extends object = any,
192
+ Scope extends object = {},
193
+ IValues extends object = any,
194
+ > = Omit<ISchema, SchemaOverrideKeys | 'items' | 'properties'> & {
195
+ component?: Component | SchemaExpression
196
+ componentProps?: ExpressionProps<TComponentProps<A, Component>>
197
+ decorator?: Decorator | SchemaExpression
198
+ decoratorProps?: ExpressionProps<TComponentProps<V, Decorator>>
199
+ properties?: SchemaPropertiesInput
200
+ reactions?: SchemaReactions<
201
+ ArrayField<Value, TComponentProps<A, Component>, TComponentProps<V, Decorator>, IRecord>,
202
+ Scope,
203
+ IRecord,
204
+ IValues
205
+ >
206
+ }
207
+
208
+ export type VoidSchema<
209
+ V extends FragmentPropsMap,
210
+ Component extends AnyComponent<V> = ComponentName<V>,
211
+ Decorator extends AnyComponent<V> = ComponentName<V>,
212
+ IRecord extends object = any,
213
+ Scope extends object = {},
214
+ IValues extends object = any,
215
+ > = Omit<ISchema, SchemaOverrideKeys | 'properties'> & {
216
+ component?: Component | SchemaExpression
217
+ componentProps?: ExpressionProps<TComponentProps<V, Component>>
218
+ decorator?: Decorator | SchemaExpression
219
+ decoratorProps?: ExpressionProps<TComponentProps<V, Decorator>>
220
+ properties?: SchemaPropertiesInput
221
+ reactions?: SchemaReactions<
222
+ VoidField<TComponentProps<V, Component>, TComponentProps<V, Decorator>, IRecord>,
223
+ Scope,
224
+ IRecord,
225
+ IValues
226
+ >
227
+ }
228
+
229
+ export interface FieldFragment<
230
+ F extends FragmentPropsMap,
231
+ V extends FragmentPropsMap,
232
+ Scope extends object = {},
233
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
234
+ > {
235
+ <Value = string>(): SchemaCreator<Value | undefined, Scope>
236
+ <
237
+ Value = string,
238
+ Component extends AnyComponent<F> = ComponentName<F>,
239
+ Decorator extends AnyComponent<V> = DefaultDecorator,
240
+ FieldScope extends object = Scope,
241
+ IRecord extends object = any,
242
+ IValues extends object = any,
243
+ >(
244
+ schema: FieldSchema<F, V, Component, Decorator, Value, IRecord, FieldScope, IValues> & { required: true }
245
+ ): SchemaCreator<Value, FieldScope, IRecord, IValues>
246
+ <
247
+ Value = string,
248
+ Component extends AnyComponent<F> = ComponentName<F>,
249
+ Decorator extends AnyComponent<V> = DefaultDecorator,
250
+ FieldScope extends object = Scope,
251
+ IRecord extends object = any,
252
+ IValues extends object = any,
253
+ >(
254
+ schema: FieldSchema<F, V, Component, Decorator, Value, IRecord, FieldScope, IValues>
255
+ ): SchemaCreator<Value | undefined, FieldScope, IRecord, IValues>
256
+ }
257
+
258
+ export interface ObjectFragment<
259
+ V extends FragmentPropsMap,
260
+ Scope extends object = {},
261
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
262
+ > {
263
+ /**
264
+ * 显式声明对象值类型与字段级 Scope,properties 中的子级自动继承:
265
+ * - 子级 creator 的值类型与 `$record` 由 Value 收敛
266
+ * - 子级未显式声明 Scope 时继承 FieldScope
267
+ * 对象自身位于父级容器中,`$record` 无法从 properties 推断,默认 any,可通过第三个泛型显式声明。
268
+ * Value 默认 never 配合 Guard,保证不传泛型时由下方的推断 overload 接管。
269
+ */
270
+ <
271
+ Value extends object = never,
272
+ FieldScope extends object = Scope,
273
+ Record extends object = any,
274
+ Component extends AnyComponent<V> = ComponentName<V>,
275
+ Decorator extends AnyComponent<V> = DefaultDecorator,
276
+ >(
277
+ properties: ExplicitTypeArgGuard<Value, SchemaPropertiesContext<Value, FieldScope>>,
278
+ schema?: ObjectSchema<V, Component, Decorator, Value, Record, FieldScope>
279
+ ): SchemaCreator<Value, FieldScope, Record>
280
+ <
281
+ Properties extends Record<string, unknown>,
282
+ Component extends AnyComponent<V> = ComponentName<V>,
283
+ Decorator extends AnyComponent<V> = DefaultDecorator,
284
+ >(
285
+ properties: Properties & ValidateSchemaProperties<Properties>,
286
+ schema?: ObjectSchema<V, Component, Decorator, SchemaPropertiesValues<Properties>, any, Scope>
287
+ ): SchemaCreator<
288
+ SchemaPropertiesValues<Properties>,
289
+ any,
290
+ SchemaPropertiesValues<Properties>,
291
+ SchemaPropertiesValues<Properties>
292
+ >
293
+ }
294
+
295
+ export type SchemaCreatorValue<T> = T extends SchemaCreator<infer Value, any, any, any> ? Value : any
296
+
297
+ /** 数组项可作为 record 类型时直接使用,基础类型退回 any(与核心 ArrayField 的 IRecord 约束一致) */
298
+ type TRecordOfItem<Item> = Item extends object ? Item : any
299
+
300
+ export interface ArrayFragment<
301
+ A extends FragmentPropsMap,
302
+ V extends FragmentPropsMap,
303
+ Scope extends object = {},
304
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
305
+ > {
306
+ /**
307
+ * 无泛型调用:从 items creator 推断数组项类型。
308
+ * 约束限定为 creator,避免显式泛型调用(第一个泛型是 Item 类型)误选本 overload。
309
+ */
310
+ <
311
+ Items extends SchemaCreator<any>,
312
+ Component extends AnyComponent<A> = ComponentName<A>,
313
+ Decorator extends AnyComponent<V> = DefaultDecorator,
314
+ >(
315
+ items: Items,
316
+ schema?: ArraySchema<
317
+ A,
318
+ V,
319
+ Component,
320
+ Decorator,
321
+ SchemaCreatorValue<Items>[],
322
+ TRecordOfItem<SchemaCreatorValue<Items>>,
323
+ Scope
324
+ >
325
+ ): SchemaCreator<SchemaCreatorValue<Items>[], any, SchemaCreatorValue<Items>, SchemaCreatorValue<Items>[]>
326
+ /**
327
+ * 显式声明数组项类型与字段级 Scope:
328
+ * - items 中的子级 creator 值类型收敛为 Item
329
+ * - 子级未显式声明 Scope 时继承 FieldScope
330
+ * 数组自身位于父级容器中,`$record` 无法从 items 推断,默认 any,可通过第三个泛型显式声明。
331
+ */
332
+ <
333
+ Item = any,
334
+ FieldScope extends object = Scope,
335
+ Record extends object = any,
336
+ Component extends AnyComponent<A> = ComponentName<A>,
337
+ Decorator extends AnyComponent<V> = DefaultDecorator,
338
+ >(
339
+ items: SchemaCreator<Item, FieldScope> | ISchema,
340
+ schema?: ArraySchema<A, V, Component, Decorator, Item[], Record, FieldScope>
341
+ ): SchemaCreator<Item[], FieldScope, Record>
342
+ }
343
+
344
+ export interface VoidFragment<
345
+ V extends FragmentPropsMap,
346
+ Scope extends object = {},
347
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
348
+ > {
349
+ /**
350
+ * 显式声明记录类型与字段级 Scope,properties 中的子级自动继承:
351
+ * - 子级 reactions 的 `$record` 收敛为 Record
352
+ * - 子级未显式声明 Scope 时继承 FieldScope
353
+ * Record 默认 never 配合 Guard,保证不传泛型时由下方的推断 overload 接管。
354
+ */
355
+ <
356
+ Record extends object = never,
357
+ FieldScope extends object = Scope,
358
+ Component extends AnyComponent<V> = ComponentName<V>,
359
+ Decorator extends AnyComponent<V> = DefaultDecorator,
360
+ >(
361
+ properties: ExplicitTypeArgGuard<Record, SchemaPropertiesContext<Record, FieldScope>>,
362
+ schema?: VoidSchema<V, Component, Decorator, Record, FieldScope>
363
+ ): VoidSchemaCreator<Record, FieldScope>
364
+ <
365
+ Properties extends Record<string, unknown>,
366
+ Component extends AnyComponent<V> = ComponentName<V>,
367
+ Decorator extends AnyComponent<V> = DefaultDecorator,
368
+ >(
369
+ properties: Properties & ValidateSchemaProperties<Properties>,
370
+ schema?: VoidSchema<V, Component, Decorator, any, Scope>
371
+ ): VoidSchemaCreator<SchemaPropertiesValues<Properties>, any, SchemaPropertiesValues<Properties>>
372
+ }
373
+
374
+ export interface FragmentBase<
375
+ F extends FragmentPropsMap,
376
+ V extends FragmentPropsMap,
377
+ A extends FragmentPropsMap,
378
+ Scope extends object = {},
379
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
380
+ > {
381
+ Field: FieldFragment<F, V, Scope, DefaultDecorator>
382
+ Object: ObjectFragment<V, Scope, DefaultDecorator>
383
+ Array: ArrayFragment<A, V, Scope, DefaultDecorator>
384
+ Void: VoidFragment<V, Scope, DefaultDecorator>
385
+ transform: (schema?: ISchema) => ISchema
386
+ }
387
+
388
+ export interface FieldFragmentItem<
389
+ F extends FragmentPropsMap,
390
+ V extends FragmentPropsMap,
391
+ K extends ComponentName<F>,
392
+ Scope extends object = {},
393
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
394
+ > {
395
+ <
396
+ Value = string,
397
+ Decorator extends AnyComponent<V> = DefaultDecorator,
398
+ FieldScope extends object = Scope,
399
+ IRecord extends object = any,
400
+ IValues extends object = any,
401
+ >(
402
+ schema: Omit<FieldSchema<F, V, K, Decorator, Value, IRecord, FieldScope, IValues>, 'component'> & { required: true }
403
+ ): SchemaCreator<Value, FieldScope, IRecord, IValues>
404
+ <
405
+ Value = string,
406
+ Decorator extends AnyComponent<V> = DefaultDecorator,
407
+ FieldScope extends object = Scope,
408
+ IRecord extends object = any,
409
+ IValues extends object = any,
410
+ >(
411
+ schema?: Omit<FieldSchema<F, V, K, Decorator, Value, IRecord, FieldScope, IValues>, 'component'>
412
+ ): SchemaCreator<Value | undefined, FieldScope, IRecord, IValues>
413
+ }
414
+
415
+ export interface VoidFragmentItem<
416
+ V extends FragmentPropsMap,
417
+ K extends ComponentName<V>,
418
+ Scope extends object = {},
419
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
420
+ > {
421
+ <
422
+ Value = any,
423
+ Decorator extends AnyComponent<V> = DefaultDecorator,
424
+ FieldScope extends object = Scope,
425
+ IRecord extends object = any,
426
+ >(
427
+ schema?: Omit<VoidSchema<V, K, Decorator, IRecord, FieldScope>, 'type' | 'component'>
428
+ ): VoidSchemaCreator<IRecord, FieldScope, Value>
429
+ }
430
+
431
+ export interface ArrayFragmentItem<
432
+ A extends FragmentPropsMap,
433
+ V extends FragmentPropsMap,
434
+ K extends ComponentName<A>,
435
+ Scope extends object = {},
436
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
437
+ > {
438
+ /**
439
+ * 无泛型调用:从 items creator 推断数组项类型。
440
+ */
441
+ <Items extends SchemaCreator<any>, Decorator extends AnyComponent<V> = DefaultDecorator>(
442
+ items: Items,
443
+ schema?: Omit<
444
+ ArraySchema<A, V, K, Decorator, SchemaCreatorValue<Items>[], TRecordOfItem<SchemaCreatorValue<Items>>, Scope>,
445
+ 'component'
446
+ >
447
+ ): SchemaCreator<SchemaCreatorValue<Items>[], any, SchemaCreatorValue<Items>, SchemaCreatorValue<Items>[]>
448
+ /**
449
+ * 显式声明数组项类型与字段级 Scope,items 中的子级自动继承。
450
+ */
451
+ <
452
+ Item = any,
453
+ FieldScope extends object = Scope,
454
+ Record extends object = any,
455
+ Decorator extends AnyComponent<V> = DefaultDecorator,
456
+ >(
457
+ items: SchemaCreator<Item, FieldScope> | ISchema,
458
+ schema?: Omit<ArraySchema<A, V, K, Decorator, Item[], Record, FieldScope>, 'component'>
459
+ ): SchemaCreator<Item[], FieldScope, Record>
460
+ }
461
+
462
+ export type FieldFragmentMapping<
463
+ F extends FragmentPropsMap,
464
+ V extends FragmentPropsMap,
465
+ Scope extends object = {},
466
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
467
+ > = {
468
+ [K in ComponentName<F>]: FieldFragmentItem<F, V, K, Scope, DefaultDecorator>
469
+ }
470
+
471
+ export type VoidFragmentMapping<
472
+ V extends FragmentPropsMap,
473
+ Scope extends object = {},
474
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
475
+ > = {
476
+ [K in ComponentName<V>]: VoidFragmentItem<V, K, Scope, DefaultDecorator>
477
+ }
478
+
479
+ export type ArrayFragmentMapping<
480
+ A extends FragmentPropsMap,
481
+ V extends FragmentPropsMap,
482
+ Scope extends object = {},
483
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
484
+ > = {
485
+ [K in ComponentName<A>]: ArrayFragmentItem<A, V, K, Scope, DefaultDecorator>
486
+ }
487
+
488
+ export type Fragment<
489
+ F extends FragmentPropsMap = {},
490
+ V extends FragmentPropsMap = {},
491
+ A extends FragmentPropsMap = {},
492
+ Scope extends object = {},
493
+ DefaultDecorator extends AnyComponent<V> = ComponentName<V>,
494
+ > = FragmentBase<F, V, A, Scope, DefaultDecorator> &
495
+ FieldFragmentMapping<F, V, Scope, DefaultDecorator> &
496
+ VoidFragmentMapping<V, Scope, DefaultDecorator> &
497
+ ArrayFragmentMapping<A, V, Scope, DefaultDecorator>