@neeloong/form 0.28.0 → 0.30.0

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
-* @neeloong/form v0.28.0
+* @neeloong/form v0.30.0
 * (c) 2024-2026 Fierflame
 * @license Apache-2.0
 */
@@ -138,7 +138,7 @@ function createRef(store) {
 
 
 /** @type {{new(...p: ConstructorParameters<typeof Store>): Store}?} */
-let ObjectStore$2 = null;
+let ObjectStore$1 = null;
 /** @type {{new(...p: ConstructorParameters<typeof Store>): ArrayStore}?} */
 let ArrayStoreClass = null;
 /** @type {Record<string, {new(...p: ConstructorParameters<typeof Store>): Store}?>} */
@@ -163,14 +163,14 @@ function create(schema, options) {
 		const C = TypeStores[type];
 		if (C) { Class = C; }
 	} else if (type && typeof type === 'object') {
-		if (ObjectStore$2) { Class = ObjectStore$2; }
+		if (ObjectStore$1) { Class = ObjectStore$1; }
 	}
 	return new Class(schema, options);
 }
 
 /** @param {{new(...p: ConstructorParameters<typeof Store>): Store}} Class */
 function setObjectStore(Class) {
-	ObjectStore$2 = Class;
+	ObjectStore$1 = Class;
 }
 
 /** @param {{new(...p: ConstructorParameters<typeof Store>): ArrayStore}} Class */
