@gjermundgaraba/pixel-paper 0.0.0-stage → 0.1.1

package/dist/command-palette/index.d.ts

@@ -0,0 +1,9 @@
+import { Choice, Command, Page, findChoices } from "./match.js";
+import { Message } from "./message.js";
+import { InitConfig, Model, OpenAtConfig, OutMessage, ScrollToCursor, ViewInputs, id, init, isOpen, isPicking, maybeCursorId, maybePageId, open, openAt, pickFailed, pickSucceeded, query, subscriptions, update, view } from "./command-palette.js";
+import { BindPaletteKeys } from "./keys.js";
+import { Focus } from "../focus/focus.js";
+declare namespace index_d_exports {
+  export { BindPaletteKeys, Choice, Command, Focus, InitConfig, Message, Model, OpenAtConfig, OutMessage, Page, ScrollToCursor, ViewInputs, findChoices, id, init, isOpen, isPicking, maybeCursorId, maybePageId, open, openAt, pickFailed, pickSucceeded, query, subscriptions, update, view };
+}
+export { BindPaletteKeys, type Choice, type Command, Focus, type InitConfig, Message, Model, type OpenAtConfig, OutMessage, type Page, ScrollToCursor, type ViewInputs, findChoices, id, index_d_exports, init, isOpen, isPicking, maybeCursorId, maybePageId, open, openAt, pickFailed, pickSucceeded, query, subscriptions, update, view };

package/dist/command-palette/index.js

@@ -0,0 +1,32 @@
+import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { Focus } from "../focus/focus.js";
+import { Message } from "./message.js";
+import { BindPaletteKeys } from "./keys.js";
+import { findChoices } from "./match.js";
+import { Model, OutMessage, ScrollToCursor, id, init, isOpen, isPicking, maybeCursorId, maybePageId, open, openAt, pickFailed, pickSucceeded, query, subscriptions, update, view } from "./command-palette.js";
+// src/command-palette/index.ts
+var command_palette_exports = /* @__PURE__ */ __exportAll({
+	BindPaletteKeys: () => __foldkitBrandViewResult((BindPaletteKeys), "@gjermundgaraba/pixel-paper/command-palette/index.js#BindPaletteKeys"),
+	Focus: () => __foldkitBrandViewResult((Focus), "@gjermundgaraba/pixel-paper/command-palette/index.js#Focus"),
+	Message: () => __foldkitBrandViewResult((Message), "@gjermundgaraba/pixel-paper/command-palette/index.js#Message"),
+	Model: () => __foldkitBrandViewResult((Model), "@gjermundgaraba/pixel-paper/command-palette/index.js#Model"),
+	OutMessage: () => __foldkitBrandViewResult((OutMessage), "@gjermundgaraba/pixel-paper/command-palette/index.js#OutMessage"),
+	ScrollToCursor: () => __foldkitBrandViewResult((ScrollToCursor), "@gjermundgaraba/pixel-paper/command-palette/index.js#ScrollToCursor"),
+	findChoices: () => __foldkitBrandViewResult((findChoices), "@gjermundgaraba/pixel-paper/command-palette/index.js#findChoices"),
+	id: () => __foldkitBrandViewResult((id), "@gjermundgaraba/pixel-paper/command-palette/index.js#id"),
+	init: () => __foldkitBrandViewResult((init), "@gjermundgaraba/pixel-paper/command-palette/index.js#init"),
+	isOpen: () => __foldkitBrandViewResult((isOpen), "@gjermundgaraba/pixel-paper/command-palette/index.js#isOpen"),
+	isPicking: () => __foldkitBrandViewResult((isPicking), "@gjermundgaraba/pixel-paper/command-palette/index.js#isPicking"),
+	maybeCursorId: () => __foldkitBrandViewResult((maybeCursorId), "@gjermundgaraba/pixel-paper/command-palette/index.js#maybeCursorId"),
+	maybePageId: () => __foldkitBrandViewResult((maybePageId), "@gjermundgaraba/pixel-paper/command-palette/index.js#maybePageId"),
+	open: () => __foldkitBrandViewResult((open), "@gjermundgaraba/pixel-paper/command-palette/index.js#open"),
+	openAt: () => __foldkitBrandViewResult((openAt), "@gjermundgaraba/pixel-paper/command-palette/index.js#openAt"),
+	pickFailed: () => __foldkitBrandViewResult((pickFailed), "@gjermundgaraba/pixel-paper/command-palette/index.js#pickFailed"),
+	pickSucceeded: () => __foldkitBrandViewResult((pickSucceeded), "@gjermundgaraba/pixel-paper/command-palette/index.js#pickSucceeded"),
+	query: () => __foldkitBrandViewResult((query), "@gjermundgaraba/pixel-paper/command-palette/index.js#query"),
+	subscriptions: () => __foldkitBrandViewResult((subscriptions), "@gjermundgaraba/pixel-paper/command-palette/index.js#subscriptions"),
+	update: () => __foldkitBrandViewResult((update), "@gjermundgaraba/pixel-paper/command-palette/index.js#update"),
+	view: () => __foldkitBrandViewResult((view), "@gjermundgaraba/pixel-paper/command-palette/index.js#view")
+});
+export { BindPaletteKeys, Focus, Message, Model, OutMessage, ScrollToCursor, command_palette_exports, findChoices, id, init, isOpen, isPicking, maybeCursorId, maybePageId, open, openAt, pickFailed, pickSucceeded, query, subscriptions, update, view };

