@piying/view-angular-core 1.7.8 → 1.8.1

package/fesm2022/piying-view-angular-core-adapter.mjs

@@ -1,135 +1,795 @@
-import { map, switchMap } from 'rxjs/operators';
-import rfdc from 'rfdc';
+import { isString, uniq, isBoolean, isUndefined, isNil, intersection, union, difference } from 'es-toolkit';
 import * as v from 'valibot';
 import * as jsonActions from '@piying/view-angular-core';
-import { hideWhen, formConfig } from '@piying/view-angular-core';
-import { isString, isNil, intersection, isBoolean, isUndefined, union, uniq } from 'es-toolkit';
-import { BehaviorSubject, merge } from 'rxjs';
+import { hideWhen, patchInputs, asControl, setComponent } from '@piying/view-angular-core';
+import { computed } from '@angular/core';
+import { merge, map, BehaviorSubject, switchMap, combineLatest } from 'rxjs';
 import { schema } from '@piying/valibot-visit';
-import { deepEqual } from 'fast-equals';
+import rfdc from 'rfdc';
 
-function createImpasseAction(key, value) {
-    return v.rawCheck(({ dataset, addIssue }) => {
-        if (dataset.issues) {
-            return;
-        }
-        addIssue({
-            label: `impasse:${key}`,
-            expected: '[no validation conflict]',
-            received: value,
-        });
-    });
-}
 function isNumber(value) {
     return typeof value === 'number';
 }
