@menapo/machine 0.0.0-stage → 0.1.0

package/dist/glue/preact.js

@@ -0,0 +1,54 @@
+import { f as DEV } from "../instance-BM2UqeXW.js";
+import { n as same } from "../source-DdFTPjID.js";
+import { a as component, o as objectProps, t as jsx } from "../naming-Csj5186j.js";
+import { useId, useLayoutEffect, useState } from "preact/hooks";
+//#region ../glue/src/preact.ts
+/**
+* Preact (machine PLAN §5.5): React's shape on `preact/hooks`, which has no
+* `useSyncExternalStore`: a state update when the snapshot moved, checked
+* again once subscribed so a change between render and subscription is not
+* lost. Side effects start in a layout effect, props are taken after each
+* commit.
+*/
+function useSource(create, props) {
+	const id = useId();
+	const [binding] = useState(() => ({
+		source: create(id, props),
+		seen: 0,
+		props
+	}));
+	const [, render] = useState(0);
+	const { source } = binding;
+	binding.seen = source.snapshot();
+	useLayoutEffect(() => {
+		const check = () => {
+			const now = source.snapshot();
+			if (now !== binding.seen) render(now);
+		};
+		const off = source.subscribe(check);
+		source.mount();
+		check();
+		return () => {
+			off();
+			source.unmount();
+		};
+	}, [source]);
+	useLayoutEffect(() => {
+		if (props && !same(props, binding.props)) source.setProps(binding.props = props);
+		source.commit();
+	});
+	return source;
+}
+//#endregion
+//#region src/glue/preact.ts
+/**
+* `useMachine` in Preact (PLAN §4.7, §5.5): React's shape on `preact/hooks`.
+* Preact takes the DOM's attribute names (`class`, `for`) and lowercases
+* event names itself (`onDblClick`).
+*/
+function useMachine(machine, props) {
+	if (DEV) objectProps(machine, props, "Preact");
+	return useSource(component(machine, jsx), props).view();
+}
+//#endregion
+export { useMachine };

package/dist/glue/react.d.ts

@@ -0,0 +1,4 @@
+import { t as View } from "../component-DDXOyYUI.js";
+//#region src/glue/react.d.ts
+export declare function useMachine(machine: object, props?: object): View;
+//#endregion

package/dist/glue/react.js

@@ -0,0 +1,50 @@
+import { f as DEV } from "../instance-BM2UqeXW.js";
+import { n as same } from "../source-DdFTPjID.js";
+import { a as component, o as objectProps, r as react } from "../naming-Csj5186j.js";
+import { useId, useLayoutEffect, useState, useSyncExternalStore } from "react";
+//#region ../glue/src/react.ts
+/**
+* React (machine PLAN §5.5, spike S3): the source lives in `useState`, so a
+* render React throws away (StrictMode, a concurrent render) never mutates
+* a live one; `useSyncExternalStore` renders once per snapshot move and
+* never tears; side effects start in a layout effect, after the DOM is
+* committed, and stop on unmount (StrictMode's mount, unmount and mount
+* leave one running). Props are taken after each commit, so a render that
+* never commits never changes the source. No `flushSync`.
+*/
+function useSource(create, props) {
+	const id = useId();
+	const [binding] = useState(() => {
+		const source = create(id, props);
+		return {
+			source,
+			subscribe: (listener) => source.subscribe(listener),
+			snapshot: () => source.snapshot(),
+			props
+		};
+	});
+	const { source } = binding;
+	useSyncExternalStore(binding.subscribe, binding.snapshot, binding.snapshot);
+	useLayoutEffect(() => {
+		source.mount();
+		return () => source.unmount();
+	}, [source]);
+	useLayoutEffect(() => {
+		if (props && !same(props, binding.props)) source.setProps(binding.props = props);
+		source.commit();
+	});
+	return source;
+}
+//#endregion
+//#region src/glue/react.ts
+/**
+* `useMachine` in React: what the plugin resolves `@menapo/machine`'s
+* `useMachine` to in a React module (PLAN §4.7, §5.5). Attribute names stay
+* as written (`onClick`, `tabIndex`).
+*/
+function useMachine(machine, props) {
+	if (DEV) objectProps(machine, props, "React");
+	return useSource(component(machine, react), props).view();
+}
+//#endregion
+export { useMachine };

