@piying/view-angular-core 1.10.4 → 2.0.1

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

@@ -1,6 +1,6 @@
 import { signal, computed, InjectionToken, effect, inject, Injector, untracked, DestroyRef, linkedSignal, isSignal, EnvironmentInjector } from '@angular/core';
 import * as v from 'valibot';
-import { isObservable, BehaviorSubject, Subject, combineLatest, startWith, skip, map } from 'rxjs';
+import { isObservable, BehaviorSubject, Subject, tap, pipe, shareReplay, combineLatest, startWith, skip, map } from 'rxjs';
 import rfdc from 'rfdc';
 import { deepEqual } from 'fast-equals';
 import { createRawConfig, metadataList, defineName, BaseSchemaHandle, convertSchema, convertCore } from '@piying/valibot-visit';
@@ -919,20 +919,6 @@ key, formConfig$$, isRoot, injector) {
     return control;
 }
 
-function unWrapSignal$1(value) {
-    return isSignal(value) ? value() : value;
-}
-
-const DCONFIG_EFAULT_MERGE_STRAGEGY = {
-    props: 'merge',
-    formConfig: 'merge',
-    renderConfig: 'merge',
-    inputs: 'merge',
-    outputs: 'merge',
-    wrappers: 'replace',
-    attributes: 'merge',
-};
-
 class ParentMap extends Map {
     parent;
     constructor(parent) {
@@ -952,10 +938,6 @@ function arrayStartsWith(list, parts) {
     return (Array.isArray(parts) ? parts : [parts]).every((item, index) => item === list[index]);
 }
 
-function unWrapSignal(value) {
-    return isSignal(value) ? value() : value;
-}
-
 function toArray(input) {
     return input === undefined
         ? input
@@ -1048,11 +1030,10 @@ function createViewControlLink(fieldControl, cva, injector) {
     }
     return (destroy) => {
         disposeList.forEach((fn) => fn());
-        if (!destroy) {
-            untracked(() => {
-                fieldControl().updateValue(fieldControl().value$$(), true);
-            });
-        }
+        // todo 需要优化
+        untracked(() => {
+            fieldControl().updateValue(fieldControl().value$$(), true);
+        });
     };
 }
 
@@ -1134,6 +1115,173 @@ function getDeepError(control) {
     return list;
 }
 
+const DefaultOptions$1 = { autoDestroy: true };
+/** set输入,()输出的是管道后的值, */
+function observableSignal(initialValue, options) {
+    options = { ...DefaultOptions$1, ...options };
+    const inputS$ = signal(initialValue, options);
+    const outputS$ = signal(undefined);
+    const loading$ = signal(false);
+    const inputR$ = new BehaviorSubject(undefined);
+    inputR$.next(inputS$());
+    const data = inputR$.pipe(tap(() => {
+        loading$.set(true);
+    }), options?.pipe ? options.pipe : pipe(), shareReplay());
+    const oldOutputSet = outputS$.set;
+    data.subscribe((value) => {
+        oldOutputSet(value);
+        loading$.set(false);
+    });
+    const oldSet = inputS$.set;
+    const changed$ = outputS$;
+    changed$.set = (value) => {
+        inputR$.next(value);
+        return oldSet(value);
+    };
+    changed$.update = (fn) => {
+        const newValue = fn(inputS$());
+        return changed$.set(newValue);
+    };
+    changed$.output = outputS$;
+    changed$.input = inputS$;
+    changed$.input$$ = inputR$.asObservable();
+    changed$.output$$ = data;
+    changed$.subject = inputR$;
+    if (options?.injector || options.autoDestroy) {
+        const injector = options?.injector ?? inject(Injector, { optional: true });
+        if (injector) {
+            injector.get(DestroyRef).onDestroy(() => {
+                inputR$.complete();
+            });
+        }
+    }
+    return changed$;
+}
+
+function asyncObjectSignal(initialValue, options) {
+    const data$ = signal(initialValue);
+    let mapFn$ = signal(undefined);
+    const signalList$ = signal([]);
+    const value$$ = computed(() => {
+        const signalList = signalList$();
+        const data = data$();
+        let mapFn = mapFn$();
+        if (!signalList.length) {
+            return mapFn ? mapFn(data) : data;
+        }
+        const data2 = { ...data };
+        signalList.forEach(([key, value]) => {
+            data2[key] = value();
+        });
+        return mapFn ? mapFn(data2) : data2;
+    }, options);
+    const disposeMap = new Map();
+    const changed$ = value$$;
+    changed$.connect = (key, value) => {
+        changed$.disconnect(key);
+        let dispose;
+        if (isPromise(value)) {
+            // promise
+            let isDestroy = false;
+            value.then((value) => {
+                if (isDestroy) {
+                    return;
+                }
+                data$.update((lastData) => ({ ...lastData, [key]: value }));
+            });
+            dispose = () => {
+                isDestroy = true;
+            };
+        }
+        else if (isSubscribable(value)) {
+            // rxjs
+            const ref = value.subscribe({
+                next: (value) => {
+                    data$.update((lastData) => ({ ...lastData, [key]: value }));
+                },
+            });
+            dispose = () => {
+                ref.unsubscribe();
+            };
+        }
+        else if (isSignal(value)) {
+            signalList$.update((list) => {
+                list = list.slice();
+                list.push([key, value]);
+                return list;
+            });
+            dispose = () => {
+                signalList$.update((list) => {
+                    const index = list.findIndex((item) => value === item[1]);
+                    if (index !== -1) {
+                        list = list.slice();
+                        list.splice(index, 1);
+                    }
+                    return list;
+                });
+            };
+        }
+        else {
+            // 普通类型
+            data$.update((lastData) => ({ ...lastData, [key]: value }));
+        }
+        if (dispose) {
+            disposeMap.set(key, dispose);
+        }
+    };
+    changed$.disconnect = (key) => {
+        untracked(() => {
+            disposeMap.get(key)?.();
+            disposeMap.delete(key);
+        });
+    };
+    changed$.set = (key) => {
+        data$.set(key);
+    };
+    changed$.update = (fn) => {
+        const result = fn(changed$());
+        data$.set(result);
+    };
+    changed$.map = (input) => {
+        mapFn$.set(input);
+    };
+    return changed$;
+}
+
+function combineSignal(initialValue = [], options) {
+    const list$ = signal(initialValue);
+    const input$$ = computed(() => list$().map((item) => item()), options);
+    const changed$ = input$$;
+    changed$.add = (item, index) => {
+        list$.update((list) => {
+            if (typeof index === 'number') {
+                list = list.slice();
+                list.splice(index, 0, item);
+                return list;
+            }
+            return [...list, item];
+        });
+    };
+    changed$.remove = (item) => {
+        list$.update((list) => {
+            const index = list.indexOf(item);
+            if (index === -1) {
+                return list;
+            }
+            list = list.slice();
+            list.splice(index, 1);
+            return list;
+        });
+    };
+    changed$.items = () => list$();
+    changed$.clean = () => list$.set([]);
+    changed$.update = (fn) => {
+        const list = fn(list$());
+        list$.set(list);
+    };
+    return changed$;
+}
+
 function* groupGenerator(list) {
     for (const item of list) {
         if (!item.keyPath?.length && item.fixedChildren?.().length) {
@@ -1187,86 +1335,40 @@ const FindConfigToken = new InjectionToken('FindConfig');
 function FindConfigFactory() {
     const globalConfig = inject(PI_VIEW_CONFIG_TOKEN);
     return {
-        findWrapper: (wrapper) => {
+        findWrapperComponent: (wrapper) => {
             let config;
             let type;
             if (typeof wrapper === 'string') {
                 config = globalConfig?.wrappers?.[wrapper];
-                type = wrapper;
-            }
-            else if (typeof wrapper.type === 'string') {
-                const defaultConfig = globalConfig?.wrappers?.[wrapper.type];
-                if (defaultConfig) {
-                    config = {
-                        type: defaultConfig.type,
-                        inputs: { ...defaultConfig.inputs, ...wrapper.inputs },
-                        attributes: { ...defaultConfig.attributes, ...wrapper.attributes },
-                        outputs: { ...defaultConfig.outputs, ...wrapper.outputs },
-                    };
+                if (!config) {
+                    throw new Error(`🈳wrapper:[${type}]❗`);
                 }
-                type = wrapper.type;
-            }
-            else {
-                config = wrapper;
-            }
-            if (!config) {
-                throw new Error(`🈳wrapper:[${type}]❗`);
+                return config?.type;
             }
-            return config;
+            return wrapper;
         },
         findComponentConfig: (type) => {
-            let define;
-            let defaultConfig;
             if (typeof type === 'string') {
                 const config = globalConfig?.types?.[type];
                 if (!config) {
                     throw new Error(`🈳define:[${type}]❗`);
                 }
-                defaultConfig = config;
-                if (Object.keys(config).length) {
-                    define = {
-                        ...config,
-                    };
-                    return {
-                        define: { ...config },
-                        defaultConfig,
-                    };
-                }
+                return config.type;
             }
             else {
-                return { define: { type: type } };
+                return type;
             }
-            return {
-                define,
-                defaultConfig,
-            };
         },
     };
 }
 
 var _a;
-// todo 临时同步
-function defineSync(field) {
-    const define = field.define?.();
-    if (define &&
-        (field.inputs !== define.inputs ||
-            field.outputs !== define.outputs ||
-            field.attributes !== define.attributes)) {
-        field.define = signal({
-            ...define,
-            inputs: field.inputs,
-            outputs: field.outputs,
-            attributes: field.attributes,
-        });
-    }
-}
 class FormBuilder {
     #scopeMap = inject(PI_FORM_BUILDER_ALIAS_MAP, { optional: true }) ??
         new ParentMap();
     #options = inject(PI_FORM_BUILDER_OPTIONS_TOKEN);
     #injector = inject(Injector);
     #envInjector = inject(EnvironmentInjector);
-    #globalConfig = inject(PI_VIEW_CONFIG_TOKEN);
     #allFieldInitHookList = [];
     buildRoot(item) {
         const field = this.#buildControl({
@@ -1307,51 +1409,17 @@ class FormBuilder {
     // 单独一项
     field, index) {
         // 利用类型查引用,
-        let viewDefaultConfig;
         const type = field.type;
         let define;
         if (type) {
-            const result = this.#findConfig.findComponentConfig(type);
-            viewDefaultConfig = result.defaultConfig;
-            define = result.define;
-        }
-        const mergeStrategy = this.#globalConfig?.defaultConfigMergeStrategy;
-        const inputs = this.configMerge([
-            this.#globalConfig?.defaultConfig?.inputs,
-            viewDefaultConfig?.inputs,
-            field.inputs,
-        ], false, mergeStrategy?.inputs ?? DCONFIG_EFAULT_MERGE_STRAGEGY.inputs);
-        const outputs = this.configMerge([
-            this.#globalConfig?.defaultConfig?.outputs,
-            viewDefaultConfig?.outputs,
-            field.outputs,
-        ], false, mergeStrategy?.outputs ?? DCONFIG_EFAULT_MERGE_STRAGEGY.outputs);
-        const attributes = this.configMerge([
-            this.#globalConfig?.defaultConfig?.attributes,
-            viewDefaultConfig?.attributes,
-            field.attributes,
-        ], false, mergeStrategy?.attributes ?? DCONFIG_EFAULT_MERGE_STRAGEGY.attributes);
-        const wrappers1 = this.configMergeRaw([
-            this.#globalConfig?.defaultConfig?.wrappers,
-            viewDefaultConfig?.wrappers,
-            field.wrappers,
-        ], true, mergeStrategy?.wrappers ?? DCONFIG_EFAULT_MERGE_STRAGEGY.wrappers);
-        const wrappers = this.#resolveWrappers(wrappers1);
-        const props = this.configMerge([
-            this.#globalConfig?.defaultConfig?.props,
-            viewDefaultConfig?.props,
-            field.props,
-        ], false, mergeStrategy?.props ?? DCONFIG_EFAULT_MERGE_STRAGEGY.props);
-        const formConfig$ = this.configMerge([
-            this.#globalConfig?.defaultConfig?.formConfig,
-            viewDefaultConfig?.formConfig,
-            field.formConfig,
-        ], false, mergeStrategy?.formConfig ?? DCONFIG_EFAULT_MERGE_STRAGEGY.formConfig);
-        const renderConfig = this.configMerge([
-            this.#globalConfig?.defaultConfig?.renderConfig,
-            viewDefaultConfig?.renderConfig,
-            field.renderConfig,
-        ], false, mergeStrategy?.renderConfig ?? DCONFIG_EFAULT_MERGE_STRAGEGY.renderConfig);
+            define = this.#findConfig.findComponentConfig(type);
+        }
+        const inputs = field.inputs;
+        const outputs = field.outputs;
+        const attributes = field.attributes;
+        const events = field.events;
+        const formConfig$ = signal(field.formConfig ?? {});
+        const renderConfig = signal(field.renderConfig ?? {});
         let control;
         let keyPath = field.key;
         if (isFieldLogicGroup(parent.form)) {
@@ -1388,23 +1456,31 @@ class FormBuilder {
             origin: field,
             renderConfig: renderConfig,
             formConfig: formConfig$,
-            props,
+            props: field.props,
             context: this.#options.context,
             priority: field.priority,
             hooks: field.hooks,
             alias: field.alias,
-            inputs: inputs,
-            outputs: outputs,
-            attributes,
+            get inputs() {
+                return resolvedConfig.define().inputs;
+            },
+            get outputs() {
+                return resolvedConfig.define().outputs;
+            },
+            get events() {
+                return resolvedConfig.define().events;
+            },
+            get attributes() {
+                return resolvedConfig.define().attributes;
+            },
             define: define
-                ? signal({ ...define, inputs, outputs, attributes })
+                ? signal({ type: define, inputs, outputs, attributes, events })
                 : undefined,
-            wrappers,
+            wrappers: field.wrappers,
             injector: this.#envInjector,
         };
         resolvedConfig =
             this.afterResolveConfig(field, resolvedConfig) ?? resolvedConfig;
-        defineSync(resolvedConfig);
         if (field.movePath) {
             this.#moveViewField(field.movePath, resolvedConfig);
         }
@@ -1618,38 +1694,6 @@ class FormBuilder {
         result.injector = injector.get(EnvironmentInjector);
         return result;
     }
-    configMergeRaw(list, isArray, strategy) {
-        let value;
-        if (isArray) {
-            if (strategy === 'merge') {
-                value = list
-                    .filter(Boolean)
-                    .flat()
-                    .map((item) => unWrapSignal$1(item));
-            }
-            else {
-                value = list.reduce((data, item) => unWrapSignal$1(item) ?? data, []);
-            }
-        }
-        else {
-            if (strategy === 'merge') {
-                value = list.reduce((obj, item) => ({
-                    ...obj,
-                    ...unWrapSignal$1(item),
-                }), {});
-            }
-            else {
-                value = list.reduce((data, item) => unWrapSignal$1(item) ?? data, {});
-            }
-        }
-        return value;
-    }
-    /**
-     * 后面覆盖前面
-     * */
-    configMerge(list, isArray, strategy) {
-        return signal(this.configMergeRaw(list, isArray, strategy));
-    }
     #moveViewField(key, inputField) {
         const parent = fieldQuery(key, inputField, this.#scopeMap, this.#options.resolvedField$());
         if (!parent) {
@@ -1661,18 +1705,6 @@ class FormBuilder {
         parent.fixedChildren().push(inputField);
     }
     #findConfig = inject(FindConfigToken);
-    #resolveWrappers(wrappers) {
-        const result = (wrappers ?? []).map((wrapper) => {
-            const config = this.#findConfig.findWrapper(wrapper);
-            return {
-                inputs: signal(config.inputs),
-                outputs: config.outputs,
-                attributes: signal(config.attributes),
-                type: config.type,
-            };
-        });
-        return signal(result);
-    }
 }
 _a = FormBuilder;
 
@@ -1703,8 +1735,7 @@ function setComponent(type) {
         });
 }
 function findComponent(field, type) {
-    return field.injector.get(FindConfigToken).findComponentConfig(type).define
-        .type;
+    return field.injector.get(FindConfigToken).findComponentConfig(type);
 }
 
 const setHooks = (hooks) => rawConfig((field) => {
@@ -1743,223 +1774,6 @@ function removeHooks(list) {
     });
 }
 
-function setInputs(inputs) {
-    return rawConfig((field) => {
-        field.inputs = inputs;
-    });
-}
-function patchInputs(inputs) {
-    return rawConfig((field) => {
-        field.inputs = {
-            ...field.inputs,
-            ...inputs,
-        };
-    });
-}
-function removeInputs(list) {
-    return rawConfig((field) => {
-        const oldValue = unWrapSignal(field.inputs);
-        if (!oldValue) {
-            return;
-        }
-        list.forEach((item) => {
-            delete oldValue[item];
-        });
-        field.inputs = oldValue;
-    });
-}
-function asyncInputMerge(dataObj, data$) {
-    const signalObj = {};
-    const inputList = Object.keys(dataObj);
-    inputList.forEach((key) => {
-        const result = dataObj[key];
-        if (isPromise(result)) {
-            // promise
-            result.then((value) => {
-                data$.update((lastData) => {
-                    lastData = { ...lastData };
-                    lastData[key] = value;
-                    return lastData;
-                });
-            });
-        }
-        else if (isSubscribable(result)) {
-            // rxjs
-            result.subscribe({
-                next: (value) => {
-                    data$.update((lastData) => {
-                        lastData = { ...lastData };
-                        lastData[key] = value;
-                        return lastData;
-                    });
-                },
-            });
-        }
-        else if (isSignal(result)) {
-            signalObj[key] = result;
-        }
-        else {
-            // 普通类型
-            data$.update((lastData) => {
-                lastData = { ...lastData };
-                lastData[key] = result;
-                return lastData;
-            });
-        }
-    });
-    const signalKeyList = Object.keys(signalObj);
-    if (signalKeyList.length) {
-        const newData = linkedSignal(computed(() => ({
-            ...data$(),
-            ...signalKeyList.reduce((obj, key) => ({ ...obj, [key]: signalObj[key]() }), {}),
-        })));
-        newData.set = (value) => {
-            data$.set(value);
-        };
-        newData.update = (fn) => {
-            const result = fn(newData());
-            data$.set(result);
-        };
-        return newData;
-    }
-    return data$;
-}
-function patchAsyncFn(patchKey) {
-    return (dataObj, options) => rawConfig((rawField) => {
-        const inputList = Object.keys(dataObj);
-        const hookName = options?.hookName ?? 'allFieldsResolved';
-        // 设置初始值
-        rawField[patchKey] = {
-            ...rawField[patchKey],
-            ...inputList.reduce((obj, item) => {
-                obj[item] = rawField[patchKey]?.[item] ?? undefined;
-                return obj;
-            }, {}),
-        };
-        return mergeHooksFn({
-            [hookName]: (field) => {
-                const result = asyncInputMerge(Object.entries(dataObj).reduce((obj, [key, value]) => {
-                    obj[key] = value(field);
-                    return obj;
-                }, {}), field[patchKey]);
-                if (patchKey !== 'props') {
-                    field.define.update((data) => ({
-                        ...data,
-                        [patchKey]: result,
-                    }));
-                }
-                field[patchKey] =
-                    result;
-            },
-        }, { position: options?.addPosition ?? 'bottom' }, rawField);
-    });
-}
-const patchAsyncInputs = patchAsyncFn('inputs');
-
-function setAttributes(attributes) {
-    return rawConfig((field) => {
-        field.attributes = attributes;
-    });
-}
-function patchAttributes(attributes) {
-    return rawConfig((field) => {
-        field.attributes = {
-            ...field.attributes,
-            ...attributes,
-        };
-    });
-}
-function removeAttributes(list) {
-    return rawConfig((field) => {
-        const oldValue = unWrapSignal(field.attributes);
-        if (!oldValue) {
-            return;
-        }
-        list.forEach((item) => {
-            delete oldValue[item];
-        });
-        field.attributes = oldValue;
-    });
-}
-const patchAsyncAttributes = patchAsyncFn('attributes');
-
-function setProps(props) {
-    return rawConfig((field) => {
-        field.props = props;
-    });
-}
-function patchProps(props) {
-    return rawConfig((field) => {
-        field.props = {
-            ...field.props,
-            ...props,
-        };
-    });
-}
-function removeProps(list) {
-    return rawConfig((field) => {
-        const oldValue = unWrapSignal(field.props);
-        if (!oldValue) {
-            return;
-        }
-        list.forEach((item) => {
-            delete oldValue[item];
-        });
-        field.props = oldValue;
-    });
-}
-const patchAsyncProps = patchAsyncFn('props');
-
-function createOutputListener(outputs, options) {
-    return rawConfig((field) => {
-        mergeHooksFn({
-            allFieldsResolved: (field) => {
-                field.outputs.update((originOutputs) => {
-                    originOutputs = options.setOutputs ? {} : { ...originOutputs };
-                    for (const key in outputs) {
-                        const oldFn = originOutputs[key];
-                        originOutputs[key] = (...args) => {
-                            if (options.mergeOutput && oldFn) {
-                                oldFn(...args, field);
-                            }
-                            return outputs[key](...args, field);
-                        };
-                    }
-                    return originOutputs;
-                });
-            },
-        }, { position: 'bottom' }, field);
-    });
-}
-function setOutputs(outputs) {
-    return createOutputListener(outputs, {
-        setOutputs: true,
-        mergeOutput: false,
-    });
-}
-function patchOutputs(outputs) {
-    return createOutputListener(outputs, {
-        setOutputs: false,
-        mergeOutput: false,
-    });
-}
-function removeOutputs(list) {
-    return rawConfig((field) => {
-        mergeHooksFn({
-            allFieldsResolved: (field) => {
-                field.outputs.update((originOutputs) => {
-                    originOutputs = { ...originOutputs };
-                    list.forEach((key) => {
-                        if (key in originOutputs) {
-                            delete originOutputs[key];
-                        }
-                    });
-                    return originOutputs;
-                });
-            },
-        }, { position: 'bottom' }, field);
-    });
-}
 function mergeOutputFn(field, outputs) {
     field.outputs.update((originOutputs) => {
         originOutputs = { ...originOutputs };
@@ -1973,9 +1787,40 @@ function mergeOutputFn(field, outputs) {
         return originOutputs;
     });
 }
-const mergeOutputs = (outputs) => createOutputListener(outputs, {
-    setOutputs: false,
-    mergeOutput: true,
+const mergeOutputs = (outputs) => rawConfig((field) => {
+    field.outputs.update((originOutputs) => {
+        originOutputs = { ...originOutputs };
+        for (const key in outputs) {
+            const oldFn = originOutputs[key];
+            originOutputs[key] = (...args) => {
+                if (oldFn) {
+                    oldFn(...args);
+                }
+                return outputs[key](...args);
+            };
+        }
+        return originOutputs;
+    });
+});
+const asyncMergeOutputs = (outputs) => rawConfig((field) => {
+    mergeHooksFn({
+        allFieldsResolved: (field) => {
+            field.outputs.update((originOutputs) => {
+                originOutputs = { ...originOutputs };
+                for (const key in outputs) {
+                    const fn = outputs[key](field);
+                    const oldFn = originOutputs[key];
+                    originOutputs[key] = (...args) => {
+                        if (oldFn) {
+                            oldFn(...args);
+                        }
+                        return fn(...args);
+                    };
+                }
+                return originOutputs;
+            });
+        },
+    }, { position: 'bottom' }, field);
 });
 function outputChangeFn(rawField, fn) {
     mergeHooksFn({
@@ -2006,89 +1851,6 @@ function outputChange(fn) {
     return rawConfig((field) => outputChangeFn(field, fn));
 }
 
-function setWrappers(wrappers) {
-    return rawConfig((field) => {
-        field.wrappers = wrappers;
-    });
-}
-const defaultValue = {
-    position: 'tail',
-};
-function patchWrappers(wrappers, options = defaultValue) {
-    return rawConfig((field) => {
-        const list = toArray(wrappers);
-        field.wrappers ??= [];
-        if (options.position === 'tail') {
-            field.wrappers.push(...list);
-        }
-        else {
-            field.wrappers.unshift(...list);
-        }
-    });
-}
-function patchAsyncWrapper(inputWrapper, options = defaultValue) {
-    return rawConfig((field) => {
-        mergeHooksFn({
-            allFieldsResolved: (field) => {
-                const findConfig = field.injector.get(FindConfigToken);
-                let inputs$ = signal({});
-                if (inputWrapper.inputs && Object.keys(inputWrapper.inputs).length) {
-                    inputs$ = asyncInputMerge(Object.entries(inputWrapper.inputs).reduce((obj, [key, value]) => {
-                        obj[key] = value(field);
-                        return obj;
-                    }, {}), inputs$);
-                }
-                let attributes$ = signal({});
-                if (inputWrapper.attributes &&
-                    Object.keys(inputWrapper.attributes).length) {
-                    attributes$ = asyncInputMerge(Object.entries(inputWrapper.attributes).reduce((obj, [key, value]) => {
-                        obj[key] = value(field);
-                        return obj;
-                    }, {}), attributes$);
-                }
-                const oldOutputs = inputWrapper.outputs;
-                const outputs = {};
-                if (oldOutputs && Object.keys(oldOutputs).length) {
-                    for (const key in oldOutputs) {
-                        const oldFn = oldOutputs[key];
-                        outputs[key] = (...args) => oldFn(...args, field);
-                    }
-                }
-                const defaultWrapperConfig = findConfig.findWrapper(inputWrapper);
-                const newWrapper = {
-                    ...defaultWrapperConfig,
-                    inputs: inputs$,
-                    outputs,
-                    attributes: attributes$,
-                };
-                field.wrappers.update((wrappers) => options.position === 'tail'
-                    ? [...wrappers, newWrapper]
-                    : [newWrapper, ...wrappers]);
-            },
-        }, { position: 'bottom' }, field);
-    });
-}
-function removeWrappers(list) {
-    return rawConfig((field) => {
-        if (!field.wrappers) {
-            return;
-        }
-        const wrappers = field.wrappers;
-        for (let i = 0; i < list.length; i++) {
-            const name = list[i];
-            for (let j = 0; j < wrappers.length; j++) {
-                const config = wrappers[j];
-                const name2 = typeof config === 'string' ? config : config.type;
-                if (name2 === name) {
-                    wrappers.splice(j, 1);
-                    break;
-                }
-            }
-        }
-        field.wrappers = wrappers;
-    });
-}
-
 function setAlias(alias) {
     return rawConfig((field) => {
         field.alias = alias;
@@ -2167,6 +1929,302 @@ function disableWhen(options) {
     });
 }
 
+function nonFieldControl(value = true) {
+    return {
+        kind: 'metadata',
+        type: 'nonFieldControl',
+        reference: nonFieldControl,
+        value: value,
+    };
+}
+
+const CustomDataSymbol = Symbol();
+const createRemovePropertyFn = (key) => (list) => rawConfig((rawField, _, ...args) => mergeHooksFn({
+    allFieldsResolved: (field) => {
+        let data$;
+        if (args.length > 0 &&
+            typeof args[args.length - 1] === 'object' &&
+            CustomDataSymbol in args[args.length - 1]) {
+            data$ = args[args.length - 1][CustomDataSymbol];
+        }
+        else {
+            data$ = (() => field);
+        }
+        const obj$ = data$()[key];
+        list.forEach((key) => {
+            obj$.disconnect(key);
+            obj$.update((object) => {
+                object = { ...object };
+                delete object[key];
+                return object;
+            });
+        });
+    },
+}, { position: 'bottom' }, rawField));
+function createPatchAsyncPropertyFn(key) {
+    return (dataObj) => rawConfig((rawField, _, ...args) => {
+        let data$;
+        if (args.length > 0 &&
+            typeof args[args.length - 1] === 'object' &&
+            CustomDataSymbol in args[args.length - 1]) {
+            data$ = args[args.length - 1][CustomDataSymbol];
+        }
+        else {
+            data$ = (() => rawField);
+        }
+        const content$ = data$()[key];
+        const inputList = Object.keys(dataObj);
+        // 设置初始值
+        content$.update((content) => ({
+            ...content,
+            ...inputList.reduce((obj, item) => {
+                obj[item] = content?.[item] ?? undefined;
+                return obj;
+            }, {}),
+        }));
+        return mergeHooksFn({
+            allFieldsResolved: (field) => {
+                Object.entries(dataObj).forEach(([key, value]) => {
+                    const result = value(field);
+                    content$.connect(key, result);
+                });
+            },
+        }, { position: 'bottom' }, rawField);
+    });
+}
+function createSetOrPatchPropertyFn(key, isPatch) {
+    return (value) => rawConfig((rawField, _, ...args) => {
+        let data$;
+        if (args.length > 0 &&
+            typeof args[args.length - 1] === 'object' &&
+            CustomDataSymbol in args[args.length - 1]) {
+            data$ = args[args.length - 1][CustomDataSymbol];
+        }
+        else {
+            data$ = (() => rawField);
+        }
+        const content$ = data$()[key];
+        if (isPatch) {
+            content$.update((data) => ({
+                ...data,
+                ...value,
+            }));
+        }
+        else {
+            content$.set(value);
+        }
+    });
+}
+function createMapPropertyFn(key) {
+    return (fn) => rawConfig((rawField, _, ...args) => {
+        let data$;
+        if (args.length > 0 &&
+            typeof args[args.length - 1] === 'object' &&
+            CustomDataSymbol in args[args.length - 1]) {
+            data$ = args[args.length - 1][CustomDataSymbol];
+        }
+        else {
+            data$ = (() => rawField);
+        }
+        const content$ = data$()[key];
+        content$.map(fn);
+    });
+}
+function createMapAsyncPropertyFn(key) {
+    return (fn) => rawConfig((rawField, _, ...args) => {
+        return mergeHooksFn({
+            allFieldsResolved: (field) => {
+                let data$;
+                if (args.length > 0 &&
+                    typeof args[args.length - 1] === 'object' &&
+                    CustomDataSymbol in args[args.length - 1]) {
+                    data$ = args[args.length - 1][CustomDataSymbol];
+                }
+                else {
+                    data$ = (() => field);
+                }
+                const content$ = data$()[key];
+                content$.map(fn(field));
+            },
+        }, { position: 'bottom' }, rawField);
+    });
+}
+const __actions = {
+    inputs: {
+        patch: createSetOrPatchPropertyFn('inputs', true),
+        set: createSetOrPatchPropertyFn('inputs'),
+        patchAsync: createPatchAsyncPropertyFn('inputs'),
+        remove: createRemovePropertyFn('inputs'),
+        map: createMapPropertyFn('inputs'),
+        mapAsync: createMapAsyncPropertyFn('inputs'),
+    },
+    outputs: {
+        patch: createSetOrPatchPropertyFn('outputs', true),
+        set: createSetOrPatchPropertyFn('outputs'),
+        patchAsync: createPatchAsyncPropertyFn('outputs'),
+        remove: createRemovePropertyFn('outputs'),
+        merge: mergeOutputs,
+        mergeAsync: asyncMergeOutputs,
+        map: createMapPropertyFn('outputs'),
+        mapAsync: createMapAsyncPropertyFn('outputs'),
+    },
+    attributes: {
+        patch: createSetOrPatchPropertyFn('attributes', true),
+        set: createSetOrPatchPropertyFn('attributes'),
+        patchAsync: createPatchAsyncPropertyFn('attributes'),
+        remove: createRemovePropertyFn('attributes'),
+        map: createMapPropertyFn('attributes'),
+        mapAsync: createMapAsyncPropertyFn('attributes'),
+    },
+    events: {
+        patch: createSetOrPatchPropertyFn('events', true),
+        set: createSetOrPatchPropertyFn('events'),
+        patchAsync: createPatchAsyncPropertyFn('events'),
+        remove: createRemovePropertyFn('events'),
+        map: createMapPropertyFn('events'),
+        mapAsync: createMapAsyncPropertyFn('events'),
+    },
+    props: {
+        patch: createSetOrPatchPropertyFn('props', true),
+        set: createSetOrPatchPropertyFn('props'),
+        patchAsync: createPatchAsyncPropertyFn('props'),
+        remove: createRemovePropertyFn('props'),
+        map: createMapPropertyFn('props'),
+        mapAsync: createMapAsyncPropertyFn('props'),
+    },
+};
+
+function setWrappers(wrappers) {
+    return rawConfig((rawField, _) => {
+        const wrapperConfig = rawField.globalConfig.additionalData['defaultWrapperMetadataGroup'];
+        const injector = rawField.globalConfig.additionalData['injector'];
+        const OptionDefine = {
+            pipe: pipe(map((item) => {
+                if (typeof item.type === 'string') {
+                    const type = wrapperConfig[item.type].type;
+                    if (!type) {
+                        throw new Error(`🈳wrapper:[${type}]❗`);
+                    }
+                    return { ...item, type: type };
+                }
+                return item;
+            })),
+            injector: injector,
+        };
+        rawField.wrappers.clean();
+        wrappers.forEach((item) => {
+            if (typeof item === 'string') {
+                const defaultActions = wrapperConfig[item]?.actions ?? [];
+                const define = observableSignal({
+                    type: item,
+                    inputs: asyncObjectSignal({}),
+                    outputs: asyncObjectSignal({}),
+                    attributes: asyncObjectSignal({}),
+                    events: asyncObjectSignal({}),
+                }, OptionDefine);
+                rawField.wrappers.add(define);
+                defaultActions.forEach((item) => {
+                    item.value(rawField, _, {
+                        [CustomDataSymbol]: define,
+                    });
+                });
+            }
+            else {
+                rawField.wrappers.add(observableSignal({
+                    type: item.type,
+                    inputs: asyncObjectSignal(item.inputs ?? {}),
+                    outputs: asyncObjectSignal(item.outputs ?? {}),
+                    attributes: asyncObjectSignal(item.attributes ?? {}),
+                    events: asyncObjectSignal(item.events ?? {}),
+                }, OptionDefine));
+            }
+        });
+    });
+}
+function removeWrappers(removeList) {
+    return rawConfig((field) => {
+        mergeHooksFn({
+            allFieldsResolved: (field) => {
+                let list;
+                if (typeof removeList === 'function') {
+                    list = removeList(field.wrappers.items());
+                }
+                else {
+                    list = field.wrappers.items().filter((item) => {
+                        const type = item.input().type;
+                        return removeList.every((name) => name !== type);
+                    });
+                }
+                field.wrappers.update(() => list);
+            },
+        }, { position: 'bottom' }, field);
+    });
+}
+function patchAsyncWrapper(type, actions, options) {
+    return rawConfig((rawFiled) => {
+        // 在这里增加要处理的wrapper类型
+        mergeHooksFn({
+            allFieldsResolved: (field) => {
+                const findConfig = field.injector.get(FindConfigToken);
+                const initData = observableSignal({
+                    type,
+                    attributes: asyncObjectSignal({}),
+                    events: asyncObjectSignal({}),
+                    inputs: asyncObjectSignal({}),
+                    outputs: asyncObjectSignal({}),
+                }, {
+                    pipe: pipe(map((item) => {
+                        const defaultWrapperConfig = findConfig.findWrapperComponent(item.type);
+                        return { ...item, type: defaultWrapperConfig };
+                    })),
+                    injector: field.injector,
+                });
+                field.wrappers.add(initData, options?.insertIndex);
+                const defaultConfig = field.injector.get(PI_VIEW_CONFIG_TOKEN);
+                let defaultActions = [];
+                if (typeof type === 'string') {
+                    defaultActions = defaultConfig.wrappers?.[type]?.actions ?? [];
+                }
+                const allActions = [...defaultActions, ...(actions ?? [])];
+                for (const item of allActions) {
+                    const tempField = {};
+                    item.value(tempField, undefined, {
+                        [CustomDataSymbol]: initData,
+                    });
+                    tempField.hooks?.allFieldsResolved?.(field);
+                }
+            },
+        }, { position: 'bottom' }, rawFiled);
+    });
+}
+function changeAsyncWrapper(indexFn, actions) {
+    return rawConfig((rawFiled) => {
+        mergeHooksFn({
+            allFieldsResolved: (field) => {
+                const initData = indexFn(field.wrappers
+                    .items()
+                    .map((item) => item.input));
+                if (!initData) {
+                    throw new Error(`change wrapper not found`);
+                }
+                for (const item of actions) {
+                    const tempField = {};
+                    item.value(tempField, undefined, {
+                        [CustomDataSymbol]: initData,
+                    });
+                    tempField.hooks?.allFieldsResolved?.(field);
+                }
+            },
+        }, { position: 'bottom' }, rawFiled);
+    });
+}
+const wrappers = {
+    set: setWrappers,
+    patchAsync: patchAsyncWrapper,
+    remove: removeWrappers,
+    changeAsync: changeAsyncWrapper,
+};
+
 /** 必须防止到所有wrappers操作后面,防止设置错误
  * 设置到顶层,可能是wrapper,也可能是component
  *
@@ -2174,7 +2232,7 @@ function disableWhen(options) {
 function topClass(className, merge) {
     return rawConfig((rawField) => {
         mergeHooksFn({
-            fieldResolved: (field) => {
+            allFieldsResolved: (field) => {
                 const wrappers = field.wrappers();
                 if (wrappers?.length) {
                     wrappers[0].attributes.update((attributes) => ({
@@ -2197,35 +2255,63 @@ function topClass(className, merge) {
     });
 }
 /** 仅设置在组件上 */
-function componentClass(className, merge) {
-    return rawConfig((field) => {
-        field.attributes = {
-            ...field.attributes,
-            class: merge
-                ? clsx(field.attributes?.['class'], className)
-                : clsx(className),
-        };
-    });
-}
+const componentClass = (className, merge) => rawConfig((rawField, _, ...args) => {
+    let data$;
+    if (args.length > 0 &&
+        typeof args[args.length - 1] === 'object' &&
+        CustomDataSymbol in args[args.length - 1]) {
+        data$ = args[args.length - 1][CustomDataSymbol];
+    }
+    else {
+        data$ = (() => rawField);
+    }
+    const content$ = data$()['attributes'];
+    content$.update((data) => ({
+        ...data,
+        class: merge ? clsx(data?.['class'], className) : clsx(className),
+    }));
+});
 const bottomClass = componentClass;
 function patchAsyncClass(fn) {
-    return patchAsyncAttributes({ class: fn });
+    return __actions.attributes.patchAsync({ class: fn });
 }
-
-function nonFieldControl(value = true) {
-    return {
-        kind: 'metadata',
-        type: 'nonFieldControl',
-        reference: nonFieldControl,
-        value: value,
-    };
+function asyncTopClass(classNameFn) {
+    return rawConfig((rawField) => {
+        mergeHooksFn({
+            allFieldsResolved: (field) => {
+                const wrappers = field.wrappers();
+                if (wrappers?.length) {
+                    wrappers[0].attributes.connect('class', classNameFn(field));
+                }
+                else {
+                    field.attributes.connect('class', classNameFn(field));
+                }
+            },
+        }, { position: 'bottom' }, rawField);
+    });
 }
+const classAction = {
+    top: topClass,
+    bottom: bottomClass,
+    component: componentClass,
+    asyncTop: asyncTopClass,
+    asyncBottom: patchAsyncClass,
+    asyncComponent: patchAsyncClass,
+};
+
+const actions = {
+    ...__actions,
+    class: classAction,
+    wrappers,
+};
 
 class CoreSchemaHandle extends BaseSchemaHandle {
-    inputs;
-    outputs;
-    wrappers;
-    attributes;
+    inputs = asyncObjectSignal({});
+    outputs = asyncObjectSignal({});
+    attributes = asyncObjectSignal({});
+    events = asyncObjectSignal({});
+    wrappers = combineSignal([]);
+    props = asyncObjectSignal({});
     alias;
     movePath;
     renderConfig;
@@ -2311,8 +2397,16 @@ class CoreSchemaHandle extends BaseSchemaHandle {
         this.formConfig.groupMode = 'reset';
     }
     enumSchema(schema) {
-        this.props ??= {};
-        this.props['options'] ??= schema.options;
+        this.props.update((data) => ({
+            ...data,
+            options: data['options'] ?? schema.options,
+        }));
+    }
+    updateProps(key, value) {
+        this.props.update((data) => ({
+            ...data,
+            [key]: value,
+        }));
     }
     intersectBefore(schema) {
         if (this.childrenAsVirtualGroup) {
@@ -2414,8 +2508,12 @@ function convert(obj, options) {
     }, {
         ...options,
         handle: options?.handle ?? CoreSchemaHandle,
+        additionalData: {
+            defaultWrapperMetadataGroup: options.fieldGlobalConfig?.wrappers,
+            injector,
+        },
         defaultMetadataActionsGroup: Object.keys(options.fieldGlobalConfig?.types ?? {}).reduce((obj, item) => {
-            let { actions } = options.fieldGlobalConfig.types[item];
+            const { actions } = options.fieldGlobalConfig.types[item];
             if (actions) {
                 obj[item] = actions;
             }
@@ -2431,5 +2529,5 @@ const NFCSchema = v.optional(v.void());
  * Generated bundle index. Do not edit.
  */
 
-export { AbstractControl, CoreSchemaHandle, FieldArray, FieldControl, FieldGroup, FieldLogicGroup, FormBuilder, INVALID, NFCSchema, PENDING, PI_CONTEXT_TOKEN, PI_FORM_BUILDER_ALIAS_MAP, PI_FORM_BUILDER_OPTIONS_TOKEN, PI_VIEW_CONFIG_TOKEN, SortedArray, UpdateType, VALID, arrayStartsWith, asyncInputMerge, bottomClass, clone, componentClass, controlStatusList, convert, createViewControlLink, disableWhen, effectListen, fieldControlStatusClass, findComponent, formConfig, getDeepError, getLazyImport, hideWhen, initListen, isArray, isFieldArray, isFieldControl, isFieldGroup, isFieldLogicGroup, isGroup, isLazyMark, layout, lazyMark, mergeHooks, mergeHooksFn, mergeOutputFn, mergeOutputs, nonFieldControl, outputChange, outputChangeFn, patchAsyncAttributes, patchAsyncClass, patchAsyncFn, patchAsyncInputs, patchAsyncProps, patchAsyncWrapper, patchAttributes, patchHooks, patchInputs, patchOutputs, patchProps, patchWrappers, rawConfig, removeAttributes, removeHooks, removeInputs, removeOutputs, removeProps, removeWrappers, renderConfig, setAlias, setAttributes, setComponent, setHooks, setInputs, setOutputs, setProps, setWrappers, toArray, toObservable, topClass, unWrapSignal, valueChange, valueChangeFn };
+export { AbstractControl, CoreSchemaHandle, CustomDataSymbol, FieldArray, FieldControl, FieldGroup, FieldLogicGroup, FormBuilder, INVALID, NFCSchema, PENDING, PI_CONTEXT_TOKEN, PI_FORM_BUILDER_ALIAS_MAP, PI_FORM_BUILDER_OPTIONS_TOKEN, PI_VIEW_CONFIG_TOKEN, SortedArray, UpdateType, VALID, actions, arrayStartsWith, asyncMergeOutputs, asyncObjectSignal, clone, combineSignal, controlStatusList, convert, createViewControlLink, disableWhen, effectListen, fieldControlStatusClass, findComponent, formConfig, getDeepError, getLazyImport, hideWhen, initListen, isArray, isFieldArray, isFieldControl, isFieldGroup, isFieldLogicGroup, isGroup, isLazyMark, layout, lazyMark, mergeHooks, mergeHooksFn, mergeOutputFn, mergeOutputs, nonFieldControl, observableSignal, outputChange, outputChangeFn, patchHooks, rawConfig, removeHooks, renderConfig, setAlias, setComponent, setHooks, toArray, toObservable, valueChange, valueChangeFn, classAction as ɵclassAction, wrappers as ɵwrappers };
 //# sourceMappingURL=piying-view-angular-core.mjs.map