@foldkit/ui 0.112.0

package/dist/toast/update.js

@@ -0,0 +1,225 @@
+import { Array, Duration, Effect, Match as M, Number, Option, Schema as S, } from 'effect';
+import * as Command from 'foldkit/command';
+import { evo } from 'foldkit/struct';
+import { Hid as AnimationHid, Showed as AnimationShowed, init as animationInit, } from '../animation/schema.js';
+import { defaultLeaveCommand as animationDefaultLeaveCommand, update as animationUpdate, } from '../animation/update.js';
+import * as OptionExt from '../internal/optionExtensions.js';
+import { DEFAULT_DURATION, Dismissed, DismissedAll, ElapsedDuration, GotAnimationMessage, makeAdded, makeDismissedToast, makeEntry, makeMessage, makeModel, makeOutMessage, } from './schema.js';
+/** Schedules an auto-dismiss timer for an entry. The result Message carries a
+ *  version so stale timers (from hover or manual dismiss) are discarded in
+ *  the update function. Static. The Command definition doesn't depend on
+ *  payload. */
+export const DismissAfter = Command.define('DismissAfter', {
+    entryId: S.String,
+    version: S.Number,
+    duration: S.DurationFromMillis,
+}, ElapsedDuration)(({ entryId, version, duration }) => Effect.sleep(duration).pipe(Effect.as(ElapsedDuration({ entryId, version }))));
+const DEFAULT_VARIANT = 'Info';
+/** Factory that binds Toast's runtime (update fn, helpers, commands) to a
+ *  specific payload schema. Called by `make` in index.ts; inner helpers close
+ *  over the payload-specific Entry / Model / Added types so generics don't
+ *  have to propagate through every helper signature.
+ *
+ *  @internal Consumers should use `Toast.make(PayloadSchema)`. This is
+ *  only exported so `index.ts` can wire the view into the bound runtime. */
+export const makeRuntime = (payloadSchema) => {
+    const EntrySchema = makeEntry(payloadSchema);
+    const ModelSchema = makeModel(payloadSchema);
+    const MessageSchema = makeMessage(payloadSchema);
+    const OutMessageSchema = makeOutMessage(payloadSchema);
+    const Added = makeAdded(payloadSchema);
+    const DismissedToast = makeDismissedToast(payloadSchema);
+    const withUpdateReturn = M.withReturnType();
+    const updateEntry = (model, entryId, f) => evo(model, {
+        entries: Array.map(entry => (entry.id === entryId ? f(entry) : entry)),
+    });
+    const removeEntry = (model, entryId) => evo(model, {
+        entries: Array.filter(({ id }) => id !== entryId),
+    });
+    const isEntryLeaving = (entry) => {
+        const { transitionState } = entry.animation;
+        return (transitionState === 'LeaveStart' || transitionState === 'LeaveAnimating');
+    };
+    const scheduleDismiss = (entryId, version, duration) => DismissAfter({ entryId, version, duration });
+    const rescheduleDismissCommands = (entry) => {
+        if (isEntryLeaving(entry) || entry.isHovered) {
+            return [];
+        }
+        else {
+            return Option.match(entry.maybeDuration, {
+                onNone: () => [],
+                onSome: duration => [
+                    scheduleDismiss(entry.id, entry.pendingDismissVersion, duration),
+                ],
+            });
+        }
+    };
+    const delegateToEntryAnimation = (model, entryId, animationMessage) => {
+        const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+        return Option.match(maybeEntry, {
+            onNone: () => [model, [], Option.none()],
+            onSome: entry => {
+                const [nextAnimation, animationCommands, maybeOutMessage] = animationUpdate(entry.animation, animationMessage);
+                const toMessage = (message) => GotAnimationMessage({ entryId, message });
+                const mappedCommands = Command.mapMessages(animationCommands, toMessage);
+                const nextEntry = evo(entry, {
+                    animation: () => nextAnimation,
+                });
+                return Option.match(maybeOutMessage, {
+                    onNone: () => [
+                        updateEntry(model, entryId, () => nextEntry),
+                        mappedCommands,
+                        Option.none(),
+                    ],
+                    onSome: M.type().pipe(withUpdateReturn, M.tagsExhaustive({
+                        StartedLeaveAnimating: () => [
+                            updateEntry(model, entryId, () => nextEntry),
+                            [
+                                ...mappedCommands,
+                                Command.mapMessage(animationDefaultLeaveCommand(nextAnimation), toMessage),
+                            ],
+                            Option.none(),
+                        ],
+                        TransitionedOut: () => [
+                            removeEntry(model, entryId),
+                            mappedCommands,
+                            Option.some(DismissedToast({ payload: entry.payload })),
+                        ],
+                    })),
+                });
+            },
+        });
+    };
+    const createEntry = (model, input) => {
+        const entryId = `${model.id}-entry-${model.nextEntryKey}`;
+        const duration = input.duration === undefined
+            ? model.defaultDuration
+            : Duration.fromInputUnsafe(input.duration);
+        const maybeDuration = OptionExt.when(!input.sticky, duration);
+        return {
+            id: entryId,
+            variant: input.variant ?? DEFAULT_VARIANT,
+            animation: animationInit({ id: entryId, isShowing: false }),
+            maybeDuration,
+            pendingDismissVersion: 0,
+            isHovered: false,
+            payload: input.payload,
+        };
+    };
+    /** Creates an initial toast container model from a config. Starts empty. */
+    const init = (config) => ({
+        id: config.id,
+        defaultDuration: config.defaultDuration === undefined
+            ? DEFAULT_DURATION
+            : Duration.fromInputUnsafe(config.defaultDuration),
+        entries: [],
+        nextEntryKey: 0,
+    });
+    /** Processes a toast message and returns the next model, commands, and
+     *  an optional `DismissedToast` OutMessage emitted once an entry has
+     *  finished its leave animation. */
+    const update = (model, message) => M.value(message).pipe(withUpdateReturn, M.tagsExhaustive({
+        Added: ({ entry }) => {
+            const modelWithEntry = evo(model, {
+                entries: entries => Array.append(entries, entry),
+                nextEntryKey: Number.increment,
+            });
+            const [modelAfterShow, showCommands] = delegateToEntryAnimation(modelWithEntry, entry.id, AnimationShowed());
+            const postShowEntry = Array.findFirst(modelAfterShow.entries, ({ id }) => id === entry.id);
+            const dismissCommands = Option.match(postShowEntry, {
+                onNone: () => [],
+                onSome: rescheduleDismissCommands,
+            });
+            return [
+                modelAfterShow,
+                [...showCommands, ...dismissCommands],
+                Option.none(),
+            ];
+        },
+        Dismissed: ({ entryId }) => {
+            const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+            return Option.match(maybeEntry, {
+                onNone: () => [model, [], Option.none()],
+                onSome: entry => {
+                    if (isEntryLeaving(entry)) {
+                        return [model, [], Option.none()];
+                    }
+                    else {
+                        return delegateToEntryAnimation(model, entryId, AnimationHid());
+                    }
+                },
+            });
+        },
+        DismissedAll: () => Array.reduce(model.entries, [model, [], Option.none()], ([currentModel, currentCommands, currentOut], entry) => {
+            if (isEntryLeaving(entry)) {
+                return [currentModel, currentCommands, currentOut];
+            }
+            const [nextModel, nextCommands] = delegateToEntryAnimation(currentModel, entry.id, AnimationHid());
+            return [
+                nextModel,
+                [...currentCommands, ...nextCommands],
+                currentOut,
+            ];
+        }),
+        ElapsedDuration: ({ entryId, version }) => {
+            const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+            return Option.match(maybeEntry, {
+                onNone: () => [model, [], Option.none()],
+                onSome: entry => {
+                    const isStale = version !== entry.pendingDismissVersion;
+                    if (isStale || isEntryLeaving(entry)) {
+                        return [model, [], Option.none()];
+                    }
+                    else {
+                        return delegateToEntryAnimation(model, entryId, AnimationHid());
+                    }
+                },
+            });
+        },
+        HoveredEntry: ({ entryId }) => [
+            updateEntry(model, entryId, entry => evo(entry, {
+                isHovered: () => true,
+                pendingDismissVersion: Number.increment,
+            })),
+            [],
+            Option.none(),
+        ],
+        LeftEntry: ({ entryId }) => {
+            const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+            return Option.match(maybeEntry, {
+                onNone: () => [model, [], Option.none()],
+                onSome: entry => {
+                    const nextEntry = evo(entry, {
+                        isHovered: () => false,
+                        pendingDismissVersion: Number.increment,
+                    });
+                    return [
+                        updateEntry(model, entryId, () => nextEntry),
+                        rescheduleDismissCommands(nextEntry),
+                        Option.none(),
+                    ];
+                },
+            });
+        },
+        GotAnimationMessage: ({ entryId, message: animationMessage }) => delegateToEntryAnimation(model, entryId, animationMessage),
+    }));
+    /** Adds a new toast entry. */
+    const show = (model, input) => update(model, Added({ entry: createEntry(model, input) }));
+    /** Begins dismissing a specific entry. */
+    const dismiss = (model, entryId) => update(model, Dismissed({ entryId }));
+    /** Begins dismissing every currently-visible entry. */
+    const dismissAll = (model) => update(model, DismissedAll());
+    return {
+        Entry: EntrySchema,
+        Model: ModelSchema,
+        Message: MessageSchema,
+        OutMessage: OutMessageSchema,
+        Added,
+        DismissedToast,
+        init,
+        update,
+        show,
+        dismiss,
+        dismissAll,
+    };
+};