package/dist/glue/solid.d.ts

@@ -0,0 +1,4 @@
+import { t as View } from "../component-DDXOyYUI.js";
+//#region src/glue/solid.d.ts
+export declare function useMachine(machine: object, props?: object | (() => object)): View;
+//#endregion

package/dist/glue/solid.js

@@ -0,0 +1,42 @@
+import { a as component, s as viewOf, t as jsx } from "../naming-Csj5186j.js";
+import { createComputed, createSignal, createUniqueId, onCleanup, onMount, untrack } from "solid-js";
+//#region ../glue/src/solid.ts
+/**
+* Solid (machine PLAN §5.5): a signal holding the snapshot, read through
+* the returned tracker, so only the computations that read it re-run, and
+* Solid's own spread applies only the attributes that changed. Props given
+* as a function are read in a computation; side effects start in `onMount`
+* and run after each change, once Solid has updated the DOM.
+*/
+function useSource(create, props) {
+	const read = typeof props === "function" ? props : void 0;
+	const source = create(createUniqueId(), read ? untrack(read) : props);
+	const [version, set] = createSignal(source.snapshot());
+	const commit = () => source.commit();
+	const off = source.subscribe(() => {
+		set(source.snapshot());
+		queueMicrotask(commit);
+	});
+	if (read) createComputed(() => {
+		const next = read();
+		untrack(() => source.setProps(next));
+	});
+	onMount(() => source.mount());
+	onCleanup(() => {
+		off();
+		source.unmount();
+	});
+	return [source, version];
+}
+//#endregion
+//#region src/glue/solid.ts
+/**
+* `useMachine` in Solid (PLAN §4.7, §5.5). Solid takes the DOM's attribute
+* names (`class`, `for`) and lowercases event names itself (`onDblClick`).
+*/
+function useMachine(machine, props) {
+	const [source, track] = useSource(component(machine, jsx), props);
+	return viewOf(source, track);
+}
+//#endregion
+export { useMachine };

package/dist/glue/svelte.svelte.d.ts

@@ -0,0 +1,4 @@
+import { t as View } from "../component-DDXOyYUI.js";
+//#region src/glue/svelte.svelte.d.ts
+export declare function useMachine(machine: object, props?: object | (() => object)): View;
+//#endregion

package/dist/glue/svelte.svelte.js

@@ -0,0 +1,57 @@
+import { t as nextId } from "../source-DdFTPjID.js";
+import { a as component, n as lower, s as viewOf } from "../naming-Csj5186j.js";
+import { onMount, tick, untrack } from "svelte";
+import { createSubscriber } from "svelte/reactivity";
+//#region ../glue/src/svelte.svelte.ts
+/**
+* Svelte 5 (machine PLAN §5.5): `createSubscriber` re-runs the effects and
+* deriveds that read the tracker when the snapshot moves; props given as a
+* getter are taken in `$effect.pre`, before the DOM updates. Side effects
+* start in `onMount` and run after each update that follows a change.
+* Svelte gives a module no id of its own, so ids come from a counter (or
+* the owner's `id`, which SSR needs).
+*/
+function useSource(create, props) {
+	const read = typeof props === "function" ? props : void 0;
+	const source = create(nextId(), read ? read() : props);
+	let update;
+	let seen = source.snapshot();
+	const track = createSubscriber((u) => {
+		update = u;
+		return () => update = void 0;
+	});
+	const commit = () => source.commit();
+	const off = source.subscribe(() => {
+		const now = source.snapshot();
+		if (now !== seen) {
+			seen = now;
+			update?.();
+		}
+		tick().then(commit);
+	});
+	if (read) $effect.pre(() => {
+		const next = read();
+		untrack(() => source.setProps(next));
+	});
+	onMount(() => {
+		source.mount();
+		return () => {
+			off();
+			source.unmount();
+		};
+	});
+	return [source, track];
+}
+//#endregion
+//#region src/glue/svelte.svelte.ts
+/**
+* `useMachine` in Svelte 5 (PLAN §4.7, §5.5): attributes are lowercase, as
+* Svelte spreads them onto elements (`onclick`, `tabindex`). A rune module,
+* so Svelte compiles the adapter it carries wherever the module is.
+*/
+function useMachine(machine, props) {
+	const [source, track] = useSource(component(machine, lower), props);
+	return viewOf(source, track);
+}
+//#endregion
+export { useMachine };

