@cssints/apg-specs 0.0.0-stage → 0.5.1

package/dist/apg/dialog-modal.bridge.d.mts

@@ -0,0 +1,35 @@
+import { ActionStep, Probe, ScenarioConfig, SpecBridge } from "../scenario.mjs";
+//#region src/apg/dialog-modal.bridge.d.ts
+export interface DialogModalConfig {
+  readonly modal: boolean;
+  readonly role: "dialog" | "alertdialog";
+  readonly open: boolean;
+  readonly dismissable: boolean;
+  readonly keyboardDismissDisabled: boolean;
+  readonly controlled: boolean;
+  /** Controlled only: the host writes every request's intent back as the value. */
+  readonly accepts: boolean;
+}
+/**
+ * Scenario `config` -> what both targets are mounted with. `controlled` puts the
+ * open state in a host; the host accepts every request unless `accepts: false`.
+ * `open` is the initial / pinned value. ariakit's `hideOnEscape: false` is a
+ * rejecting host with Escape ignored; `hideOnInteractOutside: false` makes the
+ * backdrop inert.
+ */
+export declare const dialogModalConfig: (config: ScenarioConfig) => DialogModalConfig;
+/**
+ * Dialog (Modal) vocabulary <-> `specs/apg/dialog-modal.qnt`. The spec models a
+ * four-dialog stack with a fixed page; this bridge only maps the single-dialog
+ * open/close behaviour the ported scenarios share. `open` lands on the spec's
+ * page invoker (position 1); `dismiss` and Escape on its top-dialog Escape;
+ * a click on the inert content is the spec's no-op `pointer_outside`.
+ *
+ * `controlled` puts the open state in a host; `setValue` / `hostToggle` are the
+ * host writing it (inert while uncontrolled).
+ */
+export declare const dialogModalBridge: SpecBridge;
+/** The user-level steps a differential walk draws from. */
+export declare const dialogModalSteps: ReadonlyArray<ActionStep>;
+export declare const dialogModalProbe: Probe;
+//#endregion

package/dist/apg/dialog-modal.bridge.mjs

