@foldkit/ui 0.136.0 → 0.137.0

package/dist/tooltip/tooltip.d.ts

@@ -0,0 +1,130 @@
+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';
+import { type Message, type OutMessage } from './message.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) 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;
+/** Returns the bare DOM id of the tooltip trigger button, derived from the
+ *  tooltip's base id. Use this to associate an external label with the
+ *  trigger via a native `<label for={Tooltip.triggerId(id)}>` or an
+ *  `aria-labelledby` reference. */
+export declare const triggerId: (id: string) => string;
+/** 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
+ *  `CompletedWaitBeforeShowing`. */
+export declare const WaitBeforeShowing: Command.CommandDefinitionWithArgs<"WaitBeforeShowing", {
+    delay: S.DurationFromMillis;
+    version: S.Number;
+}, Effect.Effect<{
+    readonly _tag: "CompletedWaitBeforeShowing";
+    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 isPlacementLocked: 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;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+}>;
+/** 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, or Escape. */
+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 _tag: "CompletedWaitBeforeShowing";
+    readonly version: number;
+} | {
+    readonly _tag: "CompletedAnchorTooltip";
+}, Readonly<{
+    anchor: AnchorConfig;
+    toView: (render: RenderInfo) => Html;
+    isDisabled?: boolean;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+}>>;
+export {};
+//# sourceMappingURL=tooltip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../src/tooltip/tooltip.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,MAAM,EAKN,MAAM,EAEN,MAAM,IAAI,CAAC,EACZ,MAAM,QAAQ,CAAA;AACf,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAA;AAC1C,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,IAAI,EAAmB,MAAM,cAAc,CAAA;AAC9E,OAAO,KAAK,KAAK,MAAM,eAAe,CAAA;AAEtC,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,kBAAkB,CAAA;AAE3D,OAAO,EAAE,YAAY,EAAe,MAAM,cAAc,CAAA;AAExD,OAAO,EAQL,KAAK,OAAO,EACZ,KAAK,UAAU,EAIhB,MAAM,cAAc,CAAA;AAIrB,8pBAA8pB;AAC9pB,eAAO,MAAM,KAAK;;;;;;;;;EAShB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAIrC;;;mCAGmC;AACnC,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,KAAG,MAAyB,CAAA;AAQhE,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;CAC3B,CAAC,CAAA;AAEF,0EAA0E;AAC1E,eAAO,MAAM,IAAI,GAAI,QAAQ,UAAU,KAAG,KAYxC,CAAA;AAUF;oCACoC;AACpC,eAAO,MAAM,iBAAiB;;;;;;iBAO5B,CAAA;AAEF,sEAAsE;AACtE,eAAO,MAAM,aAAa;;;;;;;;;;;;EAoBzB,CAAA;AA6GD,KAAK,YAAY,GAAG,SAAS;IAC3B,KAAK;IACL,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;CAC1B,CAAA;AAeD;;;uEAGuE;AACvE,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,EAAE,SAAS,OAAO,KAAG,YAOvD,CAAA;AAED;;wDAEwD;AACxD,eAAO,MAAM,gBAAgB,EAAE,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAI3D,CAAA;AAID;;;;;;;;;yCASyC;AACzC,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IAChC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;IACtC,KAAK,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;IACpC,SAAS,EAAE,OAAO,CAAA;CACnB,CAAC,CAAA;AAEF,qFAAqF;AACrF,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IAChC,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAA;IACpC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAC,CAAA;AAEF;;uEAEuE;AACvE,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAVP,YAAY;YACZ,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI;iBACvB,OAAO;gBACR,MAAM;qBACD,MAAM;GAuExB,CAAA"}

package/dist/tooltip/tooltip.js