package/dist/glue/vanilla.d.ts

@@ -0,0 +1,4 @@
+import { t as View } from "../component-DDXOyYUI.js";
+//#region src/glue/vanilla.d.ts
+export declare function useMachine(machine: object, props?: object): View;
+//#endregion

package/dist/glue/vanilla.js

@@ -0,0 +1,83 @@
+import { f as DEV } from "../instance-BM2UqeXW.js";
+import { t as nextId } from "../source-DdFTPjID.js";
+import { a as component, n as lower, o as objectProps, s as viewOf } from "../naming-Csj5186j.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
+/**
+* `useMachine` without a framework (PLAN §4.7, §5.5): `api.subscribe`
+* hears every visible change, and `spread` from `/dom` puts a part's
+* attributes on its element. Attributes are lowercase, as the DOM names
+* them (`onclick`, `tabindex`).
+*/
+function useMachine(machine, props) {
+	if (DEV) objectProps(machine, props, "plain code");
+	const vanilla = useSource(component(machine, lower), props);
+	return viewOf(vanilla.source, void 0, vanilla);
+}
+//#endregion
+export { useMachine };

package/dist/glue/vue.d.ts

@@ -0,0 +1,4 @@
+import { t as View } from "../component-DDXOyYUI.js";
+//#region src/glue/vue.d.ts
+export declare function useMachine(machine: object, props?: object | (() => object)): View;
+//#endregion

package/dist/glue/vue.js

