foldkit-primitives 0.15.4 → 0.16.0

package/dist/interaction/press.d.ts

@@ -0,0 +1,152 @@
+import { Schema } from "effect";
+import { Bundle, Declared } from "foldkit-bundle";
+import * as Mount from "foldkit/mount";
+import { Behavior } from "foldkit-mixins";
+export declare const PointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
+export type PointerType = typeof PointerType.Type;
+export declare const Model: Schema.Struct<{
+  /** Down and not yet released or cancelled. For styling. */
+  readonly pressed: Schema.Boolean;
+  /** The pointer that pressed, so another pointer's up cannot release it. */
+  readonly pointerId: Schema.NullOr<Schema.Number>;
+  /** Enter or Space is down. */
+  readonly key: Schema.NullOr<Schema.String>;
+  /** A click arriving before this generation's window ends is the ghost of a pointer press. */
+  readonly suppressing: Schema.NullOr<Schema.Number>;
+  readonly generation: Schema.Number;
+}>;
+export type Model = typeof Model.Type;
+export declare const Message: import("foldkit/message").MessageUnion<{
+  readonly PointerDown: {
+    pointerId: Schema.Number;
+    button: Schema.Number;
+    pointerType: Schema.String;
+  };
+  readonly PointerUp: {
+    pointerId: Schema.Number;
+    pointerType: Schema.String;
+    shiftKey: Schema.Boolean;
+  };
+  readonly PointerCancelled: {
+    pointerId: Schema.Number;
+  };
+  readonly KeyDown: {
+    key: Schema.String;
+    repeat: Schema.Boolean;
+  };
+  readonly KeyUp: {
+    key: Schema.String;
+    shiftKey: Schema.Boolean;
+  };
+  /** `detail` is 0 for a click no pointer made: keyboard on a native control, or assistive technology. */
+  readonly Clicked: {
+    detail: Schema.Number;
+    shiftKey: Schema.Boolean;
+  };
+  readonly Unsuppressed: {
+    generation: Schema.Number;
+  };
+}>;
+export type Message = typeof Message.Type;
+export declare const Pressed: Schema.TaggedStruct<"Pressed", {
+  readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
+  /** Shift was held, for a range selection. */
+  readonly shiftKey: Schema.Boolean;
+}>;
+export type Pressed = typeof Pressed.Type;
+export declare const Args: Schema.Struct<{
+  /** How long after a pointer press a `click` is taken for its ghost. */
+  readonly clickSuppressionMs: Schema.Number;
+}>;
+export type Args = typeof Args.Type;
+export declare const bundle: Bundle.Bundle<"Press", {
+  readonly clickSuppressionMs: number;
+}, {
+  readonly pressed: boolean;
+  readonly pointerId: number | null;
+  readonly key: string | null;
+  readonly suppressing: number | null;
+  readonly generation: number;
+}, {
+  readonly _tag: "Clicked";
+  readonly detail: number;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "KeyDown";
+  readonly key: string;
+  readonly repeat: boolean;
+} | {
+  readonly _tag: "KeyUp";
+  readonly key: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "PointerCancelled";
+  readonly pointerId: number;
+} | {
+  readonly _tag: "PointerDown";
+  readonly pointerId: number;
+  readonly button: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "PointerUp";
+  readonly pointerId: number;
+  readonly pointerType: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "Unsuppressed";
+  readonly generation: number;
+}, {
+  readonly _tag: "Pressed";
+  readonly pointerType: "keyboard" | "mouse" | "pen" | "touch" | "virtual";
+  readonly shiftKey: boolean;
+}, never, never, void, {}, {}>;
+/** What the element reports; `Unsuppressed` comes from the timer, not the DOM. */
+export type Fact = Exclude<Message, {
+  readonly _tag: 'Unsuppressed';
+}>;
+/**
+ * The element's press-relevant events as facts. Enter and Space key downs
+ * are default-prevented so a native control does not also click, and Space
+ * does not scroll; the Bundle owns activation. An element marked
+ * `aria-disabled="true"` (which the Behavior writes) reports nothing, read
+ * at event time so a toggle needs no remount. Nothing else is decided here.
+ */
+export declare const events: Mount.MountDefinitionNoArgs<"PressEvents", {
+  readonly _tag: "Clicked";
+  readonly detail: number;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "KeyDown";
+  readonly key: string;
+  readonly repeat: boolean;
+} | {
+  readonly _tag: "KeyUp";
+  readonly key: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "PointerCancelled";
+  readonly pointerId: number;
+} | {
+  readonly _tag: "PointerDown";
+  readonly pointerId: number;
+  readonly button: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "PointerUp";
+  readonly pointerId: number;
+  readonly pointerType: string;
+  readonly shiftKey: boolean;
+}>;
+export interface BehaviorOptions<Input, Slots> {
+  readonly target: keyof Slots & string;
+  /** Marks the target `aria-disabled`, which also silences its events. */
+  readonly disabled?: (input: Input) => boolean;
+}
+/**
+ * Attaches the events Mount to the target slot, mapped into the placement's
+ * Messages, and writes `data-pressed` while down for styling. The element
+ * decides nothing; a click, a touch, Enter, Space, or an assistive
+ * technology's click all reach `update` and come out as one `Pressed`.
+ */
+export declare const behavior: <Field extends string>(declared: Declared<typeof bundle, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model; }, ParentMessage>(options: BehaviorOptions<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+//# sourceMappingURL=press.d.ts.map

package/dist/interaction/press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"press.d.ts","names":[],"sources":["../../src/interaction/press.ts"],"mappings":";;;;qBAiBa,aAAW,OAAA;YACZ,qBAAqB,YAAY;qBAEhC,OAAK,OAAA;;;;;;;;;;;YAWN,eAAe,MAAM;qBAEpB,mCAAO;;IACH,WAAS,OAAA;IAAiB,QAAM,OAAA;IAAiB,aAAW,OAAA;;;IAC9D,WAAS,OAAA;IAAiB,aAAW,OAAA;IAAiB,UAAQ,OAAA;;;IACvD,WAAS,OAAA;;;IAClB,KAAG,OAAA;IAAiB,QAAM,OAAA;;;IAC5B,KAAG,OAAA;IAAiB,UAAQ,OAAA;;;;IAE1B,QAAM,OAAA;IAAiB,UAAQ,OAAA;;;IAC1B,YAAU,OAAA;;;YAEhB,iBAAiB,QAAQ;qBAExB,SAAO,OAAA;;;;;YAKR,iBAAiB,QAAQ;qBAExB,MAAI,OAAA;;;;YAOL,cAAc,KAAK;qBAWlB,QAAM,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA4DP,OAAO,QAAQ;WAAoB;;;;;;;;;qBASlC,QAAM,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FF,gBAAgB,OAAO;WAC7B,cAAc;;WAEd,YAAY,OAAO;;;;;;;;qBASjB,WACV,sBAAoB,UAAY,gBAAgB,QAAQ,YACxD,OAAK,OAAS,WACd,0BAA0B,KAAK,QAAQ,UAAS,eAAa,SACnD,gBAAgB,OAAO,WAC/B,SAAS,cAAc,OAAO,OAAO"}