package/dist/tooltip/index.d.ts

@@ -0,0 +1,170 @@
+import { Duration, Effect, Option, Schema as S } from 'effect';
+import * as Command from 'foldkit/command';
+import { type ChildAttribute, type Html } from 'foldkit/html';
+import * as Mount from 'foldkit/mount';
+import { type Reflect } from 'foldkit/submodel';
+import { AnchorConfig } from '../anchor.js';
+/** Schema for the tooltip component's state. `isOpen` is visibility; `isHovered` tracks pointer on trigger; `isFocused` tracks tooltip-affirming focus on the trigger (focus arriving without a preceding mouse press, like keyboard, touch, or pen; mouse-click-induced focus is excluded since it doesn't affirm the user wants the tooltip visible); `isDismissed` suppresses re-opening after the user dismissed the tooltip (via Escape or left-click) until they disengage (leave or blur). `showDelay` is the hover-to-show duration. `maybeLastPointerType` records the most recent pointer type that pressed the trigger, so a mouse-click-induced focus can be distinguished from other focus. */
+export declare const Model: S.Struct<{
+    readonly id: S.String;
+    readonly isOpen: S.Boolean;
+    readonly isHovered: S.Boolean;
+    readonly isFocused: S.Boolean;
+    readonly isDismissed: S.Boolean;
+    readonly showDelay: S.DurationFromMillis;
+    readonly pendingShowVersion: S.Number;
+    readonly maybeLastPointerType: S.Option<S.String>;
+}>;
+export type Model = typeof Model.Type;
+/** Sent when the pointer enters the tooltip trigger. */
+export declare const EnteredTrigger: import("foldkit/schema").CallableTaggedStruct<"EnteredTrigger", {}>;
+/** Sent when the pointer leaves the tooltip trigger. */
+export declare const LeftTrigger: import("foldkit/schema").CallableTaggedStruct<"LeftTrigger", {}>;
+/** Sent when focus enters the trigger. */
+export declare const FocusedTrigger: import("foldkit/schema").CallableTaggedStruct<"FocusedTrigger", {}>;
+/** Sent when focus leaves the trigger. */
+export declare const BlurredTrigger: import("foldkit/schema").CallableTaggedStruct<"BlurredTrigger", {}>;
+/** Sent when Escape is pressed while the tooltip is visible. */
+export declare const PressedEscape: import("foldkit/schema").CallableTaggedStruct<"PressedEscape", {}>;
+/** Sent when a pointer presses the trigger. */
+export declare const PressedPointerOnTrigger: import("foldkit/schema").CallableTaggedStruct<"PressedPointerOnTrigger", {
+    pointerType: S.String;
+    button: S.Number;
+}>;
+/** Sent when the show-delay timer fires. */
+export declare const ElapsedShowDelay: import("foldkit/schema").CallableTaggedStruct<"ElapsedShowDelay", {
+    version: S.Number;
+}>;
+/** Sent when the tooltip panel mounts and Floating UI has positioned it. */
+export declare const CompletedAnchorTooltip: import("foldkit/schema").CallableTaggedStruct<"CompletedAnchorTooltip", {}>;
+/** Union of all messages the tooltip component can produce. */
+export declare const Message: S.Union<[
+    typeof EnteredTrigger,
+    typeof LeftTrigger,
+    typeof FocusedTrigger,
+    typeof BlurredTrigger,
+    typeof PressedEscape,
+    typeof PressedPointerOnTrigger,
+    typeof ElapsedShowDelay,
+    typeof CompletedAnchorTooltip
+]>;
+export type EnteredTrigger = typeof EnteredTrigger.Type;
+export type LeftTrigger = typeof LeftTrigger.Type;
+export type FocusedTrigger = typeof FocusedTrigger.Type;
+export type BlurredTrigger = typeof BlurredTrigger.Type;
+export type PressedEscape = typeof PressedEscape.Type;
+export type PressedPointerOnTrigger = typeof PressedPointerOnTrigger.Type;
+export type Message = typeof Message.Type;
+/** Emitted once the tooltip transitions to visible (`isOpen` becomes true).
+ *  Consumers typically use this for analytics, instrumentation, or to
+ *  coordinate with other transient UI. */
+export declare const Shown: import("foldkit/schema").CallableTaggedStruct<"Shown", {}>;
+/** Emitted once the tooltip transitions to hidden (`isOpen` becomes false). */
+export declare const Hidden: import("foldkit/schema").CallableTaggedStruct<"Hidden", {}>;
+/** Union of out-messages the tooltip component can produce. */
+export declare const OutMessage: S.Union<readonly [import("foldkit/schema").CallableTaggedStruct<"Shown", {}>, import("foldkit/schema").CallableTaggedStruct<"Hidden", {}>]>;
+export type Shown = typeof Shown.Type;
+export type Hidden = typeof Hidden.Type;
+export type OutMessage = typeof OutMessage.Type;
+/** Configuration for creating a tooltip model with `init`. */
+export type InitConfig = Readonly<{
+    id: string;
+    showDelay?: Duration.Input;
+}>;
+/** Creates an initial tooltip model from a config. Defaults to hidden. */
+export declare const init: (config: InitConfig) => Model;
+/** Waits for the tooltip's show delay before emitting `ElapsedShowDelay`. */
+export declare const ShowAfterDelay: Command.CommandDefinitionWithArgs<"ShowAfterDelay", {
+    delay: S.DurationFromMillis;
+    version: S.Number;
+}, Effect.Effect<{
+    readonly _tag: "ElapsedShowDelay";
+    readonly version: number;
+}, never, never>>;
+/** The anchor-positioning Mount this Tooltip renders on its panel. */
+export declare const AnchorTooltip: Mount.MountDefinitionWithArgs<"AnchorTooltip", {
+    buttonId: S.String;
+    anchor: S.Struct<{
+        readonly placement: S.optional<S.Literals<readonly ["top", "right", "bottom", "left", "top-start", "top-end", "right-start", "right-end", "bottom-start", "bottom-end", "left-start", "left-end"]>>;
+        readonly gap: S.optional<S.Number>;
+        readonly offset: S.optional<S.Number>;
+        readonly padding: S.optional<S.Number>;
+        readonly portal: S.optional<S.Boolean>;
+    }>;
+}, {
+    readonly _tag: "CompletedAnchorTooltip";
+}>;
+type UpdateReturn = readonly [
+    Model,
+    ReadonlyArray<Command.Command<Message>>,
+    Option.Option<OutMessage>
+];
+/** Processes a tooltip message and returns the next model, commands, and
+ *  an optional OutMessage. `Shown`/`Hidden` fire only on `isOpen`
+ *  transitions, so consumers don't get spurious events for messages that
+ *  only update hover/focus/delay state without changing visibility. */
+export declare const update: (model: Model, message: Message) => UpdateReturn;
+/** Reflects an externally-sourced hover show-delay onto the model without
+ *  emitting an OutMessage. Use to mirror an external config value (a user
+ *  preference, a restored setting) onto the tooltip. */
+export declare const reflectShowDelay: Reflect<Model, Duration.Input>;
+/** Render-time payload published to the consumer's `toView`.
+ *
+ *  - `trigger`: attribute bundle for the trigger element. Carries the
+ *    hover/focus/keyboard handlers + ARIA `aria-describedby` linking to
+ *    the panel.
+ *  - `panel`: attribute bundle for the panel element. Carries the
+ *    `role="tooltip"`, the anchor Mount that positions the panel via
+ *    Floating UI, and a `data-open` attribute when visible.
+ *  - `isVisible`: derived state. The consumer decides whether to render
+ *    the panel conditionally on this. */
+export type RenderInfo = Readonly<{
+    trigger: ReadonlyArray<ChildAttribute>;
+    panel: ReadonlyArray<ChildAttribute>;
+    isVisible: boolean;
+}>;
+/** Per-render view inputs passed to `view` via `h.submodel`'s `viewInputs` field. */
+export type ViewInputs = Readonly<{
+    anchor: AnchorConfig;
+    toView: (render: RenderInfo) => Html;
+    isDisabled?: boolean;
+}>;
+/** Renders a headless tooltip with an anchored non-interactive panel.
+ *  Shows on hover (after delay) or focus (from keyboard, touch, or pen;
+ *  mouse-click focus is excluded); hides on leave, blur, Escape, or
+ *  left-click of the trigger. */
+export declare const view: import("foldkit/submodel").View<{
+    readonly id: string;
+    readonly isOpen: boolean;
+    readonly isHovered: boolean;
+    readonly isFocused: boolean;
+    readonly isDismissed: boolean;
+    readonly showDelay: Duration.Duration;
+    readonly pendingShowVersion: number;
+    readonly maybeLastPointerType: Option.Option<string>;
+}, {
+    readonly _tag: "EnteredTrigger";
+} | {
+    readonly _tag: "LeftTrigger";
+} | {
+    readonly _tag: "FocusedTrigger";
+} | {
+    readonly _tag: "BlurredTrigger";
+} | {
+    readonly _tag: "PressedEscape";
+} | {
+    readonly _tag: "PressedPointerOnTrigger";
+    readonly pointerType: string;
+    readonly button: number;
+} | {
+    readonly _tag: "ElapsedShowDelay";
+    readonly version: number;
+} | {
+    readonly _tag: "CompletedAnchorTooltip";
+}, Readonly<{
+    anchor: AnchorConfig;
+    toView: (render: RenderInfo) => Html;
+    isDisabled?: boolean;
+}>>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tooltip/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tooltip/index.ts"],"names":[],"mappings":"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"}

