@skdx/vue 0.26.0

package/dist/toolbar/ToolbarToggleItem.vue.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A single pressable option within a `SkdxToolbarToggleGroup`: renders
+ * `<button type="button">` marked `data-skdx-toolbar-item` (joining the
+ * toolbar's roving-tabindex group) with `aria-pressed`/`data-state`.
+ */
+type __VLS_Props = {
+    /** Unique identifier tracked in the group's pressed value(s). */
+    value: string;
+    /** Excludes this item from press toggling and roving-tabindex focus. */
+    disabled?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/toolbar/ToolbarToggleItem.vue.js

@@ -0,0 +1 @@
+import e from"./ToolbarToggleItem.vue_vue_type_script_setup_true_lang.js";var t=e;export{t as default};

package/dist/toolbar/ToolbarToggleItem.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const s=require("./context.cjs");let e=require("vue");var p=["aria-pressed","data-skdx-toolbar-item","data-state","data-disabled","disabled","tabindex"],v=(0,e.defineComponent)({__name:"ToolbarToggleItem",props:{value:{},disabled:{type:Boolean,default:!1}},setup(r){const a=r,t=(0,e.inject)(s.TOOLBAR_TOGGLE_GROUP_CONTEXT);if(!t)throw new Error("<SkdxToolbarToggleItem> must be used inside <SkdxToolbarToggleGroup>.");const o=s.useToolbarItem(),l=(0,e.computed)(()=>t.value.value.includes(a.value)),d=(0,e.computed)(()=>t.disabled.value||a.disabled||!1);function n(){d.value||(l.value?t.type==="multiple"&&t.onItemDeactivate(a.value):t.onItemActivate(a.value))}return(i,u)=>((0,e.openBlock)(),(0,e.createElementBlock)("button",{class:"skdx-toolbar__toggle-item","data-part":"toggle-item",type:"button","aria-pressed":l.value,"data-skdx-toolbar-item":(0,e.unref)(o).id,"data-state":l.value?"on":"off","data-disabled":d.value?"":void 0,disabled:d.value,tabindex:(0,e.unref)(o).tabIndex.value,onFocus:u[0]||(u[0]=(...b)=>(0,e.unref)(o).handleFocus&&(0,e.unref)(o).handleFocus(...b)),onClick:n},[(0,e.renderSlot)(i.$slots,"default")],40,p))}});exports.default=v;

package/dist/toolbar/ToolbarToggleItem.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{TOOLBAR_TOGGLE_GROUP_CONTEXT as e,useToolbarItem as a}from"./context.js";import{computed as t,createElementBlock as o,defineComponent as l,inject as d,openBlock as s,renderSlot as u,unref as n}from"vue";var i=["aria-pressed","data-skdx-toolbar-item","data-state","data-disabled","disabled","tabindex"],r=/* @__PURE__ */l({__name:"ToolbarToggleItem",props:{value:{},disabled:{type:Boolean,default:!1}},setup(l){const r=l,b=d(e);if(!b)throw new Error("<SkdxToolbarToggleItem> must be used inside <SkdxToolbarToggleGroup>.");const m=a(),v=t(()=>b.value.value.includes(r.value)),c=t(()=>b.disabled.value||r.disabled||!1);function p(){c.value||(v.value?"multiple"===b.type&&b.onItemDeactivate(r.value):b.onItemActivate(r.value))}return(e,a)=>(s(),o("button",{class:"skdx-toolbar__toggle-item","data-part":"toggle-item",type:"button","aria-pressed":v.value,"data-skdx-toolbar-item":n(m).id,"data-state":v.value?"on":"off","data-disabled":c.value?"":void 0,disabled:c.value,tabindex:n(m).tabIndex.value,onFocus:a[0]||(a[0]=(...e)=>n(m).handleFocus&&n(m).handleFocus(...e)),onClick:p},[u(e.$slots,"default")],40,i))}});export{r as default};

package/dist/toolbar/context.cjs

@@ -0,0 +1 @@
+const T=require("../utils/id.cjs");let o=require("vue");var r=Symbol("skdx-toolbar-context"),n=Symbol("skdx-toolbar-toggle-group-context");function u(){const e=(0,o.inject)(r);if(!e)throw new Error("A toolbar item must be used inside <SkdxToolbar>.");const t=T.nextId("toolbar-item");return{id:t,tabIndex:(0,o.computed)(()=>e.currentTabStopId.value===t?0:-1),handleFocus:()=>e.setCurrentTabStopId(t)}}exports.TOOLBAR_CONTEXT=r;exports.TOOLBAR_TOGGLE_GROUP_CONTEXT=n;exports.useToolbarItem=u;

package/dist/toolbar/context.d.cts

@@ -0,0 +1,25 @@
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+/** @internal Injection key a Toolbar provides so its items can join one roving-tabindex group. */
+export interface ToolbarContext {
+    orientation: 'horizontal' | 'vertical';
+    currentTabStopId: Readonly<Ref<string | null>>;
+    setCurrentTabStopId: (id: string) => void;
+}
+/** @internal Injection key a Toolbar provides so its items share orientation and the current roving tab stop. */
+export declare const TOOLBAR_CONTEXT: InjectionKey<ToolbarContext>;
+/** @internal Injection key a ToolbarToggleGroup provides so its ToolbarToggleItems can read/drive pressed state. */
+export interface ToolbarToggleGroupContext {
+    type: 'single' | 'multiple';
+    value: ComputedRef<string[]>;
+    disabled: ComputedRef<boolean>;
+    onItemActivate: (value: string) => void;
+    onItemDeactivate: (value: string) => void;
+}
+/** @internal Injection key a ToolbarToggleGroup provides so its ToolbarToggleItems share pressed state. */
+export declare const TOOLBAR_TOGGLE_GROUP_CONTEXT: InjectionKey<ToolbarToggleGroupContext>;
+/** @internal Generates a unique id for a toolbar item, and joins the toolbar's roving-tabindex group. */
+export declare function useToolbarItem(): {
+    id: string;
+    tabIndex: ComputedRef<0 | -1>;
+    handleFocus: () => void;
+};

package/dist/toolbar/context.d.ts

@@ -0,0 +1,25 @@
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+/** @internal Injection key a Toolbar provides so its items can join one roving-tabindex group. */
+export interface ToolbarContext {
+    orientation: 'horizontal' | 'vertical';
+    currentTabStopId: Readonly<Ref<string | null>>;
+    setCurrentTabStopId: (id: string) => void;
+}
+/** @internal Injection key a Toolbar provides so its items share orientation and the current roving tab stop. */
+export declare const TOOLBAR_CONTEXT: InjectionKey<ToolbarContext>;
+/** @internal Injection key a ToolbarToggleGroup provides so its ToolbarToggleItems can read/drive pressed state. */
+export interface ToolbarToggleGroupContext {
+    type: 'single' | 'multiple';
+    value: ComputedRef<string[]>;
+    disabled: ComputedRef<boolean>;
+    onItemActivate: (value: string) => void;
+    onItemDeactivate: (value: string) => void;
+}
+/** @internal Injection key a ToolbarToggleGroup provides so its ToolbarToggleItems share pressed state. */
+export declare const TOOLBAR_TOGGLE_GROUP_CONTEXT: InjectionKey<ToolbarToggleGroupContext>;
+/** @internal Generates a unique id for a toolbar item, and joins the toolbar's roving-tabindex group. */
+export declare function useToolbarItem(): {
+    id: string;
+    tabIndex: ComputedRef<0 | -1>;
+    handleFocus: () => void;
+};

package/dist/toolbar/context.js

@@ -0,0 +1 @@
+import{nextId as o}from"../utils/id.js";import{computed as t,inject as e}from"vue";var r=/* @__PURE__ */Symbol("skdx-toolbar-context"),a=/* @__PURE__ */Symbol("skdx-toolbar-toggle-group-context");function s(){const a=e(r);if(!a)throw new Error("A toolbar item must be used inside <SkdxToolbar>.");const s=o("toolbar-item");return{id:s,tabIndex:t(()=>a.currentTabStopId.value===s?0:-1),handleFocus:()=>a.setCurrentTabStopId(s)}}export{r as TOOLBAR_CONTEXT,a as TOOLBAR_TOGGLE_GROUP_CONTEXT,s as useToolbarItem};

package/dist/toolbar/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./Toolbar.vue.cjs"),e=require("./ToolbarButton.vue.cjs"),o=require("./ToolbarLink.vue.cjs"),l=require("./ToolbarSeparator.vue.cjs"),a=require("./ToolbarToggleGroup.vue.cjs"),t=require("./ToolbarToggleItem.vue.cjs");exports.SkdxToolbar=r.default;exports.SkdxToolbarButton=e.default;exports.SkdxToolbarLink=o.default;exports.SkdxToolbarSeparator=l.default;exports.SkdxToolbarToggleGroup=a.default;exports.SkdxToolbarToggleItem=t.default;

package/dist/toolbar/index.d.cts

@@ -0,0 +1,6 @@
+export { default as SkdxToolbar } from './Toolbar.vue.cjs';
+export { default as SkdxToolbarButton } from './ToolbarButton.vue.cjs';
+export { default as SkdxToolbarLink } from './ToolbarLink.vue.cjs';
+export { default as SkdxToolbarSeparator } from './ToolbarSeparator.vue.cjs';
+export { default as SkdxToolbarToggleGroup } from './ToolbarToggleGroup.vue.cjs';
+export { default as SkdxToolbarToggleItem } from './ToolbarToggleItem.vue.cjs';

package/dist/toolbar/index.d.ts

@@ -0,0 +1,6 @@
+export { default as SkdxToolbar } from './Toolbar.vue.js';
+export { default as SkdxToolbarButton } from './ToolbarButton.vue.js';
+export { default as SkdxToolbarLink } from './ToolbarLink.vue.js';
+export { default as SkdxToolbarSeparator } from './ToolbarSeparator.vue.js';
+export { default as SkdxToolbarToggleGroup } from './ToolbarToggleGroup.vue.js';
+export { default as SkdxToolbarToggleItem } from './ToolbarToggleItem.vue.js';

package/dist/toolbar/index.js

@@ -0,0 +1 @@
+import o from"./Toolbar.vue.js";import r from"./ToolbarButton.vue.js";import a from"./ToolbarLink.vue.js";import l from"./ToolbarSeparator.vue.js";import T from"./ToolbarToggleGroup.vue.js";import e from"./ToolbarToggleItem.vue.js";export{o as SkdxToolbar,r as SkdxToolbarButton,a as SkdxToolbarLink,l as SkdxToolbarSeparator,T as SkdxToolbarToggleGroup,e as SkdxToolbarToggleItem};

package/dist/tooltip/Tooltip.vue.cjs

@@ -0,0 +1 @@
+const e=require("./Tooltip.vue_vue_type_script_setup_true_lang.cjs");var t=e.default;exports.default=t;

package/dist/tooltip/Tooltip.vue.d.cts

@@ -0,0 +1,65 @@
+/**
+ * The Vue implementation of the shared Tooltip contract (see
+ * `@skdx/shared`'s `tooltipContract`). Root of a single hover/focus
+ * tooltip: owns open state (with hover-in delay and instant-close) and
+ * hands it down to `SkdxTooltipTrigger` / `SkdxTooltipPortal` /
+ * `SkdxTooltipContent` / `SkdxTooltipArrow` via context. Wraps children in
+ * the shared popper positioning root. Renders no DOM element itself.
+ *
+ * Opens on pointer-enter (after `delayDuration`) or focus, closes on
+ * pointer-leave, blur, click, or Escape. Escape is listened for on the
+ * document while open, so a tooltip opened by hover is dismissable even when
+ * keyboard focus is elsewhere (WCAG 2.2 SC 1.4.13). With
+ * `:disable-hoverable-content="false"` the pointer may instead travel from the
+ * trigger into the bubble and keep it open. Nest under a single
+ * `SkdxTooltipProvider` to share hover-delay timing across multiple
+ * tooltips.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after `SkdxTooltipContent`'s enter
+ * or exit animation ends, or in the same task when it declares none.
+ *
+ * Works controlled (`v-model:open`) or uncontrolled (`default-open`).
+ */
+type __VLS_Props = {
+    /** Whether the tooltip is open, for controlled usage. Pair with `v-model:open`. */
+    open?: boolean;
+    /** Whether the tooltip is initially open, for uncontrolled usage. */
+    defaultOpen?: boolean;
+    /** Delay before this tooltip opens on hover (ms). Overrides the ancestor `SkdxTooltipProvider`'s delay when set. */
+    delayDuration?: number;
+    /**
+     * Whether `SkdxTooltipContent` ignores the pointer, so moving off the
+     * trigger closes this tooltip even if the pointer lands on the bubble.
+     * Overrides the ancestor `SkdxTooltipProvider`'s setting, which itself
+     * defaults to `true` — unlike Radix, because tooltips here are
+     * pointer-transparent today and flipping that silently would be a
+     * breaking change.
+     */
+    disableHoverableContent?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    "open-change": (open: boolean) => any;
+    "open-change-complete": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+    "onOpen-change-complete"?: ((open: boolean) => any) | undefined;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+    delayDuration: number;
+    disableHoverableContent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The Vue implementation of the shared Tooltip contract (see
+ * `@skdx/shared`'s `tooltipContract`). Root of a single hover/focus
+ * tooltip: owns open state (with hover-in delay and instant-close) and
+ * hands it down to `SkdxTooltipTrigger` / `SkdxTooltipPortal` /
+ * `SkdxTooltipContent` / `SkdxTooltipArrow` via context. Wraps children in
+ * the shared popper positioning root. Renders no DOM element itself.
+ *
+ * Opens on pointer-enter (after `delayDuration`) or focus, closes on
+ * pointer-leave, blur, click, or Escape. Escape is listened for on the
+ * document while open, so a tooltip opened by hover is dismissable even when
+ * keyboard focus is elsewhere (WCAG 2.2 SC 1.4.13). With
+ * `:disable-hoverable-content="false"` the pointer may instead travel from the
+ * trigger into the bubble and keep it open. Nest under a single
+ * `SkdxTooltipProvider` to share hover-delay timing across multiple
+ * tooltips.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after `SkdxTooltipContent`'s enter
+ * or exit animation ends, or in the same task when it declares none.
+ *
+ * Works controlled (`v-model:open`) or uncontrolled (`default-open`).
+ */
+type __VLS_Props = {
+    /** Whether the tooltip is open, for controlled usage. Pair with `v-model:open`. */
+    open?: boolean;
+    /** Whether the tooltip is initially open, for uncontrolled usage. */
+    defaultOpen?: boolean;
+    /** Delay before this tooltip opens on hover (ms). Overrides the ancestor `SkdxTooltipProvider`'s delay when set. */
+    delayDuration?: number;
+    /**
+     * Whether `SkdxTooltipContent` ignores the pointer, so moving off the
+     * trigger closes this tooltip even if the pointer lands on the bubble.
+     * Overrides the ancestor `SkdxTooltipProvider`'s setting, which itself
+     * defaults to `true` — unlike Radix, because tooltips here are
+     * pointer-transparent today and flipping that silently would be a
+     * breaking change.
+     */
+    disableHoverableContent?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    "open-change": (open: boolean) => any;
+    "open-change-complete": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+    "onOpen-change-complete"?: ((open: boolean) => any) | undefined;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+    delayDuration: number;
+    disableHoverableContent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/Tooltip.vue.js

@@ -0,0 +1 @@
+import t from"./Tooltip.vue_vue_type_script_setup_true_lang.js";var e=t;export{e as default};

package/dist/tooltip/Tooltip.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const D=require("../utils/useOpenChangeComplete.cjs"),b=require("../utils/useDismiss.cjs"),q=require("../utils/PopperRoot.vue.cjs"),a=require("./context.cjs");let e=require("vue");var h=150,g=(0,e.defineComponent)({__name:"Tooltip",props:{open:{type:Boolean,default:void 0},defaultOpen:{type:Boolean,default:!1},delayDuration:{default:void 0},disableHoverableContent:{type:Boolean,default:void 0}},emits:["update:open","open-change","open-change-complete"],setup(m,{emit:T}){const t=m,r=T,n=(0,e.inject)(a.TOOLTIP_PROVIDER_CONTEXT,a.defaultTooltipProviderContext,!0),_=(0,e.computed)(()=>t.delayDuration??n.delayDuration),v=(0,e.computed)(()=>t.disableHoverableContent??n.disableHoverableContent),s=(0,e.ref)(null),c=(0,e.ref)(t.defaultOpen),i=(0,e.computed)(()=>t.open??c.value);let p,d;function u(){clearTimeout(p),clearTimeout(d)}(0,e.onBeforeUnmount)(u),D.useOpenChangeComplete(i,s,o=>r("open-change-complete",o));function l(o){t.open===void 0&&(c.value=o),o?n.onOpen():n.onClose(),r("update:open",o),r("open-change",o)}function C(){u(),l(!0)}function O(){clearTimeout(p),n.isOpenDelayed.value?p=setTimeout(()=>l(!0),_.value):l(!0)}function f(){u(),l(!1)}function y(){u(),d=setTimeout(()=>l(!1),h)}return b.useDismiss({enabled:i,onEscapeKeyDown:f},[]),(0,e.provide)(a.TOOLTIP_CONTEXT,{contentId:a.nextTooltipContentId(),contentRef:s,open:i,disableHoverableContent:v,onOpen:C,onDelayedOpen:O,onClose:f,onDelayedClose:y}),(o,B)=>((0,e.openBlock)(),(0,e.createBlock)(q.default,null,{default:(0,e.withCtx)(()=>[(0,e.renderSlot)(o.$slots,"default")]),_:3}))}});exports.default=g;

package/dist/tooltip/Tooltip.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{useOpenChangeComplete as e}from"../utils/useOpenChangeComplete.js";import{useDismiss as o}from"../utils/useDismiss.js";import n from"../utils/PopperRoot.vue.js";import{TOOLTIP_CONTEXT as t,TOOLTIP_PROVIDER_CONTEXT as a,defaultTooltipProviderContext as l,nextTooltipContentId as s}from"./context.js";import{computed as p,createBlock as i,defineComponent as u,inject as d,onBeforeUnmount as r,openBlock as m,provide as c,ref as f,renderSlot as v,withCtx as C}from"vue";var T=/* @__PURE__ */u({__name:"Tooltip",props:{open:{type:Boolean,default:void 0},defaultOpen:{type:Boolean,default:!1},delayDuration:{default:void 0},disableHoverableContent:{type:Boolean,default:void 0}},emits:["update:open","open-change","open-change-complete"],setup(u,{emit:T}){const O=u,y=T,D=d(a,l,!0),b=p(()=>O.delayDuration??D.delayDuration),h=p(()=>O.disableHoverableContent??D.disableHoverableContent),g=f(null),B=f(O.defaultOpen),_=p(()=>O.open??B.value);let j,x;function I(){clearTimeout(j),clearTimeout(x)}function P(e){void 0===O.open&&(B.value=e),e?D.onOpen():D.onClose(),y("update:open",e),y("open-change",e)}function E(){I(),P(!1)}return r(I),e(_,g,e=>y("open-change-complete",e)),o({enabled:_,onEscapeKeyDown:E},[]),c(t,{contentId:s(),contentRef:g,open:_,disableHoverableContent:h,onOpen:function(){I(),P(!0)},onDelayedOpen:function(){clearTimeout(j),D.isOpenDelayed.value?j=setTimeout(()=>P(!0),b.value):P(!0)},onClose:E,onDelayedClose:function(){I(),x=setTimeout(()=>P(!1),150)}}),(e,o)=>(m(),i(n,null,{default:C(()=>[v(e.$slots,"default")]),_:3}))}});export{T as default};

package/dist/tooltip/TooltipArrow.vue.cjs

@@ -0,0 +1 @@
+const e=require("./TooltipArrow.vue_vue_type_script_setup_true_lang.cjs");var r=e.default;exports.default=r;

package/dist/tooltip/TooltipArrow.vue.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Optional visual arrow pointing from `SkdxTooltipContent` back at the
+ * trigger. Must be rendered inside `SkdxTooltipContent`; self-positions
+ * based on the resolved `side`.
+ */
+type __VLS_Props = {};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/TooltipArrow.vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Optional visual arrow pointing from `SkdxTooltipContent` back at the
+ * trigger. Must be rendered inside `SkdxTooltipContent`; self-positions
+ * based on the resolved `side`.
+ */
+type __VLS_Props = {};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/TooltipArrow.vue.js

@@ -0,0 +1 @@
+import r from"./TooltipArrow.vue_vue_type_script_setup_true_lang.js";var t=r;export{t as default};

package/dist/tooltip/TooltipArrow.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const l=require("../utils/popper.cjs");let e=require("vue");var n=(0,e.defineComponent)({__name:"TooltipArrow",setup(u){const r=(0,e.inject)(l.ARROW_CONTEXT);if(!r)throw new Error("SkdxTooltipArrow must be used within SkdxTooltipContent.");const t=(0,e.ref)(null);return(0,e.onMounted)(()=>r.setArrowEl(t.value)),(0,e.onBeforeUnmount)(()=>r.setArrowEl(null)),(o,s)=>((0,e.openBlock)(),(0,e.createElementBlock)("span",{class:"skdx-tooltip__arrow","data-part":"arrow",ref_key:"elRef",ref:t,style:(0,e.normalizeStyle)((0,e.unref)(r).style.value)},[(0,e.renderSlot)(o.$slots,"default")],4))}});exports.default=n;

package/dist/tooltip/TooltipArrow.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{ARROW_CONTEXT as e}from"../utils/popper.js";import{createElementBlock as o,defineComponent as r,inject as t,normalizeStyle as s,onBeforeUnmount as a,onMounted as l,openBlock as n,ref as p,renderSlot as u,unref as i}from"vue";var f=/* @__PURE__ */r({__name:"TooltipArrow",setup(r){const f=t(e);if(!f)throw new Error("SkdxTooltipArrow must be used within SkdxTooltipContent.");const d=p(null);return l(()=>f.setArrowEl(d.value)),a(()=>f.setArrowEl(null)),(e,r)=>(n(),o("span",{class:"skdx-tooltip__arrow","data-part":"arrow",ref_key:"elRef",ref:d,style:s(i(f).style.value)},[u(e.$slots,"default")],4))}});export{f as default};

package/dist/tooltip/TooltipContent.vue.cjs

@@ -0,0 +1 @@
+const e=require("./TooltipContent.vue_vue_type_script_setup_true_lang.cjs");var t=e.default;exports.default=t;

package/dist/tooltip/TooltipContent.vue.d.cts

@@ -0,0 +1,61 @@
+import { type Align, type PhysicalSide, type Side } from '../utils/popper.cjs';
+/**
+ * The tooltip's floating bubble: `role="tooltip"` with `data-state`
+ * (`open`/`closed`), positioned via the shared popper layer against the
+ * trigger using `side` (defaults to `'top'`) / `align` / `sideOffset`
+ * (defaults to `4`) / `alignOffset`, flipping/shifting to avoid viewport
+ * collisions unless `avoidCollisions` is `false` — against
+ * `collisionBoundary` when one is given, otherwise the bubble's clipping
+ * ancestors. Also exposes `data-side`/`data-align` reflecting the resolved
+ * placement, and the measurement custom properties
+ * `--skdx-tooltip-available-width` / `-available-height` / `-trigger-width` /
+ * `-transform-origin`, so the bubble can be sized and animated from CSS
+ * without measuring anything by hand. Ignores pointer events so it never
+ * steals hover from the page, unless the tooltip was given
+ * `disable-hoverable-content="false"` — then it accepts the pointer and stays
+ * open while hovered. Mounts only while open unless `forceMount` is set. Must
+ * be used inside `SkdxTooltip`.
+ */
+type __VLS_Props = {
+    /** Preferred side of the trigger to render the tooltip on. */
+    side?: Side;
+    /** Alignment of the tooltip relative to the trigger along the chosen side. */
+    align?: Align;
+    /** Distance (px) between the tooltip and the trigger. */
+    sideOffset?: number;
+    /** Offset (px) along the alignment axis. */
+    alignOffset?: number;
+    /** Whether to flip/shift the tooltip to stay within the viewport. */
+    avoidCollisions?: boolean;
+    /** Minimum distance (px) kept from the collision boundary. A number applies to every side; an object sets only the sides it names. */
+    collisionPadding?: number | Partial<Record<PhysicalSide, number>>;
+    /**
+     * Element (or elements) collisions are measured against, instead of the
+     * bubble's clipping ancestors. Use it to keep the bubble inside a scroll
+     * container or one pane of a split layout rather than the whole viewport.
+     * @default undefined — the bubble's clipping ancestors.
+     */
+    collisionBoundary?: Element | Element[] | null;
+    /** Keep this bubble mounted even while the tooltip is closed, instead of unmounting it. */
+    forceMount?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+    side: Side;
+    align: Align;
+    sideOffset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionPadding: number | Partial<Record<PhysicalSide, number>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/TooltipContent.vue.d.ts

@@ -0,0 +1,61 @@
+import { type Align, type PhysicalSide, type Side } from '../utils/popper.js';
+/**
+ * The tooltip's floating bubble: `role="tooltip"` with `data-state`
+ * (`open`/`closed`), positioned via the shared popper layer against the
+ * trigger using `side` (defaults to `'top'`) / `align` / `sideOffset`
+ * (defaults to `4`) / `alignOffset`, flipping/shifting to avoid viewport
+ * collisions unless `avoidCollisions` is `false` — against
+ * `collisionBoundary` when one is given, otherwise the bubble's clipping
+ * ancestors. Also exposes `data-side`/`data-align` reflecting the resolved
+ * placement, and the measurement custom properties
+ * `--skdx-tooltip-available-width` / `-available-height` / `-trigger-width` /
+ * `-transform-origin`, so the bubble can be sized and animated from CSS
+ * without measuring anything by hand. Ignores pointer events so it never
+ * steals hover from the page, unless the tooltip was given
+ * `disable-hoverable-content="false"` — then it accepts the pointer and stays
+ * open while hovered. Mounts only while open unless `forceMount` is set. Must
+ * be used inside `SkdxTooltip`.
+ */
+type __VLS_Props = {
+    /** Preferred side of the trigger to render the tooltip on. */
+    side?: Side;
+    /** Alignment of the tooltip relative to the trigger along the chosen side. */
+    align?: Align;
+    /** Distance (px) between the tooltip and the trigger. */
+    sideOffset?: number;
+    /** Offset (px) along the alignment axis. */
+    alignOffset?: number;
+    /** Whether to flip/shift the tooltip to stay within the viewport. */
+    avoidCollisions?: boolean;
+    /** Minimum distance (px) kept from the collision boundary. A number applies to every side; an object sets only the sides it names. */
+    collisionPadding?: number | Partial<Record<PhysicalSide, number>>;
+    /**
+     * Element (or elements) collisions are measured against, instead of the
+     * bubble's clipping ancestors. Use it to keep the bubble inside a scroll
+     * container or one pane of a split layout rather than the whole viewport.
+     * @default undefined — the bubble's clipping ancestors.
+     */
+    collisionBoundary?: Element | Element[] | null;
+    /** Keep this bubble mounted even while the tooltip is closed, instead of unmounting it. */
+    forceMount?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+    side: Side;
+    align: Align;
+    sideOffset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionPadding: number | Partial<Record<PhysicalSide, number>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/TooltipContent.vue.js

@@ -0,0 +1 @@
+import t from"./TooltipContent.vue_vue_type_script_setup_true_lang.js";var e=t;export{e as default};

package/dist/tooltip/TooltipContent.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const C=require("../utils/composeRefs.cjs"),r=require("../utils/popper.cjs"),y=require("./context.cjs");let e=require("vue");var P=["id","data-state","data-side","data-align"],E=(0,e.defineComponent)({__name:"TooltipContent",props:{side:{default:"top"},align:{default:"center"},sideOffset:{default:4},alignOffset:{default:0},avoidCollisions:{type:Boolean,default:!0},collisionPadding:{default:8},collisionBoundary:{},forceMount:{type:Boolean,default:!1}},setup(l){const s=l,t=(0,e.inject)(y.TOOLTIP_CONTEXT);if(!t)throw new Error("SkdxTooltipContent must be used within SkdxTooltip.");const a=(0,e.inject)(r.POPPER_CONTEXT);if(!a)throw new Error("SkdxTooltipContent must be used within SkdxTooltip.");const i=(0,e.ref)(null),u=(0,e.ref)(null),d=C.composeRefs(i,t.contentRef),{style:c,arrowStyle:p,placedSide:f,placedAlign:v}=r.usePopperPosition(a.anchor,i,t.open,()=>({...s,component:"tooltip"}),u),o=(0,e.computed)(()=>!t.disableHoverableContent.value),_=(0,e.computed)(()=>({...c.value,pointerEvents:o.value?"auto":"none"}));function T(){o.value&&t.onOpen()}function m(){o.value&&t.onClose()}return(0,e.provide)(r.ARROW_CONTEXT,{style:p,setArrowEl:n=>{u.value=n}}),(n,O)=>l.forceMount||(0,e.unref)(t).open.value?((0,e.openBlock)(),(0,e.createElementBlock)("div",{key:0,class:"skdx-tooltip__content","data-part":"content",id:(0,e.unref)(t).contentId,ref:(0,e.unref)(d),role:"tooltip","data-state":(0,e.unref)(t).open.value?"open":"closed","data-side":(0,e.unref)(f),"data-align":(0,e.unref)(v),style:(0,e.normalizeStyle)(_.value),onPointerenter:T,onPointerleave:m},[(0,e.renderSlot)(n.$slots,"default")],44,P)):(0,e.createCommentVNode)("",!0)}});exports.default=E;

package/dist/tooltip/TooltipContent.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{composeRefs as e}from"../utils/composeRefs.js";import{ARROW_CONTEXT as o,POPPER_CONTEXT as t,usePopperPosition as n}from"../utils/popper.js";import{TOOLTIP_CONTEXT as a}from"./context.js";import{computed as l,createCommentVNode as s,createElementBlock as i,defineComponent as r,inject as d,normalizeStyle as p,openBlock as u,provide as f,ref as c,renderSlot as m,unref as v}from"vue";var T=["id","data-state","data-side","data-align"],C=/* @__PURE__ */r({__name:"TooltipContent",props:{side:{default:"top"},align:{default:"center"},sideOffset:{default:4},alignOffset:{default:0},avoidCollisions:{type:Boolean,default:!0},collisionPadding:{default:8},collisionBoundary:{},forceMount:{type:Boolean,default:!1}},setup(r){const C=r,O=d(a);if(!O)throw new Error("SkdxTooltipContent must be used within SkdxTooltip.");const y=d(t);if(!y)throw new Error("SkdxTooltipContent must be used within SkdxTooltip.");const E=c(null),P=c(null),k=e(E,O.contentRef),{style:w,arrowStyle:S,placedSide:x,placedAlign:_}=n(y.anchor,E,O.open,()=>({...C,component:"tooltip"}),P),g=l(()=>!O.disableHoverableContent.value),R=l(()=>({...w.value,pointerEvents:g.value?"auto":"none"}));function h(){g.value&&O.onOpen()}function B(){g.value&&O.onClose()}return f(o,{style:S,setArrowEl:e=>{P.value=e}}),(e,o)=>r.forceMount||v(O).open.value?(u(),i("div",{key:0,class:"skdx-tooltip__content","data-part":"content",id:v(O).contentId,ref:v(k),role:"tooltip","data-state":v(O).open.value?"open":"closed","data-side":v(x),"data-align":v(_),style:p(R.value),onPointerenter:h,onPointerleave:B},[m(e.$slots,"default")],44,T)):s("",!0)}});export{C as default};

package/dist/tooltip/TooltipPortal.vue.cjs

@@ -0,0 +1 @@
+const e=require("./TooltipPortal.vue_vue_type_script_setup_true_lang.cjs");var t=e.default;exports.default=t;

package/dist/tooltip/TooltipPortal.vue.d.cts

@@ -0,0 +1,30 @@
+import type { PortalContainer } from '../utils/portal.cjs';
+/**
+ * Teleports `SkdxTooltipContent` to `document.body` (or a custom `container`), so the tooltip escapes
+ * any clipping/`overflow` ancestors. Mounts only while open unless
+ * `forceMount` is set. Must be used inside `SkdxTooltip`.
+ */
+type __VLS_Props = {
+    /**
+     * DOM node (or CSS selector) the children are rendered into.
+     * @default document.body
+     */
+    container?: PortalContainer;
+    /** Keep this portal mounted even while the tooltip is closed, instead of unmounting it. */
+    forceMount?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+    container: PortalContainer;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/TooltipPortal.vue.d.ts

@@ -0,0 +1,30 @@
+import type { PortalContainer } from '../utils/portal.js';
+/**
+ * Teleports `SkdxTooltipContent` to `document.body` (or a custom `container`), so the tooltip escapes
+ * any clipping/`overflow` ancestors. Mounts only while open unless
+ * `forceMount` is set. Must be used inside `SkdxTooltip`.
+ */
+type __VLS_Props = {
+    /**
+     * DOM node (or CSS selector) the children are rendered into.
+     * @default document.body
+     */
+    container?: PortalContainer;
+    /** Keep this portal mounted even while the tooltip is closed, instead of unmounting it. */
+    forceMount?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+    container: PortalContainer;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/TooltipPortal.vue.js

@@ -0,0 +1 @@
+import t from"./TooltipPortal.vue_vue_type_script_setup_true_lang.js";var e=t;export{e as default};

package/dist/tooltip/TooltipPortal.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const n=require("../utils/Portal.vue.cjs"),u=require("./context.cjs");let e=require("vue");var l=(0,e.defineComponent)({__name:"TooltipPortal",props:{container:{default:null},forceMount:{type:Boolean,default:!1}},setup(t){const o=(0,e.inject)(u.TOOLTIP_CONTEXT);if(!o)throw new Error("SkdxTooltipPortal must be used within SkdxTooltip.");return(r,a)=>t.forceMount||(0,e.unref)(o).open.value?((0,e.openBlock)(),(0,e.createBlock)(n.default,{key:0,container:t.container},{default:(0,e.withCtx)(()=>[(0,e.renderSlot)(r.$slots,"default")]),_:3},8,["container"])):(0,e.createCommentVNode)("",!0)}});exports.default=l;

package/dist/tooltip/TooltipPortal.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import o from"../utils/Portal.vue.js";import{TOOLTIP_CONTEXT as e}from"./context.js";import{createBlock as t,createCommentVNode as r,defineComponent as a,inject as n,openBlock as l,renderSlot as s,unref as i,withCtx as u}from"vue";var p=/* @__PURE__ */a({__name:"TooltipPortal",props:{container:{default:null},forceMount:{type:Boolean,default:!1}},setup(a){const p=n(e);if(!p)throw new Error("SkdxTooltipPortal must be used within SkdxTooltip.");return(e,n)=>a.forceMount||i(p).open.value?(l(),t(o,{key:0,container:a.container},{default:u(()=>[s(e.$slots,"default")]),_:3},8,["container"])):r("",!0)}});export{p as default};

package/dist/tooltip/TooltipProvider.vue.cjs

@@ -0,0 +1 @@
+const e=require("./TooltipProvider.vue_vue_type_script_setup_true_lang.cjs");var r=e.default;exports.default=r;

package/dist/tooltip/TooltipProvider.vue.d.cts

@@ -0,0 +1,42 @@
+/**
+ * Optional ancestor that coordinates hover-delay timing across multiple
+ * `SkdxTooltip`s: after any tooltip closes, sibling tooltips open instantly
+ * (skipping `delayDuration`) for `skipDelayDuration` ms, matching how OS
+ * tooltips behave when the pointer sweeps between adjacent triggers. Also
+ * supplies the default `disableHoverableContent` its descendant tooltips use.
+ * Renders no DOM element itself; wrap it once near the root of your app or
+ * a toolbar.
+ */
+type __VLS_Props = {
+    /** Delay before a tooltip opens on hover (ms). Individual `SkdxTooltip`s can override this. */
+    delayDuration?: number;
+    /** Window after closing during which sibling tooltips open instantly (ms), skipping their open delay. */
+    skipDelayDuration?: number;
+    /**
+     * Whether `SkdxTooltipContent` ignores the pointer entirely, so moving off
+     * the trigger closes the tooltip even if the pointer lands on the bubble.
+     *
+     * Set it `false` to let the pointer travel into the content and keep the
+     * tooltip open — a short grace period covers the gap between the two. The
+     * default differs from Radix's `false`: tooltips here are pointer-
+     * transparent today, and flipping that silently would be a breaking
+     * change. Individual `SkdxTooltip`s can override it.
+     */
+    disableHoverableContent?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    delayDuration: number;
+    skipDelayDuration: number;
+    disableHoverableContent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};