@@ -0,0 +1,41 @@
+import { t as nextId } from "../source-DdFTPjID.js";
+import { a as component, i as vue, s as viewOf } from "../naming-Csj5186j.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
+/**
+* `useMachine` in Vue (PLAN §4.7, §5.5): handlers named `onKeydown`, the
+* DOM's attribute names (`../parts/naming.ts`).
+*/
+function useMachine(machine, props) {
+	const [source, track] = useSource(component(machine, vue), props);
+	return viewOf(source, track);
+}
+//#endregion
+export { useMachine };

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { a as provide, i as payload, r as defineMachine, s as start } from "./machine-BstWHtWL.js";
+import { A as StateConfig, B as PartProps, C as OwnerProps, D as PropsOf, E as Payload, F as ViewOf, H as UseProps, I as Api, L as PartBase, M as Transitions, O as Send, P as View, R as PartConfig, V as PartsConfig, _ as InstanceOf, a as Bindable, b as MachineConfig, c as Effect, d as EventUnion, f as Guard, g as Instance, h as Implementations, i as AnyMachine, j as Transition, k as StartOptions, l as EffectResult, m as HistoryState, n as AnyEvent, o as DerivedView, p as History, s as DoneEvent, t as Action, u as EventOf, w as Parallel, x as MachineEvent, y as Machine, z as PartEvent } from "./types-Bk8svtO6.js";
+import { n as inspect, t as Step } from "./inspect-C3qosuCm.js";
+//#region src/core/bindable.d.ts
+interface BindableOptions {
+  /**
+   * For a boolean bound to the state: the state it is `true` in and the
+   * state to go to when it turns `false`, as paths from the root.
+   */
+  readonly states?: {
+    readonly true: string;
+    readonly false: string;
+  };
+  /** For a value bound to data: the event the machine receives when the owner changes it. */
+  readonly changed?: string;
+}
+/**
+ * A controlled-or-uncontrolled prop: `open: bindable(false, { states: {
+ * true: "open", false: "closed" } })` gives the owner `open`, `defaultOpen`
+ * and `onOpenChange`; `value: bindable("")` is data that actions write as
+ * `props.value = next`.
+ */
+export declare const bindable: <V>(value: V, options?: BindableOptions) => Bindable<V>;
+//#endregion
+//#region src/features/history.d.ts
+/**
+ * A history pseudo-state: `resume: history()` returns to the child its
+ * parent was last in, `history("deep")` to the very states inside it.
+ */
+export declare const history: (type?: "deep") => HistoryState;
+//#endregion
+//#region src/features/job.d.ts
+/** The platform's `AbortSignal` where its types are loaded. */
+type JobSignal = typeof globalThis extends {
+  AbortSignal: {
+    prototype: infer S;
+  };
+} ? S : {
+  readonly aborted: boolean;
+};
+/** A started machine, as `start` returns it. */
+interface Child {
+  readonly context: unknown;
+  readonly done: PromiseLike<void>;
+  stop(): void;
+}
+/** What `run` may return: a promise, a started child machine, a cleanup, or nothing. */
+type Work = PromiseLike<unknown> | Child | (() => void) | void | undefined;
+/** What `done` sends as `data`: a promise's value, a child machine's context. */
+type JobData<R> = R extends PromiseLike<infer T> ? T : R extends Child ? R["context"] : never;
+/** The events of `All` whose payload has `key`: `SAVED: payload<{ data: Draft }>()` for `"data"`. */
+type Carrying<All extends AnyEvent, Key extends string> = { [K in All["type"]]: Key extends keyof Extract<All, {
+  type: K;
+}> ? K : never; }[All["type"]];
+/** What event `D` of `All` carries as `data`. */
+type DataOf<All extends AnyEvent, D> = Extract<All, {
+  type: D;
+}> extends {
+  readonly data: infer T;
+} ? T : never;
+/**
+ * The cleanup, or, when `done`'s event cannot carry what the work produces,
+ * the fix: an effect may not return a string, so the message is the error.
+ */
+type JobCleanup<All extends AnyEvent, R, D> = [D] extends [never] ? () => void : [JobData<R>] extends [DataOf<All, D>] ? () => void : `${D & string} cannot carry what the job's work returns: declare it payload<{ data: T }>() with T its result`;
+/** The events that may carry a job's outcome back: `done` takes `{ data }`, `error` `{ error }`. */
+interface JobEvents<D extends string = string, X extends string = string> {
+  /** Sent with `{ data }` when the work is done. */
+  readonly done?: D;
+  /** Sent with `{ error }` when a promise rejects. */
+  readonly error?: X;
+}
+/**
+ * Starts `run(signal)` for the state whose effect calls it and returns the
+ * cleanup that cancels it. `view` is the effect's view; `done` and
+ * `error` name events the machine declares.
+ */
+export declare function job<All extends AnyEvent, R extends Work, const D extends Carrying<All, "data"> = never, const X extends Carrying<All, "error"> = never>(view: {
+  readonly send: Send<All>;
+}, run: (signal: JobSignal) => R, events?: JobEvents<D, X>): JobCleanup<All, R, D>;
+//#endregion
+//#region src/features/parallel.d.ts
+/** Marks a state whose regions are all active at once: `editor: { type: parallel, states: { … } }`. */
+export declare const parallel: Parallel;
+//#endregion
+//#region src/parts/use.d.ts
+/**
+ * Runs `machine` in a component: `api.parts.<part>` spreads onto each
+ * element, `api.state`, `api.is`, `api.send`, `api.context` and what
+ * `expose` returns read and drive it. Vue, Svelte and Solid also take
+ * `props` as a function, read reactively.
+ */
+export declare function useMachine<M extends AnyMachine>(machine: M, props?: UseProps<M> | (() => UseProps<M>)): Api<M>;
+//#endregion
+export { type Action, type AnyEvent, type AnyMachine, type Api, type Bindable, type BindableOptions, type DerivedView, type DoneEvent, type Effect, type EffectResult, type EventOf, type EventUnion, type Guard, type History, type HistoryState, type Implementations, type Instance, type InstanceOf, type JobCleanup, type JobData, type JobEvents, type JobSignal, type Machine, type MachineConfig, type MachineEvent, type OwnerProps, type Parallel, type PartBase, type PartConfig, type PartEvent, type PartProps, type PartsConfig, type Payload, type PropsOf, type Send, type StartOptions, type StateConfig, type Step, type Transition, type Transitions, type UseProps, type View, type ViewOf, type Work, defineMachine, inspect, payload, provide, start };