@@ -0,0 +1,226 @@
+import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
+import { Duration, Effect, Equal, Function, Match as M, Number, Option, Predicate, Schema as S, } from 'effect';
+import * as Command from 'foldkit/command';
+import { childAttributes } from 'foldkit/html';
+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';
+import { BlurredTrigger, CompletedAnchorTooltip, CompletedWaitBeforeShowing, EnteredTrigger, FocusedTrigger, Hidden, LeftTrigger, PressedEscape, PressedPointerOnTrigger, Shown, } from './message.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) 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),
+});
+// SELECTORS
+/** Returns the bare DOM id of the tooltip trigger button, derived from the
+ *  tooltip's base id. Use this to associate an external label with the
+ *  trigger via a native `<label for={Tooltip.triggerId(id)}>` or an
+ *  `aria-labelledby` reference. */
+export const triggerId = (id) => __foldkitBrandViewResult((`${id}-trigger`), "@foldkit/ui/tooltip/tooltip.js#triggerId");
+const panelId = (id) => __foldkitBrandViewResult((`${id}-panel`), "@foldkit/ui/tooltip/tooltip.js#panelId");
+// INIT
+const DEFAULT_SHOW_DELAY = Duration.millis(500);
+/** Creates an initial tooltip model from a config. Defaults to hidden. */
+export const init = (config) => (__foldkitBrandViewResult(({
+    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(),
+}), "@foldkit/ui/tooltip/tooltip.js#init"));
+const withUpdateReturn = M.withReturnType();
+/** Waits for the tooltip's show delay before emitting
+ *  `CompletedWaitBeforeShowing`. */
+export const WaitBeforeShowing = Command.define('WaitBeforeShowing', {
+    args: { delay: S.DurationFromMillis, version: S.Number },
+    messages: [CompletedWaitBeforeShowing],
+    execute: ({ delay, version }) => __foldkitBrandViewResult((Effect.sleep(delay).pipe(Effect.as(CompletedWaitBeforeShowing({ version })))), "@foldkit/ui/tooltip/tooltip.js#execute"),
+});
+/** The anchor-positioning Mount this Tooltip renders on its panel. */
+export const AnchorTooltip = Mount.define('AnchorTooltip', { buttonId: S.String, anchor: AnchorConfig }, CompletedAnchorTooltip)(({ buttonId, anchor }) => __foldkitBrandViewResult((element => __foldkitBrandViewResult((Effect.gen(function* () {
+    yield* Effect.acquireRelease(Effect.sync(() => __foldkitBrandViewResult((anchorSetup({
+        buttonId,
+        anchor,
+        interceptTab: false,
+    })(element)), "@foldkit/ui/tooltip/tooltip.js#anonymous~4")), cleanup => __foldkitBrandViewResult((Effect.sync(cleanup)), "@foldkit/ui/tooltip/tooltip.js#anonymous~5"));
+    return __foldkitBrandViewResult((CompletedAnchorTooltip()), "@foldkit/ui/tooltip/tooltip.js#anonymous~3");
+})), "@foldkit/ui/tooltip/tooltip.js#anonymous~2")), "@foldkit/ui/tooltip/tooltip.js#anonymous"));
+const computeUpdate = (model, message) => __foldkitBrandViewResult((M.value(message).pipe(withUpdateReturn, M.tagsExhaustive({
+    EnteredTrigger: () => {
+        if (model.isOpen || model.isDismissed) {
+            return __foldkitBrandViewResult(([evo(model, { isHovered: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isHovered") }), []]), "@foldkit/ui/tooltip/tooltip.js#EnteredTrigger");
+        }
+        const nextVersion = Number.increment(model.pendingShowVersion);
+        return __foldkitBrandViewResult(([
+            evo(model, {
+                isHovered: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isHovered~2"),
+                pendingShowVersion: () => __foldkitBrandViewResult((nextVersion), "@foldkit/ui/tooltip/tooltip.js#pendingShowVersion"),
+            }),
+            [WaitBeforeShowing({ delay: model.showDelay, version: nextVersion })],
+        ]), "@foldkit/ui/tooltip/tooltip.js#EnteredTrigger");
+    },
+    LeftTrigger: () => __foldkitBrandViewResult(([
+        evo(model, {
+            isHovered: () => __foldkitBrandViewResult((false), "@foldkit/ui/tooltip/tooltip.js#isHovered~3"),
+            isOpen: () => __foldkitBrandViewResult((model.isFocused && model.isOpen), "@foldkit/ui/tooltip/tooltip.js#isOpen"),
+            isDismissed: () => __foldkitBrandViewResult((false), "@foldkit/ui/tooltip/tooltip.js#isDismissed"),
+            pendingShowVersion: Number.increment,
+        }),
+        [],
+    ]), "@foldkit/ui/tooltip/tooltip.js#LeftTrigger"),
+    FocusedTrigger: () => {
+        const isFromMousePress = Option.exists(model.maybeLastPointerType, Equal.equals('mouse'));
+        if (isFromMousePress) {
+            return __foldkitBrandViewResult(([
+                evo(model, {
+                    maybeLastPointerType: () => __foldkitBrandViewResult((Option.none()), "@foldkit/ui/tooltip/tooltip.js#maybeLastPointerType"),
+                }),
+                [],
+            ]), "@foldkit/ui/tooltip/tooltip.js#FocusedTrigger");
+        }
+        if (model.isDismissed) {
+            return __foldkitBrandViewResult(([
+                evo(model, {
+                    isFocused: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isFocused"),
+                    maybeLastPointerType: () => __foldkitBrandViewResult((Option.none()), "@foldkit/ui/tooltip/tooltip.js#maybeLastPointerType~2"),
+                }),
+                [],
+            ]), "@foldkit/ui/tooltip/tooltip.js#FocusedTrigger");
+        }
+        return __foldkitBrandViewResult(([
+            evo(model, {
+                isFocused: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isFocused~2"),
+                isOpen: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isOpen~2"),
+                pendingShowVersion: Number.increment,
+            }),
+            [],
+        ]), "@foldkit/ui/tooltip/tooltip.js#FocusedTrigger");
+    },
+    BlurredTrigger: () => __foldkitBrandViewResult(([
+        evo(model, {
+            isFocused: () => __foldkitBrandViewResult((false), "@foldkit/ui/tooltip/tooltip.js#isFocused~3"),
+            isOpen: () => __foldkitBrandViewResult((model.isHovered && model.isOpen), "@foldkit/ui/tooltip/tooltip.js#isOpen~3"),
+            isDismissed: () => __foldkitBrandViewResult((false), "@foldkit/ui/tooltip/tooltip.js#isDismissed~2"),
+            pendingShowVersion: Number.increment,
+            maybeLastPointerType: () => __foldkitBrandViewResult((Option.none()), "@foldkit/ui/tooltip/tooltip.js#maybeLastPointerType~3"),
+        }),
+        [],
+    ]), "@foldkit/ui/tooltip/tooltip.js#BlurredTrigger"),
+    PressedEscape: () => __foldkitBrandViewResult(([
+        evo(model, {
+            isOpen: () => __foldkitBrandViewResult((false), "@foldkit/ui/tooltip/tooltip.js#isOpen~4"),
+            isDismissed: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isDismissed~3"),
+            pendingShowVersion: Number.increment,
+        }),
+        [],
+    ]), "@foldkit/ui/tooltip/tooltip.js#PressedEscape"),
+    PressedPointerOnTrigger: ({ pointerType }) => __foldkitBrandViewResult(([
+        evo(model, {
+            maybeLastPointerType: () => __foldkitBrandViewResult((Option.some(pointerType)), "@foldkit/ui/tooltip/tooltip.js#maybeLastPointerType~4"),
+        }),
+        [],
+    ]), "@foldkit/ui/tooltip/tooltip.js#PressedPointerOnTrigger"),
+    CompletedWaitBeforeShowing: ({ version }) => {
+        if (version !== model.pendingShowVersion) {
+            return __foldkitBrandViewResult(([model, []]), "@foldkit/ui/tooltip/tooltip.js#CompletedWaitBeforeShowing");
+        }
+        if (!model.isHovered) {
+            return __foldkitBrandViewResult(([model, []]), "@foldkit/ui/tooltip/tooltip.js#CompletedWaitBeforeShowing");
+        }
+        return __foldkitBrandViewResult(([evo(model, { isOpen: () => __foldkitBrandViewResult((true), "@foldkit/ui/tooltip/tooltip.js#isOpen~5") }), []]), "@foldkit/ui/tooltip/tooltip.js#CompletedWaitBeforeShowing");
+    },
+    CompletedAnchorTooltip: () => __foldkitBrandViewResult(([model, []]), "@foldkit/ui/tooltip/tooltip.js#CompletedAnchorTooltip"),
+}))), "@foldkit/ui/tooltip/tooltip.js#computeUpdate");
+const toMaybeVisibilityOutMessage = (isOpen, isNextOpen) => {
+    if (!isOpen && isNextOpen) {
+        return __foldkitBrandViewResult((Option.some(Shown())), "@foldkit/ui/tooltip/tooltip.js#toMaybeVisibilityOutMessage");
+    }
+    else if (isOpen && !isNextOpen) {
+        return __foldkitBrandViewResult((Option.some(Hidden())), "@foldkit/ui/tooltip/tooltip.js#toMaybeVisibilityOutMessage");
+    }
+    else {
+        return __foldkitBrandViewResult((Option.none()), "@foldkit/ui/tooltip/tooltip.js#toMaybeVisibilityOutMessage");
+    }
+};
+/** 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 = toMaybeVisibilityOutMessage(model.isOpen, nextModel.isOpen);
+    return __foldkitBrandViewResult(([nextModel, commands, maybeOutMessage]), "@foldkit/ui/tooltip/tooltip.js#update");
+};
+/** 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) => __foldkitBrandViewResult((evo(model, { showDelay: () => __foldkitBrandViewResult((Duration.fromInputUnsafe(showDelay)), "@foldkit/ui/tooltip/tooltip.js#showDelay") })), "@foldkit/ui/tooltip/tooltip.js#anonymous~6"));
+/** 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, or Escape. */
+export const view = defineView((model, viewInputs, h) => {
+    const { id, isOpen } = model;
+    const { anchor, toView, isDisabled, ariaLabel, ariaLabelledBy } = viewInputs;
+    const resolveTriggerLabel = () => {
+        if (Predicate.isNotUndefined(ariaLabel)) {
+            return __foldkitBrandViewResult(([h.AriaLabel(ariaLabel)]), "@foldkit/ui/tooltip/tooltip.js#resolveTriggerLabel");
+        }
+        else if (Predicate.isNotUndefined(ariaLabelledBy)) {
+            return __foldkitBrandViewResult(([h.AriaLabelledBy(ariaLabelledBy)]), "@foldkit/ui/tooltip/tooltip.js#resolveTriggerLabel");
+        }
+        else {
+            return __foldkitBrandViewResult(([]), "@foldkit/ui/tooltip/tooltip.js#resolveTriggerLabel");
+        }
+    };
+    const triggerLabelAttributes = resolveTriggerLabel();
+    const handleTriggerKeyDown = (key) => __foldkitBrandViewResult((M.value(key).pipe(M.when('Escape', () => __foldkitBrandViewResult((OptionExt.when(isOpen, PressedEscape())), "@foldkit/ui/tooltip/tooltip.js#anonymous~8")), M.orElse(() => __foldkitBrandViewResult((Option.none()), "@foldkit/ui/tooltip/tooltip.js#anonymous~9")))), "@foldkit/ui/tooltip/tooltip.js#handleTriggerKeyDown");
+    const handleTriggerPointerDown = (pointerType) => __foldkitBrandViewResult((Option.some(PressedPointerOnTrigger({ pointerType }))), "@foldkit/ui/tooltip/tooltip.js#handleTriggerPointerDown");
+    const triggerAttributes = [
+        h.Id(triggerId(id)),
+        h.Type('button'),
+        h.AriaDescribedBy(panelId(id)),
+        ...triggerLabelAttributes,
+        ...(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(panelId(id)),
+        h.Role('tooltip'),
+        h.Style({
+            position: 'absolute',
+            margin: '0',
+            visibility: 'hidden',
+            pointerEvents: 'none',
+        }),
+        h.OnMount(AnchorTooltip({ buttonId: triggerId(id), anchor })),
+        ...(isOpen ? [h.DataAttribute('open', '')] : []),
+    ];
+    return __foldkitBrandViewResult((toView({
+        trigger: childAttributes(triggerAttributes),
+        panel: childAttributes(panelAttributes),
+        isVisible: isOpen,
+    })), "@foldkit/ui/tooltip/tooltip.js#anonymous~7");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/ui",
-  "version": "0.136.0",
+  "version": "0.137.0",
   "description": "Headless, accessible UI components for Foldkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -128,7 +128,7 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.9",
     "@foldkit/vite-plugin": "0.11.3",
-    "foldkit": "0.136.0"
+    "foldkit": "0.137.0"
   },
   "keywords": [
     "foldkit",