package/dist/tooltip/index.js

@@ -0,0 +1,253 @@
+import { Duration, Effect, Equal, Function, Match as M, Number, Option, Schema as S, } from 'effect';
+import * as Command from 'foldkit/command';
+import { childAttributes, html, } from 'foldkit/html';
+import { m } from 'foldkit/message';
+import * as Mount from 'foldkit/mount';
+import { evo } from 'foldkit/struct';
+import { defineView } from 'foldkit/submodel';
+import { AnchorConfig, anchorSetup } from '../anchor.js';
+import * as OptionExt from '../internal/optionExtensions.js';
+// MODEL
+/** Schema for the tooltip component's state. `isOpen` is visibility; `isHovered` tracks pointer on trigger; `isFocused` tracks tooltip-affirming focus on the trigger (focus arriving without a preceding mouse press, like keyboard, touch, or pen; mouse-click-induced focus is excluded since it doesn't affirm the user wants the tooltip visible); `isDismissed` suppresses re-opening after the user dismissed the tooltip (via Escape or left-click) until they disengage (leave or blur). `showDelay` is the hover-to-show duration. `maybeLastPointerType` records the most recent pointer type that pressed the trigger, so a mouse-click-induced focus can be distinguished from other focus. */
+export const Model = S.Struct({
+    id: S.String,
+    isOpen: S.Boolean,
+    isHovered: S.Boolean,
+    isFocused: S.Boolean,
+    isDismissed: S.Boolean,
+    showDelay: S.DurationFromMillis,
+    pendingShowVersion: S.Number,
+    maybeLastPointerType: S.Option(S.String),
+});
+// MESSAGE
+/** Sent when the pointer enters the tooltip trigger. */
+export const EnteredTrigger = m('EnteredTrigger');
+/** Sent when the pointer leaves the tooltip trigger. */
+export const LeftTrigger = m('LeftTrigger');
+/** Sent when focus enters the trigger. */
+export const FocusedTrigger = m('FocusedTrigger');
+/** Sent when focus leaves the trigger. */
+export const BlurredTrigger = m('BlurredTrigger');
+/** Sent when Escape is pressed while the tooltip is visible. */
+export const PressedEscape = m('PressedEscape');
+/** Sent when a pointer presses the trigger. */
+export const PressedPointerOnTrigger = m('PressedPointerOnTrigger', {
+    pointerType: S.String,
+    button: S.Number,
+});
+/** Sent when the show-delay timer fires. */
+export const ElapsedShowDelay = m('ElapsedShowDelay', {
+    version: S.Number,
+});
+/** Sent when the tooltip panel mounts and Floating UI has positioned it. */
+export const CompletedAnchorTooltip = m('CompletedAnchorTooltip');
+/** Union of all messages the tooltip component can produce. */
+export const Message = S.Union([
+    EnteredTrigger,
+    LeftTrigger,
+    FocusedTrigger,
+    BlurredTrigger,
+    PressedEscape,
+    PressedPointerOnTrigger,
+    ElapsedShowDelay,
+    CompletedAnchorTooltip,
+]);
+// OUT MESSAGE
+/** Emitted once the tooltip transitions to visible (`isOpen` becomes true).
+ *  Consumers typically use this for analytics, instrumentation, or to
+ *  coordinate with other transient UI. */
+export const Shown = m('Shown');
+/** Emitted once the tooltip transitions to hidden (`isOpen` becomes false). */
+export const Hidden = m('Hidden');
+/** Union of out-messages the tooltip component can produce. */
+export const OutMessage = S.Union([Shown, Hidden]);
+// INIT
+const DEFAULT_SHOW_DELAY = Duration.millis(500);
+const LEFT_MOUSE_BUTTON = 0;
+/** Creates an initial tooltip model from a config. Defaults to hidden. */
+export const init = (config) => ({
+    id: config.id,
+    isOpen: false,
+    isHovered: false,
+    isFocused: false,
+    isDismissed: false,
+    showDelay: config.showDelay === undefined
+        ? DEFAULT_SHOW_DELAY
+        : Duration.fromInputUnsafe(config.showDelay),
+    pendingShowVersion: 0,
+    maybeLastPointerType: Option.none(),
+});
+const withUpdateReturn = M.withReturnType();
+/** Waits for the tooltip's show delay before emitting `ElapsedShowDelay`. */
+export const ShowAfterDelay = Command.define('ShowAfterDelay', { delay: S.DurationFromMillis, version: S.Number }, ElapsedShowDelay)(({ delay, version }) => Effect.sleep(delay).pipe(Effect.as(ElapsedShowDelay({ version }))));
+/** The anchor-positioning Mount this Tooltip renders on its panel. */
+export const AnchorTooltip = Mount.define('AnchorTooltip', { buttonId: S.String, anchor: AnchorConfig }, CompletedAnchorTooltip)(({ buttonId, anchor }) => element => Effect.gen(function* () {
+    yield* Effect.acquireRelease(Effect.sync(() => anchorSetup({
+        buttonId,
+        anchor,
+        interceptTab: false,
+    })(element)), cleanup => Effect.sync(cleanup));
+    return CompletedAnchorTooltip();
+}));
+const computeUpdate = (model, message) => M.value(message).pipe(withUpdateReturn, M.tagsExhaustive({
+    EnteredTrigger: () => {
+        if (model.isOpen || model.isDismissed) {
+            return [evo(model, { isHovered: () => true }), []];
+        }
+        const nextVersion = Number.increment(model.pendingShowVersion);
+        return [
+            evo(model, {
+                isHovered: () => true,
+                pendingShowVersion: () => nextVersion,
+            }),
+            [ShowAfterDelay({ delay: model.showDelay, version: nextVersion })],
+        ];
+    },
+    LeftTrigger: () => [
+        evo(model, {
+            isHovered: () => false,
+            isOpen: () => model.isFocused && model.isOpen,
+            isDismissed: () => false,
+            pendingShowVersion: Number.increment,
+        }),
+        [],
+    ],
+    FocusedTrigger: () => {
+        const isFromMousePress = Option.exists(model.maybeLastPointerType, Equal.equals('mouse'));
+        if (isFromMousePress) {
+            return [
+                evo(model, {
+                    maybeLastPointerType: () => Option.none(),
+                }),
+                [],
+            ];
+        }
+        if (model.isDismissed) {
+            return [
+                evo(model, {
+                    isFocused: () => true,
+                    maybeLastPointerType: () => Option.none(),
+                }),
+                [],
+            ];
+        }
+        return [
+            evo(model, {
+                isFocused: () => true,
+                isOpen: () => true,
+                pendingShowVersion: Number.increment,
+            }),
+            [],
+        ];
+    },
+    BlurredTrigger: () => [
+        evo(model, {
+            isFocused: () => false,
+            isOpen: () => model.isHovered && model.isOpen,
+            isDismissed: () => false,
+            pendingShowVersion: Number.increment,
+            maybeLastPointerType: () => Option.none(),
+        }),
+        [],
+    ],
+    PressedEscape: () => [
+        evo(model, {
+            isOpen: () => false,
+            isDismissed: () => true,
+            pendingShowVersion: Number.increment,
+        }),
+        [],
+    ],
+    PressedPointerOnTrigger: ({ pointerType, button }) => {
+        const isLeftClickOnOpen = button === LEFT_MOUSE_BUTTON && model.isOpen;
+        if (isLeftClickOnOpen) {
+            return [
+                evo(model, {
+                    maybeLastPointerType: () => Option.some(pointerType),
+                    isOpen: () => false,
+                    isFocused: () => false,
+                    isDismissed: () => true,
+                    pendingShowVersion: Number.increment,
+                }),
+                [],
+            ];
+        }
+        return [
+            evo(model, {
+                maybeLastPointerType: () => Option.some(pointerType),
+            }),
+            [],
+        ];
+    },
+    ElapsedShowDelay: ({ version }) => {
+        if (version !== model.pendingShowVersion) {
+            return [model, []];
+        }
+        if (!model.isHovered) {
+            return [model, []];
+        }
+        return [evo(model, { isOpen: () => true }), []];
+    },
+    CompletedAnchorTooltip: () => [model, []],
+}));
+/** Processes a tooltip message and returns the next model, commands, and
+ *  an optional OutMessage. `Shown`/`Hidden` fire only on `isOpen`
+ *  transitions, so consumers don't get spurious events for messages that
+ *  only update hover/focus/delay state without changing visibility. */
+export const update = (model, message) => {
+    const [nextModel, commands] = computeUpdate(model, message);
+    const maybeOutMessage = !model.isOpen && nextModel.isOpen
+        ? Option.some(Shown())
+        : model.isOpen && !nextModel.isOpen
+            ? Option.some(Hidden())
+            : Option.none();
+    return [nextModel, commands, maybeOutMessage];
+};
+/** Reflects an externally-sourced hover show-delay onto the model without
+ *  emitting an OutMessage. Use to mirror an external config value (a user
+ *  preference, a restored setting) onto the tooltip. */
+export const reflectShowDelay = Function.dual(2, (model, showDelay) => evo(model, { showDelay: () => Duration.fromInputUnsafe(showDelay) }));
+/** Renders a headless tooltip with an anchored non-interactive panel.
+ *  Shows on hover (after delay) or focus (from keyboard, touch, or pen;
+ *  mouse-click focus is excluded); hides on leave, blur, Escape, or
+ *  left-click of the trigger. */
+export const view = defineView((model, viewInputs) => {
+    const h = html();
+    const { id, isOpen } = model;
+    const { anchor, toView, isDisabled } = viewInputs;
+    const handleTriggerKeyDown = (key) => M.value(key).pipe(M.when('Escape', () => OptionExt.when(isOpen, PressedEscape())), M.orElse(() => Option.none()));
+    const handleTriggerPointerDown = (pointerType, button) => Option.some(PressedPointerOnTrigger({ pointerType, button }));
+    const triggerAttributes = [
+        h.Id(`${id}-trigger`),
+        h.Type('button'),
+        h.AriaDescribedBy(`${id}-panel`),
+        ...(isOpen ? [h.DataAttribute('open', '')] : []),
+        ...(isDisabled
+            ? [h.AriaDisabled(true), h.DataAttribute('disabled', '')]
+            : [
+                h.OnMouseEnter(EnteredTrigger()),
+                h.OnMouseLeave(LeftTrigger()),
+                h.OnFocus(FocusedTrigger()),
+                h.OnBlur(BlurredTrigger()),
+                h.OnKeyDownPreventDefault(handleTriggerKeyDown),
+                h.OnPointerDown(handleTriggerPointerDown),
+            ]),
+    ];
+    const panelAttributes = [
+        h.Id(`${id}-panel`),
+        h.Role('tooltip'),
+        h.Style({
+            position: 'absolute',
+            margin: '0',
+            visibility: 'hidden',
+            pointerEvents: 'none',
+        }),
+        h.OnMount(AnchorTooltip({ buttonId: `${id}-trigger`, anchor })),
+        ...(isOpen ? [h.DataAttribute('open', '')] : []),
+    ];
+    return toView({
+        trigger: childAttributes(triggerAttributes),
+        panel: childAttributes(panelAttributes),
+        isVisible: isOpen,
+    });
+});

