@piying/view-angular-core 1.7.2 → 1.7.3

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

@@ -0,0 +1,1183 @@
+import { map, switchMap } from 'rxjs/operators';
+import rfdc from 'rfdc';
+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 } from 'rxjs';
+import { schema } from '@piying/valibot-visit';
+import { deepEqual } from 'fast-equals';
+
+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));
+    }
+    if (isString(schema.description)) {
+        action.push(v.description(schema.description));
+    }
+    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,
+                };
+            }
+            else {
+                return { value: result };
+            }
+        }
+        return {
+            value: a.length ? a : b,
+        };
+    }
+    return { value: a ?? b };
+}
+// 应该传入定制
+function jsonSchemaToValibot(schema, options) {
+    return new JsonSchemaToValibot(schema, options).convert();
+}
+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;
+    }
+    convert() {
+        return this.#jSchemaToVSchema(clone(this.root));
+    }
+    #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) {
+                    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'));
+                },
+            });
+        }
+        else if (schema$1.oneOf) {
+            vSchema = this.#conditionCreate(schema$1, {
+                useOr: true,
+                getChildren() {
+                    return schema$1.oneOf;
+                },
+                conditionCheckActionFn(childOriginSchemaList, getActivateList) {
+                    return v.rawCheck(({ dataset, addIssue }) => {
+                        if (dataset.issues) {
+                            return;
+                        }
+                        // 验证项全为可选,所以需要这里再次验证
+                        const hasSuccess = childOriginSchemaList.filter((item, index) => {
+                            const isActive = getActivateList()[index];
+                            if (!isActive) {
+                                return false;
+                            }
+                            const result = v.safeParse(item, dataset.value);
+                            return result.success;
+                        });
+                        if (hasSuccess.length !== 1) {
+                            addIssue({
+                                label: `oneOf`,
+                                expected: '1',
+                                received: `${hasSuccess.length}`,
+                            });
+                        }
+                    });
+                },
+                conditionSchemaFn(baseSchema, conditionVSchema, childSchemaList) {
+                    return v.pipe(schema.intersect([
+                        conditionVSchema,
+                        baseSchema,
+                        v.union(childSchemaList.map((item) => v.pipe(item, jsonActions.renderConfig({ hidden: true })))),
+                    ]), jsonActions.setComponent('oneOf-condition'));
+                },
+            });
+        }
+        else if ('if' in schema$1) {
+            /**
+             * 当前设计中if/then/else是采用的分离显示
+             * 也就是then/else都会合并base,然后按条件展示,
+             */
+            const useThen$ = new BehaviorSubject(undefined);
+            const baseSchema = v.pipe(this.#jsonSchemaBase(schema$1, () => [
+                ...this.#getValidationAction(schema$1),
+                hideWhen({
+                    disabled: false,
+                    listen: (fn) => fn({}).pipe(map(({ list: [value], field }) => {
+                        const isThen = isBoolean(schema$1.if)
+                            ? schema$1.if
+                            : v.safeParse(ifVSchema, value).success;
+                        field.form.parent.activateIndex$.set(isThen ? 1 : 2);
+                        useThen$.next(isThen);
+                        return !((isThen && !thenSchema) || (!isThen && !elseSchema));
+                    })),
+                }),
+            ]));
+            /** 仅为验证项,非显示用 */
+            let ifVSchema;
+            if (isBoolean(schema$1.if)) {
+                ifVSchema = v.literal(schema$1.if);
+            }
+            else {
+                const ifSchema = this.#mergeSchema(schema$1, schema$1.if);
+                ifVSchema = v.pipe(this.#jsonSchemaBase(ifSchema.schema, () => ifSchema.actionList));
+            }
+            function hideAction(isThen) {
+                return [
+                    jsonActions.renderConfig({ hidden: true }),
+                    hideWhen({
+                        disabled: true,
+                        listen(fn) {
+                            return fn({ list: [['..', 0]] }).pipe(switchMap(({ list: [] }) => useThen$), map((a) => (a === undefined ? true : isThen ? !a : a)));
+                        },
+                    }),
+                ];
+            }
+            let thenSchema;
+            if (schema$1.then && !isBoolean(schema$1.then)) {
+                const subSchema = this.#mergeSchema(schema$1, schema$1.then);
+                thenSchema = v.pipe(this.#jsonSchemaBase(subSchema.schema, () => [
+                    ...subSchema.actionList,
+                    ...hideAction(true),
+                ]));
+            }
+            let elseSchema;
+            if (schema$1.else && !isBoolean(schema$1.else)) {
+                const subSchema = this.#mergeSchema(schema$1, schema$1.else);
+                elseSchema = v.pipe(this.#jsonSchemaBase(subSchema.schema, () => [
+                    ...subSchema.actionList,
+                    ...hideAction(false),
+                ]));
+            }
+            // 这种逻辑没问题,因为jsonschema验证中,也会出现base和子级架构一起验证
+            vSchema = v.pipe(v.union([
+                baseSchema,
+                thenSchema ?? baseSchema,
+                elseSchema ?? baseSchema,
+            ].filter(Boolean)), formConfig({ disableOrUpdateActivate: true }), v.rawCheck(({ dataset, addIssue }) => {
+                if (dataset.issues) {
+                    return;
+                }
+                const status = useThen$.value;
+                if (status && thenSchema) {
+                    const result = v.safeParse(thenSchema, dataset.value);
+                    if (!result.success) {
+                        addIssue();
+                        return;
+                    }
+                }
+                if (!status && elseSchema) {
+                    const result = v.safeParse(elseSchema, dataset.value);
+                    if (!result.success) {
+                        addIssue();
+                        return;
+                    }
+                }
+            }));
+        }
+        else {
+            vSchema = v.pipe(
+            // 通用部分
+            this.#jsonSchemaBase(this.#jsonSchemaCompatiable(schema$1), () => this.#getValidationAction(schema$1)));
+        }
+        return (this.#options?.schemaHandle?.afterResolve?.(schema$1, vSchema) ?? 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` });
+                }
+            }));
+        }
+        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;
+        // 暂时为只支持一个
+        const 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(type, result2, result) ?? result2);
+        };
+        if (!isNil(schema$1.const)) {
+            return createTypeFn(v.literal(schema$1.const));
+        }
+        if (Array.isArray(schema$1.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',
+                                        });
+                                    }
+                                }
+                            }
+                        });
+                    }));
+                }
+                // 普通属性
+                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;
+                        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, hideWhen({
+                            disabled: true,
+                            listen: (fn, field) => field
+                                .get(['..', '..', 0, key])
+                                .form.control.statusChanges.pipe(map((item) => item === 'VALID')),
+                        }));
+                        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) {
+                    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;
+        if (isString(type)) {
+            return { types: [type], optional: false };
+        }
+        if (Array.isArray(type)) {
+            if (type.length === 1) {
+                return { types: type, optional: false };
+            }
+            const nullIndex = type.findIndex((item) => item === 'null');
+            if (nullIndex !== -1) {
+                type.splice(nullIndex, 1);
+            }
+            return {
+                types: type,
+                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: false }
+            : { types: anyType, optional: false };
+    }
+    #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;
+        }
+    }
+    #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;
+    }
+    #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));
+            baseKeyList = union(baseKeyList, Object.keys(childSchema));
+            for (const key of baseKeyList) {
+                switch (key) {
+                    case 'const': {
+                        childSchema[key] ??= base[key];
+                        break;
+                    }
+                    case 'type':
+                    case 'enum': {
+                        // 类型
+                        const typeResult = arrayIntersection(base[key], childSchema[key]);
+                        if (typeResult.action) {
+                            actionList.push(typeResult.action);
+                        }
+                        if (!isUndefined(typeResult.value)) {
+                            childSchema[key] = typeResult.value;
+                        }
+                        break;
+                    }
+                    case 'additionalProperties': {
+                        // todo 此属性false在当前使用,子级会验证失败,
+                        // 附加属性
+                        childSchema.additionalProperties ??= base.additionalProperties;
+                        break;
+                    }
+                    case 'contains': {
+                        if (childSchema[key] === false || base[key] === false) {
+                            actionList.push(v.check(() => false));
+                            break;
+                        }
+                        else if (childSchema[key] === true) {
+                            childSchema[key] = base[key];
+                            break;
+                        }
+                        else if (base[key] === true) {
+                            break;
+                        }
+                        if (!isUndefined(childSchema[key])) {
+                            childSchema[key] = {
+                                ...base[key],
+                                ...childSchema[key],
+                            };
+                        }
+                        else {
+                            childSchema[key] = base[key];
+                        }
+                        break;
+                    }
+                    case 'if':
+                    case 'then':
+                    case 'else':
+                    case 'patternProperties':
+                    case 'dependentSchemas':
+                    case 'propertyNames':
+                    case 'properties': {
+                        // 属性赋值
+                        if (!isUndefined(childSchema[key])) {
+                            childSchema[key] = {
+                                ...base[key],
+                                ...childSchema[key],
+                            };
+                        }
+                        else {
+                            childSchema[key] = base[key];
+                        }
+                        break;
+                    }
+                    default:
+                        childSchema[key] ??= base[key];
+                        break;
+                }
+            }
+            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 };
+    }
+    #conditionCreate(schema, options) {
+        const resolvedChildList = options
+            .getChildren()
+            .map((item) => this.#mergeSchema(schema, item));
+        const resolvedChildJSchemaList = resolvedChildList.map((item) => item.schema);
+        const isObject = [schema, ...resolvedChildJSchemaList].every((item) => item.__resolved.type.types.includes('object'));
+        /** 通用子级验证部分,不显示  */
+        const childOriginSchemaList = resolvedChildList.map((item) => v.pipe(this.#jsonSchemaBase(item.schema, () => item.actionList)));
+        let activateList = [];
+        const conditionCheckAction = options.conditionCheckActionFn(childOriginSchemaList, () => activateList);
+        // 仅处理object,实现条件显示
+        if (isObject) {
+            const conditionResult = this.#schemaExtract(schema, ...resolvedChildJSchemaList);
+            if (conditionResult) {
+                /** 子级的共同部分验证,用于检测是哪个子级,不显示 */
+                const childConditionVSchemaList = conditionResult.childConditionJSchemaList.map((schema) => {
+                    const rSchema = this.#jsonSchemaCompatiable(schema);
+                    return v.pipe(this.#jsonSchemaBase(rSchema, () => this.#getValidationAction(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);
+                        }
+                    });
+                }));
+                conditionResult.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 childVSchemaList = resolvedChildJSchemaList.map((item) => 
+                // 验证部分被单独提取出来
+                v.pipe(this.#jsonSchemaBase(item, () => [])));
+                return v.pipe(options.conditionSchemaFn(baseSchema, conditionVSchema, childVSchemaList), conditionCheckAction);
+            }
+        }
+        const baseSchema = v.pipe(this.#jsonSchemaBase(schema, () => this.#getValidationAction(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)));
+        }
+        // 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;
+            }
+        }
+        // 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.#options?.customActions?.[rawAction.name];
+                if (!inlineActions) {
+                    throw new Error(`action:[${rawAction.name}]❗`);
+                }
+                action.push(inlineActions.apply(undefined, rawAction.params));
+            }
+        }
+        return action;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { JsonSchemaToValibot, jsonSchemaToValibot };
+//# sourceMappingURL=piying-view-angular-core-adapter.mjs.map