@cube-dev/ui-kit 0.179.0 → 0.181.0

package/dist/components/form/Form/modern/store.js

@@ -0,0 +1,876 @@
+/** @license MIT | @cube-dev/ui-kit v0.181.0 | Cube Dev Team */
+import { FORM_BACKEND } from "../backend.js";
+import { createValueSnapshotter, defineValue, formValueEqual, freezeContainer, getFieldKey, hasPath, isPlainObject, normalizePath, pathValueChanged, readPath, readonlySet, sameMembers, writePath } from "./values.js";
+import { rulesSignature, runRules } from "./validation.js";
+
+//#region src/components/form/Form/modern/store.ts
+const EMPTY_ERRORS = Object.freeze([]);
+const EMPTY_OBJECT = Object.freeze({});
+const EMPTY_FIELDS = Object.freeze(Object.create(null));
+function related(a, b) {
+	return a.slice(0, Math.min(a.length, b.length)).every((key, index) => key === b[index]);
+}
+function sameDependencies(a = [], b = []) {
+	return a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
+}
+function samePaths(a = [], b = []) {
+	return a.length === b.length && a.every((path, index) => sameDependencies(path, b[index]));
+}
+/** Only traverse path ancestors; a field's value (even cyclic data) is a leaf. */
+function projectActive(value, path, previous) {
+	if (path.terminal) return value;
+	const result = Array.isArray(value) ? [] : {};
+	if (isPlainObject(value) || Array.isArray(value)) for (const [key, child] of path.children) {
+		if (!Object.hasOwn(value, key)) continue;
+		defineValue(result, key, projectActive(Reflect.get(value, key), child, readPath(previous, [key])));
+	}
+	return formValueEqual(result, previous) ? previous : freezeContainer(result);
+}
+/**
+* Framework-neutral store, registration ownership, and async pipelines.
+* Not exported from the package; React receives the public command facade.
+*/
+function createFormStore(inputOptions = {}) {
+	const options = { ...inputOptions };
+	const ownValue = createValueSnapshotter();
+	const records = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let values = ownValue(options.defaultValues ?? {});
+	let defaults = values;
+	let submitError;
+	let submission;
+	let binding;
+	let order = 0;
+	let depth = 0;
+	let notifying = false;
+	let disposed = false;
+	let pending = false;
+	let changes = [];
+	const cancellations = /* @__PURE__ */ new Set();
+	let state = Object.freeze({
+		values,
+		defaultValues: defaults,
+		activeValues: EMPTY_OBJECT,
+		fields: EMPTY_FIELDS,
+		dirtyFields: readonlySet([]),
+		touchedFields: readonlySet([]),
+		isDirty: false,
+		isTouched: false,
+		isValid: false,
+		isInvalid: false,
+		isValidating: false,
+		isSubmitting: false,
+		canReset: false,
+		submitError: void 0,
+		revision: 0
+	});
+	function assertLive() {
+		if (disposed) throw new Error("Cannot use a disposed modern form store.");
+	}
+	function report(error) {
+		try {
+			if (options.onListenerError) options.onListenerError(error);
+			else console.error("[form-store] Listener failed", error);
+		} catch (reportError) {
+			console.error("[form-store] Error reporter failed", reportError);
+		}
+	}
+	function developmentError(message) {
+		if (process.env.NODE_ENV === "production") return;
+		try {
+			if (options.onDevelopmentError) options.onDevelopmentError(message);
+			else console.error(`[form-store] ${message}`);
+		} catch (error) {
+			report(error);
+		}
+	}
+	function ensure(path, explicit = true) {
+		const normalized = normalizePath(path);
+		const name = getFieldKey(normalized);
+		let record = records.get(name);
+		if (!record) {
+			record = {
+				name,
+				path: normalized,
+				explicit,
+				registrations: /* @__PURE__ */ new Set(),
+				touched: false,
+				errors: EMPTY_ERRORS,
+				status: "unvalidated",
+				validationRevision: 0
+			};
+			records.set(name, record);
+		}
+		record.explicit ||= explicit;
+		return record;
+	}
+	function dirty(record) {
+		return hasPath(values, record.path) && !(record.owner?.options.isEqual ?? formValueEqual)(readPath(values, record.path), readPath(defaults, record.path));
+	}
+	function invalidate(record, keepErrors = false) {
+		const controller = record.validation;
+		record.validation = void 0;
+		record.reads = void 0;
+		record.readsAll = false;
+		record.validationRevision++;
+		record.status = "unvalidated";
+		if (!keepErrors) record.errors = EMPTY_ERRORS;
+		if (controller) cancellations.add(controller);
+	}
+	function cancelPending() {
+		for (const controller of Array.from(cancellations)) {
+			cancellations.delete(controller);
+			controller.abort();
+		}
+	}
+	function dependencyChanged(record, previous) {
+		return record.owner?.options.dependsOn?.some((path) => pathValueChanged(previous, values, path)) ?? false;
+	}
+	function validationReadChanged(record, previous) {
+		if (!record.validation) return false;
+		if (record.readsAll && previous !== values) return true;
+		for (const path of record.reads?.values() ?? []) if (pathValueChanged(previous, values, path)) return true;
+		return false;
+	}
+	function invalidateRelated(path, previous, config) {
+		for (const record of records.values()) {
+			const dependency = dependencyChanged(record, previous);
+			const fieldChanged = related(path, record.path) || pathValueChanged(previous, values, record.path);
+			if (fieldChanged || dependency || validationReadChanged(record, previous)) {
+				const revalidate = (fieldChanged || dependency) && !!config && !!record.registrations.size && (config.validate === "always" || config.validate !== "never" && (record.owner?.options.validateTrigger === "onChange" || !!record.errors.length || dependency && record.status !== "unvalidated"));
+				invalidate(record, revalidate);
+				if (revalidate) validateRecord(record, false);
+			}
+		}
+	}
+	function activeValues() {
+		const tree = {
+			terminal: false,
+			children: /* @__PURE__ */ new Map()
+		};
+		for (const record of records.values()) {
+			if (!record.registrations.size || !hasPath(values, record.path)) continue;
+			let node = tree;
+			for (const key of record.path) {
+				let child = node.children.get(key);
+				if (!child) {
+					child = {
+						terminal: false,
+						children: /* @__PURE__ */ new Map()
+					};
+					node.children.set(key, child);
+				}
+				node = child;
+			}
+			node.terminal = true;
+		}
+		return projectActive(values, tree, state.activeValues);
+	}
+	function buildSnapshot() {
+		const fields = Object.create(null);
+		const dirtyNames = /* @__PURE__ */ new Set();
+		const touchedNames = /* @__PURE__ */ new Set();
+		let activeCount = 0;
+		let validCount = 0;
+		let invalid = false;
+		let validating = false;
+		let resettable = submitError != null;
+		for (const record of records.values()) {
+			const field = {
+				name: record.name,
+				value: readPath(values, record.path),
+				defaultValue: readPath(defaults, record.path),
+				errors: record.errors,
+				status: record.status,
+				touched: record.touched,
+				dirty: dirty(record),
+				active: record.registrations.size > 0,
+				registrationCount: record.registrations.size,
+				validationRevision: record.validationRevision
+			};
+			const previous = state.fields[record.name];
+			Object.defineProperty(fields, record.name, {
+				value: formValueEqual(field, previous) ? previous : Object.freeze(field),
+				enumerable: true
+			});
+			if (field.dirty) dirtyNames.add(record.name);
+			if (field.touched) touchedNames.add(record.name);
+			resettable ||= field.dirty || field.touched || !!field.errors.length || field.status !== "unvalidated";
+			if (field.active) {
+				activeCount++;
+				if (field.status === "valid") validCount++;
+				invalid ||= field.status === "invalid";
+				validating ||= field.status === "validating";
+			}
+		}
+		const next = {
+			values,
+			defaultValues: defaults,
+			activeValues: activeValues(),
+			fields: formValueEqual(fields, state.fields) ? state.fields : Object.freeze(fields),
+			dirtyFields: sameMembers(dirtyNames, state.dirtyFields) ? state.dirtyFields : readonlySet(dirtyNames),
+			touchedFields: sameMembers(touchedNames, state.touchedFields) ? state.touchedFields : readonlySet(touchedNames),
+			isDirty: dirtyNames.size > 0,
+			isTouched: touchedNames.size > 0,
+			isValid: activeCount > 0 && validCount === activeCount,
+			isInvalid: invalid,
+			isValidating: validating,
+			isSubmitting: !!submission,
+			canReset: !submission && resettable,
+			submitError,
+			revision: state.revision
+		};
+		if (formValueEqual(next, state)) return state;
+		return Object.freeze({
+			...next,
+			revision: state.revision + 1
+		});
+	}
+	function flush() {
+		if (depth || notifying || disposed) return;
+		notifying = true;
+		try {
+			while ((pending || cancellations.size) && !disposed) {
+				pending = false;
+				const events = changes;
+				changes = [];
+				const previous = state;
+				state = buildSnapshot();
+				const published = state;
+				if (state !== previous) for (const listener of Array.from(listeners)) {
+					if (!listeners.has(listener)) continue;
+					try {
+						listener.notify();
+					} catch (error) {
+						report(error);
+					}
+				}
+				if (events.length && !disposed && resolveCallbacks().onValuesChange) {
+					const change = Object.freeze({
+						names: Object.freeze(Array.from(new Set(events.flatMap((event) => event.names)))),
+						source: events.some((event) => event.source === "user") ? "user" : "program",
+						kind: events[events.length - 1].kind
+					});
+					try {
+						const result = resolveCallbacks().onValuesChange?.(published.values, change);
+						if (result) Promise.resolve(result).catch(report);
+					} catch (error) {
+						report(error);
+					}
+				}
+				cancelPending();
+			}
+		} finally {
+			notifying = false;
+		}
+	}
+	function batch(fn) {
+		assertLive();
+		depth++;
+		try {
+			fn();
+		} finally {
+			depth--;
+			pending = true;
+			flush();
+		}
+	}
+	function event(names, kind, source = "program") {
+		if (names.length) changes.push({
+			names,
+			kind,
+			source
+		});
+	}
+	function write(path, value, config = {}) {
+		const normalized = normalizePath(path);
+		const previous = values;
+		const next = writePath(values, normalized, ownValue(value));
+		const record = ensure(normalized);
+		const changed = next !== values;
+		if (changed) {
+			values = next;
+			invalidateRelated(record.path, previous, config);
+		}
+		if (config.touch ?? config.source === "user") record.touched = true;
+		if (changed && (config.notify ?? config.source === "user")) event([record.name], "set", config.source);
+		return changed;
+	}
+	function setValue(path, value, config) {
+		const normalized = normalizePath(path);
+		const prepared = { ...config };
+		batch(() => {
+			write(normalized, value, prepared);
+		});
+	}
+	function setValues(next, config) {
+		assertLive();
+		const prepared = { ...config };
+		const entries = Object.entries(next).map(([name, value]) => [normalizePath(name), ownValue(value)]);
+		let checked = values;
+		for (const [path, value] of entries) checked = writePath(checked, path, value);
+		batch(() => {
+			for (const [path, value] of entries) write(path, value, prepared);
+		});
+	}
+	function prepareRegistration(path, config) {
+		const prepared = {
+			...config,
+			deps: config.deps ? Object.freeze([...config.deps]) : void 0,
+			dependsOn: config.dependsOn?.map((dependency) => Object.freeze(normalizePath(dependency))),
+			rules: config.rules?.map((rule) => Object.freeze({
+				...rule,
+				...rule.enum ? { enum: Object.freeze([...rule.enum]) } : {}
+			}))
+		};
+		if (Object.hasOwn(prepared, "defaultValue")) {
+			prepared.defaultValue = ownValue(prepared.defaultValue);
+			const normalized = normalizePath(path);
+			if (!hasPath(values, normalized) && !hasPath(defaults, normalized)) {
+				writePath(values, normalized, prepared.defaultValue);
+				writePath(defaults, normalized, prepared.defaultValue);
+			}
+		}
+		return prepared;
+	}
+	function seed(record, registration) {
+		if (registration.defaultConsidered || !Object.hasOwn(registration.options, "defaultValue")) return;
+		registration.defaultConsidered = true;
+		const value = ownValue(registration.options.defaultValue);
+		if (!hasPath(values, record.path) && !hasPath(defaults, record.path)) {
+			const previous = values;
+			values = writePath(values, record.path, value);
+			defaults = writePath(defaults, record.path, value);
+			record.fieldDefault = { value };
+			invalidateRelated(record.path, previous);
+		} else if (record.fieldDefault && record.registrations.size > 1 && !formValueEqual(record.fieldDefault.value, value)) developmentError(`Field "${record.name}" registered with conflicting defaultValue; the first default is kept.`);
+	}
+	function register(path, config = {}) {
+		assertLive();
+		const normalized = normalizePath(path);
+		const prepared = prepareRegistration(normalized, config);
+		const signature = rulesSignature(prepared.rules, { hashFunctions: prepared.rulesKey === void 0 });
+		const record = ensure(normalized);
+		const registration = {
+			options: prepared,
+			signature,
+			order: ++order,
+			defaultConsidered: false
+		};
+		let released = false;
+		batch(() => {
+			record.registrations.add(registration);
+			record.owner = registration;
+			seed(record, registration);
+			invalidate(record);
+		});
+		return Object.freeze({
+			name: record.name,
+			get released() {
+				return released || disposed;
+			},
+			update(next) {
+				if (released || disposed) return;
+				const prepared = prepareRegistration(record.path, next);
+				const signature = rulesSignature(prepared.rules, { hashFunctions: prepared.rulesKey === void 0 });
+				const validationChanged = registration.signature !== signature || registration.options.rulesKey !== prepared.rulesKey || !sameDependencies(registration.options.deps, prepared.deps) || !samePaths(registration.options.dependsOn, prepared.dependsOn) || registration.options.validationDelay !== prepared.validationDelay || registration.options.validateTrigger !== prepared.validateTrigger || registration.options.errorPolicy !== prepared.errorPolicy;
+				if (!(!registration.defaultConsidered && Object.hasOwn(prepared, "defaultValue")) && !validationChanged && (registration.options.preserve ?? true) === (prepared.preserve ?? true) && registration.options.isEqual === prepared.isEqual) {
+					registration.options = prepared;
+					return;
+				}
+				batch(() => {
+					registration.options = prepared;
+					registration.signature = signature;
+					registration.order = ++order;
+					const revalidate = validationChanged && record.status !== "unvalidated";
+					if (record.owner !== registration || validationChanged) invalidate(record, revalidate);
+					record.owner = registration;
+					seed(record, registration);
+					if (revalidate) validateRecord(record, false);
+				});
+			},
+			release(config = {}) {
+				if (released || disposed) return;
+				released = true;
+				batch(() => {
+					record.registrations.delete(registration);
+					if (record.owner === registration) {
+						record.owner = Array.from(record.registrations).sort((a, b) => b.order - a.order)[0];
+						invalidate(record);
+					}
+					if (!record.registrations.size) {
+						if (registration.options.preserve === false) {
+							const removeValue = () => {
+								const previous = values;
+								values = writePath(values, record.path, void 0, true);
+								record.touched = false;
+								invalidateRelated(record.path, previous, { validate: "auto" });
+								if (!hasPath(defaults, record.path)) records.delete(record.name);
+							};
+							if (config.deferValueRemoval) {
+								const revision = record.validationRevision;
+								queueMicrotask(() => {
+									if (!disposed && records.get(record.name) === record && !record.registrations.size && record.validationRevision === revision) batch(removeValue);
+								});
+							} else removeValue();
+						}
+						if (!hasPath(values, record.path) && !hasPath(defaults, record.path)) records.delete(record.name);
+					}
+				});
+			}
+		});
+	}
+	function replaceDefaults(next) {
+		const entries = Object.keys(next);
+		entries.forEach((name) => normalizePath(name));
+		defaults = ownValue(next);
+		for (const name of entries) ensure(name, false);
+		for (const record of records.values()) record.fieldDefault = void 0;
+	}
+	function setDefaultValues(next, config = {}) {
+		const replace = config.currentValues === "replace";
+		batch(() => {
+			replaceDefaults(next);
+			if (replace) {
+				values = defaults;
+				for (const record of records.values()) {
+					invalidate(record);
+					record.touched = false;
+				}
+				event(Array.from(records.keys()), "defaults");
+			}
+		});
+	}
+	function adoptDefaultValues(next, config = {}) {
+		const when = config.when ?? "untouched";
+		const preserveDirty = config.preserveDirty ?? false;
+		batch(() => {
+			const candidates = Array.from(records.values());
+			const preserved = candidates.filter((record) => {
+				if (!record.explicit && candidates.some((child) => child.explicit && child.path.length > record.path.length && related(record.path, child.path))) return false;
+				return when === "untouched" && record.touched || when === "clean" && dirty(record) || preserveDirty && dirty(record);
+			}).map((record) => ({
+				path: record.path,
+				exists: hasPath(values, record.path),
+				value: readPath(values, record.path)
+			}));
+			const previous = values;
+			replaceDefaults(next);
+			values = defaults;
+			for (const saved of preserved.sort((a, b) => a.path.length - b.path.length)) values = writePath(values, saved.path, saved.value, !saved.exists);
+			const names = [];
+			for (const record of records.values()) {
+				const changed = pathValueChanged(previous, values, record.path);
+				if (changed || dependencyChanged(record, previous) || validationReadChanged(record, previous)) invalidate(record);
+				if (changed) names.push(record.name);
+			}
+			event(names, "adopt");
+		});
+	}
+	function reset(config = {}) {
+		batch(() => {
+			if (Object.hasOwn(config, "values")) replaceDefaults(config.values ?? {});
+			values = defaults;
+			const names = Array.from(records.keys());
+			for (const record of records.values()) {
+				invalidate(record);
+				record.touched = false;
+				if (!record.registrations.size && !hasPath(values, record.path)) records.delete(record.name);
+			}
+			const previous = submission;
+			submission = void 0;
+			submitError = void 0;
+			if (previous) cancellations.add(previous);
+			event(names, "reset");
+		});
+	}
+	function setFieldErrors(path, errors) {
+		assertLive();
+		const copied = errors.length ? Object.freeze([...errors]) : EMPTY_ERRORS;
+		batch(() => {
+			const record = ensure(path);
+			const status = copied.length ? "invalid" : "valid";
+			if (record.status === status && formValueEqual(record.errors, copied)) return;
+			invalidate(record);
+			record.errors = copied;
+			record.status = status;
+		});
+	}
+	function startValidation(path) {
+		assertLive();
+		const record = records.get(getFieldKey(path));
+		if (!record?.registrations.size) throw new Error("Only active form fields can validate.");
+		const controller = new AbortController();
+		batch(() => {
+			invalidate(record, true);
+			record.validation = controller;
+			record.status = "validating";
+		});
+		const current = () => !disposed && record.validation === controller && !controller.signal.aborted;
+		return Object.freeze({
+			signal: controller.signal,
+			complete(errors) {
+				if (!current()) return false;
+				const copied = errors.length ? Object.freeze([...errors]) : EMPTY_ERRORS;
+				batch(() => {
+					record.validation = void 0;
+					record.reads = void 0;
+					record.readsAll = false;
+					record.errors = copied;
+					record.status = copied.length ? "invalid" : "valid";
+				});
+				return true;
+			},
+			cancel() {
+				if (current()) batch(() => {
+					invalidate(record, true);
+				});
+			}
+		});
+	}
+	function startSubmission() {
+		assertLive();
+		if (submission) return void 0;
+		const controller = new AbortController();
+		batch(() => {
+			submission = controller;
+			submitError = void 0;
+		});
+		return Object.freeze({
+			signal: controller.signal,
+			complete(result) {
+				if (disposed || submission !== controller || controller.signal.aborted) return false;
+				const error = result?.error;
+				batch(() => {
+					submission = void 0;
+					submitError = error;
+				});
+				return true;
+			}
+		});
+	}
+	function validateRecord(record, immediate, parentSignal) {
+		const result = (errors, stale = false) => ({
+			name: record.name,
+			errors,
+			isValid: !stale && !errors.length,
+			stale
+		});
+		if (parentSignal?.aborted) return Promise.resolve(result(EMPTY_ERRORS, true));
+		const config = record.owner?.options;
+		const rules = config?.rules ?? [];
+		const token = startValidation(record.path);
+		const revision = record.validationRevision;
+		if (token.signal.aborted || parentSignal?.aborted) {
+			token.cancel();
+			return Promise.resolve(result(EMPTY_ERRORS, true));
+		}
+		if (!rules.length) {
+			record.reads = void 0;
+			record.readsAll = false;
+			const committed = token.complete(EMPTY_ERRORS);
+			return Promise.resolve(result(EMPTY_ERRORS, !committed || record.validationRevision !== revision));
+		}
+		const validationValues = values;
+		const reads = /* @__PURE__ */ new Map();
+		record.reads = reads;
+		record.readsAll = false;
+		const value = readPath(validationValues, record.path);
+		return new Promise((resolve) => {
+			let timer;
+			let settled = false;
+			const finish = (errors, stale) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				token.signal.removeEventListener("abort", abort);
+				parentSignal?.removeEventListener("abort", cancel);
+				resolve(result(errors, stale));
+			};
+			const abort = () => finish(EMPTY_ERRORS, true);
+			const cancel = () => token.cancel();
+			token.signal.addEventListener("abort", abort, { once: true });
+			parentSignal?.addEventListener("abort", cancel, { once: true });
+			const run = async () => {
+				timer = void 0;
+				const errors = await runRules(value, rules, {
+					name: record.name,
+					signal: token.signal,
+					getValue: (path) => {
+						const normalized = normalizePath(path);
+						if (!settled && !token.signal.aborted) {
+							reads.set(getFieldKey(normalized), normalized);
+							if (pathValueChanged(validationValues, values, normalized)) token.cancel();
+						}
+						return readPath(validationValues, normalized);
+					},
+					getValues: () => {
+						if (!settled && !token.signal.aborted) {
+							record.readsAll = true;
+							if (values !== validationValues) token.cancel();
+						}
+						return validationValues;
+					}
+				}, config?.errorPolicy ?? options.errorPolicy ?? "first");
+				if (!settled) {
+					const committed = token.complete(errors);
+					finish(Object.freeze(errors), !committed || record.validationRevision !== revision || !!parentSignal?.aborted);
+				}
+			};
+			const delay = immediate ? 0 : config?.validationDelay ?? 0;
+			if (delay > 0) timer = setTimeout(() => void run(), delay);
+			else run();
+		});
+	}
+	function validate(paths, config = {}) {
+		assertLive();
+		const active = (paths ? Array.from(new Set(paths.map(getFieldKey))).map((key) => records.get(key)) : Array.from(records.values())).filter((record) => !!record?.registrations.size);
+		let runs = [];
+		let revisions = [];
+		batch(() => {
+			runs = active.map((record) => validateRecord(record, config.immediate ?? true, config.signal));
+			revisions = active.map((record) => record.validationRevision);
+		});
+		return Promise.all(runs).then((results) => {
+			const fields = results.map((result, index) => {
+				const record = active[index];
+				return record.validationRevision === revisions[index] && !!record.registrations.size && !config.signal?.aborted ? result : {
+					...result,
+					stale: true,
+					isValid: false
+				};
+			});
+			return {
+				fields,
+				stale: fields.some((field) => field.stale) || !!config.signal?.aborted,
+				isValid: !!fields.length && fields.every((field) => field.isValid)
+			};
+		});
+	}
+	function resolveCallbacks() {
+		return {
+			...options,
+			...binding?.callbacks
+		};
+	}
+	function cancelSubmission() {
+		batch(() => {
+			if (submission) cancellations.add(submission);
+			submission = void 0;
+		});
+	}
+	function bindCallbacks(callbacks) {
+		assertLive();
+		if (binding) developmentError("A second Form root owns this controller; the newest callback binding wins.");
+		const own = { callbacks: { ...callbacks } };
+		binding = own;
+		let released = false;
+		return Object.freeze({
+			update(next) {
+				if (!released && !disposed && binding === own) own.callbacks = { ...next };
+			},
+			release() {
+				if (released || disposed) return;
+				released = true;
+				if (binding === own) {
+					binding = void 0;
+					cancelSubmission();
+				}
+			}
+		});
+	}
+	async function submit(config = {}) {
+		const token = startSubmission();
+		if (!token) return {
+			status: "ignored",
+			reason: "submitting"
+		};
+		const include = config.include ?? "active";
+		return new Promise((resolve) => {
+			let settled = false;
+			const finish = (result) => {
+				if (settled) return;
+				settled = true;
+				token.signal.removeEventListener("abort", abort);
+				resolve(result);
+			};
+			const abort = () => finish({ status: "stale" });
+			token.signal.addEventListener("abort", abort, { once: true });
+			if (token.signal.aborted) {
+				abort();
+				return;
+			}
+			const run = async () => {
+				const pendingValidation = validate(void 0, { signal: token.signal });
+				const validatedRecords = Array.from(records.values()).filter((record) => record.registrations.size);
+				const revisions = validatedRecords.map((record) => record.validationRevision);
+				const validation = await pendingValidation;
+				if (settled) return;
+				const changedSinceValidation = validatedRecords.length !== validation.fields.length || validatedRecords.length !== Array.from(records.values()).filter((record) => record.registrations.size).length || validatedRecords.some((record, index) => !record.registrations.size || record.validationRevision !== revisions[index]);
+				if (validation.stale || changedSinceValidation) {
+					token.complete();
+					finish({ status: "stale" });
+					return;
+				}
+				const callbacks = resolveCallbacks();
+				let result;
+				if (!validation.isValid) {
+					const errors = Object.fromEntries(validation.fields.filter((field) => !field.isValid).map((field) => [field.name, field.errors]));
+					result = {
+						status: "invalid",
+						errors: Object.freeze(errors)
+					};
+					try {
+						await callbacks.onSubmitFailed?.({
+							status: "invalid",
+							errors: Object.freeze(errors)
+						});
+					} catch (error) {
+						report(error);
+					}
+					if (!settled) {
+						token.complete();
+						finish(result);
+					}
+					return;
+				}
+				try {
+					await callbacks.onSubmit?.(include === "all" ? values : activeValues(), {
+						include,
+						signal: token.signal
+					});
+					result = { status: "submitted" };
+				} catch (error) {
+					if (settled) return;
+					batch(() => {
+						submitError = error;
+					});
+					try {
+						await callbacks.onSubmitFailed?.({
+							status: "failed",
+							error
+						});
+					} catch (failure) {
+						report(failure);
+					}
+					result = {
+						status: "failed",
+						error
+					};
+				}
+				if (!settled) {
+					token.complete(result.status === "failed" ? { error: result.error } : void 0);
+					finish(result);
+				}
+			};
+			run().catch((error) => {
+				if (!settled) {
+					token.complete({ error });
+					finish({
+						status: "failed",
+						error
+					});
+				}
+			});
+		});
+	}
+	function subscribe(listener) {
+		assertLive();
+		const entry = { notify: listener };
+		listeners.add(entry);
+		return () => {
+			listeners.delete(entry);
+		};
+	}
+	function dispose() {
+		if (disposed) return;
+		disposed = true;
+		listeners.clear();
+		binding = void 0;
+		changes = [];
+		pending = false;
+		for (const record of records.values()) {
+			record.registrations.clear();
+			record.owner = void 0;
+			invalidate(record);
+		}
+		const previous = submission;
+		submission = void 0;
+		if (previous) cancellations.add(previous);
+		state = buildSnapshot();
+		records.clear();
+		cancelPending();
+	}
+	for (const name of Object.keys(values)) ensure(name, false);
+	state = buildSnapshot();
+	return Object.freeze({
+		[FORM_BACKEND]: "modern",
+		getSnapshot: () => state,
+		getFieldSnapshot: (path) => state.fields[getFieldKey(path)],
+		getValue: (path) => readPath(values, normalizePath(path)),
+		getValues: () => values,
+		getActiveValues: () => activeValues(),
+		subscribe,
+		subscribeSelector(selector, listener, isEqual = Object.is) {
+			let selected = selector(state);
+			return subscribe(() => {
+				const next = selector(state);
+				if (isEqual(selected, next)) return;
+				const previous = selected;
+				selected = next;
+				listener(next, previous);
+			});
+		},
+		register,
+		validate,
+		submit,
+		bindCallbacks,
+		updateCallbacks(callbacks) {
+			options.onSubmit = callbacks.onSubmit;
+			options.onSubmitFailed = callbacks.onSubmitFailed;
+			options.onValuesChange = callbacks.onValuesChange;
+		},
+		blur(path) {
+			const record = records.get(getFieldKey(path));
+			if (!record?.registrations.size) return;
+			batch(() => {
+				record.touched = true;
+				if ((record.owner?.options.validateTrigger ?? "onBlur") === "onBlur") validateRecord(record, false);
+			});
+		},
+		setValue,
+		setValues,
+		batch,
+		setDefaultValues,
+		adoptDefaultValues,
+		reset,
+		touch(path, touched = true) {
+			batch(() => {
+				ensure(path).touched = touched;
+			});
+		},
+		setFieldErrors,
+		clearFieldErrors: (path) => setFieldErrors(path, EMPTY_ERRORS),
+		startValidation,
+		startSubmission,
+		setSubmitError(error) {
+			batch(() => {
+				submitError = error;
+			});
+		},
+		clearSubmitError() {
+			batch(() => {
+				submitError = void 0;
+			});
+		},
+		dispose,
+		debug: Object.freeze({
+			listenerCount: () => listeners.size,
+			registrationCount: () => Array.from(records.values()).reduce((count, record) => count + record.registrations.size, 0)
+		})
+	});
+}
+
+//#endregion
+export { createFormStore };
+//# sourceMappingURL=store.js.map