foldkit 0.69.0 → 0.71.0

package/dist/ui/toast/update.js

@@ -0,0 +1,203 @@
+import { Array, Duration, Effect, Match as M, Number, Option, } from 'effect';
+import * as Command from '../../command';
+import { OptionExt } from '../../effectExtensions';
+import { evo } from '../../struct';
+import * as Task from '../../task';
+import { Hid as TransitionHid, Showed as TransitionShowed, init as transitionInit, } from '../transition/schema';
+import { defaultLeaveCommand as transitionDefaultLeaveCommand, update as transitionUpdate, } from '../transition/update';
+import { DEFAULT_DURATION, Dismissed, DismissedAll, ElapsedDuration, GotTransitionMessage, makeAdded, makeEntry, makeMessage, makeModel, } from './schema';
+/** 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', ElapsedDuration);
+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 `Ui.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 Added = makeAdded(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.transition;
+        return (transitionState === 'LeaveStart' || transitionState === 'LeaveAnimating');
+    };
+    const scheduleDismiss = (entryId, version, duration) => DismissAfter(Task.delay(duration).pipe(Effect.as(ElapsedDuration({ entryId, version }))));
+    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 delegateToEntryTransition = (model, entryId, transitionMessage) => {
+        const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+        return Option.match(maybeEntry, {
+            onNone: () => [model, []],
+            onSome: entry => {
+                const [nextTransition, transitionCommands, maybeOutMessage] = transitionUpdate(entry.transition, transitionMessage);
+                const toMessage = (message) => GotTransitionMessage({ entryId, message });
+                const mappedCommands = transitionCommands.map(Command.mapEffect(Effect.map(toMessage)));
+                const nextEntry = evo(entry, {
+                    transition: () => nextTransition,
+                });
+                return Option.match(maybeOutMessage, {
+                    onNone: () => [
+                        updateEntry(model, entryId, () => nextEntry),
+                        mappedCommands,
+                    ],
+                    onSome: M.type().pipe(withUpdateReturn, M.tagsExhaustive({
+                        StartedLeaveAnimating: () => [
+                            updateEntry(model, entryId, () => nextEntry),
+                            [
+                                ...mappedCommands,
+                                Command.mapEffect(transitionDefaultLeaveCommand(nextTransition), Effect.map(toMessage)),
+                            ],
+                        ],
+                        TransitionedOut: () => [
+                            removeEntry(model, entryId),
+                            mappedCommands,
+                        ],
+                    })),
+                });
+            },
+        });
+    };
+    const createEntry = (model, input) => {
+        const entryId = `${model.id}-entry-${model.nextEntryKey}`;
+        const duration = input.duration === undefined
+            ? model.defaultDuration
+            : Duration.decode(input.duration);
+        const maybeDuration = OptionExt.when(!input.sticky, duration);
+        return {
+            id: entryId,
+            variant: input.variant ?? DEFAULT_VARIANT,
+            transition: transitionInit({ 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.decode(config.defaultDuration),
+        entries: [],
+        nextEntryKey: 0,
+    });
+    /** Processes a toast message and returns the next model and commands. */
+    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] = delegateToEntryTransition(modelWithEntry, entry.id, TransitionShowed());
+            const postShowEntry = Array.findFirst(modelAfterShow.entries, ({ id }) => id === entry.id);
+            const dismissCommands = Option.match(postShowEntry, {
+                onNone: () => [],
+                onSome: rescheduleDismissCommands,
+            });
+            return [modelAfterShow, [...showCommands, ...dismissCommands]];
+        },
+        Dismissed: ({ entryId }) => {
+            const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+            return Option.match(maybeEntry, {
+                onNone: () => [model, []],
+                onSome: entry => {
+                    if (isEntryLeaving(entry)) {
+                        return [model, []];
+                    }
+                    else {
+                        return delegateToEntryTransition(model, entryId, TransitionHid());
+                    }
+                },
+            });
+        },
+        DismissedAll: () => Array.reduce(model.entries, [model, []], ([currentModel, currentCommands], entry) => {
+            if (isEntryLeaving(entry)) {
+                return [currentModel, currentCommands];
+            }
+            const [nextModel, nextCommands] = delegateToEntryTransition(currentModel, entry.id, TransitionHid());
+            return [nextModel, [...currentCommands, ...nextCommands]];
+        }),
+        ElapsedDuration: ({ entryId, version }) => {
+            const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+            return Option.match(maybeEntry, {
+                onNone: () => [model, []],
+                onSome: entry => {
+                    const isStale = version !== entry.pendingDismissVersion;
+                    if (isStale || isEntryLeaving(entry)) {
+                        return [model, []];
+                    }
+                    else {
+                        return delegateToEntryTransition(model, entryId, TransitionHid());
+                    }
+                },
+            });
+        },
+        HoveredEntry: ({ entryId }) => [
+            updateEntry(model, entryId, entry => evo(entry, {
+                isHovered: () => true,
+                pendingDismissVersion: Number.increment,
+            })),
+            [],
+        ],
+        LeftEntry: ({ entryId }) => {
+            const maybeEntry = Array.findFirst(model.entries, ({ id }) => id === entryId);
+            return Option.match(maybeEntry, {
+                onNone: () => [model, []],
+                onSome: entry => {
+                    const nextEntry = evo(entry, {
+                        isHovered: () => false,
+                        pendingDismissVersion: Number.increment,
+                    });
+                    return [
+                        updateEntry(model, entryId, () => nextEntry),
+                        rescheduleDismissCommands(nextEntry),
+                    ];
+                },
+            });
+        },
+        GotTransitionMessage: ({ entryId, message: transitionMessage }) => delegateToEntryTransition(model, entryId, transitionMessage),
+    }));
+    /** 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,
+        Added,
+        init,
+        update,
+        show,
+        dismiss,
+        dismissAll,
+    };
+};

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

@@ -0,0 +1,96 @@
+import { Duration, Schema as S } from 'effect';
+import * as Command from '../../command';
+import { type Attribute, type Html } from '../../html';
+import type { AnchorConfig } from '../anchor';
+/** 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 — 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<{
+    id: typeof S.String;
+    isOpen: typeof S.Boolean;
+    isHovered: typeof S.Boolean;
+    isFocused: typeof S.Boolean;
+    isDismissed: typeof S.Boolean;
+    showDelay: typeof S.DurationFromMillis;
+    pendingShowVersion: typeof S.Number;
+    maybeLastPointerType: S.OptionFromSelf<typeof S.String>;
+}>;
+export type Model = typeof Model.Type;
+/** Sent when the pointer enters the tooltip trigger. Starts the show-delay timer. */
+export declare const EnteredTrigger: import("../../schema").CallableTaggedStruct<"EnteredTrigger", {}>;
+/** Sent when the pointer leaves the tooltip trigger. Cancels any pending show-delay and hides the tooltip unless focus is active. */
+export declare const LeftTrigger: import("../../schema").CallableTaggedStruct<"LeftTrigger", {}>;
+/** Sent when focus enters the trigger. Shows the tooltip immediately unless the focus was caused by a mouse press, in which case the hover-delay path handles it instead. */
+export declare const FocusedTrigger: import("../../schema").CallableTaggedStruct<"FocusedTrigger", {}>;
+/** Sent when focus leaves the trigger. Hides the tooltip unless hover is active. */
+export declare const BlurredTrigger: import("../../schema").CallableTaggedStruct<"BlurredTrigger", {}>;
+/** Sent when Escape is pressed while the tooltip is visible. Hides the tooltip and flags `isDismissed` so hover and focus do not re-open it until the user disengages (leaves or blurs the trigger). */
+export declare const PressedEscape: import("../../schema").CallableTaggedStruct<"PressedEscape", {}>;
+/** Sent when a pointer presses the trigger. Records the pointer type so a following focus event from the same mouse click can be suppressed, and a left-click on an open tooltip dismisses it (the user is clicking the button for its action, not to keep the tooltip visible). */
+export declare const PressedPointerOnTrigger: import("../../schema").CallableTaggedStruct<"PressedPointerOnTrigger", {
+    pointerType: typeof S.String;
+    button: typeof S.Number;
+}>;
+/** Sent when the show-delay timer fires. Carries a generation number that is compared against the current pending version to discard stale timers. */
+export declare const ElapsedShowDelay: import("../../schema").CallableTaggedStruct<"ElapsedShowDelay", {
+    version: typeof S.Number;
+}>;
+/** Signals that the show-delay has changed (e.g. in response to a user preference, input-method change, or reduced-motion setting). Does not affect the current open/closed state; the new delay applies to the next hover. Typically dispatched via the `setShowDelay` helper. */
+export declare const ChangedShowDelay: import("../../schema").CallableTaggedStruct<"ChangedShowDelay", {
+    showDelay: typeof S.DurationFromMillis;
+}>;
+/** 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 ChangedShowDelay
+]>;
+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;
+/** Configuration for creating a tooltip model with `init`. `showDelay` controls how long the pointer must hover before the tooltip appears (default 500ms). Accepts any `Duration.DurationInput` — a bare number is interpreted as milliseconds. Keyboard focus shows the tooltip immediately regardless of this value. */
+export type InitConfig = Readonly<{
+    id: string;
+    showDelay?: Duration.DurationInput;
+}>;
+/** Creates an initial tooltip model from a config. Defaults to hidden. */
+export declare const init: (config: InitConfig) => Model;
+type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>];
+/** Waits for the tooltip's show delay before emitting `ElapsedShowDelay`. The version is echoed back so a stale timer is ignored when the user leaves before the delay fires. */
+export declare const ShowAfterDelay: Command.CommandDefinition<"ShowAfterDelay", {
+    readonly _tag: "ElapsedShowDelay";
+    readonly version: number;
+}>;
+/** Processes a tooltip message and returns the next model and commands. */
+export declare const update: (model: Model, message: Message) => UpdateReturn;
+/** Programmatically updates the tooltip's hover show-delay. Use this in response to user preference changes, input-method switches, or reduced-motion settings. The new delay applies to the next hover; any pending timer is unaffected (its stale version will discard harmlessly when it fires). */
+export declare const setShowDelay: (model: Model, showDelay: Duration.DurationInput) => readonly [Model, ReadonlyArray<Command.Command<Message>>];
+/** Configuration for rendering a tooltip with `view`. */
+export type ViewConfig<Message> = Readonly<{
+    model: Model;
+    toParentMessage: (message: EnteredTrigger | LeftTrigger | FocusedTrigger | BlurredTrigger | PressedEscape | PressedPointerOnTrigger) => Message;
+    anchor: AnchorConfig;
+    triggerContent: Html;
+    triggerClassName?: string;
+    triggerAttributes?: ReadonlyArray<Attribute<Message>>;
+    content: Html;
+    panelClassName?: string;
+    panelAttributes?: ReadonlyArray<Attribute<Message>>;
+    isDisabled?: boolean;
+    className?: string;
+    attributes?: ReadonlyArray<Attribute<Message>>;
+}>;
+/** 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. Uses `role="tooltip"` and links the trigger via `aria-describedby`. */
+export declare const view: <Message>(config: ViewConfig<Message>) => Html;
+/** Creates a memoized tooltip view. Static config is captured in a closure;
+ *  only `model` and `toParentMessage` are compared per render via `createLazy`. */
+export declare const lazy: <Message>(staticConfig: Omit<ViewConfig<Message>, "model" | "toParentMessage">) => ((model: Model, toParentMessage: ViewConfig<Message>["toParentMessage"]) => Html);
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/ui/tooltip/index.js