package/dist/interaction/press.js

@@ -0,0 +1,229 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import * as Mount from "foldkit/mount";
+import { Capability } from "foldkit-mixins";
+import { BundleBehavior } from "./bundle-behavior.js";
+// src/interaction/press.ts
+/**
+* Press: pointer and keyboard activation of one element as one fact. A Mount
+* reports what the element saw (pointer down, up, cancel, key down, up,
+* click) with the detail Foldkit's declarative attributes do not carry; the
+* Bundle's `update` decides what counts as a press; the ghost click that
+* follows a touch is suppressed by a timed Command on Effect's clock, never
+* by a clock read in a handler. Activation is an OutMessage, `Pressed`, so
+* the placement must say what a press does.
+*/
+const PointerType = Schema.Literals([
+	"mouse",
+	"touch",
+	"pen",
+	"keyboard",
+	"virtual"
+]);
+const Model = Schema.Struct({
+	/** Down and not yet released or cancelled. For styling. */
+	pressed: Schema.Boolean,
+	/** The pointer that pressed, so another pointer's up cannot release it. */
+	pointerId: Schema.NullOr(Schema.Number),
+	/** Enter or Space is down. */
+	key: Schema.NullOr(Schema.String),
+	/** A click arriving before this generation's window ends is the ghost of a pointer press. */
+	suppressing: Schema.NullOr(Schema.Number),
+	generation: Schema.Number
+});
+const Message = defineMessageUnion({
+	PointerDown: {
+		pointerId: Schema.Number,
+		button: Schema.Number,
+		pointerType: Schema.String
+	},
+	PointerUp: {
+		pointerId: Schema.Number,
+		pointerType: Schema.String,
+		shiftKey: Schema.Boolean
+	},
+	PointerCancelled: { pointerId: Schema.Number },
+	KeyDown: {
+		key: Schema.String,
+		repeat: Schema.Boolean
+	},
+	KeyUp: {
+		key: Schema.String,
+		shiftKey: Schema.Boolean
+	},
+	/** `detail` is 0 for a click no pointer made: keyboard on a native control, or assistive technology. */
+	Clicked: {
+		detail: Schema.Number,
+		shiftKey: Schema.Boolean
+	},
+	Unsuppressed: { generation: Schema.Number }
+});
+const Pressed = Schema.TaggedStruct("Pressed", {
+	pointerType: PointerType,
+	/** Shift was held, for a range selection. */
+	shiftKey: Schema.Boolean
+});
+const Args = Schema.Struct({ 
+/** How long after a pointer press a `click` is taken for its ghost. */
+clickSuppressionMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.check(Schema.isFinite())) });
+const idle = (model) => ({
+	...model,
+	pressed: false,
+	pointerId: null,
+	key: null
+});
+const isActivationKey = (key) => key === "Enter" || key === " ";
+const asPointerType = (raw) => raw === "touch" || raw === "pen" ? raw : "mouse";
+const bundle = Bundle.make("Press", {
+	Model,
+	Message,
+	args: Args,
+	init: () => ({ model: {
+		pressed: false,
+		pointerId: null,
+		key: null,
+		suppressing: null,
+		generation: 0
+	} }),
+	update: (model, message, args) => Message.match(message, {
+		PointerDown: ({ pointerId, button }) => button !== 0 || model.pointerId !== null ? { model } : { model: {
+			...model,
+			pressed: true,
+			pointerId
+		} },
+		PointerUp: ({ pointerId, pointerType, shiftKey }) => {
+			if (model.pointerId !== pointerId) return { model };
+			const generation = model.generation + 1;
+			return {
+				model: {
+					...idle(model),
+					suppressing: generation,
+					generation
+				},
+				commands: [{
+					name: "Press.unsuppress",
+					args: { generation },
+					effect: Effect.as(Effect.sleep(args.clickSuppressionMs), Message.Unsuppressed({ generation }))
+				}],
+				outMessage: Pressed.make({
+					pointerType: asPointerType(pointerType),
+					shiftKey
+				})
+			};
+		},
+		PointerCancelled: ({ pointerId }) => model.pointerId === pointerId ? { model: idle(model) } : { model },
+		KeyDown: ({ key, repeat }) => !isActivationKey(key) || repeat || model.key !== null || model.pointerId !== null ? { model } : { model: {
+			...model,
+			pressed: true,
+			key
+		} },
+		KeyUp: ({ key, shiftKey }) => model.key === key ? {
+			model: idle(model),
+			outMessage: Pressed.make({
+				pointerType: "keyboard",
+				shiftKey
+			})
+		} : { model },
+		Clicked: ({ detail, shiftKey }) => detail === 0 ? {
+			model,
+			outMessage: Pressed.make({
+				pointerType: "virtual",
+				shiftKey
+			})
+		} : model.suppressing !== null ? { model } : {
+			model,
+			outMessage: Pressed.make({
+				pointerType: "mouse",
+				shiftKey
+			})
+		},
+		Unsuppressed: ({ generation }) => model.suppressing === generation ? { model: {
+			...model,
+			suppressing: null
+		} } : { model }
+	})
+});
+/**
+* The element's press-relevant events as facts. Enter and Space key downs
+* are default-prevented so a native control does not also click, and Space
+* does not scroll; the Bundle owns activation. An element marked
+* `aria-disabled="true"` (which the Behavior writes) reports nothing, read
+* at event time so a toggle needs no remount. Nothing else is decided here.
+*/
+const events = Mount.defineStream("PressEvents", {
+	messages: [
+		Message.PointerDown,
+		Message.PointerUp,
+		Message.PointerCancelled,
+		Message.KeyDown,
+		Message.KeyUp,
+		Message.Clicked
+	],
+	execute: ({ element }) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const offer = (message) => {
+			if (element.getAttribute("aria-disabled") === "true") return;
+			Queue.offerUnsafe(queue, message);
+		};
+		const listeners = [
+			["pointerdown", (event) => {
+				const pointer = event;
+				offer(Message.PointerDown({
+					pointerId: pointer.pointerId ?? 0,
+					button: pointer.button ?? 0,
+					pointerType: pointer.pointerType ?? "mouse"
+				}));
+			}],
+			["pointerup", (event) => {
+				const pointer = event;
+				offer(Message.PointerUp({
+					pointerId: pointer.pointerId ?? 0,
+					pointerType: pointer.pointerType ?? "mouse",
+					shiftKey: pointer.shiftKey ?? false
+				}));
+			}],
+			["pointerleave", (event) => offer(Message.PointerCancelled({ pointerId: event.pointerId ?? 0 }))],
+			["pointercancel", (event) => offer(Message.PointerCancelled({ pointerId: event.pointerId ?? 0 }))],
+			["keydown", (event) => {
+				const key = event;
+				if (isActivationKey(key.key)) key.preventDefault();
+				offer(Message.KeyDown({
+					key: key.key,
+					repeat: key.repeat
+				}));
+			}],
+			["keyup", (event) => {
+				const key = event;
+				offer(Message.KeyUp({
+					key: key.key,
+					shiftKey: key.shiftKey
+				}));
+			}],
+			["click", (event) => {
+				const click = event;
+				offer(Message.Clicked({
+					detail: click.detail ?? 0,
+					shiftKey: click.shiftKey ?? false
+				}));
+			}]
+		];
+		for (const [type, listener] of listeners) element.addEventListener(type, listener);
+		return listeners;
+	}), (listeners) => Effect.sync(() => {
+		for (const [type, listener] of listeners) element.removeEventListener(type, listener);
+	})))
+});
+/**
+* Attaches the events Mount to the target slot, mapped into the placement's
+* Messages, and writes `data-pressed` while down for styling. The element
+* decides nothing; a click, a touch, Enter, Space, or an assistive
+* technology's click all reach `update` and come out as one `Pressed`.
+*/
+const behavior = (declared) => (slots) => (options) => BundleBehavior.fromBundle(declared)(slots)({ [options.target]: {
+	requires: { capability: Capability.Interactive },
+	attributes: ({ input, h }) => [...input[declared.field].pressed ? [h.DataAttribute("pressed", "true")] : [], ...options.disabled?.(input) === true ? [h.AriaDisabled(true)] : []],
+	events: events()
+} }, { name: "Press" });
+export { Args, Message, Model, PointerType, Pressed, behavior, bundle, events };
+
+//# sourceMappingURL=press.js.map