@@ -201,79 +201,127 @@ function toResult(v) {
 /**
  * 
  * @param {Store} store 
- * @param  {...Schema.Validator | undefined | null | (Schema.Validator | undefined | null)[]} validators 
+ * @param {Schema.SyncValidator[]} syncValidators 
  * @returns 
  */
-function createValidator(store, ...validators) {
-	const allValidators = validators.flat().filter(v => typeof v === 'function');
-	if (!allValidators.length) {
-		return new Signal.Computed(() => /** @type {string[]} */([]));
-	}
+function createSyncValidator(store, syncValidators) {
 	return new Signal.Computed(() => {
 		const results = [];
-		for (const validator of allValidators) {
+		for (const item of syncValidators) {
 			try {
-				results.push(validator(store));
-			} catch (e){
+				results.push(item(store));
+			} catch (e) {
 				results.push(e);
 			}
 		}
 		return results.flat().map(toResult).filter(Boolean);
-	})
+	});
 }
+
 /**
  * 
  * @param {Store} store 
- * @param  {...Schema.AsyncValidator | undefined | null | (Schema.AsyncValidator | undefined | null)[]} validators 
- * @returns {[exec: () => Promise<string[]>, state: Signal.Computed<string[]>, stop: () => void]}
+ * @param {Map<string, Schema.AsyncValidator[]>} eventsValidators 
+ * @returns {[Record<string, () => Promise<string[]>>, results: Signal.State<string[]>[], stop: () => void]}
  */
-function createAsyncValidator(store, ...validators) {
-	const allValidators = validators.flat().filter(v => typeof v === 'function');
-	if (!allValidators.length) {
-		return [
-			()=>Promise.resolve([]),
-			new Signal.Computed(() => /** @type {string[]} */([])),
-			() => {}
-		];
-	}
-	const st = new Signal.State(/** @type {string[]} */([]));
-	/**
-	 * 
-	 * @param {Schema.AsyncValidator} validator 
-	 * @param {AbortSignal} signal 
-	 */
-	async function run(validator, signal) {
-		let results = [];
-		try {
-			results.push(await validator(store, signal));
-		} catch (e){
-			results.push(e);
+function createEventsValidator(store, eventsValidators) {
+	/** @type {Record<string, () => Promise<string[]>>} */
+	const eventExecMap = {};
+	/** @type {(() => void)[]} */
+	const allCancels = [];
+	/** @type {Signal.State<string[]>[]} */
+	const results = [];
+	for (const [name, validators] of eventsValidators) {
+		const st = new Signal.State(/** @type {string[]} */([]));
+		/**
+		 * 
+		 * @param {Schema.AsyncValidator} validator 
+		 * @param {AbortSignal} signal 
+		 */
+		async function run(validator, signal) {
+			let results = [];
+			try {
+				results.push(await validator(store, signal));
+			} catch (e) {
+				results.push(e);
+			}
+			const list = results.flat().map(toResult).filter(Boolean);
+			if (!signal.aborted && list.length) { st.set([...st.get(), ...list]); }
+			return list;
+		}
+		/** @type {AbortController?} */
+		let ac = null;
+		function exec() {
+			ac?.abort();
+			ac = new AbortController();
+			const signal = ac.signal;
+			st.set([]);
+
+			return Promise.all(validators.map(f => run(f, signal))).then(v => v.flat());
 		}
-		const list = results.flat().map(toResult).filter(Boolean);
-		if (!signal.aborted && list.length) { st.set([...st.get(), ...list]); }
-		return list;
+		eventExecMap[name] = exec;
+		allCancels.push(() => { ac?.abort(); st.set([]); });
+		results.push(st);
 	}
-	/** @type {AbortController?} */
-	let ac = null;
-	function exec() {
-		ac?.abort();
-		ac = new AbortController();
-		const signal = ac.signal;
-		st.set([]);
-		
-		return Promise.all(allValidators.map(f => run(f, signal))).then(v => v.flat());
-	}
-	return [exec, new Signal.Computed(() => st.get()), () => {ac?.abort(); st.set([]);}]
+
+	function stop() {
+		for (const c of allCancels) {
+			c();
+		}
+
+	}
+
+	return [eventExecMap, results, stop];
 }
 
 /**
  * 
- * @param  {...Signal.Computed<string[]>} v 
- * @returns 
+ * @param {Store} store 
+ * @param  {...Schema.Validator | undefined | null | (Schema.Validator | undefined | null)[]} validators 
+ * @returns {[exec: () => Promise<string[]>, Record<string, () => Promise<string[]>>, state: Signal.Computed<string[]>, stop: () => void]}
  */
-function merge(...v) {
-	const list = /** @type {Signal.Computed<string[]>[]} */(v.filter(Boolean));
-	return new Signal.Computed(() => list.flatMap(v => v.get()));
+function createValidator(store, ...validators) {
+
+	/** @type {Schema.SyncValidator[]} */
+	const syncValidators = [];
+	/** @type {Map<string, Schema.AsyncValidator[]>} */
+	const eventsValidators = new Map();
+	for (const v of validators.flat()) {
+		if (!v) { continue; }
+		if (typeof v === 'function') {
+			syncValidators.push(v);
+			continue;
+		}
+		const { event, validator } = v;
+		if (typeof validator !== 'function') { continue; }
+		if (typeof event !== 'string') {
+			syncValidators.push(validator);
+			continue;
+		}
+		const list = eventsValidators.get(event);
+		if (list) {
+			list.push(validator);
+		} else {
+			eventsValidators.set(event, [validator]);
+		}
+	}
+
+
+	const validatorResult = syncValidators.length
+		? createSyncValidator(store, syncValidators)
+		: new Signal.Computed(() => /** @type {string[]} */([]));
+	if (!eventsValidators.size) {
+		return [() => Promise.resolve(validatorResult.get()), {}, validatorResult, () => {}];
+	}
+
+	const [eventExecMap, results, stop] = createEventsValidator(store, eventsValidators);
+
+	const errors = new Signal.Computed(() => [validatorResult, ...results].flatMap(v => v.get()));
+	const execAll = () => Promise.all([
+		validatorResult.get(),
+		...Object.values(eventExecMap).map(exec => exec()),
+	]).then(v => v.flat());
+	return [execAll, eventExecMap, errors, stop];
 }
 
 /** @import Store from './Store.mjs' */
@@ -292,52 +340,6 @@ function makeDefault(store, def) {
 	return (value) => structuredClone(def(store, value));
 }
 
-/** @import { Schema } from '../Schema.types.mjs' */
-
-/**
- * @template [T=any]
- * @template [M=any]
- * @template {Object.<string, Schema.State>} [S=Object.<string, Schema.State>]
- * @extends {Store<T, M, S>}
- */
-class BindObjectStore extends Store {
-
-	get kind() { return 'object'; }
-	/** @type {Record<string, Store>} */
-	#children = Object.create(null);
-	*[Symbol.iterator]() { yield* Object.entries(this.#children); }
-	/**
-	 * 
-	 * @param {string | number} key 
-	 * @returns {Store?}
-	 */
-	child(key) { return this.#children[key] || null; }
-	/**
-	 * @param {Schema<any, Object.<string, Schema.State>>} schema 数据结构模式
-	 * @param {Store<T, M, S>} store
-	 */
-	constructor(schema, store) {
-		super(store);
-		const children = this.#children;
-		for (const [index, field] of Object.entries(schema)) {
-			const bindStore = create(field, {
-				index, parent: this,
-				/** @param {*} value @param {*} index @param {Store} store */
-				onUpdate: (value, index, store) => {
-					if (store !== children[index]) { return; }
-					const val = this.value ?? null;
-					if (typeof val !== 'object' || Array.isArray(val)) { return; }
-					// @ts-ignore
-					this.value = { ...val, [index]: value };
-				},
-			});
-			children[index] = bindStore;
-		}
-	}
-}
-// @ts-ignore
-setObjectStore(ObjectStore);
-
 /** @import { Ref } from './ref.mjs' */
 /** @import { Schema } from '../Schema.types.mjs' */
 /** @import { StoreLayout } from '../StoreLayout.types.mjs' */
@@ -378,10 +380,25 @@ class Store {
 	/**
 	 * 监听事件
 	 * @template {keyof Schema.Events} K
+	 * @overload
 	 * @param {K} event 
 	 * @param  {(this: this, p: Schema.Events[K], store: this) => void | boolean | null} listener
 	 * @returns {() => void}
 	 */
+	/**
+	 * 监听事件
+	 * @template {keyof Schema.Events} K
+	 * @overload
+	 * @param {string} event 
+	 * @param  {(this: this, p: unknown, store: this) => void | boolean | null} listener
+	 * @returns {() => void}
+	 */
+	/**
+	 * 监听事件
+	 * @param {string} event 
+	 * @param  {(this: this, p: unknown, store: this) => void | boolean | null} listener
+	 * @returns {() => void}
+	 */
 	listen(event, listener) {
 		const originStore = this.#originStore;
 		if (originStore) { return originStore.listen(event, p => listener.call(this, p, this)); }
@@ -426,116 +443,87 @@ class Store {
 	get ref() { return this.#ref || createRef(this); }
 	/**
 	 * @param {Schema.Field<M, S> | Store<T,M,S>} schema 字段的 Schema 定义
-	 * @param {object} [options] 可选配置
-	 * @param {Store?} [options.parent] 
-	 * @param {Partial<S>?} [options.states] 
-	 * @param {((store: Store, value?: any) => any) | object | number | string | boolean | null | undefined} [options.default]
-	 * @param {number | string | null} [options.index] 
-	 * @param {number | Signal.State<number> | Signal.Computed<number>} [options.size] 
-	 * @param {boolean} [options.null] 
-	 * @param {boolean} [options.new] 
-	 * @param {boolean} [options.hidden] 
-	 * @param {boolean} [options.clearable] 
-	 * @param {boolean} [options.required] 
-	 * @param {boolean} [options.disabled] 
-	 * @param {boolean} [options.readonly] 
-	 * @param {boolean} [options.removable] 
-	 * 
-	 * @param {string} [options.label] 字段标签
-	 * @param {string} [options.description] 字段描述
-	 * @param {string} [options.placeholder] 占位符
-	 * @param {number} [options.min] 日期、时间、数字的最小值
-	 * @param {number} [options.max] 日期、时间、数字的最大值
-	 * @param {number} [options.step] 日期、时间、数字的步长
-	 * @param {number} [options.minLength] 
-	 * @param {number} [options.maxLength] 
-	 * @param {RegExp} [options.pattern] 
-	 * @param {(Schema.Value.Group | Schema.Value | string | number)[]} [options.values] 可选值
-	 * @param {Schema.Validator | Schema.Validator[] | null} [options.validator]
-	 * @param {{[k in keyof Schema.Events]?: Schema.AsyncValidator | Schema.AsyncValidator[] | null}} [options.validators]
-	 * 
-	 * @param {Ref?} [options.ref]
-	 * 
-	 * @param {((value: any) => any)?} [options.setValue] 
-	 * @param {((value: any) => any)?} [options.convert] 
-	 * 
-	 * @param {((value: T?, index: any, store: Store) => void)?} [options.onUpdate] 
+	 * @param {StoreOptions | AbortSignal | null} [options] 可选配置
 	 */
-	constructor(schema, {
-		null: isNull, ref, default: defaultValue,
-		setValue, convert, onUpdate, states,
-		validator, validators,
-		index, size, new: isNew, parent: parentNode,
-		hidden, clearable, required, disabled, readonly, removable,
-		label, description, placeholder, min, max, step, minLength, maxLength, pattern, values: values$1
-	} = {}) {
+	constructor(schema, options) {
 		if (schema instanceof Store) {
-			this.#originStore = schema;
-			this.#schema = schema.#schema;
-			this.#null = schema.#null;
-			this.#ref = schema.#ref;
-			this.#states = schema.#states;
-			this.#layout = schema.#layout;
-			this.#createDefault = schema.#createDefault;
-			this.#setValue = schema.#setValue;
-			this.#convert = schema.#convert;
-			this.#onUpdate = schema.#onUpdate;
-			this.#parent = schema.#parent;
-			this.#root = schema.#root;
-			this.#type = schema.#type;
-			this.#meta = schema.#meta;
-			this.#component = schema.#component;
-			this.#selfLoading = schema.#selfLoading;
-			this.#loading = schema.#loading;
-			this.#size = schema.#size;
-			this.#index = schema.#index;
-			this.#creatable = schema.#creatable;
-			this.#immutable = schema.#immutable;
-			this.#new = schema.#new;
-			this.#selfNew = schema.#selfNew;
-			this.#selfHidden = schema.#selfHidden;
-			this.#hidden = schema.#hidden;
-			this.#selfClearable = schema.#selfClearable;
-			this.#clearable = schema.#clearable;
-			this.#selfRequired = schema.#selfRequired;
-			this.#required = schema.#required;
-			this.#selfDisabled = schema.#selfDisabled;
-			this.#disabled = schema.#disabled;
-			this.#selfReadonly = schema.#selfReadonly;
-			this.#readonly = schema.#readonly;
-			this.#selfRemovable = schema.#selfRemovable;
-			this.#removable = schema.#removable;
-			this.#selfLabel = schema.#selfLabel;
-			this.#label = schema.#label;
-			this.#selfDescription = schema.#selfDescription;
-			this.#description = schema.#description;
-			this.#selfPlaceholder = schema.#selfPlaceholder;
-			this.#placeholder = schema.#placeholder;
-			this.#selfMin = schema.#selfMin;
-			this.#min = schema.#min;
-			this.#selfMax = schema.#selfMax;
-			this.#max = schema.#max;
-			this.#selfStep = schema.#selfStep;
-			this.#step = schema.#step;
-			this.#selfMinLength = schema.#selfMinLength;
-			this.#minLength = schema.#minLength;
-			this.#selfMaxLength = schema.#selfMaxLength;
-			this.#maxLength = schema.#maxLength;
-			this.#selfPattern = schema.#selfPattern;
-			this.#pattern = schema.#pattern;
-			this.#selfValues = schema.#selfValues;
-			this.#values = schema.#values;
-			this.#errors = schema.#errors;
-			this.#validatorResult = schema.#validatorResult;
-			this.#changed = schema.#changed;
-			this.#blurred = schema.#blurred;
-			this.#cancelChange = schema.#cancelChange;
-			this.#cancelBlur = schema.#cancelBlur;
-			this.#set = schema.#set;
-			this.#initValue = schema.#initValue;
-			this.#value = schema.#value;
+			const store = schema.#originStore || schema;
+			this.#originStore = store;
+			this.#schema = store.#schema;
+			this.#null = store.#null;
+			this.#ref = store.#ref;
+			this.#states = store.#states;
+			this.#layout = store.#layout;
+			this.#createDefault = store.#createDefault;
+			this.#setValue = store.#setValue;
+			this.#convert = store.#convert;
+			this.#onUpdate = store.#onUpdate;
+			this.#parent = store.#parent;
+			this.#root = store.#root;
+			this.#type = store.#type;
+			this.#meta = store.#meta;
+			this.#component = store.#component;
+			this.#selfLoading = store.#selfLoading;
+			this.#loading = store.#loading;
+			this.#size = store.#size;
+			this.#index = store.#index;
+			this.#creatable = store.#creatable;
+			this.#immutable = store.#immutable;
+			this.#new = store.#new;
+			this.#selfNew = store.#selfNew;
+			this.#selfHidden = store.#selfHidden;
+			this.#hidden = store.#hidden;
+			this.#selfClearable = store.#selfClearable;
+			this.#clearable = store.#clearable;
+			this.#selfRequired = store.#selfRequired;
+			this.#required = store.#required;
+			this.#selfDisabled = store.#selfDisabled;
+			this.#disabled = store.#disabled;
+			this.#selfReadonly = store.#selfReadonly;
+			this.#readonly = store.#readonly;
+			this.#selfRemovable = store.#selfRemovable;
+			this.#removable = store.#removable;
+			this.#selfLabel = store.#selfLabel;
+			this.#label = store.#label;
+			this.#selfDescription = store.#selfDescription;
+			this.#description = store.#description;
+			this.#selfPlaceholder = store.#selfPlaceholder;
+			this.#placeholder = store.#placeholder;
+			this.#selfMin = store.#selfMin;
+			this.#min = store.#min;
+			this.#selfMax = store.#selfMax;
+			this.#max = store.#max;
+			this.#selfStep = store.#selfStep;
+			this.#step = store.#step;
+			this.#selfMinLength = store.#selfMinLength;
+			this.#minLength = store.#minLength;
+			this.#selfMaxLength = store.#selfMaxLength;
+			this.#maxLength = store.#maxLength;
+			this.#selfPattern = store.#selfPattern;
+			this.#pattern = store.#pattern;
+			this.#selfValues = store.#selfValues;
+			this.#values = store.#values;
+			this.#errors = store.#errors;
+			this.#execValidators = store.#execValidators;
+			this.#cancelEventValidator = store.#cancelEventValidator;
+			this.#set = store.#set;
+			this.#initValue = store.#initValue;
+			this.#value = store.#value;
+			const signal = options instanceof AbortSignal ? options : null;
+			if (signal?.aborted) { return; }
+			const subBindStores = store.#subBindStores;
+			subBindStores.add(this);
+			signal?.addEventListener('abort', () => subBindStores.delete(this));
+			store.#requestUpdate();
 			return;
 		}
+		const {
+			null: isNull, ref, default: defaultValue,
+			setValue, convert, onUpdate, states, validator,
+			index, size, new: isNew, parent: parentNode,
+			hidden, clearable, required, disabled, readonly, removable,
+			label, description, placeholder, min, max, step, minLength, maxLength, pattern, values: values$1
+		} = !(options instanceof AbortSignal) && options || {};
 		this.#schema = schema;
 		const parent = parentNode instanceof Store ? parentNode : null;
 		if (parent) {
@@ -606,9 +594,6 @@ class Store {
 
 		[this.#selfRemovable, this.#removable] = createBooleanStates(this, removable, schema.removable ?? true);
 
-		const validatorResult = createValidator(this, schema.validator, validator);
-
-
 		const schemaStates = schema.states;
 		this.#states = schemaStates ? Object.defineProperties(Object.create(null),
 			Object.fromEntries(
@@ -624,16 +609,13 @@ class Store {
 				})
 			)) : null;
 
-		const [changed, changedResult, cancelChange] = createAsyncValidator(this, schema.validators?.change, validators?.change);
-		const [blurred, blurredResult, cancelBlur] = createAsyncValidator(this, schema.validators?.blur, validators?.blur);
-		this.listen('change', () => { changed(); });
-		this.listen('blur', () => { blurred(); });
-		this.#errors = merge(validatorResult, changedResult, blurredResult);
-		this.#validatorResult = validatorResult;
-		this.#changed = changed;
-		this.#blurred = blurred;
-		this.#cancelChange = cancelChange;
-		this.#cancelBlur = cancelBlur;
+		const [execValidators, eventExecMap, errors, cancelEventValidator] = createValidator(this, schema.validator, validator);
+		for (const [name, exec] of Object.entries(eventExecMap)) {
+			this.listen(name, () => { exec(); });
+		}
+		this.#errors = errors;
+		this.#execValidators = execValidators;
+		this.#cancelEventValidator = cancelEventValidator;
 
 		if (size instanceof Signal.State || size instanceof Signal.Computed) {
 			this.#size = size;
@@ -918,16 +900,10 @@ class Store {
 
 	/** @type {Signal.Computed<string[]>} */
 	#errors;
-	/** @type {Signal.Computed<string[]>} */
-	#validatorResult;
-	/** @type {() => Promise<string[]>} */
-	#changed;
 	/** @type {() => Promise<string[]>} */
-	#blurred;
+	#execValidators;
 	/** @type {() => void} */
-	#cancelChange;
-	/** @type {() => void} */
-	#cancelBlur;
+	#cancelEventValidator;
 	/** 所有校验错误列表 */
 	get errors() { return this.#errors.get(); }
 	/** 字段校验错误信息 */
@@ -948,24 +924,6 @@ class Store {
 
 	/** @type {Set<Store>} */
 	#subBindStores = new Set();
-	/**
-	 * @template [M=any]
-	 * @template {Object.<string, Schema.State>} [S=Object.<string, Schema.State>]
-	 * @param {Schema<M, S>} schema 数据结构模式
-	 * @param {AbortSignal} [signal]
-	 * @returns {BindObjectStore}
-	 */
-	bindObject(schema, signal) {
-		const originStore = this.#originStore;
-		if (originStore) { return originStore.bindObject(schema, signal); }
-		const store = new BindObjectStore(schema, this);
-		if (signal?.aborted) { return store; }
-		const subBindStores = this.#subBindStores;
-		subBindStores.add(store);
-		signal?.addEventListener('abort', () => subBindStores.delete(store));
-		this.#requestUpdate();
-		return store;
-	}
 
 	/** 内容是否已改变 */
 	get changed() { return !Object.is(this.#value.get(), this.#initValue.get()); }
@@ -1009,8 +967,7 @@ class Store {
 		this.#selfNew.set(isNew);
 		const newValue = this.#setValue?.(v);
 		const value = newValue === undefined ? v : newValue;
-		this.#cancelChange();
-		this.#cancelBlur();
+		this.#cancelEventValidator();
 		this.#set = true;
 		if (!value || typeof value !== 'object') {
 			for (const bind of [this, ...this.#subBindStores]) {
@@ -1062,7 +1019,7 @@ class Store {
 			// @ts-ignore
 			let newValues = Array.isArray(val) ? [...val] : { ...val };
 			let updated = false;
-			for (const bind of [this,...this.#subBindStores]) {
+			for (const bind of [this, ...this.#subBindStores]) {
 				for (const [key, field] of bind) {
 					// @ts-ignore
 					const data = Object.hasOwn(val, key) ? val[key] : undefined;
@@ -1106,11 +1063,7 @@ class Store {
 	validate(path) {
 		if (path === true) {
 			if (this.#originStore) { return Promise.resolve(null); }
-			return Promise.all([this.#validatorResult.get(), this.#changed(), this.#blurred()])
-				.then(v => {
-					const errors = v.flat();
-					return errors.length ? errors : null;
-				});
+			return this.#execValidators().then(errors => errors.length ? errors : null);
 		}
 		const selfPath = Array.isArray(path) ? path : [];
 		if (!this.#originStore && this.#hidden.get()) { return Promise.resolve([]); }
@@ -1128,6 +1081,45 @@ class Store {
 	}
 }
 
+/**
+ * @template [T=any]
+ * @template [M=any]
+ * @template {Object.<string, Schema.State>} [S=Object.<string, Schema.State>]
+ * @typedef {object} StoreOptions
+ * @property {Store?} [parent] 
+ * @property {Partial<S>?} [states] 
+ * @property {((store: Store, value?: any) => any) | object | number | string | boolean | null | undefined} [default]
+ * @property {number | string | null} [index] 
+ * @property {number | Signal.State<number> | Signal.Computed<number>} [size] 
+ * @property {boolean} [null] 
+ * @property {boolean} [new] 
+ * @property {boolean} [hidden] 
+ * @property {boolean} [clearable] 
+ * @property {boolean} [required] 
+ * @property {boolean} [disabled] 
+ * @property {boolean} [readonly] 
+ * @property {boolean} [removable] 
+ * 
+ * @property {string} [label] 字段标签
+ * @property {string} [description] 字段描述
+ * @property {string} [placeholder] 占位符
+ * @property {number} [min] 日期、时间、数字的最小值
+ * @property {number} [max] 日期、时间、数字的最大值
+ * @property {number} [step] 日期、时间、数字的步长
+ * @property {number} [minLength] 
+ * @property {number} [maxLength] 
+ * @property {RegExp} [pattern] 
+ * @property {(Schema.Value.Group | Schema.Value | string | number)[]} [values] 可选值
+ * @property {Schema.Validator | Schema.Validator[] | null} [validator]
+ * 
+ * @property {Ref?} [ref]
+ * 
+ * @property {((value: any) => any)?} [setValue] 
+ * @property {((value: any) => any)?} [convert] 
+ * 
+ * @property {((value: T?, index: any, store: Store) => void)?} [onUpdate] 
+ */
+
 /** @import { Schema } from '../Schema.types.mjs' */
 
 /**
@@ -1136,7 +1128,7 @@ class Store {
  * @template {Object.<string, Schema.State>} [S=Object.<string, Schema.State>]
  * @extends {Store<T, M, S>}
  */
-let ObjectStore$1 = class ObjectStore extends Store {
+class ObjectStore extends Store {
 	get kind() { return 'object'; }
 	/** @type {Record<string, Store>} */
 	#children;
@@ -1189,9 +1181,9 @@ let ObjectStore$1 = class ObjectStore extends Store {
 		}
 		this.#children = children;
 	}
-};
+}
 // @ts-ignore
-setObjectStore(ObjectStore$1);
+setObjectStore(ObjectStore);
 
 /** @import { Schema } from '../Schema.types.mjs' */
 
@@ -1433,6 +1425,51 @@ class ArrayStore extends Store {
 // @ts-ignore
 setArrayStore(ArrayStore);
 
+/** @import { Schema } from '../Schema.types.mjs' */
+
+/**
+ * @template [T=any]
+ * @template [M=any]
+ * @template {Object.<string, Schema.State>} [S=Object.<string, Schema.State>]
+ * @extends {Store<T, M, S>}
+ */
+class BindObjectStore extends Store {
+
+	get kind() { return 'object'; }
+	/** @type {Record<string, Store>} */
+	#children = Object.create(null);
+	*[Symbol.iterator]() { yield* Object.entries(this.#children); }
+	/**
+	 * 
+	 * @param {string | number} key 
+	 * @returns {Store?}
+	 */
+	child(key) { return this.#children[key] || null; }
+	/**
+	 * @param {Schema<any, Object.<string, Schema.State>>} schema 数据结构模式
+	 * @param {Store<T, M, S>} store
+	 * @param {AbortSignal} [signal]
+	 */
+	constructor(schema, store, signal) {
+		super(store, signal);
+		const children = this.#children;
+		for (const [index, field] of Object.entries(schema)) {
+			const bindStore = create(field, {
+				index, parent: this,
+				/** @param {*} value @param {*} index @param {Store} store */
+				onUpdate: (value, index, store) => {
+					if (store !== children[index]) { return; }
+					const val = this.value ?? null;
+					if (typeof val !== 'object' || Array.isArray(val)) { return; }
+					// @ts-ignore
+					this.value = { ...val, [index]: value };
+				},
+			});
+			children[index] = bindStore;
+		}
+	}
+}
+
 /** @import * as Layout from './index.mjs' */
 
 /** @import { OldNode } from './createElement.mjs' */
@@ -4861,7 +4898,7 @@ function renderChild(layout, parent, next, parentEnv, parentTemplates, component
 		if (list instanceof ArrayStore) {
 			return renderArray(parent, next, list, env, r, layout.sort);
 		}
-		if (list instanceof ObjectStore$1) {
+		if (list instanceof ObjectStore) {
 			return renderObject(parent, next, list, env, r, layout.sort);
 		}
 		if (typeof list === 'function') {
@@ -6593,4 +6630,4 @@ function renderStore(store, fieldRenderer, root, layout, options) {
 	}, { once: true });
 }
 
-export { ArrayStore, index as Layout, ObjectStore$1 as ObjectStore, Store, effect, render, renderStore, watch };
+export { ArrayStore, BindObjectStore, index as Layout, ObjectStore, Store, effect, render, renderStore, watch };