@@ -0,0 +1,244 @@
+import { Duration, Effect, Equal, Match as M, Number, Option, Schema as S, } from 'effect';
+import * as Command from '../../command';
+import { OptionExt } from '../../effectExtensions';
+import { createLazy, html } from '../../html';
+import { m } from '../../message';
+import { evo } from '../../struct';
+import * as Task from '../../task';
+import { anchorHooks } from '../anchor';
+// 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 — 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.OptionFromSelf(S.String),
+});
+// MESSAGE
+/** Sent when the pointer enters the tooltip trigger. Starts the show-delay timer. */
+export const EnteredTrigger = m('EnteredTrigger');
+/** Sent when the pointer leaves the tooltip trigger. Cancels any pending show-delay and hides the tooltip unless focus is active. */
+export const LeftTrigger = m('LeftTrigger');
+/** Sent when focus enters the trigger. Shows the tooltip immediately unless the focus was caused by a mouse press, in which case the hover-delay path handles it instead. */
+export const FocusedTrigger = m('FocusedTrigger');
+/** Sent when focus leaves the trigger. Hides the tooltip unless hover is active. */
+export const BlurredTrigger = m('BlurredTrigger');
+/** Sent when Escape is pressed while the tooltip is visible. Hides the tooltip and flags `isDismissed` so hover and focus do not re-open it until the user disengages (leaves or blurs the trigger). */
+export const PressedEscape = m('PressedEscape');
+/** Sent when a pointer presses the trigger. Records the pointer type so a following focus event from the same mouse click can be suppressed, and a left-click on an open tooltip dismisses it (the user is clicking the button for its action, not to keep the tooltip visible). */
+export const PressedPointerOnTrigger = m('PressedPointerOnTrigger', {
+    pointerType: S.String,
+    button: S.Number,
+});
+/** Sent when the show-delay timer fires. Carries a generation number that is compared against the current pending version to discard stale timers. */
+export const ElapsedShowDelay = m('ElapsedShowDelay', {
+    version: S.Number,
+});
+/** Signals that the show-delay has changed (e.g. in response to a user preference, input-method change, or reduced-motion setting). Does not affect the current open/closed state; the new delay applies to the next hover. Typically dispatched via the `setShowDelay` helper. */
+export const ChangedShowDelay = m('ChangedShowDelay', {
+    showDelay: S.DurationFromMillis,
+});
+/** Union of all messages the tooltip component can produce. */
+export const Message = S.Union(EnteredTrigger, LeftTrigger, FocusedTrigger, BlurredTrigger, PressedEscape, PressedPointerOnTrigger, ElapsedShowDelay, ChangedShowDelay);
+// 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.decode(config.showDelay),
+    pendingShowVersion: 0,
+    maybeLastPointerType: Option.none(),
+});
+const withUpdateReturn = M.withReturnType();
+/** Waits for the tooltip's show delay before emitting `ElapsedShowDelay`. The version is echoed back so a stale timer is ignored when the user leaves before the delay fires. */
+export const ShowAfterDelay = Command.define('ShowAfterDelay', ElapsedShowDelay);
+/** Processes a tooltip message and returns the next model and commands. */
+export const update = (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(Task.delay(model.showDelay).pipe(Effect.as(ElapsedShowDelay({ 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 }), []];
+    },
+    ChangedShowDelay: ({ showDelay }) => [
+        evo(model, { showDelay: () => showDelay }),
+        [],
+    ],
+}));
+/** Programmatically updates the tooltip's hover show-delay. Use this in response to user preference changes, input-method switches, or reduced-motion settings. The new delay applies to the next hover; any pending timer is unaffected (its stale version will discard harmlessly when it fires). */
+export const setShowDelay = (model, showDelay) => update(model, ChangedShowDelay({ showDelay: Duration.decode(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. Uses `role="tooltip"` and links the trigger via `aria-describedby`. */
+export const view = (config) => {
+    const { div, AriaDescribedBy, AriaDisabled, Class, DataAttribute, Id, OnBlur, OnDestroy, OnFocus, OnInsert, OnKeyDownPreventDefault, OnMouseEnter, OnMouseLeave, OnPointerDown, Role, Style, Type, keyed, } = html();
+    const { model: { id, isOpen }, toParentMessage, anchor, triggerContent, triggerClassName, triggerAttributes = [], content, panelClassName, panelAttributes = [], isDisabled, className, attributes = [], } = config;
+    const handleTriggerKeyDown = (key) => M.value(key).pipe(M.when('Escape', () => OptionExt.when(isOpen, toParentMessage(PressedEscape()))), M.orElse(() => Option.none()));
+    const handleTriggerPointerDown = (pointerType, button) => Option.some(toParentMessage(PressedPointerOnTrigger({ pointerType, button })));
+    const resolvedTriggerAttributes = [
+        Id(`${id}-trigger`),
+        Type('button'),
+        AriaDescribedBy(`${id}-panel`),
+        ...(isOpen ? [DataAttribute('open', '')] : []),
+        ...(isDisabled
+            ? [AriaDisabled(true), DataAttribute('disabled', '')]
+            : [
+                OnMouseEnter(toParentMessage(EnteredTrigger())),
+                OnMouseLeave(toParentMessage(LeftTrigger())),
+                OnFocus(toParentMessage(FocusedTrigger())),
+                OnBlur(toParentMessage(BlurredTrigger())),
+                OnKeyDownPreventDefault(handleTriggerKeyDown),
+                OnPointerDown(handleTriggerPointerDown),
+            ]),
+        ...(triggerClassName ? [Class(triggerClassName)] : []),
+        ...triggerAttributes,
+    ];
+    const hooks = anchorHooks({
+        buttonId: `${id}-trigger`,
+        anchor,
+        interceptTab: false,
+    });
+    const anchorAttributes = [
+        Style({
+            position: 'absolute',
+            margin: '0',
+            visibility: 'hidden',
+            pointerEvents: 'none',
+        }),
+        OnInsert(hooks.onInsert),
+        OnDestroy(hooks.onDestroy),
+    ];
+    const resolvedPanelAttributes = [
+        Id(`${id}-panel`),
+        Role('tooltip'),
+        ...anchorAttributes,
+        ...(isOpen ? [DataAttribute('open', '')] : []),
+        ...(panelClassName ? [Class(panelClassName)] : []),
+        ...panelAttributes,
+    ];
+    const wrapperAttributes = [
+        ...(className ? [Class(className)] : []),
+        ...attributes,
+    ];
+    return div(wrapperAttributes, [
+        keyed('button')(`${id}-trigger`, resolvedTriggerAttributes, [
+            triggerContent,
+        ]),
+        ...(isOpen
+            ? [keyed('div')(`${id}-panel`, resolvedPanelAttributes, [content])]
+            : []),
+    ]);
+};
+/** Creates a memoized tooltip view. Static config is captured in a closure;
+ *  only `model` and `toParentMessage` are compared per render via `createLazy`. */
+export const lazy = (staticConfig) => {
+    const lazyView = createLazy();
+    return (model, toParentMessage) => lazyView((currentModel, currentToMessage) => view({
+        ...staticConfig,
+        model: currentModel,
+        toParentMessage: currentToMessage,
+    }), [model, toParentMessage]);
+};

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

@@ -0,0 +1,4 @@
+export { init, update, view, lazy, setShowDelay, Model, Message, EnteredTrigger, LeftTrigger, FocusedTrigger, BlurredTrigger, PressedEscape, PressedPointerOnTrigger, ElapsedShowDelay, ChangedShowDelay, ShowAfterDelay, } from './index';
+export type { InitConfig, ViewConfig } from './index';
+export type { AnchorConfig } from '../anchor';
+//# sourceMappingURL=public.d.ts.map

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

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

package/dist/ui/tooltip/public.js

@@ -0,0 +1 @@
+export { init, update, view, lazy, setShowDelay, Model, Message, EnteredTrigger, LeftTrigger, FocusedTrigger, BlurredTrigger, PressedEscape, PressedPointerOnTrigger, ElapsedShowDelay, ChangedShowDelay, ShowAfterDelay, } from './index';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.69.0",
+  "version": "0.71.0",
   "description": "A frontend framework for TypeScript, built on Effect, using The Elm Architecture",
   "type": "module",
   "main": "./dist/index.js",
@@ -143,6 +143,14 @@
       "types": "./dist/ui/tabs/public.d.ts",
       "import": "./dist/ui/tabs/public.js"
     },
+    "./ui/toast": {
+      "types": "./dist/ui/toast/public.d.ts",
+      "import": "./dist/ui/toast/public.js"
+    },
+    "./ui/tooltip": {
+      "types": "./dist/ui/tooltip/public.d.ts",
+      "import": "./dist/ui/tooltip/public.js"
+    },
     "./ui/transition": {
       "types": "./dist/ui/transition/public.d.ts",
       "import": "./dist/ui/transition/public.js"