@menapo/forms 0.0.0-stage → 0.1.0

package/dist/glue/vanilla.js

@@ -0,0 +1,88 @@
+import { a as objectOptions, r as create } from "../view--JGPLHEo.js";
+import { r as lower, t as names } from "../names-D_TE3BpM.js";
+import { t as nextId } from "../source-DdFTPjID.js";
+//#region ../glue/src/vanilla.ts
+/**
+* No framework (machine PLAN §5.5): listeners hear when the snapshot moves,
+* and deferred side effects run right after them, so they find the DOM the
+* listeners updated (D13: in vanilla, right after the event). Sources mount
+* on the next microtask, after the code that created them has had a chance
+* to render them once, and `stop()` is the unmount plain code has none of.
+* A class, so each source costs one object and one closure.
+*/
+/** Sources waiting for the microtask that mounts them. */
+let waiting;
+function mountWaiting() {
+	const sources = waiting;
+	waiting = void 0;
+	for (const source of sources) source.mount();
+}
+var Vanilla = class {
+	source;
+	/** The snapshot listeners last heard; nothing is computed while none listens. */
+	seen = -1;
+	/** Copied on write: a change being told keeps the listeners it started with. */
+	listeners;
+	/** Unsubscribes from the source. */
+	off;
+	constructor(source) {
+		this.source = source;
+		this.off = source.subscribe(() => this.tell());
+	}
+	tell() {
+		const { source, listeners } = this;
+		if (listeners) {
+			const now = source.snapshot();
+			if (now !== this.seen) {
+				this.seen = now;
+				for (const listener of listeners) listener();
+			}
+		}
+		source.commit();
+	}
+	/** Calls `listener` after each change the snapshot shows; returns the unsubscribe. */
+	subscribe(listener) {
+		if (!this.listeners) this.seen = this.source.snapshot();
+		this.listeners = this.listeners ? [...this.listeners, listener] : [listener];
+		return () => {
+			this.listeners = this.listeners?.filter((l) => l !== listener);
+		};
+	}
+	/** What a framework does on unmount: listeners go, side effects stop, and a source not mounted yet never is. */
+	stop() {
+		this.listeners = void 0;
+		this.off();
+		const at = waiting ? waiting.indexOf(this.source) : -1;
+		if (at >= 0) waiting.splice(at, 1);
+		this.source.unmount();
+	}
+};
+function useSource(create, props) {
+	const source = create(nextId(), props);
+	if (!waiting) {
+		waiting = [];
+		queueMicrotask(mountWaiting);
+	}
+	waiting.push(source);
+	return new Vanilla(source);
+}
+//#endregion
+//#region src/glue/vanilla.ts
+/**
+* `useForm` without a framework (PLAN §5.2): `f.subscribe` hears each
+* change the view read, and `spread(el, f.parts.form)` from
+* `@menapo/machine/dom` puts parts on elements. Attributes are lowercase,
+* as the DOM names them (`oninput`, `onfocusout`); the instance mounts on
+* the next microtask, after the code that created it rendered it once.
+*/
+const N = names(lower, false);
+function useForm(source, options) {
+	objectOptions(options, "plain code");
+	const vanilla = useSource(create(source, N), options);
+	const view = vanilla.source;
+	view.keep = true;
+	view.u = vanilla;
+	return view.current();
+}
+//#endregion
+export { useForm };

package/dist/glue/vue.d.ts

@@ -0,0 +1,4 @@
+import { i as Form, t as FormViewImpl } from "../view-5_kyMWP3.js";
+//#region src/glue/vue.d.ts
+export declare function useForm(source: Form | FormViewImpl, options?: object | (() => object)): FormViewImpl;
+//#endregion

package/dist/glue/vue.js

