@mantaq/viz 0.0.0 → 0.2.0

package/dist/html-BfvuzJs6.mjs

@@ -0,0 +1,55 @@
+// src/html.ts
+/** Element id the standalone page carries its document in (read by `mountEmbedded`). */
+const DOCUMENT_ELEMENT_ID = "mantaq-viz-document";
+function escapeText(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+/** Inline script or style text may not close its own element early. */
+function inline(text, tag) {
+	return text.replaceAll(`</${tag}`, `<\\/${tag}`);
+}
+/**
+* One HTML file that shows `document` with no server and no network: the
+* viewer bundle, its CSS and the document are all inlined.
+*/
+function standaloneHtml(parts) {
+	return [
+		"<!doctype html>",
+		"<html lang=\"en\">",
+		"<head>",
+		"<meta charset=\"utf-8\" />",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />",
+		`<title>${escapeText(parts.title)}</title>`,
+		`<style>${inline(parts.css, "style")}</style>`,
+		"</head>",
+		"<body class=\"viz\">",
+		"<main id=\"app\"></main>",
+		`<script type="application/json" id="${DOCUMENT_ELEMENT_ID}">${parts.document.replaceAll("<", "\\u003c")}<\/script>`,
+		`<script>${inline(parts.script, "script")}<\/script>`,
+		"</body>",
+		"</html>",
+		""
+	].join("\n");
+}
+/** Custom HMR event `@mantaq/inspect/vite` sends after a machine file changes. */
+const UPDATE_EVENT = "mantaq:viz-update";
+/** The live page: the viewer as a module, fetching the document from `source`. */
+function livePageHtml(parts) {
+	return [
+		"<!doctype html>",
+		"<html lang=\"en\">",
+		"<head>",
+		"<meta charset=\"utf-8\" />",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />",
+		`<title>${escapeText(parts.title)}</title>`,
+		`<style>${inline(parts.css, "style")}</style>`,
+		"</head>",
+		"<body class=\"viz\">",
+		`<main id="app" data-src="${escapeText(parts.source)}"></main>`,
+		`<script type="module" src="${escapeText(parts.entry)}"><\/script>`,
+		"</body>",
+		"</html>",
+		""
+	].join("\n");
+}
+export { standaloneHtml as i, UPDATE_EVENT as n, livePageHtml as r, DOCUMENT_ELEMENT_ID as t };

package/dist/index.d.mts

@@ -0,0 +1,82 @@
+import { A as coveredByAny, C as VizLiveState, D as VizMachine, E as VizLocation, M as scopeOf, O as VizState, S as VizLiveOutcome, T as VizLiveTimer, _ as VizExplanation, a as VIZ_SCHEMA_VERSION, b as VizFuzzSequence, c as VizComparison, d as VizDriver, f as VizEdge, g as VizEvent, h as VizEffect, i as ANY_STATE, j as isAnyState, k as VizStep, l as VizCoverage, m as VizEdgeOrigin, n as validateViz, o as VizBranch, p as VizEdgeKind, r as VizIssue, s as VizBranchTarget, t as parseViz, u as VizDocument, v as VizFuzz, w as VizLiveStep, x as VizJson, y as VizFuzzError } from "./validate-C_EXBtem.mjs";
+/** Byte-stable JSON: sorted object keys, two-space indent, trailing newline. */
+export declare function serializeViz(document: VizDocument): string;
+/**
+ * Walking the drawn graph by hand: no actor runs. A path is the edges taken
+ * from the initial state, each with the state it led to. Guards are not
+ * evaluated, so a path shows what the declarations allow, not what a run does.
+ */
+interface ExploreStep {
+  edge: string;
+  to: string;
+}
+/**
+ * `input`: sent from outside. `effect`: sent by an effect of the current
+ * state (its `sends` list). `internal`: any other internal event (another
+ * actor, a timer the effect did not declare, a test injecting it).
+ */
+type MoveGroup = "input" | "effect" | "internal";
+interface Move {
+  edge: VizEdge;
+  /** States this edge can lead to; several for an undetermined edge, none when unknown. */
+  targets: string[];
+  group: MoveGroup;
+  /** Effects of the current state whose `sends` list this event. */
+  sentBy: string[];
+}
+/**
+ * Every edge an event can take out of `state`: its own registrations and the
+ * `onAny` ones. A final state has none: the actor has stopped.
+ */
+export declare function movesFrom(machine: VizMachine, state: string): Move[];
+/** Where a path ends: the last step's target, or the initial state. */
+export declare function stateAfter(machine: VizMachine, path: ReadonlyArray<ExploreStep>): string | null;
+/** Events an effect of `state` declares in `sends` that no handler in `state` takes. */
+export declare function unhandledSends(machine: VizMachine, state: string): Array<{
+  effect: string;
+  event: string;
+}>;
+/** One step as text for a URL: the edge id, plus `~target` when the edge has no single target. */
+export declare function encodeStep(machine: VizMachine, step: ExploreStep): string;
+/**
+ * Rebuild a path from encoded steps (e.g. `?step=` in a shared link). Stops at
+ * the first step the graph does not allow from where the path has got to, so
+ * a link from an older document still opens at its last valid point.
+ */
+export declare function decodePath(machine: VizMachine, encoded: ReadonlyArray<string>): ExploreStep[];
+interface RoutingWarning {
+  machine: string;
+  event: string;
+  message: string;
+}
+/**
+ * `onAny` handlers that pick their target from the current state. Drawn from
+ * `*`, they claim every declared target from every state; per-state `m.on`
+ * registrations would draw the exact source/target pairs.
+ */
+export declare function routingWarnings(machine: VizMachine): RoutingWarning[];
+/** Element id the standalone page carries its document in (read by `mountEmbedded`). */
+export declare const DOCUMENT_ELEMENT_ID = "mantaq-viz-document";
+/**
+ * One HTML file that shows `document` with no server and no network: the
+ * viewer bundle, its CSS and the document are all inlined.
+ */
+export declare function standaloneHtml(parts: {
+  title: string;
+  /** Built viewer bundle (classic script) whose entry is `viewer/standalone.ts`. */
+  script: string;
+  css: string;
+  /** Serialized viz document. */
+  document: string;
+}): string;
+/** Custom HMR event `@mantaq/inspect/vite` sends after a machine file changes. */
+export declare const UPDATE_EVENT = "mantaq:viz-update";
+/** The live page: the viewer as a module, fetching the document from `source`. */
+export declare function livePageHtml(parts: {
+  title: string;
+  source: string;
+  entry: string;
+  /** Stylesheet text, inlined: the built entry carries no CSS of its own. */
+  css: string;
+}): string;
+export { ANY_STATE, type ExploreStep, type Move, type MoveGroup, type RoutingWarning, VIZ_SCHEMA_VERSION, VizBranch, VizBranchTarget, VizComparison, VizCoverage, VizDocument, VizDriver, VizEdge, VizEdgeKind, VizEdgeOrigin, VizEffect, VizEvent, VizExplanation, VizFuzz, VizFuzzError, VizFuzzSequence, type VizIssue, VizJson, VizLiveOutcome, VizLiveState, VizLiveStep, VizLiveTimer, VizLocation, VizMachine, VizState, VizStep, coveredByAny, isAnyState, parseViz, scopeOf, validateViz };

package/dist/index.mjs

@@ -0,0 +1,13 @@
+import { a as encodeStep, c as stateAfter, d as validateViz, f as ANY_STATE, g as scopeOf, h as isAnyState, l as unhandledSends, m as coveredByAny, o as movesFrom, p as VIZ_SCHEMA_VERSION, r as decodePath, t as routingWarnings, u as parseViz } from "./routing-xXYo05xv.mjs";
+import { i as standaloneHtml, n as UPDATE_EVENT, r as livePageHtml, t as DOCUMENT_ELEMENT_ID } from "./html-BfvuzJs6.mjs";
+// src/serialize.ts
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, sortKeys(child)]));
+}
+/** Byte-stable JSON: sorted object keys, two-space indent, trailing newline. */
+function serializeViz(document) {
+	return `${JSON.stringify(sortKeys(document), null, 2)}\n`;
+}
+export { ANY_STATE, DOCUMENT_ELEMENT_ID, UPDATE_EVENT, VIZ_SCHEMA_VERSION, coveredByAny, decodePath, encodeStep, isAnyState, livePageHtml, movesFrom, parseViz, routingWarnings, scopeOf, serializeViz, standaloneHtml, stateAfter, unhandledSends, validateViz };

