@neeloong/form 0.6.2 → 0.7.0

package/index.js

@@ -1,5 +1,5 @@
 /*!
-* @neeloong/form v0.6.2
+* @neeloong/form v0.7.0
 * (c) 2024-2025 Fierflame
 * @license Apache-2.0
 */
@@ -688,7 +688,85 @@
 
   }
 
+  const ref = Symbol();
+  /** @import Store from './index.mjs' */
+  /** @typedef {{ [ref]: Store; [k: string]: Ref | undefined;}} Ref */
+
+  /**
+   * @param {Store} store
+   */
+  function createRef(store) {
+
+  	/** @type{Ref} */
+  	const r = { [ref]: store };
+  	for (const [k, f] of store) {
+  		Object.defineProperty(r, k, {
+  			get() { return f.ref; },
+  			configurable: false,
+  			enumerable: true,
+  		});
+  	}
+  	Object.defineProperty(r, ref, {
+  		get() { return store; },
+  		configurable: false,
+  		enumerable: true,
+  	});
+  	return r;
+  }
+
   /** @import { Schema } from '../types.mjs' */
+
+
+  /** @type {{new(...p: ConstructorParameters<typeof Store>): Store}?} */
+  let ObjectStore$1 = null;
+  /** @type {{new(...p: ConstructorParameters<typeof Store>): Store}?} */
+  let ArrayStore$1 = null;
+  /** @type {Record<string, {new(...p: ConstructorParameters<typeof Store>): Store}?>} */
+  let TypeStores = Object.create(null);
+  /**
+   * @param {Schema.Field} schema
+   * @param {object} [options] 
+   * @param {Store?} [options.parent]
+   * @param {string | number | null} [options.index] 
+   * @param {boolean} [options.new] 
+   * @param {(value: any, index: any, store: Store) => void} [options.onUpdate] 
+   * @param {(value: any, index: any, store: Store) => void} [options.onUpdateState] 
+   */
+  function create(schema, options) {
+  	const type = schema.type;
+  	/** @type {{new(...p: ConstructorParameters<typeof Store>): Store}} */
+  	let Class = Store;
+  	if (schema.array && !(ArrayStore$1 && options?.parent instanceof ArrayStore$1)) {
+  		if (ArrayStore$1) { Class = ArrayStore$1; }
+  	} else if (typeof type === 'string') {
+  		const C = TypeStores[type];
+  		if (C) { Class = C; }
+  	} else if (type && typeof type === 'object') {
+  		if (ObjectStore$1) { Class = ObjectStore$1; }
+  	}
+  	return new Class(schema, options);
+  }
+
+  /** @param {{new(...p: ConstructorParameters<typeof Store>): Store}} Class */
+  function setObjectStore(Class) {
+  	ObjectStore$1 = Class;
+  }
+
+  /** @param {{new(...p: ConstructorParameters<typeof Store>): Store}} Class */
+  function setArrayStore(Class) {
+  	ArrayStore$1 = Class;
+  }
+  /**
+   * @param {string} type
+   * @param {{new(...p: ConstructorParameters<typeof Store>): Store}} Class
+   */
+  function setStore$1(type, Class) {
+  	TypeStores[type] = Class;
+  }
+
+  /** @import { Ref } from './ref.mjs' */
+  /** @import { Schema } from '../types.mjs' */
+
   /**
    * @template [T=any]
    */