@@ -0,0 +1,186 @@
+import { Unsupported } from "../scenario.mjs";
+//#region src/apg/dialog-modal.bridge.ts
+const specEvent = (tag, params = {}) => ({
+	_tag: tag,
+	...params
+});
+const CONFIG_KEYS = /* @__PURE__ */ new Set([
+	"modal",
+	"role",
+	"open",
+	"defaultOpen",
+	"isDismissable",
+	"isKeyboardDismissDisabled",
+	"controlled",
+	"accepts",
+	"hideOnEscape",
+	"hideOnInteractOutside"
+]);
+/**
+* Scenario `config` -> what both targets are mounted with. `controlled` puts the
+* open state in a host; the host accepts every request unless `accepts: false`.
+* `open` is the initial / pinned value. ariakit's `hideOnEscape: false` is a
+* rejecting host with Escape ignored; `hideOnInteractOutside: false` makes the
+* backdrop inert.
+*/
+const dialogModalConfig = (config) => {
+	let modal = true;
+	let role = "dialog";
+	let open = false;
+	let dismissable = true;
+	let keyboardDismissDisabled = false;
+	let controlled = false;
+	let accepts = true;
+	for (const [key, raw] of Object.entries(config)) {
+		if (!CONFIG_KEYS.has(key)) throw new Unsupported(`config ${key}=${JSON.stringify(raw)}`);
+		if ((key === "open" || key === "defaultOpen") && typeof raw === "boolean") open = raw;
+		else if (key === "controlled" && typeof raw === "boolean") controlled ||= raw;
+		else if (key === "accepts" && typeof raw === "boolean") accepts = raw;
+		else if (key === "hideOnEscape" && raw === false) {
+			controlled = true;
+			accepts = false;
+			keyboardDismissDisabled = true;
+		} else if (key === "hideOnInteractOutside" && raw === false) dismissable = false;
+		else if (key === "modal" && typeof raw === "boolean") {
+			if (!raw) throw new Unsupported("config modal=false");
+			modal = raw;
+		} else if (key === "role" && (raw === "dialog" || raw === "alertdialog")) role = raw;
+		else if (key === "isDismissable" && typeof raw === "boolean") dismissable = raw;
+		else if (key === "isKeyboardDismissDisabled" && typeof raw === "boolean") keyboardDismissDisabled = raw;
+		else throw new Unsupported(`config ${key}=${JSON.stringify(raw)}`);
+	}
+	return {
+		modal,
+		role,
+		open,
+		dismissable,
+		keyboardDismissDisabled,
+		controlled,
+		accepts: controlled && accepts
+	};
+};
+const PARTS = /* @__PURE__ */ new Set([
+	"trigger",
+	"dialog",
+	"dismiss",
+	"button",
+	"outside",
+	"backdrop"
+]);
+const part = (target) => {
+	const name = (target ?? "").replace(/:0$/, "");
+	if (!PARTS.has(name)) throw new Unsupported(`part ${name}`);
+	return name;
+};
+const ACTIVATION_KEYS = /* @__PURE__ */ new Set([
+	"Enter",
+	" ",
+	"Space"
+]);
+/**
+* Dialog (Modal) vocabulary <-> `specs/apg/dialog-modal.qnt`. The spec models a
+* four-dialog stack with a fixed page; this bridge only maps the single-dialog
+* open/close behaviour the ported scenarios share. `open` lands on the spec's
+* page invoker (position 1); `dismiss` and Escape on its top-dialog Escape;
+* a click on the inert content is the spec's no-op `pointer_outside`.
+*
+* `controlled` puts the open state in a host; `setValue` / `hostToggle` are the
+* host writing it (inert while uncontrolled).
+*/
+const dialogModalBridge = {
+	setup: (config) => {
+		const { open, controlled, accepts } = dialogModalConfig(config);
+		if (controlled) return [
+			specEvent("control"),
+			...accepts ? [specEvent("acceptRequests")] : [],
+			...open ? [specEvent("setValue", { v: true })] : []
+		];
+		return open ? [specEvent("focus_attempt", { target: 1n }), specEvent("activate")] : [];
+	},
+	event: (step) => {
+		switch (step.event) {
+			case "click": {
+				const name = part(step.target);
+				if (name === "outside" || name === "backdrop") return [specEvent("pointer_outside")];
+				if (name === "dismiss") return [specEvent("escape")];
+				return [specEvent("focus_attempt", { target: 1n }), specEvent("activate")];
+			}
+			case "key": {
+				const name = part(step.target);
+				if (step.key === "Escape") return [specEvent("escape")];
+				if (name === "trigger" && ACTIVATION_KEYS.has(step.key ?? "")) return [specEvent("focus_attempt", { target: 1n }), specEvent("activate")];
+				if (name !== "trigger" && ACTIVATION_KEYS.has(step.key ?? "")) return [specEvent("escape")];
+				throw new Unsupported(`key ${step.key ?? ""}`);
+			}
+			case "focus": return part(step.target) === "trigger" ? [specEvent("focus_attempt", { target: 1n })] : [];
+			case "blur":
+			case "hover":
+			case "unhover": return [];
+			case "prop": switch (step.prop) {
+				case "pressEnter":
+				case "pressSpace": return [specEvent("focus_attempt", { target: 1n }), specEvent("activate")];
+				case "escape": return [specEvent("escape")];
+				case "setValue": return [specEvent("setValue", { v: step.value === true })];
+				case "hostToggle": return [specEvent("hostToggle")];
+				default: throw new Unsupported(`prop ${step.prop ?? ""}`);
+			}
+			default: throw new Unsupported(`event ${step.event}`);
+		}
+	},
+	value: (state) => Number(state["depth"]) > 0,
+	focus: () => {
+		throw new Unsupported("the reference model encodes focus as an example-specific target");
+	},
+	attr: (state, target, name) => {
+		if (part(target) === "dialog") {
+			if (name === "role") return "dialog";
+			if (name === "aria-modal") return Number(state["depth"]) > 0 ? "true" : null;
+		}
+		throw new Unsupported(`attribute ${name} on ${target}`);
+	},
+	visible: (state) => Number(state["depth"]) > 0 ? ["dialog"] : [],
+	events: (before, after) => before["requests"] === after["requests"] ? [] : [["onOpenChange", after["requested"] === true]]
+};
+/** The user-level steps a differential walk draws from. */
+const dialogModalSteps = [
+	{
+		event: "click",
+		target: "trigger"
+	},
+	{
+		event: "click",
+		target: "dismiss"
+	},
+	{
+		event: "prop",
+		prop: "pressEnter"
+	},
+	{
+		event: "prop",
+		prop: "pressSpace"
+	},
+	{
+		event: "prop",
+		prop: "escape"
+	},
+	{
+		event: "prop",
+		prop: "setValue",
+		value: true
+	},
+	{
+		event: "prop",
+		prop: "setValue",
+		value: false
+	},
+	{
+		event: "prop",
+		prop: "hostToggle"
+	}
+];
+const dialogModalProbe = {
+	attrs: [["dialog", "role"], ["dialog", "aria-modal"]],
+	events: ["onOpenChange"]
+};
+//#endregion
+export { dialogModalBridge, dialogModalConfig, dialogModalProbe, dialogModalSteps };