package/dist/live.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/live.mjs

@@ -0,0 +1,16 @@
+import { n as UPDATE_EVENT } from "./html-BfvuzJs6.mjs";
+import { mountLive } from "./page.mjs";
+// src/viewer/live.ts
+/**
+* Entry of the live page the `@mantaq/inspect/vite` plugin serves. Reads the
+* document URL from `#app[data-src]` and redraws, keeping the walk, whenever
+* the dev server reports that a machine file changed.
+*/
+const root = document.querySelector("#app");
+const source = root?.dataset["src"];
+if (root && source !== void 0) {
+	const draw = () => void mountLive(root, source);
+	draw();
+	import.meta.hot?.on(UPDATE_EVENT, draw);
+}
+export {};

package/dist/page.d.mts

@@ -0,0 +1,7 @@
+import { a as ViewerOptions } from "./embed-CISoaFIK.mjs";
+/** Options that open the walk named in the address bar and keep it there. */
+export declare function linkOptions(): ViewerOptions;
+/** Mount the document embedded in the page itself. */
+export declare function mountEmbedded(root: HTMLElement): void;
+/** Fetch the document from `source` and mount it; call again to redraw, keeping the walk. */
+export declare function mountLive(root: HTMLElement, source: string): Promise<void>;

package/dist/page.mjs