@@ -736,14 +814,24 @@
   	 * @param {boolean} [options.new] 
   	 */
   	static create(schema, options = {}) {
-  		return new ObjectStore({type: schema}, { ...options, parent: null });
+  		return create({type: schema}, { ...options, parent: null });
+  	}
+  	/**
+  	 * @param {string} type
+  	 * @param {{new(...p: ConstructorParameters<typeof Store>): Store}} Class
+  	 */
+  	static setStore(type, Class) {
+  		return setStore$1(type, Class);
   	}
   	#null = false;
   	get null() { return this.#null; }
   	get kind() { return ''; }
+  	/** @type {Ref?} */
+  	#ref = null;
+  	get ref() { return this.#ref || createRef(this); }
   	/**
   	 * @param {Schema.Field} schema
-  	 * @param {object} options 
+  	 * @param {object} [options] 
   	 * @param {*} [options.parent] 
   	 * @param {*} [options.state] 
   	 * @param {number | string | null} [options.index] 
@@ -764,19 +852,22 @@
   	 * @param {number} [options.step] 日期、时间、数字的步长
   	 * @param {(Schema.Value.Group | Schema.Value | string | number)[]} [options.values] 可选值
   	 * 
+  	 * @param {Ref?} [options.ref]
+  	 * 
   	 * @param {((value: any) => any)?} [options.setValue] 
   	 * @param {((value: any) => any)?} [options.setState] 
   	 * @param {((value: any, state: any) => [value: any, state: any])?} [options.convert] 
-  	 * @param {((value: T?, index: any) => void)?} [options.onUpdate] 
-  	 * @param {((value: T?, index: any) => void)?} [options.onUpdateState] 
+  	 * 
+  	 * @param {((value: T?, index: any, store: Store) => void)?} [options.onUpdate] 
+  	 * @param {((value: T?, index: any, store: Store) => void)?} [options.onUpdateState] 
   	 */
   	constructor(schema, {
-  		null: isNull, state,
+  		null: isNull, state, ref,
   		setValue, setState, convert, onUpdate, onUpdateState,
   		index, length, new: isNew, parent: parentNode,
   		hidden, clearable, required, disabled, readonly,
   		label, description, placeholder, min, max, step, values: values$1
-  	}) {
+  	} = {}) {
   		this.schema = schema;
   		this.#state.set(typeof state === 'object' && state || {});
   		const parent = parentNode instanceof Store ? parentNode : null;
@@ -845,8 +936,10 @@
 
   		if (isNull) {
   			this.#null = true;
+  			this.#ref = createRef(this);
   			return;
   		}
+  		this.#ref = ref || null;
   		this.#onUpdate = onUpdate || null;
   		this.#onUpdateState = onUpdateState || null;
   		this.#setValue = typeof setValue === 'function' ? setValue : null;
@@ -859,19 +952,16 @@
   			// @ts-ignore
   			this.listen(k, f);
   		}
-  		
-
   	}
-  	#destroyed = false;
   	/** @type {((value: any) => any)?} */
   	#setValue = null
   	/** @type {((value: any) => any)?} */
   	#setState = null
   	/** @type {((value: any, state: any) => [value: any, state: any])?} */
   	#convert = null
-  	/** @type {((value: any, index: any) => void)?} */
+  	/** @type {((value: any, index: any, store: Store) => void)?} */
   	#onUpdate = null
-  	/** @type {((value: any, index: any) => void)?} */
+  	/** @type {((value: any, index: any, store: Store) => void)?} */
   	#onUpdateState = null
   	/** @readonly @type {Store?} */
   	#parent = null;