package/dist/interaction/press.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"press.js","names":[],"sources":["../../src/interaction/press.ts"],"sourcesContent":["/**\n * Press: pointer and keyboard activation of one element as one fact. A Mount\n * reports what the element saw (pointer down, up, cancel, key down, up,\n * click) with the detail Foldkit's declarative attributes do not carry; the\n * Bundle's `update` decides what counts as a press; the ghost click that\n * follows a touch is suppressed by a timed Command on Effect's clock, never\n * by a clock read in a handler. Activation is an OutMessage, `Pressed`, so\n * the placement must say what a press does.\n */\nimport { Effect, Queue, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Mount from 'foldkit/mount'\nimport type * as Update from 'foldkit/update'\nimport { Bundle, type Declared } from 'foldkit-bundle'\nimport { Behavior, Capability } from 'foldkit-mixins'\nimport { BundleBehavior } from './bundle-behavior.js'\n\nexport const PointerType = Schema.Literals(['mouse', 'touch', 'pen', 'keyboard', 'virtual'])\nexport type PointerType = typeof PointerType.Type\n\nexport const Model = Schema.Struct({\n  /** Down and not yet released or cancelled. For styling. */\n  pressed: Schema.Boolean,\n  /** The pointer that pressed, so another pointer's up cannot release it. */\n  pointerId: Schema.NullOr(Schema.Number),\n  /** Enter or Space is down. */\n  key: Schema.NullOr(Schema.String),\n  /** A click arriving before this generation's window ends is the ghost of a pointer press. */\n  suppressing: Schema.NullOr(Schema.Number),\n  generation: Schema.Number,\n})\nexport type Model = typeof Model.Type\n\nexport const Message = defineMessageUnion({\n  PointerDown: { pointerId: Schema.Number, button: Schema.Number, pointerType: Schema.String },\n  PointerUp: { pointerId: Schema.Number, pointerType: Schema.String, shiftKey: Schema.Boolean },\n  PointerCancelled: { pointerId: Schema.Number },\n  KeyDown: { key: Schema.String, repeat: Schema.Boolean },\n  KeyUp: { key: Schema.String, shiftKey: Schema.Boolean },\n  /** `detail` is 0 for a click no pointer made: keyboard on a native control, or assistive technology. */\n  Clicked: { detail: Schema.Number, shiftKey: Schema.Boolean },\n  Unsuppressed: { generation: Schema.Number },\n})\nexport type Message = typeof Message.Type\n\nexport const Pressed = Schema.TaggedStruct('Pressed', {\n  pointerType: PointerType,\n  /** Shift was held, for a range selection. */\n  shiftKey: Schema.Boolean,\n})\nexport type Pressed = typeof Pressed.Type\n\nexport const Args = Schema.Struct({\n  /** How long after a pointer press a `click` is taken for its ghost. */\n  clickSuppressionMs: Schema.Number.pipe(\n    Schema.check(Schema.isGreaterThanOrEqualTo(0)),\n    Schema.check(Schema.isFinite()),\n  ),\n})\nexport type Args = typeof Args.Type\n\nconst idle = (model: Model): Model => ({ ...model, pressed: false, pointerId: null, key: null })\n\nconst isActivationKey = (key: string): boolean => key === 'Enter' || key === ' '\n\nconst asPointerType = (raw: string): PointerType =>\n  raw === 'touch' || raw === 'pen' ? raw : 'mouse'\n\ntype Return = Update.ReturnWithOutMessage<Model, Message, Pressed>\n\nexport const bundle = Bundle.make('Press', {\n  Model,\n  Message,\n  args: Args,\n  init: () => ({\n    model: { pressed: false, pointerId: null, key: null, suppressing: null, generation: 0 },\n  }),\n  update: (model, message, args): Return =>\n    Message.match<Return>(message, {\n      PointerDown: ({ pointerId, button }) =>\n        button !== 0 || model.pointerId !== null\n          ? { model }\n          : { model: { ...model, pressed: true, pointerId } },\n      PointerUp: ({ pointerId, pointerType, shiftKey }) => {\n        if (model.pointerId !== pointerId) return { model }\n        const generation = model.generation + 1\n        return {\n          model: { ...idle(model), suppressing: generation, generation },\n          commands: [\n            {\n              name: 'Press.unsuppress',\n              args: { generation },\n              effect: Effect.as(\n                Effect.sleep(args.clickSuppressionMs),\n                Message.Unsuppressed({ generation }),\n              ),\n            },\n          ],\n          outMessage: Pressed.make({ pointerType: asPointerType(pointerType), shiftKey }),\n        }\n      },\n      PointerCancelled: ({ pointerId }) =>\n        model.pointerId === pointerId ? { model: idle(model) } : { model },\n      KeyDown: ({ key, repeat }) =>\n        !isActivationKey(key) || repeat || model.key !== null || model.pointerId !== null\n          ? { model }\n          : { model: { ...model, pressed: true, key } },\n      KeyUp: ({ key, shiftKey }) =>\n        model.key === key\n          ? { model: idle(model), outMessage: Pressed.make({ pointerType: 'keyboard', shiftKey }) }\n          : { model },\n      Clicked: ({ detail, shiftKey }) =>\n        detail === 0\n          ? { model, outMessage: Pressed.make({ pointerType: 'virtual', shiftKey }) }\n          : model.suppressing !== null\n            ? { model }\n            : { model, outMessage: Pressed.make({ pointerType: 'mouse', shiftKey }) },\n      Unsuppressed: ({ generation }) =>\n        model.suppressing === generation ? { model: { ...model, suppressing: null } } : { model },\n    }),\n})\n\ntype PointerLike = Event & {\n  readonly pointerId?: number\n  readonly button?: number\n  readonly pointerType?: string\n  readonly shiftKey?: boolean\n}\n\n/** What the element reports; `Unsuppressed` comes from the timer, not the DOM. */\nexport type Fact = Exclude<Message, { readonly _tag: 'Unsuppressed' }>\n\n/**\n * The element's press-relevant events as facts. Enter and Space key downs\n * are default-prevented so a native control does not also click, and Space\n * does not scroll; the Bundle owns activation. An element marked\n * `aria-disabled=\"true\"` (which the Behavior writes) reports nothing, read\n * at event time so a toggle needs no remount. Nothing else is decided here.\n */\nexport const events = Mount.defineStream('PressEvents', {\n  messages: [\n    Message.PointerDown,\n    Message.PointerUp,\n    Message.PointerCancelled,\n    Message.KeyDown,\n    Message.KeyUp,\n    Message.Clicked,\n  ],\n  execute: ({ element }) =>\n    Stream.callback<Fact>(queue =>\n      Effect.acquireRelease(\n        Effect.sync(() => {\n          const offer = (message: Fact) => {\n            if (element.getAttribute('aria-disabled') === 'true') return\n            Queue.offerUnsafe(queue, message)\n          }\n          const listeners: ReadonlyArray<readonly [string, (event: Event) => void]> = [\n            [\n              'pointerdown',\n              event => {\n                const pointer = event as PointerLike\n                offer(\n                  Message.PointerDown({\n                    pointerId: pointer.pointerId ?? 0,\n                    button: pointer.button ?? 0,\n                    pointerType: pointer.pointerType ?? 'mouse',\n                  }),\n                )\n              },\n            ],\n            [\n              'pointerup',\n              event => {\n                const pointer = event as PointerLike\n                offer(\n                  Message.PointerUp({\n                    pointerId: pointer.pointerId ?? 0,\n                    pointerType: pointer.pointerType ?? 'mouse',\n                    shiftKey: pointer.shiftKey ?? false,\n                  }),\n                )\n              },\n            ],\n            [\n              'pointerleave',\n              event =>\n                offer(\n                  Message.PointerCancelled({ pointerId: (event as PointerLike).pointerId ?? 0 }),\n                ),\n            ],\n            [\n              'pointercancel',\n              event =>\n                offer(\n                  Message.PointerCancelled({ pointerId: (event as PointerLike).pointerId ?? 0 }),\n                ),\n            ],\n            [\n              'keydown',\n              event => {\n                const key = event as KeyboardEvent\n                if (isActivationKey(key.key)) key.preventDefault()\n                offer(Message.KeyDown({ key: key.key, repeat: key.repeat }))\n              },\n            ],\n            [\n              'keyup',\n              event => {\n                const key = event as KeyboardEvent\n                offer(Message.KeyUp({ key: key.key, shiftKey: key.shiftKey }))\n              },\n            ],\n            [\n              'click',\n              event => {\n                const click = event as MouseEvent\n                offer(\n                  Message.Clicked({ detail: click.detail ?? 0, shiftKey: click.shiftKey ?? false }),\n                )\n              },\n            ],\n          ]\n          for (const [type, listener] of listeners) element.addEventListener(type, listener)\n          return listeners\n        }),\n        listeners =>\n          Effect.sync(() => {\n            for (const [type, listener] of listeners) element.removeEventListener(type, listener)\n          }),\n      ),\n    ),\n})\n\nexport interface BehaviorOptions<Input, Slots> {\n  readonly target: keyof Slots & string\n  /** Marks the target `aria-disabled`, which also silences its events. */\n  readonly disabled?: (input: Input) => boolean\n}\n\n/**\n * Attaches the events Mount to the target slot, mapped into the placement's\n * Messages, and writes `data-pressed` while down for styling. The element\n * decides nothing; a click, a touch, Enter, Space, or an assistive\n * technology's click all reach `update` and come out as one `Pressed`.\n */\nexport const behavior =\n  <Field extends string>(declared: Declared<typeof bundle, Field>) =>\n  <Slots>(slots: Slots) =>\n  <Input extends { readonly [K in Field]: Model }, ParentMessage>(\n    options: BehaviorOptions<Input, Slots>,\n  ): Behavior.NamedBehavior<Slots, Input, ParentMessage> =>\n    BundleBehavior.fromBundle(declared)(slots)<Input, ParentMessage>(\n      {\n        [options.target]: {\n          requires: { capability: Capability.Interactive },\n          attributes: ({ input, h }) => [\n            ...(input[declared.field].pressed ? [h.DataAttribute('pressed', 'true')] : []),\n            ...(options.disabled?.(input) === true ? [h.AriaDisabled(true)] : []),\n          ],\n          events: events(),\n        },\n      },\n      { name: 'Press' },\n    )\n"],"mappings":"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"}