-const anyType = [
-    'object',
-    'array',
-    'string',
-    'number',
-    'boolean',
-    'null',
-    'integer',
-];
-// todo 先按照类型不可变设计,之后修改代码支持组件变更
-const clone = rfdc({ proto: false, circles: false });
-function getMetadataAction(schema) {
-    const action = [];
-    if (isString(schema.title)) {
-        action.push(v.title(schema.title));
+
+var ChildKind;
+(function (ChildKind) {
+    ChildKind[ChildKind["child"] = 0] = "child";
+    ChildKind[ChildKind["condition"] = 1] = "condition";
+})(ChildKind || (ChildKind = {}));
+class TypeContext {
+    parent;
+    parentObject;
+    level = 0;
+    instance;
+}
+class BaseTypeService {
+    static index = 0;
+    context = new TypeContext();
+    parent;
+    instance;
+    schema;
+    name;
+    index = 0;
+    instanceNamePrefix$$ = computed(() => `${this.index}-type`);
+    constructor(instance, schema) {
+        this.context.instance = this;
+        this.instance = instance;
+        this.schema = schema;
     }
-    if (isString(schema.description)) {
-        action.push(v.description(schema.description));
+    getAllActionList(actionList) {
+        return [...actionList, ...this.getExtraActionList()];
     }
-    return action;
-}
-function arrayIntersection(a, b) {
-    if (!isNil(a) && !isNil(b)) {
-        a = Array.isArray(a) ? a : [a];
-        b = Array.isArray(b) ? b : [b];
-        if (a.length && b.length) {
-            const result = intersection(a, b);
-            if (result.length === 0) {
-                return {
-                    action: createImpasseAction('applicator'),
-                    value: undefined,
-                };
+    isOptional() {
+        return this.schema.__resolved.type.optional;
+    }
+    parseBase(actionList) {
+        const Define = v.pipe(this.getBaseDefine(), ...this.getAllActionList(actionList));
+        const OptDefine = this.isOptional()
+            ? v.optional(Define, this.schema.default)
+            : Define;
+        return OptDefine;
+    }
+    parse(actionList) {
+        const OptDefine = this.parseBase(actionList);
+        return (this.instance.options?.schemaHandle?.type?.afterResolve(OptDefine, this.schema, this.name) ?? OptDefine);
+    }
+    getBaseDefine() {
+        throw new Error('');
+    }
+    getValidationActionList(schema) {
+        const action = [];
+        // string/array
+        if (isNumber(schema.minLength) || isNumber(schema.minItems)) {
+            action.push(v.minLength(schema.minLength ?? schema.minItems));
+        }
+        // string/array
+        if (isNumber(schema.maxLength) || isNumber(schema.maxItems)) {
+            action.push(v.maxLength(schema.maxLength ?? schema.maxItems));
+        }
+        // string
+        if (isString(schema.pattern)) {
+            action.push(v.regex(new RegExp(schema.pattern)));
+        }
+        // todo format https://json-schema.org/understanding-json-schema/reference/type#built-in-formats
+        // duration idn-email idn-hostname uri-reference iri iri-reference uri-template json-pointer regex
+        if (schema.format) {
+            switch (schema.format) {
+                // case 'date-time': {
+                //   action.push(v.isoDateTime());
+                //   break;
+                // }
+                // case 'time': {
+                //   action.push(v.isoTime());
+                //   break;
+                // }
+                case 'date': {
+                    action.push(v.isoDate());
+                    break;
+                }
+                case 'email': {
+                    action.push(v.email());
+                    break;
+                }
+                case 'ipv4': {
+                    action.push(v.ipv4());
+                    break;
+                }
+                case 'ipv6': {
+                    action.push(v.ipv6());
+                    break;
+                }
+                case 'uuid': {
+                    action.push(v.uuid());
+                    break;
+                }
+                case 'uri': {
+                    action.push(v.url());
+                    break;
+                }
+                default:
+                    break;
             }
-            else {
-                return { value: result };
+        }
+        // number
+        if (isNumber(schema.exclusiveMinimum)) {
+            action.push(v.gtValue(schema.exclusiveMinimum));
+        }
+        if (isNumber(schema.exclusiveMaximum)) {
+            action.push(v.ltValue(schema.exclusiveMaximum));
+        }
+        if (isNumber(schema.minimum)) {
+            action.push(v.minValue(schema.minimum));
+        }
+        if (isNumber(schema.maximum)) {
+            action.push(v.maxValue(schema.maximum));
+        }
+        // number
+        if (isNumber(schema.multipleOf)) {
+            action.push(v.multipleOf(schema.multipleOf));
+        }
+        // array
+        if (schema.uniqueItems) {
+            action.push(v.check((input) => uniq(input).length === input.length));
+        }
+        // object
+        if (isNumber(schema.maxProperties)) {
+            action.push(v.maxEntries(schema.maxProperties));
+        }
+        // object
+        if (isNumber(schema.minProperties)) {
+            action.push(v.minEntries(schema.minProperties));
+        }
+        if (schema.actions) {
+            for (const rawAction of schema.actions) {
+                const inlineActions = jsonActions[rawAction.name] ??
+                    this.instance.options?.customActions?.[rawAction.name];
+                if (!inlineActions) {
+                    throw new Error(`action:[${rawAction.name}]❗`);
+                }
+                action.push(inlineActions(...rawAction.params));
             }
         }
-        return {
-            value: a.length ? a : b,
-        };
+        return action;
+    }
+    getExtraActionList() {
+        return [];
+    }
+    typeParse(type, schema, actionList, options) {
+        const instance = this.getTypeParse(type, schema, options);
+        return instance.parse(actionList);
+    }
+    getTypeParse(type, schema, options) {
+        const Parser = this.instance.getTypeParser(type);
+        const instance = new Parser(this.instance, schema);
+        instance.index = ++BaseTypeService.index;
+        instance.context.parent = this.context;
+        if (instance.context.level) {
+            instance.context.parentObject = this.context.parentObject;
+        }
+        if (options?.kind === ChildKind.child) {
+            if (instance.context.level === 0) {
+                instance.context.parentObject = instance.context;
+            }
+        }
+        else if (options?.kind === ChildKind.condition) {
+            instance.context.level++;
+            instance.context.parentObject = this.context.parentObject ?? this.context;
+        }
+        return instance;
+    }
+    commonTypeParse(schema, options) {
+        // const resolved = this.resolveSchema2(schema as any);
+        return this.typeParse('common', schema, [], options);
+    }
+    resolveSchema2(schema) {
+        return this.instance.resolveSchema2(schema);
+    }
+    schemahasRef(schema) {
+        if (isBoolean(schema)) {
+            return false;
+        }
+        else {
+            const result = this.resolveSchema2(schema);
+            return result.__resolved.hasRef;
+        }
+    }
+    getFixedChild() {
+        let context = this.context;
+        let childObject = {};
+        while (context?.level) {
+            context = context.parentObject;
+            const instance = context?.instance;
+            childObject = { ...childObject, ...instance.childObject };
+        }
+        return childObject;
+    }
+    getFixedChildBy(key) {
+        let context = this.context;
+        while (context?.level) {
+            context = context.parentObject;
+            const instance = context?.instance;
+            if (instance.name === 'object') {
+                const maybeName = instance.getFixedChildPath(key);
+                if (maybeName) {
+                    return maybeName;
+                }
+            }
+        }
+        throw new Error('');
     }
-    return { value: a ?? b };
 }
-// 应该传入定制
-function jsonSchemaToValibot(schema, options) {
-    return new JsonSchemaToValibot(schema, options).convert();
+
+class NumberTypeService extends BaseTypeService {
+    name = 'number';
+    getBaseDefine() {
+        return v.number();
+    }
 }
-const Schema2012 = 'https://json-schema.org/draft/2020-12/schema';
-class JsonSchemaToValibot {
-    root;
-    #options;
-    cacheSchema = new WeakMap();
-    constructor(root, options) {
-        this.root = root;
-        this.#options = options;
-        root.$schema ??= Schema2012;
+
+class IntegerTypeService extends NumberTypeService {
+    name = 'integer';
+    getBaseDefine() {
+        return v.number();
     }
-    convert() {
-        return this.#jSchemaToVSchema(clone(this.root));
+    getExtraActionList() {
+        return [v.integer()];
     }
-    #applicatorParse(schema$1) {
-        let vSchema;
-        if (schema$1.allOf) {
-            const result = this.#mergeSchema(schema$1, ...schema$1.allOf);
-            vSchema = v.pipe(this.#jsonSchemaBase(result.schema, () => result.actionList));
+}
+
+class BooleanTypeService extends BaseTypeService {
+    name = 'boolean';
+    getBaseDefine() {
+        return v.boolean();
+    }
+}
+
+class StringTypeService extends BaseTypeService {
+    name = 'string';
+    getBaseDefine() {
+        return v.string();
+    }
+}
+
+class NullTypeService extends BaseTypeService {
+    name = 'number';
+    parseBase(actionList) {
+        const Define = v.pipe(v.optional(v.null(), null), ...this.getAllActionList(actionList));
+        return Define;
+    }
+}
+
+class ConstTypeService extends BaseTypeService {
+    name = 'const';
+    parseBase(actionList) {
+        const value = this.schema.const;
+        const Define = v.pipe(v.optional(v.literal(value), value), ...this.getAllActionList(actionList));
+        return Define;
+    }
+}
+
+class ObjectTypeService extends BaseTypeService {
+    name = 'object';
+    actionList = [];
+    #optional = false;
+    childObject = {};
+    fixedActionList = [];
+    // fixedObjName!: string;
+    isOptional() {
+        return super.isOptional() || this.#optional;
+    }
+    getExtraActionList() {
+        return this.actionList;
+    }
+    getFixedChildPath(key) {
+        if (key in this.childObject) {
+            return this.instanceNamePrefix$$();
         }
-        else if (schema$1.anyOf) {
-            vSchema = this.#conditionCreate(schema$1, {
-                useOr: false,
-                getChildren: () => schema$1.anyOf,
-                conditionCheckActionFn(childOriginSchemaList, getActivateList) {
-                    return v.rawCheck(({ dataset, addIssue }) => {
-                        if (dataset.issues) {
-                            return;
-                        }
-                        let childFailedResult;
-                        // 验证项全为可选,所以需要这里再次验证
-                        const hasSuccess = childOriginSchemaList.some((item, index) => {
-                            const isActive = getActivateList()[index];
-                            if (!isActive) {
-                                childFailedResult ??= { index: index };
-                                return false;
-                            }
-                            const result = v.safeParse(item, dataset.value);
-                            if (!result.success) {
-                                childFailedResult = { index: index, issues: result.issues };
+        return undefined;
+    }
+    getBaseDefine() {
+        const fixedObjName = `${this.instanceNamePrefix$$()}-fixed`;
+        const actionList = this.actionList;
+        const schema$1 = this.schema;
+        const childObject = {};
+        this.childObject = childObject;
+        /** 附加 */
+        let defaultRest;
+        let mode = 'default';
+        if (schema$1.dependentRequired) {
+            actionList.push(v.rawCheck(({ dataset, addIssue }) => {
+                if (dataset.issues) {
+                    return;
+                }
+                Object.keys(schema$1.dependentRequired).forEach((key) => {
+                    if (dataset.value?.[key] !== undefined) {
+                        for (const reqKey of schema$1.dependentRequired[key]) {
+                            if (dataset.value[reqKey] === undefined) {
+                                addIssue({
+                                    label: `dependentRequired:${key}=>${reqKey}`,
+                                    expected: '[required]',
+                                    received: 'undefined',
+                                });
                             }
-                            return result.success;
-                        });
-                        if (!hasSuccess) {
-                            const extMessage = childFailedResult?.issues
-                                ?.map((item) => item.message)
-                                .join(',') ?? '';
-                            addIssue({
-                                label: `anyOf:${childFailedResult?.index ?? ''}:${extMessage}`,
-                            });
                         }
+                    }
+                });
+            }));
+        }
+        let hasRequiredKey = false;
+        // 普通属性
+        if (schema$1.properties) {
+            for (const key in schema$1.properties) {
+                const propJSchema = schema$1.properties[key];
+                let propData;
+                if (isBoolean(propJSchema)) {
+                    propData = { optional: false, hasRef: false };
+                }
+                else {
+                    const rSchema = this.resolveSchema2(propJSchema);
+                    propData = {
+                        optional: rSchema.__resolved.type.optional,
+                        hasRef: rSchema.__resolved.hasRef,
+                    };
+                }
+                const isRequired = !!schema$1.required?.includes(key);
+                const wrapperOptional = !isRequired && !propData.optional;
+                if (isRequired && !propData.optional) {
+                    hasRequiredKey = true;
+                }
+                const createRef = () => {
+                    let propVSchema = this.commonTypeParse(propJSchema, {
+                        kind: ChildKind.child,
                     });
-                },
-                conditionSchemaFn(baseSchema, conditionVSchema, childSchemaList) {
-                    return v.pipe(v.intersect([
-                        conditionVSchema,
-                        baseSchema,
-                        schema.intersect(childSchemaList.map((item) => v.pipe(v.optional(item), jsonActions.renderConfig({ hidden: true })))),
-                    ]), jsonActions.setComponent('anyOf-condition'));
-                },
-            });
+                    const depList = schema$1.dependentRequired?.[key];
+                    if (depList) {
+                        propVSchema = v.pipe(propVSchema, jsonActions.patchHooks({
+                            allFieldsResolved: (field) => {
+                                field.form.control.statusChanges.subscribe(() => {
+                                    const valid = field.form.control.valid;
+                                    depList.map((item) => {
+                                        field.form.parent.get(item)?.config$.update((config) => ({
+                                            ...config,
+                                            required: valid,
+                                        }));
+                                    });
+                                });
+                            },
+                        }));
+                    }
+                    return propVSchema;
+                };
+                childObject[key] = propData.hasRef
+                    ? wrapperOptional
+                        ? v.optional(v.lazy(() => createRef()))
+                        : v.lazy(() => createRef())
+                    : wrapperOptional
+                        ? v.optional(createRef())
+                        : createRef();
+            }
+        }
+        // 附加属性规则
+        if (isBoolean(schema$1.additionalProperties)) {
+            mode = schema$1.additionalProperties === false ? 'strict' : mode;
+        }
+        else if (schema$1.additionalProperties) {
+            mode = 'rest';
+            // rest要符合的规则
+            defaultRest = this.commonTypeParse(schema$1.additionalProperties, {
+                kind: ChildKind.condition,
+            });
+        }
+        const patternRestList = [];
+        if (schema$1.patternProperties) {
+            for (const key in schema$1.patternProperties) {
+                const item = this.commonTypeParse(schema$1.patternProperties[key], {
+                    kind: ChildKind.condition,
+                });
+                if (!item) {
+                    throw new Error(`patternProperties->${key}: 定义未找到`);
+                }
+                patternRestList.push({
+                    regexp: new RegExp(key),
+                    schema: item,
+                });
+            }
+        }
+        /** 条件显示 */
+        const conditionList = [];
+        if (schema$1.dependentSchemas) {
+            const depSchemaMap = {};
+            for (const key in schema$1.dependentSchemas) {
+                const jSchema = schema$1.dependentSchemas[key];
+                let vSchema = this.commonTypeParse(jSchema, {
+                    kind: ChildKind.condition,
+                });
+                if (!vSchema) {
+                    throw new Error(`依赖->${key}: 定义未找到`);
+                }
+                depSchemaMap[key] = vSchema;
+                vSchema = v.pipe(vSchema, jsonActions.renderConfig({ hidden: true }), hideWhen({
+                    disabled: true,
+                    listen: (fn, field) => {
+                        const controlField = field.get(['..', '..', 0, key]).form
+                            .control;
+                        return merge(controlField.valueChanges, controlField.statusChanges).pipe(map(() => !(controlField.valid && controlField.value !== undefined)));
+                    },
+                }));
+                conditionList.push(vSchema);
+            }
+            actionList.push(v.rawCheck(({ dataset, addIssue }) => {
+                if (dataset.issues) {
+                    return;
+                }
+                Object.keys(schema$1.dependentSchemas).forEach((key) => {
+                    if (dataset.value?.[key] !== undefined) {
+                        const result = v.safeParse(depSchemaMap[key], dataset.value);
+                        if (!result.success) {
+                            for (const item of result.issues) {
+                                addIssue({
+                                    ...item,
+                                });
+                            }
+                        }
+                    }
+                });
+            }));
+        }
+        if (isBoolean(schema$1.propertyNames) && !schema$1.propertyNames) {
+            actionList.push(v.check(() => false));
+        }
+        else if (schema$1.propertyNames) {
+            const propNameSchema = this.commonTypeParse(schema$1.propertyNames);
+            actionList.push(v.rawCheck(({ dataset, addIssue }) => {
+                if (dataset.issues) {
+                    return;
+                }
+                if (dataset.value && typeof dataset.value === 'object') {
+                    for (const key of Object.keys(dataset.value)) {
+                        const result = v.safeParse(propNameSchema, key);
+                        if (!result.success) {
+                            addIssue({
+                                label: `propertyNames:${key}`,
+                                expected: `[match]`,
+                                received: key,
+                            });
+                        }
+                    }
+                }
+            }));
+        }
+        let schemaDefine;
+        if (!Object.keys(childObject).length || !hasRequiredKey) {
+            this.#optional = true;
+        }
+        if (mode === 'default') {
+            if (conditionList.length) {
+                schemaDefine = schema.intersect([
+                    v.pipe(v.looseObject(childObject), jsonActions.setAlias(fixedObjName)),
+                    v.optional(v.intersect(conditionList)),
+                ]);
+            }
+            else {
+                schemaDefine = v.pipe(v.looseObject(childObject), jsonActions.setAlias(fixedObjName));
+            }
+        }
+        else if (mode === 'strict') {
+            if (conditionList.length) {
+                schemaDefine = v.pipe(schema.intersect([
+                    v.pipe(v.object(childObject), jsonActions.setAlias(fixedObjName)),
+                    v.optional(v.intersect(conditionList)),
+                ]));
+            }
+            else {
+                schemaDefine = v.pipe(v.object(childObject), jsonActions.setAlias(fixedObjName));
+            }
+        }
+        else {
+            // rest
+            let restDefine = v.any();
+            //propCheck patternMapRest addonRest
+            if (defaultRest && !patternRestList.length) {
+                restDefine = defaultRest;
+            }
+            else {
+                restDefine = v.any();
+            }
+            if (conditionList.length) {
+                schemaDefine = v.intersect([
+                    v.pipe(v.objectWithRest(childObject, restDefine), jsonActions.setAlias(fixedObjName)),
+                    v.optional(v.intersect(conditionList)),
+                ]);
+            }
+            else {
+                schemaDefine = v.pipe(v.objectWithRest(childObject, restDefine), jsonActions.setAlias(fixedObjName));
+            }
+        }
+        if (schema$1.patternProperties && schema$1.additionalProperties) {
+            actionList.push(v.rawCheck(({ dataset, addIssue }) => {
+                if (dataset.issues || dataset.value === undefined) {
+                    return;
+                }
+                if (typeof dataset.value === 'object') {
+                    datasetLoop: for (const key in dataset.value) {
+                        if (key in childObject) {
+                            continue;
+                        }
+                        for (const { regexp, schema } of patternRestList) {
+                            const isMatch = regexp.test(key);
+                            if (!isMatch) {
+                                continue;
+                            }
+                            const result = v.safeParse(schema, dataset.value[key]);
+                            if (!result.success) {
+                                addIssue();
+                            }
+                            continue datasetLoop;
+                        }
+                        if (defaultRest) {
+                            const result = v.safeParse(defaultRest, dataset.value[key]);
+                            if (!result.success) {
+                                addIssue();
+                            }
+                        }
+                    }
+                }
+            }));
+        }
+        return schemaDefine;
+    }
+}
+
+function createImpasseAction(key, value) {
+    return v.rawCheck(({ dataset, addIssue }) => {
+        if (dataset.issues) {
+            return;
+        }
+        addIssue({
+            label: `impasse:${key}`,
+            expected: '[no validation conflict]',
+            received: value,
+        });
+    });
+}
+
+class ArrayTypeService extends BaseTypeService {
+    name = 'array';
+    actionList = [];
+    getExtraActionList() {
+        return this.actionList;
+    }
+    getBaseDefine() {
+        const actionList = this.actionList;
+        const schema = this.schema;
+        let parent;
+        const fixedItems = schema.prefixItems;
+        if (isBoolean(schema.contains) && !schema.contains) {
+            actionList.push(createImpasseAction('contains', schema.contains));
+        }
+        else if (schema.contains && !isBoolean(schema.contains)) {
+            const containsSchema = this.commonTypeParse(schema.contains);
+            const minContains = schema.minContains ?? 1;
+            actionList.push(v.check((list) => {
+                if (Array.isArray(list)) {
+                    const result = list.filter((item) => v.safeParse(containsSchema, item).success);
+                    if (result.length < minContains) {
+                        return false;
+                    }
+                    if (typeof schema.maxContains === 'number') {
+                        return result.length <= schema.maxContains;
+                    }
+                    return true;
+                }
+                return false;
+            }));
+        }
+        const jSchemaToVSchema = (schema) => {
+            const hasRef = this.schemahasRef(schema);
+            return hasRef
+                ? v.lazy(() => this.commonTypeParse(schema))
+                : this.commonTypeParse(schema);
+        };
+        if (fixedItems && fixedItems.length) {
+            const fixedList = fixedItems.map((item) => jSchemaToVSchema(item));
+            if (schema.items) {
+                const result = jSchemaToVSchema(schema.items);
+                parent = v.tupleWithRest(fixedList, result);
+            }
+            else if (schema.items === false) {
+                parent = v.tuple(fixedList);
+            }
+            else {
+                parent = v.looseTuple(fixedList);
+            }
+        }
+        else if (isBoolean(schema.items)) {
+            parent = schema.items ? v.array(v.any()) : v.tuple([]);
+        }
+        else if (schema.items) {
+            const result = jSchemaToVSchema(schema.items);
+            parent = v.array(result);
+        }
+        else {
+            parent = v.array(v.any());
+        }
+        return parent;
+    }
+}
+
+const alwaysTrueDefine = v.pipe(v.any(), jsonActions.setComponent('always-true'));
+const alwaysFalseDefine = v.pipe(v.any(), v.check((value) => isUndefined(value)));
+function getBooleanDefine(value) {
+    return value ? alwaysTrueDefine : alwaysFalseDefine;
+}
+
+const clone = rfdc({ proto: false, circles: false });
+
+function toFixedList(data, labelFn = (a) => a) {
+    return data.map((item) => {
+        return { label: labelFn(item), value: item };
+    });
+}
+
+function arrayIntersection(a, b) {
+    if (!isNil(a) && !isNil(b)) {
+        a = Array.isArray(a) ? a : [a];
+        b = Array.isArray(b) ? b : [b];
+        if (a.length && b.length) {
+            const result = intersection(a, b);
+            if (result.length === 0) {
+                return {
+                    action: createImpasseAction('applicator'),
+                    value: undefined,
+                };
+            }
+            else {
+                return { value: result };
+            }
+        }
+        return {
+            value: a.length ? a : b,
+        };
+    }
+    return { value: a ?? b };
+}
+function getMetadataAction(schema) {
+    const action = [];
+    if (isString(schema.title)) {
+        action.push(v.title(schema.title));
+    }
+    if (isString(schema.description)) {
+        action.push(v.description(schema.description));
+    }
+    return action;
+}
+class CommonTypeService extends BaseTypeService {
+    name = 'common';
+    cacheSchema = new WeakMap();
+    parse(actionList) {
+        return this.jSchemaToVSchema2(this.schema);
+    }
+    jSchemaToVSchema2(input) {
+        if (isBoolean(input)) {
+            return getBooleanDefine(input);
+        }
+        if (this.cacheSchema.has(input)) {
+            return this.cacheSchema.get(input);
+        }
+        const schema = this.resolveSchema2(input);
+        this.schema = schema;
+        const actionList = this.#applicatorNot(schema);
+        const result = actionList.length
+            ? v.pipe(this.#applicatorParse(schema), ...actionList)
+            : this.#applicatorParse(schema);
+        this.cacheSchema.set(input, result);
+        return result;
+    }
+    #applicatorNot(schema) {
+        const actionList = [];
+        if (isBoolean(schema.not)) {
+            if (schema.not) {
+                actionList.push(createImpasseAction('not', schema.not));
+            }
+        }
+        else if (schema.not) {
+            const vSchema = this.#jsonSchemaBase(this.resolveSchema2(schema.not), () => []);
+            actionList.push(v.rawCheck(({ dataset, addIssue }) => {
+                if (dataset.issues) {
+                    return;
+                }
+                const result = v.safeParse(vSchema, dataset.value);
+                if (result.success) {
+                    addIssue({ label: `applicator:not` });
+                }
+            }));
+        }
+        return actionList;
+    }
+    #jsonSchemaBase(schema, getValidationActionList) {
+        const types = schema.__resolved.type;
+        // 暂时为只支持一个
+        const type = types.types[0];
+        const actionList = getMetadataAction(schema);
+        switch (type) {
+            case 'picklist': {
+                return this.typeParse('__fixedList', {
+                    type: '__fixedList',
+                    data: { options: [toFixedList(schema.enum)], multi: false },
+                }, [...getValidationActionList(), ...actionList]);
+            }
+            case 'const':
+            case '__fixedList':
+            case 'object':
+            case 'null':
+            case 'string':
+            case 'boolean':
+            case 'integer':
+            case 'number': {
+                return this.typeParse(type, schema, [
+                    ...getValidationActionList(),
+                    ...actionList,
+                ]);
+            }
+            case 'array': {
+                if (schema.items && !isBoolean(schema.items)) {
+                    let result = this.getOptions([this.resolveSchema2(schema)]);
+                    if (result) {
+                        return this.typeParse('__fixedList', { type: '__fixedList', data: result }, [...getValidationActionList(), ...actionList]);
+                    }
+                }
+                return this.typeParse(type, schema, [
+                    ...getValidationActionList(),
+                    ...actionList,
+                ]);
+            }
+            default:
+                throw new Error(`未知类型:${type}`);
+        }
+    }
+    #applicatorParse(schema$1) {
+        let vSchema;
+        if (schema$1.allOf) {
+            const result = this.#mergeSchema(schema$1, ...schema$1.allOf);
+            vSchema = v.pipe(this.#jsonSchemaBase(result.schema, () => result.actionList));
+        }
+        else if (schema$1.anyOf) {
+            vSchema = this.#conditionCreate(schema$1, {
+                useOr: false,
+                getChildren: () => schema$1.anyOf,
+                conditionCheckActionFn(childOriginSchemaList, getActivateList) {
+                    return v.rawCheck(({ dataset, addIssue }) => {
+                        if (dataset.issues) {
+                            return;
+                        }
+                        let childFailedResult;
+                        // 验证项全为可选,所以需要这里再次验证
+                        const hasSuccess = childOriginSchemaList.some((item, index) => {
+                            const isActive = getActivateList()[index];
+                            if (!isActive) {
+                                childFailedResult ??= { index: index };
+                                return false;
+                            }
+                            const result = v.safeParse(item, dataset.value);
+                            if (!result.success) {
+                                childFailedResult = { index: index, issues: result.issues };
+                            }
+                            return result.success;
+                        });
+                        if (!hasSuccess) {
+                            const extMessage = childFailedResult?.issues
+                                ?.map((item) => item.message)
+                                .join(',') ?? '';
+                            addIssue({
+                                label: `anyOf:${childFailedResult?.index ?? ''}:${extMessage}`,
+                            });
+                        }
+                    });
+                },
+                conditionSchemaFn: (baseSchema, conditionVSchema, childSchemaList) => v.pipe(v.intersect([
+                    conditionVSchema,
+                    baseSchema,
+                    v.pipe(schema.intersect(childSchemaList.map((item) => v.pipe(v.optional(item), jsonActions.renderConfig({ hidden: true })))), jsonActions.setAlias(`${this.instanceNamePrefix$$()}-cond-display`)),
+                ]), jsonActions.setComponent('anyOf-condition')),
+            });
         }
         else if (schema$1.oneOf) {
             vSchema = this.#conditionCreate(schema$1, {
@@ -154,8 +814,8 @@ class JsonSchemaToValibot {
                         if (hasSuccess.length !== 1) {
                             addIssue({
                                 label: `oneOf`,
-                                expected: '1',
-                                received: `${hasSuccess.length}`,
+                                expected: '1📏',
+                                received: `${hasSuccess.length}📏`,
                             });
                         }
                     });
@@ -176,8 +836,8 @@ class JsonSchemaToValibot {
              */
             const useThen$ = new BehaviorSubject(undefined);
             const baseSchema = v.pipe(this.#jsonSchemaBase(schema$1, () => [
-                ...this.#getValidationAction(schema$1),
-                hideWhen({
+                ...this.getValidationActionList(schema$1),
+                jsonActions.hideWhen({
                     disabled: false,
                     listen: (fn) => fn({}).pipe(map(({ list: [value], field }) => {
                         const isThen = isBoolean(schema$1.if)
@@ -201,7 +861,7 @@ class JsonSchemaToValibot {
             function hideAction(isThen) {
                 return [
                     jsonActions.renderConfig({ hidden: true }),
-                    hideWhen({
+                    jsonActions.hideWhen({
                         disabled: true,
                         listen(fn) {
                             return fn({ list: [['..', 0]] }).pipe(switchMap(({ list: [] }) => useThen$), map((a) => (a === undefined ? true : isThen ? !a : a)));
@@ -230,7 +890,7 @@ class JsonSchemaToValibot {
                 baseSchema,
                 thenSchema ?? baseSchema,
                 elseSchema ?? baseSchema,
-            ].filter(Boolean)), formConfig({ disableOrUpdateActivate: true }), v.rawCheck(({ dataset, addIssue }) => {
+            ].filter(Boolean)), jsonActions.formConfig({ disableOrUpdateActivate: true }), v.rawCheck(({ dataset, addIssue }) => {
                 if (dataset.issues) {
                     return;
                 }
@@ -254,523 +914,18 @@ class JsonSchemaToValibot {
         else {
             vSchema = v.pipe(
             // 通用部分
-            this.#jsonSchemaBase(this.#jsonSchemaCompatiable(schema$1), () => this.#getValidationAction(schema$1)));
-        }
-        return (this.#options?.schemaHandle?.afterResolve?.(vSchema, schema$1) ?? vSchema);
-    }
-    #applicatorNot(schema) {
-        const actionList = [];
-        if (isBoolean(schema.not)) {
-            if (schema.not) {
-                actionList.push(createImpasseAction('not', schema.not));
-            }
-        }
-        else if (schema.not) {
-            const vSchema = this.#jSchemaToVSchema(schema.not);
-            actionList.push(v.rawCheck(({ dataset, addIssue }) => {
-                if (dataset.issues) {
-                    return;
-                }
-                const result = v.safeParse(vSchema, dataset.value);
-                if (result.success) {
-                    addIssue({ label: `applicator:not` });
-                }
-            }));
+            this.#jsonSchemaBase(this.resolveSchema2(schema$1), () => this.getValidationActionList(schema$1)));
         }
-        return actionList;
-    }
-    #jSchemaToVSchema(input) {
-        if (isBoolean(input)) {
-            return input
-                ? v.pipe(v.any(), jsonActions.setComponent('always-true'))
-                : v.pipe(v.any(), v.check((value) => isUndefined(value)));
-        }
-        if (this.cacheSchema.has(input)) {
-            return this.cacheSchema.get(input);
-        }
-        const schema = this.#resolveSchema2(input);
-        const actionList = this.#applicatorNot(schema);
-        const result = actionList.length
-            ? v.pipe(this.#applicatorParse(schema), ...actionList)
-            : this.#applicatorParse(schema);
-        this.cacheSchema.set(input, result);
-        return result;
-    }
-    #jsonSchemaCompatiable(schema) {
-        if ('__resolved' in schema && schema.__resolved.isResolved) {
-            return schema;
-        }
-        const resolved = schema;
-        const type = this.#guessSchemaType(resolved);
-        resolved.__resolved = { ...resolved.__resolved, type, isResolved: true };
-        if (type.types.includes('object')) {
-            this.#objectCompatible(resolved);
-        }
-        if (type.types.includes('array')) {
-            this.#arrayCompatible(resolved);
-        }
-        if (type.types.includes('number') || type.types.includes('integer')) {
-            if (resolved.exclusiveMaximum === true) {
-                resolved.exclusiveMaximum = resolved.maximum;
-                delete resolved.maximum;
-            }
-            if (resolved.exclusiveMinimum === true) {
-                resolved.exclusiveMinimum = resolved.minimum;
-                delete resolved.minimum;
-            }
-        }
-        return resolved;
-    }
-    #jsonSchemaBase(schema$1, getValidationActionList) {
-        const types = schema$1.__resolved.type;
-        // 暂时为只支持一个
-        let type = types.types[0];
-        const actionList = getMetadataAction(schema$1);
-        const createTypeFn = (input) => {
-            const result = v.pipe(input, ...actionList, ...getValidationActionList());
-            const result2 = types.optional
-                ? v.optional(result, schema$1.default)
-                : result;
-            return (this.#options?.schemaHandle?.type?.afterResolve(result2, schema$1, type) ?? result2);
-        };
-        if (!isNil(schema$1.const)) {
-            type = 'const';
-            return createTypeFn(v.literal(schema$1.const));
-        }
-        if (Array.isArray(schema$1.enum)) {
-            type = 'enum';
-            return createTypeFn(v.picklist(schema$1.enum));
-        }
-        switch (type) {
-            case 'number': {
-                return createTypeFn(v.number());
-            }
-            case 'integer': {
-                actionList.push(v.integer());
-                return createTypeFn(v.number());
-            }
-            case 'boolean': {
-                return createTypeFn(v.boolean());
-            }
-            case 'string': {
-                return createTypeFn(v.string());
-            }
-            case 'null': {
-                return createTypeFn(v.optional(v.null(), null));
-            }
-            case 'object': {
-                const childObject = {};
-                /** 附加 */
-                let defaultRest;
-                let mode = 'default';
-                if (schema$1.dependentRequired) {
-                    actionList.push(v.rawCheck(({ dataset, addIssue }) => {
-                        if (dataset.issues) {
-                            return;
-                        }
-                        Object.keys(schema$1.dependentRequired).forEach((key) => {
-                            if (dataset.value?.[key] !== undefined) {
-                                for (const reqKey of schema$1.dependentRequired[key]) {
-                                    if (dataset.value[reqKey] === undefined) {
-                                        addIssue({
-                                            label: `dependentRequired:${key}=>${reqKey}`,
-                                            expected: '[required]',
-                                            received: 'undefined',
-                                        });
-                                    }
-                                }
-                            }
-                        });
-                    }));
-                }
-                let hasRequiredKey = false;
-                // 普通属性
-                if (schema$1.properties) {
-                    for (const key in schema$1.properties) {
-                        const propJSchema = schema$1.properties[key];
-                        let propData;
-                        if (isBoolean(propJSchema)) {
-                            propData = { optional: false, hasRef: false };
-                        }
-                        else {
-                            const rSchema = this.#resolveSchema2(propJSchema);
-                            propData = {
-                                optional: rSchema.__resolved.type.optional,
-                                hasRef: rSchema.__resolved.hasRef,
-                            };
-                        }
-                        const isRequired = !!schema$1.required?.includes(key);
-                        const wrapperOptional = !isRequired && !propData.optional;
-                        if (isRequired && !propData.optional) {
-                            hasRequiredKey = true;
-                        }
-                        const createRef = () => {
-                            let propVSchema = this.#jSchemaToVSchema(propJSchema);
-                            const depList = schema$1.dependentRequired?.[key];
-                            if (depList) {
-                                propVSchema = v.pipe(propVSchema, jsonActions.patchHooks({
-                                    allFieldsResolved: (field) => {
-                                        field.form.control.statusChanges.subscribe(() => {
-                                            const valid = field.form.control.valid;
-                                            depList.map((item) => {
-                                                field.form.parent
-                                                    .get(item)
-                                                    ?.config$.update((config) => ({
-                                                    ...config,
-                                                    required: valid,
-                                                }));
-                                            });
-                                        });
-                                    },
-                                }));
-                            }
-                            return propVSchema;
-                        };
-                        childObject[key] = propData.hasRef
-                            ? wrapperOptional
-                                ? v.optional(v.lazy(() => createRef()))
-                                : v.lazy(() => createRef())
-                            : wrapperOptional
-                                ? v.optional(createRef())
-                                : createRef();
-                    }
-                }
-                // 附加属性规则
-                if (isBoolean(schema$1.additionalProperties)) {
-                    mode = schema$1.additionalProperties === false ? 'strict' : mode;
-                }
-                else if (schema$1.additionalProperties) {
-                    mode = 'rest';
-                    // rest要符合的规则
-                    defaultRest = this.#jSchemaToVSchema(schema$1.additionalProperties);
-                }
-                const patternRestList = [];
-                if (schema$1.patternProperties) {
-                    for (const key in schema$1.patternProperties) {
-                        const item = this.#jSchemaToVSchema(schema$1.patternProperties[key]);
-                        if (!item) {
-                            throw new Error(`patternProperties->${key}: 定义未找到`);
-                        }
-                        patternRestList.push({
-                            regexp: new RegExp(key),
-                            schema: item,
-                        });
-                    }
-                }
-                /** 条件显示 */
-                const conditionList = [];
-                if (schema$1.dependentSchemas) {
-                    const depSchemaMap = {};
-                    for (const key in schema$1.dependentSchemas) {
-                        const jSchema = schema$1.dependentSchemas[key];
-                        let vSchema = this.#jSchemaToVSchema(jSchema);
-                        if (!vSchema) {
-                            throw new Error(`依赖->${key}: 定义未找到`);
-                        }
-                        depSchemaMap[key] = vSchema;
-                        vSchema = v.pipe(vSchema, jsonActions.renderConfig({ hidden: true }), hideWhen({
-                            disabled: true,
-                            listen: (fn, field) => {
-                                let controlField = field.get(['..', '..', 0, key]).form
-                                    .control;
-                                return merge(controlField.valueChanges, controlField.statusChanges).pipe(map(() => {
-                                    return !(controlField.valid && controlField.value !== undefined);
-                                }));
-                            },
-                        }));
-                        conditionList.push(vSchema);
-                    }
-                    actionList.push(v.rawCheck(({ dataset, addIssue }) => {
-                        if (dataset.issues) {
-                            return;
-                        }
-                        Object.keys(schema$1.dependentSchemas).forEach((key) => {
-                            if (dataset.value?.[key] !== undefined) {
-                                const result = v.safeParse(depSchemaMap[key], dataset.value);
-                                if (!result.success) {
-                                    for (const item of result.issues) {
-                                        addIssue({
-                                            ...item,
-                                        });
-                                    }
-                                }
-                            }
-                        });
-                    }));
-                }
-                if (isBoolean(schema$1.propertyNames) && !schema$1.propertyNames) {
-                    actionList.push(v.check(() => false));
-                }
-                else if (schema$1.propertyNames) {
-                    const propNameSchema = this.#jSchemaToVSchema(schema$1.propertyNames);
-                    actionList.push(v.rawCheck(({ dataset, addIssue }) => {
-                        if (dataset.issues) {
-                            return;
-                        }
-                        if (dataset.value && typeof dataset.value === 'object') {
-                            for (const key of Object.keys(dataset.value)) {
-                                const result = v.safeParse(propNameSchema, key);
-                                if (!result.success) {
-                                    addIssue({
-                                        label: `propertyNames:${key}`,
-                                        expected: `[match]`,
-                                        received: key,
-                                    });
-                                }
-                            }
-                        }
-                    }));
-                }
-                let schemaDefine;
-                if (!Object.keys(childObject).length || !hasRequiredKey) {
-                    types.optional = true;
-                }
-                if (mode === 'default') {
-                    if (conditionList.length) {
-                        schemaDefine = v.pipe(schema.intersect([
-                            v.looseObject(childObject),
-                            v.optional(v.intersect(conditionList)),
-                        ]));
-                    }
-                    else {
-                        schemaDefine = v.pipe(v.looseObject(childObject));
-                    }
-                }
-                else if (mode === 'strict') {
-                    if (conditionList.length) {
-                        schemaDefine = v.pipe(schema.intersect([
-                            v.object(childObject),
-                            v.optional(v.intersect(conditionList)),
-                        ]));
-                    }
-                    else {
-                        schemaDefine = v.pipe(v.object(childObject));
-                    }
-                }
-                else {
-                    // rest
-                    let restDefine = v.any();
-                    //propCheck patternMapRest addonRest
-                    if (defaultRest && !patternRestList.length) {
-                        restDefine = defaultRest;
-                    }
-                    else {
-                        restDefine = v.any();
-                    }
-                    if (conditionList.length) {
-                        schemaDefine = v.intersect([
-                            v.objectWithRest(childObject, restDefine),
-                            v.optional(v.intersect(conditionList)),
-                        ]);
-                    }
-                    else {
-                        schemaDefine = v.pipe(v.objectWithRest(childObject, restDefine));
-                    }
-                }
-                if (schema$1.patternProperties && schema$1.additionalProperties) {
-                    actionList.push(v.rawCheck(({ dataset, addIssue }) => {
-                        if (dataset.issues || dataset.value === undefined) {
-                            return;
-                        }
-                        if (typeof dataset.value === 'object') {
-                            datasetLoop: for (const key in dataset.value) {
-                                if (key in childObject) {
-                                    continue;
-                                }
-                                for (const { regexp, schema } of patternRestList) {
-                                    const isMatch = regexp.test(key);
-                                    if (!isMatch) {
-                                        continue;
-                                    }
-                                    const result = v.safeParse(schema, dataset.value[key]);
-                                    if (!result.success) {
-                                        addIssue();
-                                    }
-                                    continue datasetLoop;
-                                }
-                                if (defaultRest) {
-                                    const result = v.safeParse(defaultRest, dataset.value[key]);
-                                    if (!result.success) {
-                                        addIssue();
-                                    }
-                                }
-                            }
-                        }
-                    }));
-                }
-                return createTypeFn(schemaDefine);
-            }
-            case 'array': {
-                let parent;
-                const fixedItems = schema$1.prefixItems;
-                if (isBoolean(schema$1.contains) && !schema$1.contains) {
-                    actionList.push(createImpasseAction('contains', schema$1.contains));
-                }
-                else if (schema$1.contains && !isBoolean(schema$1.contains)) {
-                    const containsSchema = this.#jSchemaToVSchema(schema$1.contains);
-                    const minContains = schema$1.minContains ?? 1;
-                    actionList.push(v.check((list) => {
-                        if (Array.isArray(list)) {
-                            const result = list.filter((item) => v.safeParse(containsSchema, item).success);
-                            if (result.length < minContains) {
-                                return false;
-                            }
-                            if (typeof schema$1.maxContains === 'number') {
-                                return result.length <= schema$1.maxContains;
-                            }
-                            return true;
-                        }
-                        return false;
-                    }));
-                }
-                const jSchemaToVSchema = (schema) => {
-                    const hasRef = this.#schemahasRef(schema);
-                    return hasRef
-                        ? v.lazy(() => this.#jSchemaToVSchema(schema))
-                        : this.#jSchemaToVSchema(schema);
-                };
-                if (fixedItems && fixedItems.length) {
-                    const fixedList = fixedItems.map((item) => jSchemaToVSchema(item));
-                    if (schema$1.items) {
-                        const result = jSchemaToVSchema(schema$1.items);
-                        parent = v.tupleWithRest(fixedList, result);
-                    }
-                    else if (schema$1.items === false) {
-                        parent = v.tuple(fixedList);
-                    }
-                    else {
-                        parent = v.looseTuple(fixedList);
-                    }
-                }
-                else if (isBoolean(schema$1.items)) {
-                    parent = schema$1.items ? v.array(v.any()) : v.tuple([]);
-                }
-                else if (schema$1.items) {
-                    const result = jSchemaToVSchema(schema$1.items);
-                    parent = v.array(result);
-                }
-                else {
-                    parent = v.array(v.any());
-                }
-                return createTypeFn(parent);
-            }
-            default:
-                throw new Error(`未知类型:${type}`);
-        }
-    }
-    #resolveDefinition(schema) {
-        if (!schema.$ref) {
-            return schema;
-        }
-        const [uri, pointer] = schema.$ref.split('#/');
-        if (uri) {
-            throw Error(`Remote schemas for ${schema.$ref} not supported yet.`);
-        }
-        const definition = !pointer
-            ? null
-            : pointer
-                .split('/')
-                .reduce((def, path) => def?.hasOwnProperty(path) ? def[path] : null, this.root);
-        if (!definition) {
-            throw Error(`Cannot find a definition for ${schema.$ref}.`);
-        }
-        if (definition.$ref) {
-            return this.#resolveDefinition(definition);
-        }
-        return {
-            ...definition,
-            ...['title', 'description', 'default', 'actions'].reduce((annotation, p) => {
-                if (schema.hasOwnProperty(p)) {
-                    annotation[p] = schema[p];
-                }
-                return annotation;
-            }, {}),
-            $ref: undefined,
-            __resolved: {
-                hasRef: true,
-            },
-        };
-    }
-    /** todo 当前只能存在一个类型 */
-    #guessSchemaType(schema) {
-        let type = schema?.type;
-        let optional = 'default' in schema;
-        if (isString(type)) {
-            return { types: [type], optional: optional };
-        }
-        if (Array.isArray(type)) {
-            if (type.length === 1) {
-                return { types: type, optional: optional };
-            }
-            const nullIndex = type.findIndex((item) => item === 'null');
-            if (nullIndex !== -1) {
-                type.splice(nullIndex, 1);
-            }
-            return {
-                types: type,
-                optional: optional || nullIndex !== -1,
-            };
-        }
-        if (schema.items ||
-            schema.prefixItems ||
-            isNumber(schema.minContains) ||
-            isNumber(schema.maxContains) ||
-            !isNil(schema.contains) ||
-            isBoolean(schema.uniqueItems)) {
-            type = 'array';
-        }
-        else if (isNumber(schema.minimum) ||
-            isNumber(schema.maximum) ||
-            isNumber(schema.exclusiveMaximum) ||
-            isNumber(schema.exclusiveMinimum) ||
-            isNumber(schema.multipleOf)) {
-            type = 'number';
-        }
-        else if (isNumber(schema.minLength) ||
-            isNumber(schema.maxLength) ||
-            isString(schema.pattern)) {
-            type = 'string';
-        }
-        return type
-            ? { types: [type], optional: optional }
-            : { types: anyType, optional: optional };
-    }
-    #objectCompatible(schema) {
-        if ('dependencies' in schema && schema.dependencies) {
-            const dependencies = schema.dependencies;
-            const dependentRequiredData = {};
-            const dependentSchemasData = {};
-            Object.keys(dependencies).forEach((prop) => {
-                const dependency = dependencies[prop];
-                if (Array.isArray(dependency)) {
-                    dependentRequiredData[prop] = dependency;
-                }
-                else {
-                    dependentSchemasData[prop] = dependency;
-                }
-            });
-            schema.dependentRequired = dependentRequiredData;
-            schema.dependentSchemas = dependentSchemasData;
-            delete schema.dependencies;
-        }
-    }
-    #arrayCompatible(schema) {
-        if (this.root.$schema !== Schema2012 || !isNil(schema.additionalItems)) {
-            if (!isNil(schema.items) || !isNil(schema.additionalItems)) {
-                // 2019-09
-                schema.prefixItems = schema.items;
-                schema.items = schema.additionalItems;
-            }
-        }
-        return;
+        return (this.instance.options?.schemaHandle?.afterResolve?.(vSchema, schema$1) ??
+            vSchema);
     }
     #mergeSchema(schema, ...list) {
         let base = clone(schema);
         let baseKeyList = Object.keys(base);
-        const actionList = this.#getValidationAction(base);
-        for (let childSchema of list.filter((item) => !isBoolean(item))) {
-            childSchema = this.#resolveSchema2(childSchema);
-            actionList.push(...this.#getValidationAction(childSchema));
+        const actionList = this.getValidationActionList(base);
+        for (const rawChildSchema of list.filter((item) => !isBoolean(item))) {
+            const childSchema = this.resolveSchema2(rawChildSchema);
+            actionList.push(...this.getValidationActionList(childSchema));
             baseKeyList = union(baseKeyList, Object.keys(childSchema));
             for (const key of baseKeyList) {
                 switch (key) {
@@ -798,7 +953,7 @@ class JsonSchemaToValibot {
                     }
                     case 'contains': {
                         if (childSchema[key] === false || base[key] === false) {
-                            actionList.push(v.check(() => false));
+                            actionList.push(createImpasseAction('contains', false));
                             break;
                         }
                         else if (childSchema[key] === true) {
@@ -838,6 +993,10 @@ class JsonSchemaToValibot {
                         }
                         break;
                     }
+                    case 'required': {
+                        childSchema.required = union(childSchema.required ?? [], base.required ?? []);
+                        break;
+                    }
                     default:
                         childSchema[key] ??= base[key];
                         break;
@@ -845,192 +1004,10 @@ class JsonSchemaToValibot {
             }
             base = childSchema;
         }
-        return { schema: this.#jsonSchemaCompatiable(base), actionList };
-    }
-    #resolveSchema2(schema) {
-        return this.#jsonSchemaCompatiable(this.#resolveDefinition(schema));
-    }
-    #schemahasRef(schema) {
-        if (isBoolean(schema)) {
-            return false;
-        }
-        else {
-            const result = this.#resolveSchema2(schema);
-            return result.__resolved.hasRef;
-        }
-    }
-    #parseEnum(schema) {
-        // 普通枚举
-        if (schema.enum) {
-            return {
-                type: 'enum',
-                data: {
-                    enum: schema.enum,
-                },
-            };
-        }
-        else if (schema.const) {
-            return { type: 'const', data: { const: schema.const } };
-        }
-        else if (schema.items && !isBoolean(schema.items)) {
-            const result = this.#parseEnum(schema.items);
-            if (result?.data) {
-                return {
-                    type: 'multiselect',
-                    data: {
-                        items: result.data,
-                    },
-                };
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    #intersectSchemaType(a, b) {
-        const parent = a ? this.#resolveSchema2(a) : undefined;
-        b = parent ? this.#mergeSchema(parent, b).schema : b;
-        const child = this.#resolveSchema2(b);
-        const parentEnum = parent ? this.#parseEnum(parent) : undefined;
-        const childEnum = this.#parseEnum(child);
-        if (parentEnum?.data.items && childEnum?.data.items) {
-            const result = intersection(parentEnum.data.items.enum, childEnum.data.items.enum);
-            if (result.length) {
-                return {
-                    type: 'multiselect',
-                    data: {
-                        items: {
-                            enum: result,
-                        },
-                    },
-                };
-            }
-        }
-        else if (childEnum?.type === 'multiselect') {
-            return childEnum;
-        }
-        // 枚举
-        if (parentEnum?.data.enum && childEnum?.data.enum) {
-            const result = intersection(parentEnum.data.enum, childEnum.data.enum);
-            if (result.length) {
-                return {
-                    type: 'enum',
-                    data: { enum: result },
-                };
-            }
-        }
-        else if (childEnum?.data.enum) {
-            return childEnum;
-        }
-        // 常量
-        if (isNil(parentEnum?.data.const) && !isNil(childEnum?.data.const)) {
-            return childEnum;
-        }
-        // 类型
-        const typeResult = parent?.__resolved.type.types
-            ? intersection(parent.__resolved.type.types, child.__resolved.type.types)
-            : child.__resolved.type.types;
-        if (typeResult.length) {
-            delete child['resolved'];
-            const result = this.#jsonSchemaCompatiable({
-                ...child,
-                type: typeResult[0],
-            });
-            return {
-                type: typeResult[0],
-                data: result,
-            };
-        }
-        return;
-    }
-    #schemaExtract(schema, ...childList) {
-        /** 所有子属性key */
-        const childKeyList = uniq(childList.flatMap((item) => Object.keys(item.properties ?? {})));
-        if (!childKeyList.length) {
-            // 无效返回
-            return;
-        }
-        const conditionJSchema = {
-            properties: {},
-            additionalProperties: false,
-        };
-        const childConditionJSchemaList = childList.map(() => ({ properties: {} }));
-        const conditionKeyList = [];
-        for (const key of childKeyList) {
-            const parentItem = schema.properties?.[key];
-            //如果父级不存在这个属性,并且禁止添加,跳过
-            // todo 还应该增加额外的匹配
-            if (!parentItem && schema.additionalProperties === false) {
-                continue;
-            }
-            // 所有子级都存在某个Key
-            const keyExist = childList.every((item) => {
-                const propItem = item.properties?.[key];
-                // todo 对象应该先解析
-                return propItem && !isBoolean(propItem) && propItem.type !== 'object';
-            });
-            if (!keyExist) {
-                continue;
-            }
-            let currentType = undefined;
-            const childPropList = [];
-            for (const sub of childList) {
-                const result = this.#intersectSchemaType(schema?.properties?.[key], sub.properties[key]);
-                if (!result) {
-                    currentType = undefined;
-                    break;
-                }
-                else if (currentType === undefined ||
-                    deepEqual(currentType, result.type)) {
-                    currentType = result.type;
-                    // 枚举
-                    if (result.data.enum ||
-                        'const' in result.data ||
-                        result.type === 'multiselect') {
-                        childPropList.push(result.data);
-                    }
-                    else {
-                        childPropList.push(result.data);
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-            if (currentType) {
-                conditionKeyList.push(key);
-                for (let index = 0; index < childConditionJSchemaList.length; index++) {
-                    const schema = childConditionJSchemaList[index];
-                    schema.properties[key] = childPropList[index];
-                }
-                if (currentType === 'enum') {
-                    conditionJSchema.properties[key] = {
-                        enum: childPropList.flatMap((item) => item.enum),
-                    };
-                }
-                else if (currentType === 'const') {
-                    conditionJSchema.properties[key] = {
-                        enum: childPropList.flatMap((item) => item.const),
-                    };
-                }
-                else if (currentType === 'multiselect') {
-                    conditionJSchema.properties[key] = {
-                        type: 'array',
-                        items: {
-                            enum: childPropList.flatMap((item) => item.items.enum),
-                        },
-                        uniqueItems: true,
-                    };
-                }
-                else {
-                    conditionJSchema.properties[key] = {
-                        type: currentType,
-                    };
-                }
-            }
-        }
-        return { conditionJSchema, childConditionJSchemaList, conditionKeyList };
+        return { schema: base, actionList };
     }
     #conditionCreate(schema, options) {
+        const fixedKeyList = Object.keys(this.getFixedChild());
         const resolvedChildList = options
             .getChildren()
             .map((item) => this.#mergeSchema(schema, item));
@@ -1044,146 +1021,428 @@ class JsonSchemaToValibot {
         if (isObject) {
             const conditionResult = this.#schemaExtract(schema, ...resolvedChildJSchemaList);
             if (conditionResult) {
+                const conditionKeyList = conditionResult.conditionKeyList;
+                const excludeFixedConditionList = difference(conditionResult.conditionKeyList, fixedKeyList);
                 /** 子级的共同部分验证,用于检测是哪个子级,不显示 */
                 const childConditionVSchemaList = conditionResult.childConditionJSchemaList.map((schema) => {
-                    const rSchema = this.#jsonSchemaCompatiable(schema);
-                    return v.pipe(this.#jsonSchemaBase(rSchema, () => this.#getValidationAction(rSchema)));
+                    const rSchema = this.resolveSchema2(schema);
+                    return v.pipe(this.#jsonSchemaBase(rSchema, () => this.getValidationActionList(rSchema)));
                 });
-                /** 主条件部分,用于显示切换 */
-                const conditionVSchema = v.pipe(this.#jsonSchemaBase(this.#jsonSchemaCompatiable(conditionResult.conditionJSchema), () => []), jsonActions.valueChange((fn) => {
-                    fn().subscribe(({ list: [value], field }) => {
-                        activateList.length = 0;
-                        const conditionParent = field.get(['..', 2]).form
-                            .control;
-                        const parentAList = [];
-                        for (let index = 0; index < childConditionVSchemaList.length; index++) {
-                            const schema = childConditionVSchemaList[index];
-                            const result = v.safeParse(schema, value);
-                            activateList.push(result.success);
-                            field.get(['..', 2, index])?.renderConfig.update((data) => ({
-                                ...data,
-                                hidden: !result.success,
-                            }));
-                            if (result.success) {
-                                parentAList.push(conditionParent.children$$()[index]);
-                            }
-                        }
-                        if (!options.useOr) {
-                            conditionParent.activateControls$.set(parentAList);
+                if (fixedKeyList.length) {
+                    for (const key of fixedKeyList) {
+                        delete conditionResult.conditionJSchema.properties?.[key];
+                        conditionResult.childConditionJSchemaList.forEach((schema) => {
+                            delete schema.properties?.[key];
+                        });
+                    }
+                    conditionResult.conditionKeyList = excludeFixedConditionList;
+                }
+                const checkAction = jsonActions.patchHooks({
+                    allFieldsResolved: (field) => {
+                        const displayName = ['..', 2];
+                        const list = [];
+                        const currenConditionSchema = field;
+                        list.push(currenConditionSchema.form.control.valueChanges);
+                        if (fixedKeyList.length) {
+                            list.push(combineLatest(fixedKeyList.map((key) => {
+                                const instanceNamePrefix = this.getFixedChildBy(key);
+                                return field.get([
+                                    '#',
+                                    `@${instanceNamePrefix}-fixed`,
+                                    key,
+                                ]).form.control.valueChanges;
+                            })).pipe(map((list) => list.reduce((obj, cur, i) => {
+                                obj[fixedKeyList[i]] = cur;
+                                return obj;
+                            }, {}))));
                         }
-                    });
-                }));
-                conditionResult.conditionKeyList.forEach((key) => {
+                        combineLatest(list)
+                            .pipe(map((list) => list.reduce((obj, cur) => {
+                            obj = { ...obj, ...cur };
+                            return obj;
+                        }, {})))
+                            .subscribe((value) => {
+                            activateList.length = 0;
+                            const conditionDisplay = field.get([...displayName]).form
+                                .control;
+                            const parentAList = [];
+                            for (let index = 0; index < childConditionVSchemaList.length; index++) {
+                                const schema = childConditionVSchemaList[index];
+                                const result = v.safeParse(schema, value);
+                                activateList.push(result.success);
+                                // todo key需要查询
+                                field
+                                    .get([...displayName, index])
+                                    ?.renderConfig.update((data) => ({
+                                    ...data,
+                                    hidden: !result.success,
+                                }));
+                                if (result.success) {
+                                    parentAList.push(conditionDisplay.children$$()[index]);
+                                }
+                            }
+                            if (!options.useOr) {
+                                conditionDisplay.activateControls$.set(parentAList);
+                            }
+                        });
+                    },
+                });
+                // todo 修改支持父级监听
+                // todo 主条件要过滤
+                /** 主条件部分,用于显示切换 */
+                const conditionVSchema = v.pipe(this.#jsonSchemaBase(this.resolveSchema2(conditionResult.conditionJSchema), () => []), checkAction);
+                conditionKeyList.forEach((key) => {
                     resolvedChildJSchemaList.forEach((item) => {
                         delete item.properties[key];
                     });
                     delete schema.properties?.[key];
                 });
-                const baseSchema = v.pipe(this.#jsonSchemaBase(schema, () => this.#getValidationAction(schema)));
+                const baseSchema = v.pipe(this.#jsonSchemaBase(schema, () => this.getValidationActionList(schema)));
+                // todo 解析条件也要过滤
                 const childVSchemaList = resolvedChildJSchemaList.map((item) => 
                 // 验证部分被单独提取出来
                 v.pipe(this.#jsonSchemaBase(item, () => [])));
-                return v.pipe(options.conditionSchemaFn(baseSchema, conditionVSchema, childVSchemaList), conditionCheckAction);
+                return v.pipe(options.conditionSchemaFn(baseSchema, v.pipe(conditionVSchema, jsonActions.setAlias(`${this.instanceNamePrefix$$()}-cond`)), childVSchemaList), conditionCheckAction);
             }
         }
-        const baseSchema = v.pipe(this.#jsonSchemaBase(schema, () => this.#getValidationAction(schema)));
+        const result = this.getOptions(resolvedChildJSchemaList);
+        if (result) {
+            const instance = this.getTypeParse('__fixedList', {
+                data: result,
+                type: '__fixedList',
+            });
+            activateList = childOriginSchemaList.map((_, i) => true);
+            return v.pipe(instance.parse([]), conditionCheckAction);
+        }
+        const baseSchema = v.pipe(this.#jsonSchemaBase(schema, () => this.getValidationActionList(schema)));
         activateList = childOriginSchemaList.map((_, i) => true);
         return v.pipe(baseSchema, conditionCheckAction);
     }
-    #getValidationAction(schema) {
-        const action = [];
-        // string/array
-        if (isNumber(schema.minLength) || isNumber(schema.minItems)) {
-            action.push(v.minLength(schema.minLength ?? schema.minItems));
-        }
-        // string/array
-        if (isNumber(schema.maxLength) || isNumber(schema.maxItems)) {
-            action.push(v.maxLength(schema.maxLength ?? schema.maxItems));
-        }
-        // string
-        if (isString(schema.pattern)) {
-            action.push(v.regex(new RegExp(schema.pattern)));
+    getOptions(childList) {
+        if (!childList.length) {
+            return;
         }
-        // todo format https://json-schema.org/understanding-json-schema/reference/type#built-in-formats
-        // duration idn-email idn-hostname uri-reference iri iri-reference uri-template json-pointer regex
-        if (schema.format) {
-            switch (schema.format) {
-                // case 'date-time': {
-                //   action.push(v.isoDateTime());
-                //   break;
-                // }
-                // case 'time': {
-                //   action.push(v.isoTime());
-                //   break;
-                // }
-                case 'date': {
-                    action.push(v.isoDate());
-                    break;
+        const fn2 = () => {
+            let data = {
+                multi: undefined,
+                uniqueItems: true,
+            };
+            const fn = (schema) => {
+                let options;
+                let multi2 = false;
+                if (!isUndefined(schema.const)) {
+                    options = [
+                        { value: schema.const, label: schema.title ?? schema.const },
+                    ];
                 }
-                case 'email': {
-                    action.push(v.email());
-                    break;
+                else if (schema.enum) {
+                    if (schema.enum.length === 1) {
+                        options = [
+                            {
+                                value: schema.enum[0],
+                                label: schema.title ?? schema.enum[0],
+                            },
+                        ];
+                    }
+                    options = schema.enum.map((item) => ({ label: item, value: item }));
                 }
-                case 'ipv4': {
-                    action.push(v.ipv4());
-                    break;
+                else if (schema.items && !isBoolean(schema.items)) {
+                    const items = this.resolveSchema2(schema.items);
+                    options = fn2().fn(items);
+                    multi2 = true;
+                    data.uniqueItems &&= !!schema.uniqueItems;
                 }
-                case 'ipv6': {
-                    action.push(v.ipv6());
-                    break;
+                if (!options) {
+                    return undefined;
                 }
-                case 'uuid': {
-                    action.push(v.uuid());
-                    break;
+                if (data.multi === undefined) {
+                    data.multi = multi2;
                 }
-                case 'uri': {
-                    action.push(v.url());
-                    break;
+                else if (data.multi !== multi2) {
+                    throw new Error(`options multi conflict`);
                 }
-                default:
-                    break;
+                return options;
+            };
+            return {
+                fn,
+                getData: () => data,
+            };
+        };
+        const list = [];
+        const fn$ = fn2();
+        for (const schema of childList) {
+            const item = fn$.fn(schema);
+            if (!item) {
+                return undefined;
             }
+            list.push(item);
         }
-        // number
-        if (isNumber(schema.exclusiveMinimum)) {
-            action.push(v.gtValue(schema.exclusiveMinimum));
+        let data = fn$.getData();
+        return {
+            uniqueItems: data.uniqueItems,
+            multi: data.multi,
+            options: list,
+        };
+    }
+    #schemaExtract(schema, ...childList) {
+        const childKeyList = childList.reduce((cur, item) => {
+            if (cur && !cur.length) {
+                return cur;
+            }
+            const keyList = Object.keys(item.properties ?? {}).filter((key) => {
+                const propItem = item.properties[key];
+                if (isBoolean(propItem)) {
+                    return false;
+                }
+                const resolved = this.resolveSchema2(propItem);
+                return !resolved.__resolved.type.types.includes('object');
+            });
+            if (!cur) {
+                return keyList;
+            }
+            else {
+                return intersection(cur, keyList);
+            }
+        }, undefined);
+        if (!childKeyList.length) {
+            // 无效返回
+            return;
         }
-        if (isNumber(schema.exclusiveMaximum)) {
-            action.push(v.ltValue(schema.exclusiveMaximum));
+        const conditionJSchema = {
+            properties: {},
+            additionalProperties: false,
+        };
+        const childConditionJSchemaList = childList.map(() => ({ properties: {} }));
+        const conditionKeyList = [];
+        for (const key of childKeyList) {
+            const parentItem = schema.properties?.[key];
+            //如果父级不存在这个属性,并且禁止添加,跳过
+            // todo 还应该增加额外的匹配
+            if (!parentItem && schema.additionalProperties === false) {
+                continue;
+            }
+            const optionsResult = this.getOptions(childList.map((item) => this.resolveSchema2(item.properties[key])));
+            if (optionsResult) {
+                conditionKeyList.push(key);
+                conditionJSchema.properties[key] = {
+                    type: '__fixedList',
+                    data: optionsResult,
+                };
+                childConditionJSchemaList.forEach((item, i) => {
+                    item.properties[key] = childList[i].properties[key];
+                });
+            }
+            else {
+                conditionKeyList.push(key);
+                conditionJSchema.properties[key] = {
+                    type: this.resolveSchema2(childList[0].properties[key])
+                        .__resolved.type.types[0],
+                };
+                childConditionJSchemaList.forEach((item, i) => {
+                    item.properties[key] = childList[i].properties[key];
+                });
+            }
         }
-        if (isNumber(schema.minimum)) {
-            action.push(v.minValue(schema.minimum));
+        return { conditionJSchema, childConditionJSchemaList, conditionKeyList };
+    }
+}
+
+class ListTypeService extends BaseTypeService {
+    name = '__fixedList';
+    parse(actionList) {
+        const context = this.schema['data'];
+        const define = v.picklist(context.options.flat().map((option) => option.value));
+        if (context.multi) {
+            return v.pipe(v.array(define), patchInputs({ options: context.options }), asControl(), setComponent(context.uniqueItems ? 'multiselect' : 'multiselect-repeat'));
         }
-        if (isNumber(schema.maximum)) {
-            action.push(v.maxValue(schema.maximum));
+        else {
+            return v.pipe(define, patchInputs({ options: context.options }));
         }
-        // number
-        if (isNumber(schema.multipleOf)) {
-            action.push(v.multipleOf(schema.multipleOf));
+    }
+}
+
+const anyType = [
+    'object',
+    'array',
+    'string',
+    'number',
+    'boolean',
+    'null',
+    'integer',
+];
+// 应该传入定制
+function jsonSchemaToValibot(schema, options) {
+    return new JsonSchemaToValibot(schema, options).convert();
+}
+const Schema2012 = 'https://json-schema.org/draft/2020-12/schema';
+const TypeMap = {
+    number: NumberTypeService,
+    integer: IntegerTypeService,
+    boolean: BooleanTypeService,
+    string: StringTypeService,
+    null: NullTypeService,
+    const: ConstTypeService,
+    object: ObjectTypeService,
+    array: ArrayTypeService,
+    common: CommonTypeService,
+    __fixedList: ListTypeService,
+};
+class JsonSchemaToValibot {
+    root;
+    options;
+    cacheSchema = new WeakMap();
+    constructor(root, options) {
+        this.root = root;
+        this.options = options;
+        root.$schema ??= Schema2012;
+    }
+    convert() {
+        const Service = TypeMap['common'];
+        const instance = new Service(this, this.root);
+        return instance.parse([]);
+    }
+    #jsonSchemaCompatiable(schema) {
+        if ('__resolved' in schema && schema.__resolved.isResolved) {
+            return schema;
         }
-        // array
-        if (schema.uniqueItems) {
-            action.push(v.check((input) => uniq(input).length === input.length));
+        const resolved = schema;
+        const type = this.#guessSchemaType(resolved);
+        resolved.__resolved = { ...resolved.__resolved, type, isResolved: true };
+        if (type.types.includes('object')) {
+            this.#objectCompatible(resolved);
         }
-        // object
-        if (isNumber(schema.maxProperties)) {
-            action.push(v.maxEntries(schema.maxProperties));
+        if (type.types.includes('array')) {
+            this.#arrayCompatible(resolved);
         }
-        // object
-        if (isNumber(schema.minProperties)) {
-            action.push(v.minEntries(schema.minProperties));
+        if (type.types.includes('number') || type.types.includes('integer')) {
+            if (resolved.exclusiveMaximum === true) {
+                resolved.exclusiveMaximum = resolved.maximum;
+                delete resolved.maximum;
+            }
+            if (resolved.exclusiveMinimum === true) {
+                resolved.exclusiveMinimum = resolved.minimum;
+                delete resolved.minimum;
+            }
         }
-        if (schema.actions) {
-            for (const rawAction of schema.actions) {
-                const inlineActions = jsonActions[rawAction.name] ??
-                    this.#options?.customActions?.[rawAction.name];
-                if (!inlineActions) {
-                    throw new Error(`action:[${rawAction.name}]❗`);
+        return resolved;
+    }
+    #resolveDefinition(schema) {
+        if (!schema.$ref) {
+            return schema;
+        }
+        const [uri, pointer] = schema.$ref.split('#/');
+        if (uri) {
+            throw Error(`Remote schemas for ${schema.$ref} not supported yet.`);
+        }
+        const definition = !pointer
+            ? null
+            : pointer
+                .split('/')
+                .reduce((def, path) => def?.hasOwnProperty(path) ? def[path] : null, this.root);
+        if (!definition) {
+            throw Error(`Cannot find a definition for ${schema.$ref}.`);
+        }
+        if (definition.$ref) {
+            return this.#resolveDefinition(definition);
+        }
+        return {
+            ...definition,
+            ...['title', 'description', 'default', 'actions'].reduce((annotation, p) => {
+                if (schema.hasOwnProperty(p)) {
+                    annotation[p] = schema[p];
                 }
-                action.push(inlineActions.apply(undefined, rawAction.params));
+                return annotation;
+            }, {}),
+            $ref: undefined,
+            __resolved: {
+                hasRef: true,
+            },
+        };
+    }
+    /** todo 当前只能存在一个类型 */
+    #guessSchemaType(schema) {
+        const optional = 'default' in schema;
+        if (!isUndefined(schema.const)) {
+            return { types: ['const'], optional: optional };
+        }
+        else if (Array.isArray(schema.enum)) {
+            return { types: ['picklist'], optional: optional };
+        }
+        let type = schema?.type;
+        if (isString(type)) {
+            return { types: [type], optional: optional };
+        }
+        if (Array.isArray(type)) {
+            if (type.length === 1) {
+                return { types: type, optional: optional };
             }
+            const nullIndex = type.findIndex((item) => item === 'null');
+            if (nullIndex !== -1) {
+                type.splice(nullIndex, 1);
+            }
+            return {
+                types: type,
+                optional: optional || nullIndex !== -1,
+            };
         }
-        return action;
+        if (schema.items ||
+            schema.prefixItems ||
+            isNumber(schema.minContains) ||
+            isNumber(schema.maxContains) ||
+            !isNil(schema.contains) ||
+            isBoolean(schema.uniqueItems)) {
+            type = 'array';
+        }
+        else if (isNumber(schema.minimum) ||
+            isNumber(schema.maximum) ||
+            isNumber(schema.exclusiveMaximum) ||
+            isNumber(schema.exclusiveMinimum) ||
+            isNumber(schema.multipleOf)) {
+            type = 'number';
+        }
+        else if (isNumber(schema.minLength) ||
+            isNumber(schema.maxLength) ||
+            isString(schema.pattern)) {
+            type = 'string';
+        }
+        return type
+            ? { types: [type], optional: optional }
+            : { types: anyType, optional: optional };
+    }
+    #objectCompatible(schema) {
+        if ('dependencies' in schema && schema.dependencies) {
+            const dependencies = schema.dependencies;
+            const dependentRequiredData = {};
+            const dependentSchemasData = {};
+            Object.keys(dependencies).forEach((prop) => {
+                const dependency = dependencies[prop];
+                if (Array.isArray(dependency)) {
+                    dependentRequiredData[prop] = dependency;
+                }
+                else {
+                    dependentSchemasData[prop] = dependency;
+                }
+            });
+            schema.dependentRequired = dependentRequiredData;
+            schema.dependentSchemas = dependentSchemasData;
+            delete schema.dependencies;
+        }
+    }
+    #arrayCompatible(schema) {
+        if (this.root.$schema !== Schema2012 || !isNil(schema.additionalItems)) {
+            if (!isNil(schema.items) || !isNil(schema.additionalItems)) {
+                // 2019-09
+                schema.prefixItems = schema.items;
+                schema.items = schema.additionalItems;
+            }
+        }
+        return;
+    }
+    resolveSchema2(schema) {
+        return this.#jsonSchemaCompatiable(this.#resolveDefinition(schema));
+    }
+    getTypeParser(type) {
+        return TypeMap[type];
     }
 }