package/dist/tooltip/public.d.ts

@@ -0,0 +1,4 @@
+export { init, update, view, reflectShowDelay, Model, Message, OutMessage, Shown, Hidden, EnteredTrigger, LeftTrigger, FocusedTrigger, BlurredTrigger, PressedEscape, PressedPointerOnTrigger, ElapsedShowDelay, ShowAfterDelay, CompletedAnchorTooltip, AnchorTooltip, } from './index.js';
+export type { InitConfig, ViewInputs, RenderInfo } from './index.js';
+export type { AnchorConfig } from '../anchor.js';
+//# sourceMappingURL=public.d.ts.map

package/dist/tooltip/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/tooltip/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,gBAAgB,EAChB,KAAK,EACL,OAAO,EACP,UAAU,EACV,KAAK,EACL,MAAM,EACN,cAAc,EACd,WAAW,EACX,cAAc,EACd,cAAc,EACd,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEpE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA"}

package/dist/tooltip/public.js

@@ -0,0 +1 @@
+export { init, update, view, reflectShowDelay, Model, Message, OutMessage, Shown, Hidden, EnteredTrigger, LeftTrigger, FocusedTrigger, BlurredTrigger, PressedEscape, PressedPointerOnTrigger, ElapsedShowDelay, ShowAfterDelay, CompletedAnchorTooltip, AnchorTooltip, } from './index.js';

package/dist/typeahead.d.ts

@@ -0,0 +1,4 @@
+import { Option } from 'effect';
+/** Finds the first enabled item whose search text starts with the query, searching forward from the active item and wrapping around. On a fresh search, starts after the active item; on a refinement, includes the active item. */
+export declare const resolveTypeaheadMatch: <Item>(items: ReadonlyArray<Item>, query: string, maybeActiveItemIndex: Option.Option<number>, isDisabled: (index: number) => boolean, itemToSearchText: (item: Item, index: number) => string, isRefinement: boolean) => Option.Option<number>;
+//# sourceMappingURL=typeahead.d.ts.map