@@ -1032,10 +1122,6 @@
   	get values() { return this.#values.get(); }
   	set values(v) { this.#selfValues.set(values(v)); }
 
-
-
-
-
   	/** @returns {IterableIterator<[key: string | number, value: Store]>} */
   	*[Symbol.iterator]() {}
   	/**
@@ -1046,39 +1132,30 @@
   	child(key) { return null; }
 
   	#set = false;
-  	/** @type {T?} */
-  	#initValue = null;
-  	#lastValue = this.#initValue;
-  	#value = new exports.Signal.State(this.#initValue);
+  	#initValue = new exports.Signal.State(/** @type {T?} */(null));
+  	#value = new exports.Signal.State(this.#initValue.get());
 
   	
   	#state = new exports.Signal.State(/** @type {any} */(null));
-  	#lastState = this.#state.get();
-
 
-  	get changed() { return this.#value.get() === this.#lastValue; }
-  	get saved() { return this.#value.get() === this.#initValue; }
+  	get changed() { return this.#value.get() === this.#initValue.get(); }
 
   	get value() { return this.#value.get(); }
   	set value(v) {
-  		if (this.#destroyed) { return; }
   		const val = this.#setValue?.(v) || v;
   		this.#value.set(val);
   		if (!this.#set) {
-  			this.#set = true;
-  			this.#initValue = v;
+  			this.#initValue.set(val);
   		}
-  		this.#onUpdate?.(this.#value.get(), this.#index.get());
+  		this.#onUpdate?.(val, this.#index.get(), this);
   		this.#requestUpdate();
   	}
 
   	get state() { return this.#state.get(); }
   	set state(v) {
-  		if (this.#destroyed) { return; }
   		const sta = this.#setState?.(v) || v;
   		this.#state.set(sta);
-  		this.#set = true;
-  		this.#onUpdateState?.(this.#state.get(), this.#index.get());
+  		this.#onUpdateState?.(sta, this.#index.get(), this);
   		this.#requestUpdate();
   	}
   	#requestUpdate() {
@@ -1087,9 +1164,30 @@
   		queueMicrotask(() => {
   			const oldValue = this.#value.get();
   			const oldState = this.#state.get();
-  			return this.#runUpdate(oldValue, oldState);
+  			this.#runUpdate(oldValue, oldState);
   		});
   	}
+  	reset(value = this.#initValue.get()) {
+  		this.#reset(value);
+  	}
+  	/**
+  	 * 
+  	 * @param {*} value 
+  	 * @returns 
+  	 */
+  	#reset(value) {
+  		this.#value.set(value);
+  		this.#initValue.set(value);
+  		if (!value || typeof value !== 'object') {
+  			for (const [, field] of this) {
+  				field.#reset(null);
+  			}
+  			return;
+  		}
+  		for (const [key, field] of this) {
+  			field.#reset(value[key]);
+  		}
+  	}
 
 
   	#needUpdate = false;
@@ -1100,26 +1198,21 @@
   	 * @returns 
   	 */
   	#toUpdate(value, state) {
-  		if (this.#destroyed) { return value; }
   		const [val,sta] = this.#convert?.(value, state) || [value, state];
   		if(this.#value.get() === val && this.#state.get() === sta) { return [val,sta] }
   		this.#value.set(val);
   		this.#state.set(sta);
-  		if (!this.#set) {
-  			this.#set = true;
-  			this.#initValue = val;
-  		}
   		return this.#runUpdate(val, sta);
   	}
   	/**
   	 * 
   	 * @param {*} val 
   	 * @param {*} sta 
-  	 * @returns 
+  	 * @returns {[any, any]}
   	 */
   	#runUpdate(val, sta) {
-  		if (this.#destroyed) { return [val, sta]; }
   		this.#needUpdate = false;
+  		let initValue = val;
   		if (val && typeof val === 'object') {
   			/** @type {T} */
   			// @ts-ignore
@@ -1144,34 +1237,26 @@
   			if (updated) {
   				val = newValues;
   				sta = newStates;
+  				initValue = val;
   				this.#value.set(val);
   				this.#state.set(newStates);
   			}
   		}
-  		if (this.#lastValue === val && this.#lastState === sta) {
-  			return [val, sta];
+  		if (!this.#set) {
+  			this.#set = true;
+  			this.#initValue.set(initValue);
   		}
-  		this.#lastValue = val;
-  		this.#lastState = sta;
   		return [val, sta];
-
-  	}
-
-
-
-  	get destroyed() { return this.#destroyed; }
-  	destroy() {
-  		if (this.#destroyed) { return; }
-  		this.#destroyed = true;
-  		for (const [, field] of this) {
-  			field.destroy();
-  		}
   	}
 
   }
 
+  /** @import { Schema } from '../types.mjs' */
 
-
+  /**
+   * @template {Record<string, any>} [T=Record<string, any>]
+   * @extends {Store<T>}
+   */
   class ObjectStore extends Store {
   	get kind() { return 'object'; }
   	/** @type {Record<string, Store>} */
@@ -1187,24 +1272,18 @@
   	 * @param {Schema.Object & Schema.Attr} schema
   	 * @param {object} [options] 
   	 * @param {Store?} [options.parent] 
-  	 * @param {string | number} [options.index] 
+  	 * @param {number | string | null} [options.index] 
   	 * @param {boolean} [options.new] 
-  	 * @param {(value: any, index: any) => void} [options.onUpdate] 
-  	 * @param {(value: any, index: any) => void} [options.onUpdateState] 
+  	 * @param {((value: T?, index: any, store: Store) => void)?} [options.onUpdate] 
+  	 * @param {((value: T?, index: any, store: Store) => void)?} [options.onUpdateState] 
   	 */
   	constructor(schema,{ parent, index, new: isNew, onUpdate, onUpdateState } = {}) {
   		const childrenTypes = Object.entries(schema.type);
   		super(schema, {
   			parent, index, new: isNew, onUpdate, onUpdateState,
   			length: childrenTypes.length,
-  			setValue(v) {
-  				if (typeof v !== 'object') { return {}; }
-  				return v;
-  			},
-  			setState(v) {
-  				if (typeof v !== 'object') { return {}; }
-  				return v;
-  			},
+  			setValue(v) { return typeof v === 'object' ? v : null; },
+  			setState(v) { return typeof v === 'object' ? v : null; },
   			convert(v, state) {
   				return [
   					typeof v === 'object' ? v : {},
@@ -1215,34 +1294,31 @@
   		const children = Object.create(null);
   		const childCommonOptions = {
   			parent: this,
-  			/** @param {*} value @param {*} index */
-  			onUpdate: (value, index) => {
+  			/** @param {*} value @param {*} index @param {Store} store */
+  			onUpdate: (value, index, store) => {
+  				if (store !== this.#children[index]) { return; }
+  				// @ts-ignore
   				this.value = {...this.value, [index]: value};
   			},
-  			/** @param {*} state @param {*} index */
-  			onUpdateState: (state, index) => {
+  			/** @param {*} state @param {*} index @param {Store} store */
+  			onUpdateState: (state, index, store) => {
+  				if (store !== this.#children[index]) { return; }
   				this.state = {...this.state, [index]: state};
   			}
   		};
 
   		for (const [index, field] of childrenTypes) {
-  			let child;
-  			if (typeof field.type === 'string') {
-  				if (field.array) {
-  					child = new ArrayStore(field, {...childCommonOptions, index});
-  				} else {
-  					child = new Store(field, {...childCommonOptions, index});
-  				}
-  			} else if (field.array) {
-  				child = new ArrayStore(field, {...childCommonOptions, index});
-  			} else {
-  				child = new ObjectStore(/**@type {*}*/(field), { ...childCommonOptions, index});
-  			}
-  			children[index] = child;
+  			children[index] = create(field, {...childCommonOptions, index});
   		}
   		this.#children = children;
   	}
   }
+  // @ts-ignore
+  setObjectStore(ObjectStore);
+
+  /** @import { Schema } from '../types.mjs' */
+
+
 
   /**
    * @template [T=any]
@@ -1274,23 +1350,19 @@
   	 * @param {Store?} [options.parent]
   	 * @param {string | number | null} [options.index] 
   	 * @param {boolean} [options.new] 
-  	 * @param {(value: any, index: any) => void} [options.onUpdate] 
-  	 * @param {(value: any, index: any) => void} [options.onUpdateState] 
+  	 * @param {(value: any, index: any, store: Store) => void} [options.onUpdate] 
+  	 * @param {(value: any, index: any, store: Store) => void} [options.onUpdateState] 
   	 */
-  	constructor(schema,  { parent, onUpdate, onUpdateState, index, new: isNew} = {}) {
+  	constructor(schema, { parent, onUpdate, onUpdateState, index, new: isNew} = {}) {
   		const childrenState = new exports.Signal.State(/** @type {Store[]} */([]));
   		// @ts-ignore
   		const updateChildren = (list) => {
-  			if (this.destroyed) { return; }
   			const length = Array.isArray(list) && list.length || 0;
   			const children = [...childrenState.get()];
   			const oldLength = children.length;
   			for (let i = children.length; i < length; i++) {
   					children.push(this.#create(i));
   			}
-  			for (const schema of children.splice(length)) {
-  				schema.destroy();
-  			}
   			if (oldLength !== length) {
   				childrenState.set(children);
   			}
@@ -1300,27 +1372,28 @@
   			index, new: isNew, parent,
   			length: new exports.Signal.Computed(() => childrenState.get().length),
   			state: [],
-  			setValue(v) { return Array.isArray(v) ? v : v == null ? [] : [v] },
-  			setState(v) { return Array.isArray(v) ? v : v == null ? [] : [v] },
+  			setValue(v) { return Array.isArray(v) ? v : v == null ? null : [v] },
+  			setState(v) { return Array.isArray(v) ? v : v == null ? null : [v] },
   			convert(v, state) {
-  				const val = Array.isArray(v) ? v : v == null ? [] : [v];
+  				const val = Array.isArray(v) ? v : v == null ? null : [v];
   				updateChildren(val);
   				return [
   					val,
   					(Array.isArray(state) ? state : v == null ? [] : [state]),
   				];
   			},
-  			onUpdate:(value, index) => {
+  			onUpdate:(value, index, state) => {
   				updateChildren(value);
-  				onUpdate?.(value, index);
+  				onUpdate?.(value, index, state);
   			},
   			onUpdateState,
   		});
   		this.#children = childrenState;
   		const childCommonOptions = {
   			parent: this,
-  			/** @param {*} value @param {*} index */
-  			onUpdate: (value, index) => {
+  			/** @param {*} value @param {*} index @param {Store} store */
+  			onUpdate: (value, index, store) => {
+  				if (childrenState.get()[index] !== store) { return;}
   				const val = [...this.value || []];
   				if (val.length < index) {
   					val.length = index;
@@ -1328,8 +1401,9 @@
   				val[index] = value;
   				this.value = val;
   			},
-  			/** @param {*} state @param {*} index */
-  			onUpdateState: (state, index) => {
+  			/** @param {*} state @param {*} index @param {Store} store */
+  			onUpdateState: (state, index, store) => {
+  				if (childrenState.get()[index] !== store) { return;}
   				const sta = [...this.state || []];
   				if (sta.length < index) {
   					sta.length = index;
@@ -1338,33 +1412,21 @@
   				this.state = sta;
   			},
   		};
-  		if (typeof schema.type === 'string') {
-  			this.#create = (index, isNew) =>  {
-  				const child = new Store(schema, {...childCommonOptions, index, new: isNew });
-  				child.index = index;
-  				return child
-  			};
-  		} else if (schema.type && typeof schema.type === 'object' && !Array.isArray(schema.type)) {
-  			this.#create = (index, isNew) =>  {
-  				const child = new ObjectStore(/** @type {*} */(schema), { ...childCommonOptions, index, new: isNew});
-  				child.index = index;
-  				return child
-  			};
-  		} else {
-  			throw new Error();
-  		}
-  		
+  		this.#create = (index, isNew) =>  {
+  			const child = create(schema, {...childCommonOptions, index, new: isNew });
+  			child.index = index;
+  			return child
+  		};
   	}
   	/**
   	 * 
   	 * @param {number} index 
-  	 * @param {T} value 
+  	 * @param {T?} [value] 
   	 * @param {boolean} [isNew] 
   	 * @returns 
   	 */
-  	insert(index, value, isNew) {
-  		if (this.destroyed) { return false; }
-  		const data = this.value;
+  	insert(index, value = null, isNew) {
+  		const data = this.value || [];
   		if (!Array.isArray(data)) { return false; }
   		const children = [...this.#children.get()];
   		const insertIndex = Math.max(0, Math.min(Math.floor(index), children.length));
@@ -1382,16 +1444,16 @@
   			sta.splice(insertIndex, 0, {});
   			this.state = sta;
   		}
-  		this.value = val;
   		this.#children.set(children);
+  		this.value = val;
   		return true;
   	}
   	/**
   	 * 
-  	 * @param {T} value 
+  	 * @param {T?} [value] 
   	 * @returns 
   	 */
-  	add(value) {
+  	add(value = null) {
   		return this.insert(this.#children.get().length, value);
   	}
   	/**
@@ -1400,7 +1462,6 @@
   	 * @returns 
   	 */
   	remove(index) {
-  		if (this.destroyed) { return; }
   		const data = this.value;
   		if (!Array.isArray(data)) { return; }
   		const children = [...this.#children.get()];
@@ -1410,7 +1471,6 @@
   		for (let i = index; i < children.length; i++) {
   			children[i].index = i;
   		}
-  		item.destroy();
   		const val = [...data];
   		const [value] = val.splice(removeIndex, 1);
   		const state = this.state;
@@ -1419,8 +1479,8 @@
   			sta.splice(removeIndex, 1);
   			this.state = sta;
   		}
-  		this.value = val;
   		this.#children.set(children);
+  		this.value = val;
   		return value;
 
   	}
@@ -1431,7 +1491,6 @@
   	 * @returns 
   	 */
   	move(from, to) {
-  		if (this.destroyed) { return false; }
   		const data = this.value;
   		if (!Array.isArray(data)) { return false; }
   		const children = [...this.#children.get()];
@@ -1457,8 +1516,8 @@
   			}
   			this.state = sta;
   		}
-  		this.value = val;
   		this.#children.set(children);
+  		this.value = val;
   		return true;
 
   	}
@@ -1469,7 +1528,6 @@
   	 * @returns 
   	 */
   	exchange(a, b) {
-  		if (this.destroyed) { return false; }
   		const data = this.value;
   		if (!Array.isArray(data)) { return false; }
   		const children = [...this.#children.get()];
@@ -1494,11 +1552,13 @@
   			sta[a] = bValue;
   			this.state = sta;
   		}
-  		this.value = val;
   		this.#children.set(children);
+  		this.value = val;
   		return true;
   	}
   }
+  // @ts-ignore
+  setArrayStore(ArrayStore);
 
   const errors = {
   	CALC: 'no `createCalc` option, no expression parsing support',
@@ -2410,6 +2470,7 @@
   	store: true,
   	parent: true,
   	root: true,
+  	ref: true,
 
   	schema: true,
 
@@ -2417,6 +2478,7 @@
   	readonly: true,
   	creatable: true,
   	immutable: true,
+  	changed: true,
 
   	required: true,
   	clearable: true,
@@ -2455,6 +2517,7 @@
   	}
   	yield [`${key}${sign}value`, {get: () => val.value, set: v => val.value = v}];
   	yield [`${key}${sign}state`, {get: () => val.state, set: v => val.state = v}];
+  	yield [`${key}${sign}reset`, {exec: () => val.reset()}];
   	if (!(val instanceof ArrayStore)) { return; }
   	yield [`${key}${sign}insert`, {exec: (index, value) => val.insert(index, value)}];
   	yield [`${key}${sign}add`, {exec: (v) => val.add(v)}];
@@ -2527,6 +2590,17 @@
   /** @import { ValueDefine, ExecDefine, CalcDefine } from './index.mjs' */
 
 
+  /** @type {Record<string, ValueDefine | ExecDefine | CalcDefine>} */
+  const items = {
+  	value$: { calc(r) { return r?.[ref].value; } },
+  	state$: { calc(r) { return r?.[ref].state; } },
+  };
+
+  var globals = Object.getOwnPropertyDescriptors(items);
+
+  /** @import { ValueDefine, ExecDefine, CalcDefine } from './index.mjs' */
+
+
   /**
    * 
    * @param {string} key 
@@ -2544,7 +2618,7 @@
    */
   function toGlobal(global) {
   	/** @type {Record<string, ValueDefine | ExecDefine | CalcDefine>} */
-  	const items = Object.create(null);
+  	const items = Object.create(null, globals);
   	if (!global || typeof global !== 'object') { return items; }
   	for (const [key, value] of Object.entries(global)) {
   		if (!testKey(key)) { continue; }