package/dist/interaction/roving-tabindex.d.ts

@@ -0,0 +1,85 @@
+import { Schema } from "effect";
+import { Bundle, Declared } from "foldkit-bundle";
+import { Behavior, Behaviors, SlotItem } from "foldkit-mixins";
+import { Attribute, HtmlBuilder, KeyboardModifiers } from "foldkit/html";
+export declare const Orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
+export type Orientation = typeof Orientation.Type;
+export declare const Model: Schema.Struct<{
+  /** The current item's id, or `null` before any item has been focused. */
+  readonly current: Schema.NullOr<Schema.String>;
+}>;
+export type Model = typeof Model.Type;
+export declare const Message: import("foldkit/message").MessageUnion<{
+  /** An item became current: the user focused it, or a key moved there. */
+  readonly Focused: {
+    id: Schema.String;
+  };
+}>;
+export type Message = typeof Message.Type;
+export declare const Args: Schema.Struct<{
+  readonly orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
+  /** Wrap from the last enabled item to the first, and back. */
+  readonly loop: Schema.Boolean;
+  /** Keep DOM focus on the container and point at the current item with
+   *  `aria-activedescendant` instead of moving focus. */
+  readonly virtual: Schema.Boolean;
+}>;
+export type Args = typeof Args.Type;
+export declare const bundle: Bundle.Bundle<"RovingTabindex", {
+  readonly orientation: "both" | "horizontal" | "vertical";
+  readonly loop: boolean;
+  readonly virtual: boolean;
+}, {
+  readonly current: string | null;
+}, {
+  readonly _tag: "Focused";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+export type Direction = 'ltr' | 'rtl';
+export interface MoveOptions {
+  readonly orientation: Orientation;
+  readonly loop: boolean;
+  readonly direction: Direction;
+  /** How many enabled items PageUp and PageDown move; absent, they are not handled. */
+  readonly page?: number;
+}
+/**
+ * The index the key moves to from `current`, over the enabled indices only, or
+ * `undefined` when the key is not a navigation key here. `current` may be
+ * `-1` (nothing current yet): arrows then land on the first or last enabled
+ * item. Under `rtl`, left and right swap. PageUp and PageDown move by `page`
+ * and clamp at the ends, never wrapping.
+ */
+export declare const move: (enabled: ReadonlyArray<number>, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions) => number | undefined;
+/** The item that holds the tab stop: the current one, else the first enabled. */
+export declare const tabStop: (items: Behaviors.Collection.Items<unknown>, current: string | null) => number;
+export interface BehaviorOptions<Input, Slots> {
+  /** The slot that receives the arrow keys. */
+  readonly container: keyof Slots & string;
+  /** The slot rendered once per item; must carry the item's id (see `Behaviors.Collection`). */
+  readonly item: keyof Slots & string;
+  readonly items: (input: Input) => Behaviors.Collection.Items<unknown>;
+  /** Default `'ltr'`; return `'rtl'` to swap left and right. */
+  readonly direction?: (input: Input) => Direction;
+}
+/** A selector for an element by id, safe for any id. */
+export declare const idSelector: (id: string) => string;
+/**
+ * The attributes one item gets: `tabindex` 0 when it holds the tab stop and
+ * -1 otherwise (none under `virtual`), and `OnFocus` reporting it current.
+ * Shared with `ListNavigation`.
+ */
+export declare const itemAttributes: <ParentMessage>(h: HtmlBuilder<ParentMessage>, items: Behaviors.Collection.Items<unknown>, current: string | null, item: SlotItem, virtual: boolean, focused: (id: string) => ParentMessage) => ReadonlyArray<Attribute<ParentMessage>>;
+/**
+ * Wires a placed `RovingTabindex` to the slots: the container's arrow, Home
+ * and End keys focus the next item (synchronously, then dispatch), each item
+ * gets `tabindex` 0 or -1 and reports `Focused` when focused. Under `virtual`
+ * DOM focus never leaves the container: the key only dispatches, the
+ * container carries `aria-activedescendant`, and items keep no `tabindex`.
+ *
+ * Every handled key is default-prevented. Nothing is written on dispose: the
+ * attributes are data, so a view that no longer attaches this leaves no
+ * `tabindex` behind.
+ */
+export declare const behavior: <Field extends string>(declared: Declared<typeof bundle, Field>, args: Args) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model; }, ParentMessage>(options: BehaviorOptions<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+//# sourceMappingURL=roving-tabindex.d.ts.map

package/dist/interaction/roving-tabindex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roving-tabindex.d.ts","names":[],"sources":["../../src/interaction/roving-tabindex.ts"],"mappings":";;;;qBAea,aAAW,OAAA;YACZ,qBAAqB,YAAY;qBAEhC,OAAK,OAAA;;;;YAIN,eAAe,MAAM;qBAEpB,mCAAO;;;IAEP,IAAE,OAAA;;;YAEH,iBAAiB,QAAQ;qBAExB,MAAI,OAAA;;;;;;;;YAQL,cAAc,KAAK;qBAElB,QAAM,OAAA;;;;;;;;;;YAUP;iBAEK;WACN,aAAa;WACb;WACA,WAAW;;WAEX;;;;;;;;;qBAaE,OAAI,SACN,uBAAqB,iBACf,aACJ,WACA,mBAAiB,SACnB;;qBAiCE,UAAO,OACX,UAAU,WAAW,gBAAc;iBAQ3B,gBAAgB,OAAO;;WAE7B,iBAAiB;;WAEjB,YAAY;WACZ,QAAQ,OAAO,UAAU,UAAU,WAAW;;WAE9C,aAAa,OAAO,UAAU;;;qBAI5B,aAAU;;;;;;qBAOV,iBAAkB,eAAa,GACvC,YAAY,gBAAc,OACtB,UAAU,WAAW,gBAAc,wBACpB,MAChB,UAAQ,kBACE,UACN,eAAe,kBACxB,cAAc,UAAU;;;;;;;;;;;;qBAkBd,WACV,sBAAoB,UAAY,gBAAgB,QAAQ,QAAM,MAAQ,UACtE,OAAK,OAAS,WACd,0BAA0B,KAAK,QAAQ,UAAS,eAAa,SACnD,gBAAgB,OAAO,WAC/B,SAAS,cAAc,OAAO,OAAO"}

package/dist/interaction/roving-tabindex.js

@@ -0,0 +1,142 @@
+import { Option, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { perInput } from "../internal.js";
+import { Behavior, Capability } from "foldkit-mixins";
+// src/interaction/roving-tabindex.ts
+/**
+* One tab stop for a set of items (a toolbar, a tab list, a listbox): arrows
+* move focus between them, the rest stay out of the tab order. The current
+* item's id is the Model slice, so a reorder keeps the same item current and a
+* resumed page knows where focus was. Which item comes next is a pure
+* function of the items and the key; the Behavior wires it to the slots.
+*/
+const Orientation = Schema.Literals([
+	"vertical",
+	"horizontal",
+	"both"
+]);
+const Model = Schema.Struct({ 
+/** The current item's id, or `null` before any item has been focused. */
+current: Schema.NullOr(Schema.String) });
+const Message = defineMessageUnion({ 
+/** An item became current: the user focused it, or a key moved there. */
+Focused: { id: Schema.String } });
+const Args = Schema.Struct({
+	orientation: Orientation,
+	/** Wrap from the last enabled item to the first, and back. */
+	loop: Schema.Boolean,
+	/** Keep DOM focus on the container and point at the current item with
+	*  `aria-activedescendant` instead of moving focus. */
+	virtual: Schema.Boolean
+});
+const bundle = Bundle.make("RovingTabindex", {
+	Model,
+	Message,
+	args: Args,
+	init: () => ({ model: { current: null } }),
+	update: (model, message) => model.current === message.id ? { model } : { model: { current: message.id } }
+});
+const isPlain = (modifiers) => !modifiers.ctrlKey && !modifiers.altKey && !modifiers.metaKey;
+/**
+* The index the key moves to from `current`, over the enabled indices only, or
+* `undefined` when the key is not a navigation key here. `current` may be
+* `-1` (nothing current yet): arrows then land on the first or last enabled
+* item. Under `rtl`, left and right swap. PageUp and PageDown move by `page`
+* and clamp at the ends, never wrapping.
+*/
+const move = (enabled, current, key, modifiers, options) => {
+	if (enabled.length === 0 || !isPlain(modifiers)) return void 0;
+	const first = enabled[0];
+	const last = enabled[enabled.length - 1];
+	if (key === "Home") return first;
+	if (key === "End") return last;
+	if (options.page !== void 0 && (key === "PageUp" || key === "PageDown")) {
+		const position = enabled.indexOf(current);
+		if (position === -1) return key === "PageDown" ? first : last;
+		const jumped = position + (key === "PageDown" ? options.page : -options.page);
+		return enabled[Math.min(enabled.length - 1, Math.max(0, jumped))];
+	}
+	const vertical = options.orientation !== "horizontal";
+	const horizontal = options.orientation !== "vertical";
+	const forwardKey = options.direction === "rtl" ? "ArrowLeft" : "ArrowRight";
+	const backwardKey = options.direction === "rtl" ? "ArrowRight" : "ArrowLeft";
+	const step = vertical && key === "ArrowDown" || horizontal && key === forwardKey ? 1 : vertical && key === "ArrowUp" || horizontal && key === backwardKey ? -1 : 0;
+	if (step === 0) return void 0;
+	const position = enabled.indexOf(current);
+	if (position === -1) return step === 1 ? first : last;
+	const next = position + step;
+	if (next < 0) return options.loop ? last : first;
+	if (next >= enabled.length) return options.loop ? first : last;
+	return enabled[next];
+};
+/** The item that holds the tab stop: the current one, else the first enabled. */
+const tabStop = (items, current) => {
+	const index = current === null ? -1 : items.indexOf(current);
+	if (index !== -1 && !items.isDisabled(index)) return index;
+	return items.enabled[0] ?? -1;
+};
+/** A selector for an element by id, safe for any id. */
+const idSelector = (id) => `[id="${id.replace(/["\\]/g, "\\$&")}"]`;
+/**
+* The attributes one item gets: `tabindex` 0 when it holds the tab stop and
+* -1 otherwise (none under `virtual`), and `OnFocus` reporting it current.
+* Shared with `ListNavigation`.
+*/
+const itemAttributes = (h, items, current, item, virtual, focused) => {
+	const id = item.id ?? items.ids[item.index];
+	if (id === void 0) return [];
+	const isStop = tabStop(items, current) === item.index;
+	return [...virtual ? [] : [h.Tabindex(isStop ? 0 : -1)], h.OnFocus(focused(id))];
+};
+/**
+* Wires a placed `RovingTabindex` to the slots: the container's arrow, Home
+* and End keys focus the next item (synchronously, then dispatch), each item
+* gets `tabindex` 0 or -1 and reports `Focused` when focused. Under `virtual`
+* DOM focus never leaves the container: the key only dispatches, the
+* container carries `aria-activedescendant`, and items keep no `tabindex`.
+*
+* Every handled key is default-prevented. Nothing is written on dispose: the
+* attributes are data, so a view that no longer attaches this leaves no
+* `tabindex` behind.
+*/
+const behavior = (declared, args) => (slots) => (options) => {
+	const wrap = (id) => declared.wrapper.make(Message.Focused({ id }));
+	const slice = (input) => input[declared.field];
+	const itemsOf = perInput(options.items);
+	return Behavior.forSlots(slots)({
+		[options.container]: Behavior.slot({
+			requires: { capability: Capability.Interactive },
+			attributes: ({ input, h }) => {
+				const items = itemsOf(input);
+				const current = slice(input).current;
+				const from = current === null ? -1 : items.indexOf(current);
+				const direction = options.direction?.(input) ?? "ltr";
+				const stop = tabStop(items, current);
+				const stopId = stop === -1 ? void 0 : items.ids[stop];
+				const target = (key, modifiers) => {
+					const next = move(items.enabled, from, key, modifiers, {
+						...args,
+						direction
+					});
+					return next === void 0 ? void 0 : items.ids[next];
+				};
+				if (args.virtual) return [h.OnKeyDownPreventDefault((key, modifiers) => Option.map(Option.fromNullishOr(target(key, modifiers)), wrap)), ...stopId === void 0 ? [] : [h.AriaActiveDescendant(stopId)]];
+				return [h.OnKeyDownFocus((key, modifiers) => Option.map(Option.fromNullishOr(target(key, modifiers)), (id) => ({
+					focusSelector: idSelector(id),
+					message: wrap(id)
+				})))];
+			}
+		}),
+		[options.item]: Behavior.slot({
+			requires: { capability: Capability.Focusable },
+			attributes: ({ input, h, item }) => {
+				if (item === void 0) return [];
+				return itemAttributes(h, itemsOf(input), slice(input).current, item, args.virtual, wrap);
+			}
+		})
+	}, { name: "RovingTabindex" });
+};
+export { Args, Message, Model, Orientation, behavior, bundle, idSelector, itemAttributes, move, tabStop };
+
+//# sourceMappingURL=roving-tabindex.js.map