@@ -0,0 +1,53 @@
+import "./html-BfvuzJs6.mjs";
+import { n as showIssues, t as mountVizText } from "./embed-QX7vRXoL.mjs";
+// src/viewer/page.ts
+/**
+* Whole-page entries: a self-contained HTML file (`mountEmbedded`) and a live
+* page served by a dev server (`mountLive`). Both keep `?machine=&step=` in
+* the address bar so a walk can be shared.
+*/
+function rememberWalk(where) {
+	const next = new URLSearchParams(location.search);
+	next.set("machine", where.machine);
+	next.delete("step");
+	for (const step of where.steps) next.append("step", step);
+	history.replaceState(null, "", `?${next.toString()}`);
+}
+/** Options that open the walk named in the address bar and keep it there. */
+function linkOptions() {
+	const params = new URLSearchParams(location.search);
+	const machine = params.get("machine");
+	return {
+		...machine === null ? {} : { machine },
+		steps: params.getAll("step"),
+		onNavigate: rememberWalk
+	};
+}
+/** Mount the document embedded in the page itself. */
+function mountEmbedded(root) {
+	const text = document.getElementById("mantaq-viz-document")?.textContent ?? "";
+	mountVizText(root, {
+		source: document.title,
+		text
+	}, linkOptions());
+}
+/** Fetch the document from `source` and mount it; call again to redraw, keeping the walk. */
+async function mountLive(root, source) {
+	const response = await fetch(source).catch(() => null);
+	if (response === null || !response.ok) {
+		const status = response === null ? "network error" : `HTTP ${response.status}`;
+		showIssues(root, {
+			source,
+			issues: [{
+				path: "$",
+				message: status
+			}]
+		});
+		return;
+	}
+	mountVizText(root, {
+		source,
+		text: await response.text()
+	}, linkOptions());
+}
+export { linkOptions, mountEmbedded, mountLive };