@@ -0,0 +1,47 @@
+import { r as create } from "../view--JGPLHEo.js";
+import { a as vue, t as names } from "../names-D_TE3BpM.js";
+import { t as nextId } from "../source-DdFTPjID.js";
+import { nextTick, onBeforeUnmount, onMounted, shallowRef, useId, watch } from "vue";
+//#region ../glue/src/vue.ts
+/**
+* Vue 3.5 (machine PLAN §5.5): a `shallowRef` holding the snapshot, which a
+* render reads through the returned tracker and which a change replaces,
+* so only views that read it update. Props given as a function are watched
+* before each render; side effects start once mounted and run after each
+* flush that follows a change (`nextTick`, queued after Vue's own).
+*/
+/** Returns the tracker: call it in a render or `computed` to update with the source. */
+function useSource(create, props) {
+	const read = typeof props === "function" ? props : void 0;
+	const source = create(useId() ?? nextId(), read ? read() : props);
+	const version = shallowRef(source.snapshot());
+	const commit = () => source.commit();
+	const off = source.subscribe(() => {
+		version.value = source.snapshot();
+		nextTick(commit);
+	});
+	if (read) watch(read, (next) => source.setProps(next), { flush: "pre" });
+	onMounted(() => source.mount());
+	onBeforeUnmount(() => {
+		off();
+		source.unmount();
+	});
+	return [source, () => version.value];
+}
+//#endregion
+//#region src/glue/vue.ts
+/**
+* `useForm` in Vue (PLAN §5.2): the shared glue's `shallowRef` adapter;
+* every read calls the tracker, and options given as a getter are watched,
+* so pristine fields follow new defaults (D11). Handlers are named
+* `onInput`, `onFocusout` (glue's naming).
+*/
+const N = names(vue, false);
+function useForm(source, options) {
+	const [view, track] = useSource(create(source, N), options);
+	view.k = track;
+	view.keep = true;
+	return view.current();
+}
+//#endregion
+export { useForm };

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { o as form } from "./view-5_kyMWP3.js";
+import { S as UseFormOptions, _ as OutputOf, a as FieldOf, b as ShownError, c as FieldView, d as FormOptions, g as OptionParts, h as InputOf, i as Defaults, l as Fields, m as FormView, n as Attrs, p as FormState, r as Checks, t as ArrayField, u as Form, v as Refreshable, y as RouteFormOptions } from "./types-CdCFdlFp.js";
+//#region src/core/env.d.ts
+/** What DevTools hears (M6): an instance's change, or a submit that ended. */
+type DevtoolsEvent = {
+  readonly kind: "change";
+  readonly instance: object;
+} | {
+  readonly kind: "gone";
+  readonly instance: object;
+} | {
+  readonly kind: "submit";
+  readonly instance: object;
+  readonly ms: number;
+  readonly error?: unknown;
+};
+//#endregion
+//#region src/core/inspect.d.ts
+/** `listener` hears every change of any rendered form and every submit's end; returns the stop. */
+export declare function inspect(listener: (event: DevtoolsEvent) => void): () => void;
+//#endregion
+//#region src/core/use.d.ts
+interface UseForm {
+  /** A parent's view, for a child component: its own subscription to the same form. */
+  <F>(view: FormView<F>): FormView<F>;
+  /** A form in a component; Vue, Svelte and Solid also take the options as a getter. */
+  <F extends {
+    readonly name: string;
+  }>(form: F, options?: UseFormOptions<InputOf<F>, OutputOf<F>> | (() => UseFormOptions<InputOf<F>, OutputOf<F>>)): FormView<F>;
+}
+/** Reads a form in a component: values, errors, submission and parts (§5.3). */
+export declare const useForm: UseForm;
+//#endregion
+export { type ArrayField, type Attrs, type Checks, type Defaults, type DevtoolsEvent, type FieldOf, type FieldView, type Fields, type Form, type FormOptions, type FormState, type FormView, type OptionParts, type Refreshable, type RouteFormOptions, type ShownError, type UseForm, type UseFormOptions, form };

package/dist/index.js

@@ -0,0 +1,30 @@
+import { i as fail, r as env } from "./instance-C1aijv06.js";
+import { r as form } from "./form-BZ2OH06z.js";
+//#region src/core/inspect.ts
+/**
+* `inspect` (D18): what DevTools reads the forms through, a nullable hook
+* in the core as machine's and query's. An app that never imports it ships
+* none of this; the plugin's dev-only page module is the one caller.
+*/
+/** `listener` hears every change of any rendered form and every submit's end; returns the stop. */
+function inspect(listener) {
+	const previous = env.devtools;
+	env.devtools = (event) => {
+		previous?.(event);
+		listener(event);
+	};
+	return () => void (env.devtools = previous);
+}
+//#endregion
+//#region src/core/use.ts
+/**
+* `useForm` as `@menapo/forms` exports it (PLAN §5.2): the Vite plugin
+* resolves each module's import to its framework's glue (`src/glue/`), so
+* this body runs only when the plugin is missing, and says so.
+*/
+/** Reads a form in a component: values, errors, submission and parts (§5.3). */
+const useForm = (() => {
+	throw fail("NO_PLUGIN", "useForm ran without the Vite plugin; add forms() from \"@menapo/forms/vite\" to vite.config.ts, and reach useForm from a module the plugin transforms, by import.");
+});
+//#endregion
+export { form, inspect, useForm };