package/dist/command-palette/keys.d.ts

@@ -0,0 +1,13 @@
+import "./message.js";
+import { Option, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+/** What the palette's card needs of the document as it is at the event: Backspace in an empty
+ *  field on a page goes back (its default prevented), a key an IME is composing never reaches
+ *  the field's handler, and a press on a row keeps focus in the field, so a refused pick
+ *  leaves it there. The arrows and Enter are the field's own handler's, in the view, which
+ *  knows the rows. Escape is the Dialog's: it closes the whole palette. In a Scene, resolve it
+ *  with `Message.PressedBackspace`. */
+export declare const BindPaletteKeys: Mount.MountDefinitionNoArgs<"BindPaletteKeys", {
+  readonly _tag: "PressedBackspace";
+  readonly maybeShownPage: Option.Option<string>;
+}>;

package/dist/command-palette/keys.js

@@ -0,0 +1,71 @@
+import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
+import { isPlain } from "../keys/keys.js";
+import { Message } from "./message.js";
+import { Match, Option, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+import * as Dom from "foldkit/dom";
+// src/command-palette/keys.ts
+const OPTION_SELECTOR = "[role=\"option\"]";
+const FIELD_ATTRIBUTE = "pixel-paper-palette-field";
+const PAGE_ATTRIBUTE = "pixel-paper-palette-page";
+const shownPageOf = (element) => __foldkitBrandViewResult((Option.fromNullishOr(element.getAttribute(`data-${PAGE_ATTRIBUTE}`))), "@gjermundgaraba/pixel-paper/command-palette/keys.js#shownPageOf");
+const isEmptyFieldOnPage = (root, field) => __foldkitBrandViewResult((field instanceof HTMLInputElement && field.value === "" && Option.isSome(shownPageOf(root))), "@gjermundgaraba/pixel-paper/command-palette/keys.js#isEmptyFieldOnPage");
+const isComposingModifiedOrHandled = (event) => __foldkitBrandViewResult((event.isComposing || !isPlain(event) || event.defaultPrevented), "@gjermundgaraba/pixel-paper/command-palette/keys.js#isComposingModifiedOrHandled");
+const fieldKey = (root, event) => {
+	const field = root.querySelector(`[data-${FIELD_ATTRIBUTE}]`);
+	if (field === null || event.target !== field || event.key !== "Backspace" || isComposingModifiedOrHandled(event) || !isEmptyFieldOnPage(root, field)) return __foldkitBrandViewResult((Option.none()), "@gjermundgaraba/pixel-paper/command-palette/keys.js#fieldKey");
+	return __foldkitBrandViewResult((Option.some(Message.PressedBackspace({ maybeShownPage: shownPageOf(root) }))), "@gjermundgaraba/pixel-paper/command-palette/keys.js#fieldKey");
+};
+const composingKey = (event) => {
+	if (event.isComposing) event.stopPropagation();
+	return __foldkitBrandViewResult((Option.none()), "@gjermundgaraba/pixel-paper/command-palette/keys.js#composingKey");
+};
+const rowPress = (event) => {
+	if (event.target instanceof Element && event.target.closest("[role=\"option\"]") !== null) event.preventDefault();
+	return __foldkitBrandViewResult((Option.none()), "@gjermundgaraba/pixel-paper/command-palette/keys.js#rowPress");
+};
+/** What the palette's card needs of the document as it is at the event: Backspace in an empty
+*  field on a page goes back (its default prevented), a key an IME is composing never reaches
+*  the field's handler, and a press on a row keeps focus in the field, so a refused pick
+*  leaves it there. The arrows and Enter are the field's own handler's, in the view, which
+*  knows the rows. Escape is the Dialog's: it closes the whole palette. In a Scene, resolve it
+*  with `Message.PressedBackspace`. */
+const BindPaletteKeys = Mount.defineStream("BindPaletteKeys", {
+	messages: [Message.PressedBackspace],
+	execute: ({ element }) => __foldkitBrandViewResult((Stream.mergeAll([
+		Dom.streamFromEventFilterMap({
+			target: element,
+			type: "keydown",
+			options: { capture: true },
+			filterMapEvent: composingKey
+		}),
+		Dom.streamFromEventFilterMapPreventDefault({
+			target: element,
+			type: "keydown",
+			filterMapEvent: (event) => __foldkitBrandViewResult((fieldKey(element, event)), "@gjermundgaraba/pixel-paper/command-palette/keys.js#filterMapEvent")
+		}),
+		Dom.streamFromEventFilterMap({
+			target: element,
+			type: "mousedown",
+			filterMapEvent: rowPress
+		})
+	], { concurrency: "unbounded" })), "@gjermundgaraba/pixel-paper/command-palette/keys.js#execute")
+});
+const isInsidePalette = (paletteId, event) => __foldkitBrandViewResult((Option.exists(Option.fromNullishOr(document.querySelector(`#${CSS.escape(paletteId)}`)), (dialog) => __foldkitBrandViewResult((event.target instanceof Node && dialog.contains(event.target)), "@gjermundgaraba/pixel-paper/command-palette/keys.js#anonymous"))), "@gjermundgaraba/pixel-paper/command-palette/keys.js#isInsidePalette");
+const earlyKeyMessageOf = (key) => __foldkitBrandViewResult((Match.value(key).pipe(Match.withReturnType(), Match.whenOr("ArrowDown", "ArrowUp", (arrow) => __foldkitBrandViewResult((Option.some(Message.PressedEarlyArrowKey({ key: arrow }))), "@gjermundgaraba/pixel-paper/command-palette/keys.js#anonymous~2")), Match.when("Enter", () => __foldkitBrandViewResult((Option.some(Message.PressedEarlyEnter())), "@gjermundgaraba/pixel-paper/command-palette/keys.js#anonymous~3")), Match.orElse(() => __foldkitBrandViewResult((Option.none()), "@gjermundgaraba/pixel-paper/command-palette/keys.js#anonymous~4")))), "@gjermundgaraba/pixel-paper/command-palette/keys.js#earlyKeyMessageOf");
+const earlyKey = (paletteId, event) => {
+	if (isInsidePalette(paletteId, event) || isComposingModifiedOrHandled(event)) return __foldkitBrandViewResult((Option.none()), "@gjermundgaraba/pixel-paper/command-palette/keys.js#earlyKey");
+	const maybeMessage = earlyKeyMessageOf(event.key);
+	if (Option.isSome(maybeMessage)) {
+		event.preventDefault();
+		event.stopPropagation();
+	}
+	return __foldkitBrandViewResult((maybeMessage), "@gjermundgaraba/pixel-paper/command-palette/keys.js#earlyKey");
+};
+const earlyKeys = (paletteId) => __foldkitBrandViewResult((Dom.streamFromEventFilterMap({
+	target: () => __foldkitBrandViewResult((window), "@gjermundgaraba/pixel-paper/command-palette/keys.js#target"),
+	type: "keydown",
+	options: { capture: true },
+	filterMapEvent: (event) => __foldkitBrandViewResult((earlyKey(paletteId, event)), "@gjermundgaraba/pixel-paper/command-palette/keys.js#filterMapEvent~2")
+})), "@gjermundgaraba/pixel-paper/command-palette/keys.js#earlyKeys");
+export { BindPaletteKeys, FIELD_ATTRIBUTE, OPTION_SELECTOR, PAGE_ATTRIBUTE, composingKey, earlyKey, earlyKeys, fieldKey, rowPress, shownPageOf };

package/dist/command-palette/match.d.ts

@@ -0,0 +1,43 @@
+import { GlyphName } from "../glyph/glyphs.js";
+import { HashSet } from "effect";
+/** One row of the palette: a command, or a choice on a page. */
+export type Choice = Readonly<{
+  id: string;
+  label: string;
+  /** A key or a note at the right (`KeyHint.keyLabel` prints a binding). */
+  hint?: string;
+  /** An authored title (a page, an item): set in sans with a glyph. On the commands it waits
+   *  for a query. */
+  isAuthored?: boolean;
+  glyph?: GlyphName;
+  /** It cannot run now: still found, and the cursor still lands on it, but Enter and a click
+   *  do nothing. Say why in `reason`. */
+  isDisabled?: boolean;
+  /** Why it cannot run now (`"No item open"`), printed in place of the hint while held. */
+  reason?: string;
+  /** On a page, its depth in the page's tree, from 1 at the roots: it sits under the nearest
+   *  choice before it one level up, and indents by its depth. A page without levels is flat. */
+  level?: number;
+}>;
+/** A page of choices a command opens in place (a status, a date, a destination). */
+export type Page = Readonly<{
+  /** The page's name, in the head after Back (`"Status"`, `"Move to"`). */
+  title: string;
+  choices: readonly Choice[];
+  /** The field's placeholder; `"type to narrow"` when not given. */
+  find?: string;
+  /** The choice in force now: tagged current, and not picked again. */
+  current?: string;
+  /** Where the cursor starts while the reader has not moved it: this choice while the query
+   *  finds it, else `current` while the query finds it, else the first choice the query finds
+   *  (the next status after the current one; the first a typed query finds). */
+  start?: string;
+}>;
+/** One command, under its group's heading. With a `page` it opens that page in place instead
+ *  of being selected. */
+export type Command = Omit<Choice, "level"> & Readonly<{
+  group: string;
+  page?: Page;
+}>;
+/** The choices a page's query finds. */
+export declare const findChoices: (page: Page, query: string) => readonly Choice[];

package/dist/command-palette/match.js

@@ -0,0 +1,45 @@
+import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
+import { Array, HashSet, Option, Order, String, pipe } from "effect";
+// src/command-palette/match.ts
+const isSubsequence = (needle, haystack) => __foldkitBrandViewResult((Array.reduce(Array.fromIterable(haystack), 0, (found, character) => __foldkitBrandViewResult((needle.charAt(found) === character ? found + 1 : found), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous")) === needle.length), "@gjermundgaraba/pixel-paper/command-palette/match.js#isSubsequence");
+const matches = (query, label) => {
+	const needle = pipe(query, String.trim, String.toLowerCase);
+	return __foldkitBrandViewResult((isSubsequence(needle, String.toLowerCase(label))), "@gjermundgaraba/pixel-paper/command-palette/match.js#matches");
+};
+const isBlank = (query) => __foldkitBrandViewResult((String.isEmpty(String.trim(query))), "@gjermundgaraba/pixel-paper/command-palette/match.js#isBlank");
+const findCommands = (commands, query) => {
+	const hits = isBlank(query) ? Array.filter(commands, (command) => __foldkitBrandViewResult((command.isAuthored !== true), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~2")) : Array.filter(commands, (command) => __foldkitBrandViewResult((matches(query, command.label)), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~3"));
+	const ordered = [...Array.filter(hits, (command) => __foldkitBrandViewResult((command.isAuthored !== true), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~4")), ...Array.filter(hits, (command) => __foldkitBrandViewResult((command.isAuthored === true), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~5"))];
+	const groups = Array.dedupe(Array.map(ordered, ({ group }) => __foldkitBrandViewResult((group), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~6")));
+	const groupIndex = (command) => __foldkitBrandViewResult((Option.getOrElse(Array.findFirstIndex(groups, (group) => __foldkitBrandViewResult((group === command.group), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~7")), () => __foldkitBrandViewResult((groups.length), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~8"))), "@gjermundgaraba/pixel-paper/command-palette/match.js#groupIndex");
+	return __foldkitBrandViewResult((Array.sort(ordered, Order.mapInput(Order.Number, groupIndex))), "@gjermundgaraba/pixel-paper/command-palette/match.js#findCommands");
+};
+/** The choices a page's query finds. */
+const findChoices = (page, query) => __foldkitBrandViewResult((isBlank(query) ? page.choices : Array.filter(page.choices, (choice) => __foldkitBrandViewResult((matches(query, choice.label)), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~9"))), "@gjermundgaraba/pixel-paper/command-palette/match.js#findChoices");
+const WALK_START = {
+	chain: [],
+	keptIds: HashSet.empty()
+};
+const unfiltered = (page) => (__foldkitBrandViewResult(({
+	rows: page.choices,
+	found: page.choices,
+	contextIds: HashSet.empty()
+}), "@gjermundgaraba/pixel-paper/command-palette/match.js#unfiltered"));
+const treeChoices = (page, query) => {
+	const found = findChoices(page, query);
+	const foundIds = HashSet.fromIterable(Array.map(found, ({ id }) => __foldkitBrandViewResult((id), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~10")));
+	const { keptIds } = Array.reduce(page.choices, WALK_START, ({ chain, keptIds: keptSoFar }, choice) => {
+		const nextChain = Array.append(Array.take(chain, (choice.level ?? 1) - 1), choice);
+		return __foldkitBrandViewResult(({
+			chain: nextChain,
+			keptIds: HashSet.has(foundIds, choice.id) ? HashSet.union(keptSoFar, HashSet.fromIterable(Array.map(nextChain, ({ id }) => __foldkitBrandViewResult((id), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~12")))) : keptSoFar
+		}), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~11");
+	});
+	return __foldkitBrandViewResult(({
+		rows: Array.filter(page.choices, ({ id }) => __foldkitBrandViewResult((HashSet.has(keptIds, id)), "@gjermundgaraba/pixel-paper/command-palette/match.js#anonymous~13")),
+		found,
+		contextIds: HashSet.difference(keptIds, foundIds)
+	}), "@gjermundgaraba/pixel-paper/command-palette/match.js#treeChoices");
+};
+const pageChoices = (page, query) => __foldkitBrandViewResult((isBlank(query) ? unfiltered(page) : treeChoices(page, query)), "@gjermundgaraba/pixel-paper/command-palette/match.js#pageChoices");
+export { findChoices, findCommands, matches, pageChoices };

package/dist/command-palette/message.d.ts

@@ -0,0 +1,94 @@
+import { Schema } from "effect";
+/** Union of all Messages a command palette can produce. */
+export declare const Message: import("foldkit/message").MessageUnion<{
+  readonly GotDialogMessage: {
+    message: import("foldkit/message").MessageUnion<{
+      readonly GotDialogMessage: {
+        message: import("foldkit/message").MessageUnion<{
+          readonly RequestedOpen: {};
+          readonly RequestedClose: {};
+          readonly SucceededShowDialog: {};
+          readonly FailedShowDialog: {};
+          readonly SucceededAcquireResources: {};
+          readonly FailedAcquireResources: {};
+          readonly CompletedCloseDialog: {};
+          readonly Unmounted: {};
+          readonly CompletedReleaseDialogResources: {};
+          readonly GotAnimationMessage: {
+            message: import("foldkit/message").MessageUnion<{
+              readonly Showed: {};
+              readonly Hid: {};
+              readonly CompletedWaitForPaint: {
+                generation: Schema.Number;
+              };
+              readonly EndedAnimation: {
+                generation: Schema.Number;
+              };
+            }>;
+          };
+        }>;
+      };
+      readonly PressedActionKey: {
+        direction: Schema.Literals<readonly ["Previous", "Next"]>;
+      };
+    }>;
+  };
+  readonly UpdatedQuery: {
+    value: Schema.String;
+    maybeShownPage: Schema.Option<Schema.String>;
+  };
+  readonly PressedArrowKey: {
+    key: Schema.Literals<readonly ["ArrowUp", "ArrowDown"]>;
+    snapshot: Schema.Struct<{
+      readonly maybeShownPage: Schema.Option<Schema.String>;
+      readonly shownQuery: Schema.String;
+      readonly shownShift: Schema.Finite;
+      readonly rows: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly isHeld: Schema.Boolean;
+        readonly hasPage: Schema.Boolean;
+      }>>;
+      readonly maybeShownCursor: Schema.Option<Schema.String>;
+    }>;
+  };
+  readonly PressedEarlyArrowKey: {
+    key: Schema.Literals<readonly ["ArrowUp", "ArrowDown"]>;
+  };
+  readonly CompletedReportPendingKeys: {
+    renderGeneration: Schema.Int;
+    maybeRow: Schema.Option<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly isHeld: Schema.Boolean;
+      readonly hasPage: Schema.Boolean;
+    }>>;
+  };
+  readonly PressedEnter: {
+    snapshot: Schema.Struct<{
+      readonly maybeShownPage: Schema.Option<Schema.String>;
+      readonly shownQuery: Schema.String;
+      readonly shownShift: Schema.Finite;
+      readonly rows: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly isHeld: Schema.Boolean;
+        readonly hasPage: Schema.Boolean;
+      }>>;
+      readonly maybeShownCursor: Schema.Option<Schema.String>;
+    }>;
+  };
+  readonly PressedEarlyEnter: {};
+  readonly PressedBackspace: {
+    maybeShownPage: Schema.Option<Schema.String>;
+  };
+  readonly ClickedRow: {
+    row: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly isHeld: Schema.Boolean;
+      readonly hasPage: Schema.Boolean;
+    }>;
+    maybeShownPage: Schema.Option<Schema.String>;
+  };
+  readonly ClickedBack: {};
+  readonly CompletedScrollToCursor: {};
+  readonly CompletedFocus: {};
+}>;
+export type Message = typeof Message.Type;

package/dist/command-palette/message.js

@@ -0,0 +1,46 @@
+import { Message as Message$1 } from "../dialog/dialog.js";
+import { Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/command-palette/message.ts
+const ShownPage = Schema.Option(Schema.String);
+const ShownRow = Schema.Struct({
+	id: Schema.String,
+	isHeld: Schema.Boolean,
+	hasPage: Schema.Boolean
+});
+const RenderSnapshot = Schema.Struct({
+	maybeShownPage: ShownPage,
+	shownQuery: Schema.String,
+	shownShift: Schema.Finite,
+	rows: Schema.Array(ShownRow),
+	maybeShownCursor: Schema.Option(Schema.String)
+});
+const ArrowKey = Schema.Literals(["ArrowUp", "ArrowDown"]);
+/** Union of all Messages a command palette can produce. */
+const Message = defineMessageUnion({
+	GotDialogMessage: { message: Message$1 },
+	UpdatedQuery: {
+		value: Schema.String,
+		maybeShownPage: ShownPage
+	},
+	PressedArrowKey: {
+		key: ArrowKey,
+		snapshot: RenderSnapshot
+	},
+	PressedEarlyArrowKey: { key: ArrowKey },
+	CompletedReportPendingKeys: {
+		renderGeneration: Schema.Int,
+		maybeRow: Schema.Option(ShownRow)
+	},
+	PressedEnter: { snapshot: RenderSnapshot },
+	PressedEarlyEnter: {},
+	PressedBackspace: { maybeShownPage: ShownPage },
+	ClickedRow: {
+		row: ShownRow,
+		maybeShownPage: ShownPage
+	},
+	ClickedBack: {},
+	CompletedScrollToCursor: {},
+	CompletedFocus: {}
+});
+export { ArrowKey, Message, ShownRow };

package/dist/confirm-dialog/confirm-dialog.d.ts

@@ -0,0 +1,287 @@
+import { UpdateContext } from "../dialog/dialog.js";
+import { Schema } from "effect";
+import { Html } from "foldkit/html";
+import * as Update from "foldkit/update";
+/** Schema for a confirm dialog: the pixel-paper Dialog it opens in. */
+export declare const Model: Schema.Struct<{
+  readonly dialog: Schema.Struct<{
+    readonly dialog: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly isOpen: Schema.Boolean;
+      readonly isAnimated: Schema.Boolean;
+      readonly animation: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly isShowing: Schema.Boolean;
+        readonly transitionState: Schema.Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        readonly transitionGeneration: Schema.Number;
+      }>;
+      readonly maybeFocusSelector: Schema.Option<Schema.String>;
+    }>;
+  }>;
+}>;
+export type Model = typeof Model.Type;
+/** Union of all Messages a confirm dialog can produce. */
+export declare const Message: import("foldkit/message").MessageUnion<{
+  readonly GotDialogMessage: {
+    message: import("foldkit/message").MessageUnion<{
+      readonly GotDialogMessage: {
+        message: import("foldkit/message").MessageUnion<{
+          readonly RequestedOpen: {};
+          readonly RequestedClose: {};
+          readonly SucceededShowDialog: {};
+          readonly FailedShowDialog: {};
+          readonly SucceededAcquireResources: {};
+          readonly FailedAcquireResources: {};
+          readonly CompletedCloseDialog: {};
+          readonly Unmounted: {};
+          readonly CompletedReleaseDialogResources: {};
+          readonly GotAnimationMessage: {
+            message: import("foldkit/message").MessageUnion<{
+              readonly Showed: {};
+              readonly Hid: {};
+              readonly CompletedWaitForPaint: {
+                generation: Schema.Number;
+              };
+              readonly EndedAnimation: {
+                generation: Schema.Number;
+              };
+            }>;
+          };
+        }>;
+      };
+      readonly PressedActionKey: {
+        direction: Schema.Literals<readonly ["Previous", "Next"]>;
+      };
+    }>;
+  };
+  readonly ClickedConfirm: {};
+  readonly ClickedCancel: {};
+}>;
+export type Message = typeof Message.Type;
+/** Union of OutMessages a confirm dialog reports. `Confirmed`: the reader pressed the action;
+ *  the dialog stays open until the parent calls `close`. `Cancelled`: cancel, Escape or a click
+ *  on the veil; the dialog has closed, and whether that also stops work already running is
+ *  the parent's to decide. Never reported while its ways out are held (`Dialog.UpdateContext`). */
+export declare const OutMessage: import("foldkit/message").MessageUnion<{
+  readonly Confirmed: {};
+  readonly Cancelled: {};
+}>;
+export type OutMessage = typeof OutMessage.Type;
+/** Configuration for creating a confirm dialog with `init`. */
+export type InitConfig = Readonly<{
+  id: string;
+}>;
+/** Creates a closed confirm dialog. */
+export declare const init: (config: InitConfig) => Model;
+/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage.
+ *  While `context.isCloseHeld`, cancel, Escape and the veil change nothing. */
+export declare const update: (model: Model, message: Message, context?: UpdateContext) => Readonly<{
+  model: {
+    readonly dialog: {
+      readonly dialog: {
+        readonly id: string;
+        readonly isOpen: boolean;
+        readonly isAnimated: boolean;
+        readonly animation: {
+          readonly id: string;
+          readonly isShowing: boolean;
+          readonly transitionState: "EnterAnimating" | "EnterStart" | "Idle" | "LeaveAnimating" | "LeaveStart";
+          readonly transitionGeneration: number;
+        };
+        readonly maybeFocusSelector: import("effect/Option").Option<string>;
+      };
+    };
+  };
+  commands?: Update.Commands<{
+    readonly _tag: "ClickedCancel";
+  } | {
+    readonly _tag: "ClickedConfirm";
+  } | {
+    readonly _tag: "GotDialogMessage";
+    readonly message: {
+      readonly _tag: "GotDialogMessage";
+      readonly message: {
+        readonly _tag: "CompletedCloseDialog";
+      } | {
+        readonly _tag: "CompletedReleaseDialogResources";
+      } | {
+        readonly _tag: "FailedAcquireResources";
+      } | {
+        readonly _tag: "FailedShowDialog";
+      } | {
+        readonly _tag: "GotAnimationMessage";
+        readonly message: {
+          readonly _tag: "CompletedWaitForPaint";
+          readonly generation: number;
+        } | {
+          readonly _tag: "EndedAnimation";
+          readonly generation: number;
+        } | {
+          readonly _tag: "Hid";
+        } | {
+          readonly _tag: "Showed";
+        };
+      } | {
+        readonly _tag: "RequestedClose";
+      } | {
+        readonly _tag: "RequestedOpen";
+      } | {
+        readonly _tag: "SucceededAcquireResources";
+      } | {
+        readonly _tag: "SucceededShowDialog";
+      } | {
+        readonly _tag: "Unmounted";
+      };
+    } | {
+      readonly _tag: "PressedActionKey";
+      readonly direction: "Next" | "Previous";
+    };
+  }, never>;
+  outMessage?: {
+    readonly _tag: "Cancelled";
+  } | {
+    readonly _tag: "Confirmed";
+  };
+}>;
+/** Opens the confirm dialog: focus starts on the action, or on cancel when it is `isDanger`. */
+export declare const open: (model: Model) => Update.Return<Model, Message>;
+/** Closes the confirm dialog without reporting `Cancelled`: call it once confirmed work has
+ *  landed. */
+export declare const close: (model: Model) => Update.Return<Model, Message>;
+/** The confirm dialog's id, unique in the document. */
+export declare const id: (model: Model) => string;
+/** Whether the confirm dialog is open. */
+export declare const isOpen: (model: Model) => boolean;
+/** Per-render inputs passed to `view` through `h.submodel`'s `viewInputs`. */
+export type ViewInputs = Readonly<{
+  /** The title bar: the action's name (`"Delete"`). */
+  title: string;
+  /** Pixel caps under the glyph: the question (`"Delete this file?"`), the Outcome's title. */
+  question: string;
+  /** One sans sentence: what happens, and what cannot be undone. Markup that carries no
+   *  handlers: it is built in the application's boundary and rendered in this Submodel's (put
+   *  controls in `toDetailView`). */
+  body: ReadonlyArray<Html | string>;
+  /** Under the sentence: what the work said back (an error Notice, what to do about it, a
+   *  notice with its own retry). A slot that may carry the application's handlers, so a
+   *  function. */
+  toDetailView?: () => ReadonlyArray<Html | string>;
+  /** The confirming button's word (`"delete"`). */
+  label: string;
+  /** Destructive: the confirming button turns red and cancel becomes the default. */
+  isDanger?: boolean;
+  /** The confirmed work is running: the confirming button is held (its word stays, the
+   *  working cursor prints, a second press does nothing) and keeps focus, and cancel is held
+   *  with it. Pair it with `isCloseHeld` in `update`'s context, from the same state, so
+   *  Escape and the veil change nothing either. */
+  isBusy?: boolean;
+  /** The action cannot run now (nothing is running; it is blocked): the confirming button is
+   *  held, `aria-disabled` without the working cursor, and stays in the keyboard, so focus
+   *  does not fall to the page. Cancel stays live. */
+  isDisabled?: boolean;
+  /** The page's live region and toasts while this is the topmost open dialog, `undefined`
+   *  while it is not (see `Dialog`). */
+  toLiveRegionView?: (() => Html) | undefined;
+}>;
+/**
+ * The one question before an irreversible step: a glyph in a box, a headline, a sentence. With
+ * `isDanger` it is the system's only destructive confirm. The thing that destroys (delete,
+ * disable, reset) is a neutral Button at rest that opens this dialog; the red button is the
+ * commit inside it, focus starts on cancel, and the dialog is an alert (`alertdialog`); without
+ * it the dialog is a plain one with focus on the action. There is no inline
+ * arm-then-confirm button: red never rests on a button, and an armed button is easy to
+ * double-click through.
+ *
+ * Work that takes a while stays in the dialog: set `isBusy` while it runs (and `isCloseHeld`
+ * in `update`'s context), `close` once it has landed, and on failure keep it open with the
+ * error in `toDetailView`.
+ */
+export declare const view: import("foldkit/submodel").View<{
+  readonly dialog: {
+    readonly dialog: {
+      readonly id: string;
+      readonly isOpen: boolean;
+      readonly isAnimated: boolean;
+      readonly animation: {
+        readonly id: string;
+        readonly isShowing: boolean;
+        readonly transitionState: "EnterAnimating" | "EnterStart" | "Idle" | "LeaveAnimating" | "LeaveStart";
+        readonly transitionGeneration: number;
+      };
+      readonly maybeFocusSelector: import("effect/Option").Option<string>;
+    };
+  };
+}, {
+  readonly _tag: "ClickedCancel";
+} | {
+  readonly _tag: "ClickedConfirm";
+} | {
+  readonly _tag: "GotDialogMessage";
+  readonly message: {
+    readonly _tag: "GotDialogMessage";
+    readonly message: {
+      readonly _tag: "CompletedCloseDialog";
+    } | {
+      readonly _tag: "CompletedReleaseDialogResources";
+    } | {
+      readonly _tag: "FailedAcquireResources";
+    } | {
+      readonly _tag: "FailedShowDialog";
+    } | {
+      readonly _tag: "GotAnimationMessage";
+      readonly message: {
+        readonly _tag: "CompletedWaitForPaint";
+        readonly generation: number;
+      } | {
+        readonly _tag: "EndedAnimation";
+        readonly generation: number;
+      } | {
+        readonly _tag: "Hid";
+      } | {
+        readonly _tag: "Showed";
+      };
+    } | {
+      readonly _tag: "RequestedClose";
+    } | {
+      readonly _tag: "RequestedOpen";
+    } | {
+      readonly _tag: "SucceededAcquireResources";
+    } | {
+      readonly _tag: "SucceededShowDialog";
+    } | {
+      readonly _tag: "Unmounted";
+    };
+  } | {
+    readonly _tag: "PressedActionKey";
+    readonly direction: "Next" | "Previous";
+  };
+}, Readonly<{
+  /** The title bar: the action's name (`"Delete"`). */
+  title: string;
+  /** Pixel caps under the glyph: the question (`"Delete this file?"`), the Outcome's title. */
+  question: string;
+  /** One sans sentence: what happens, and what cannot be undone. Markup that carries no
+   *  handlers: it is built in the application's boundary and rendered in this Submodel's (put
+   *  controls in `toDetailView`). */
+  body: ReadonlyArray<Html | string>;
+  /** Under the sentence: what the work said back (an error Notice, what to do about it, a
+   *  notice with its own retry). A slot that may carry the application's handlers, so a
+   *  function. */
+  toDetailView?: () => ReadonlyArray<Html | string>;
+  /** The confirming button's word (`"delete"`). */
+  label: string;
+  /** Destructive: the confirming button turns red and cancel becomes the default. */
+  isDanger?: boolean;
+  /** The confirmed work is running: the confirming button is held (its word stays, the
+   *  working cursor prints, a second press does nothing) and keeps focus, and cancel is held
+   *  with it. Pair it with `isCloseHeld` in `update`'s context, from the same state, so
+   *  Escape and the veil change nothing either. */
+  isBusy?: boolean;
+  /** The action cannot run now (nothing is running; it is blocked): the confirming button is
+   *  held, `aria-disabled` without the working cursor, and stays in the keyboard, so focus
+   *  does not fall to the page. Cancel stays live. */
+  isDisabled?: boolean;
+  /** The page's live region and toasts while this is the topmost open dialog, `undefined`
+   *  while it is not (see `Dialog`). */
+  toLiveRegionView?: (() => Html) | undefined;
+}>>;