@skdx/vue 0.26.0

package/dist/listbox/index.d.ts

@@ -0,0 +1,5 @@
+export { default as SkdxListbox } from './Listbox.vue.js';
+export { default as SkdxListboxItem } from './ListboxItem.vue.js';
+export { default as SkdxListboxItemIndicator } from './ListboxItemIndicator.vue.js';
+export { default as SkdxListboxGroup } from './ListboxGroup.vue.js';
+export { default as SkdxListboxLabel } from './ListboxLabel.vue.js';

package/dist/listbox/index.js

@@ -0,0 +1 @@
+import o from"./Listbox.vue.js";import t from"./ListboxItem.vue.js";import s from"./ListboxItemIndicator.vue.js";import i from"./ListboxGroup.vue.js";import x from"./ListboxLabel.vue.js";export{o as SkdxListbox,i as SkdxListboxGroup,t as SkdxListboxItem,s as SkdxListboxItemIndicator,x as SkdxListboxLabel};

package/dist/loading-overlay/LoadingOverlay.vue.cjs

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

package/dist/loading-overlay/LoadingOverlay.vue.d.cts

@@ -0,0 +1,96 @@
+/**
+ * The Vue implementation of the shared LoadingOverlay contract (see
+ * `@skdx/shared`'s `loadingOverlayContract`). Wraps the content being
+ * covered, owns the visibility (`visible`/`defaultVisible`/`visible-change`)
+ * and hands it to `<SkdxLoadingOverlayBackdrop>` and
+ * `<SkdxLoadingOverlayContent>` through `provide`. Renders a plain `<div>` —
+ * give it `position: relative` and the backdrop covers exactly this box; set
+ * `fullScreen` and it covers the viewport instead.
+ *
+ * While visible the root is `aria-busy="true"` and carries the `inert`
+ * attribute, so the pointer and the tab sequence both stop at the overlay
+ * rather than walking into the controls it is hiding. Deliberately **not** a
+ * focus trap: this is not a dialog, there is nothing inside to focus and
+ * nothing to dismiss, so trapping would strand the keyboard on a spinner.
+ * Because `inert` also takes the subtree out of the accessibility tree, the
+ * announcement is made through the process-wide live region (see
+ * `utils/liveAnnouncer`) rather than from the `<SkdxSpinner>` inside — a
+ * `role="status"` in an inert subtree announces nothing.
+ *
+ * `delay` exists for the same reason `SkdxTooltip` has one: a request that
+ * resolves in 80ms should never paint a spinner. The timer is cancelled when
+ * `visible` flips back to false before it fires, and on unmount.
+ *
+ * `data-state` is `"visible"`/`"hidden"` and reflects the *effective*
+ * visibility, i.e. after `delay`.
+ *
+ * @example
+ * ```vue
+ * <SkdxLoadingOverlay :visible="isFetching" :delay="150" loading-label="Loading invoices">
+ *   <InvoiceTable />
+ *   <SkdxLoadingOverlayBackdrop />
+ *   <SkdxLoadingOverlayContent />
+ * </SkdxLoadingOverlay>
+ * ```
+ */
+type __VLS_Props = {
+    /**
+     * Whether work is in flight, for controlled usage. Pair with
+     * `v-model:visible` or `@visible-change`.
+     * @default undefined — uncontrolled, tracks its own visibility internally.
+     */
+    visible?: boolean;
+    /**
+     * Initial visibility, for uncontrolled usage, seeding the first render.
+     * @default false — the overlay starts hidden and the wrapped content is interactive.
+     */
+    defaultVisible?: boolean;
+    /**
+     * Cover the viewport instead of the root's own box. Emits
+     * `data-full-screen` (style it `position: fixed; inset: 0`) and locks body
+     * scroll while visible — an inline overlay never locks the body, because
+     * freezing the whole page for a spinner over one card is a bug, not a
+     * feature.
+     * @default false — the overlay covers only the root element's box, and never touches body scroll.
+     */
+    fullScreen?: boolean;
+    /**
+     * Text announced politely when the overlay becomes visible, and the default
+     * `<SkdxSpinner>` label inside `<SkdxLoadingOverlayContent>`.
+     * @default 'Loading' — announced as "Loading"; name the work ("Loading invoices") when the page has more than one.
+     */
+    loadingLabel?: string;
+    /**
+     * Milliseconds to wait after `visible` turns true before the overlay
+     * actually appears. A response that arrives inside the window never renders
+     * an overlay at all, which is what stops the flash-of-spinner on fast
+     * requests. The pending timer is cancelled if `visible` flips back to false
+     * first, and on unmount.
+     * @default 0 — shows immediately, so nothing is hidden from a slow connection by accident.
+     */
+    delay?: number;
+};
+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, {
+    "update:visible": (visible: boolean) => any;
+    "visible-change": (visible: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    visible: boolean;
+    defaultVisible: boolean;
+    fullScreen: boolean;
+    loadingLabel: string;
+    delay: 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/loading-overlay/LoadingOverlay.vue.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The Vue implementation of the shared LoadingOverlay contract (see
+ * `@skdx/shared`'s `loadingOverlayContract`). Wraps the content being
+ * covered, owns the visibility (`visible`/`defaultVisible`/`visible-change`)
+ * and hands it to `<SkdxLoadingOverlayBackdrop>` and
+ * `<SkdxLoadingOverlayContent>` through `provide`. Renders a plain `<div>` —
+ * give it `position: relative` and the backdrop covers exactly this box; set
+ * `fullScreen` and it covers the viewport instead.
+ *
+ * While visible the root is `aria-busy="true"` and carries the `inert`
+ * attribute, so the pointer and the tab sequence both stop at the overlay
+ * rather than walking into the controls it is hiding. Deliberately **not** a
+ * focus trap: this is not a dialog, there is nothing inside to focus and
+ * nothing to dismiss, so trapping would strand the keyboard on a spinner.
+ * Because `inert` also takes the subtree out of the accessibility tree, the
+ * announcement is made through the process-wide live region (see
+ * `utils/liveAnnouncer`) rather than from the `<SkdxSpinner>` inside — a
+ * `role="status"` in an inert subtree announces nothing.
+ *
+ * `delay` exists for the same reason `SkdxTooltip` has one: a request that
+ * resolves in 80ms should never paint a spinner. The timer is cancelled when
+ * `visible` flips back to false before it fires, and on unmount.
+ *
+ * `data-state` is `"visible"`/`"hidden"` and reflects the *effective*
+ * visibility, i.e. after `delay`.
+ *
+ * @example
+ * ```vue
+ * <SkdxLoadingOverlay :visible="isFetching" :delay="150" loading-label="Loading invoices">
+ *   <InvoiceTable />
+ *   <SkdxLoadingOverlayBackdrop />
+ *   <SkdxLoadingOverlayContent />
+ * </SkdxLoadingOverlay>
+ * ```
+ */
+type __VLS_Props = {
+    /**
+     * Whether work is in flight, for controlled usage. Pair with
+     * `v-model:visible` or `@visible-change`.
+     * @default undefined — uncontrolled, tracks its own visibility internally.
+     */
+    visible?: boolean;
+    /**
+     * Initial visibility, for uncontrolled usage, seeding the first render.
+     * @default false — the overlay starts hidden and the wrapped content is interactive.
+     */
+    defaultVisible?: boolean;
+    /**
+     * Cover the viewport instead of the root's own box. Emits
+     * `data-full-screen` (style it `position: fixed; inset: 0`) and locks body
+     * scroll while visible — an inline overlay never locks the body, because
+     * freezing the whole page for a spinner over one card is a bug, not a
+     * feature.
+     * @default false — the overlay covers only the root element's box, and never touches body scroll.
+     */
+    fullScreen?: boolean;
+    /**
+     * Text announced politely when the overlay becomes visible, and the default
+     * `<SkdxSpinner>` label inside `<SkdxLoadingOverlayContent>`.
+     * @default 'Loading' — announced as "Loading"; name the work ("Loading invoices") when the page has more than one.
+     */
+    loadingLabel?: string;
+    /**
+     * Milliseconds to wait after `visible` turns true before the overlay
+     * actually appears. A response that arrives inside the window never renders
+     * an overlay at all, which is what stops the flash-of-spinner on fast
+     * requests. The pending timer is cancelled if `visible` flips back to false
+     * first, and on unmount.
+     * @default 0 — shows immediately, so nothing is hidden from a slow connection by accident.
+     */
+    delay?: number;
+};
+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, {
+    "update:visible": (visible: boolean) => any;
+    "visible-change": (visible: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    visible: boolean;
+    defaultVisible: boolean;
+    fullScreen: boolean;
+    loadingLabel: string;
+    delay: 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/loading-overlay/LoadingOverlay.vue.js

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

package/dist/loading-overlay/LoadingOverlay.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const f=require("../utils/useBodyScrollLock.cjs"),p=require("../utils/liveAnnouncer.cjs"),b=require("./context.cjs");let e=require("vue");var m=["aria-busy","inert","data-state","data-full-screen"],_=(0,e.defineComponent)({__name:"LoadingOverlay",props:{visible:{type:Boolean,default:void 0},defaultVisible:{type:Boolean,default:!1},fullScreen:{type:Boolean,default:!1},loadingLabel:{default:"Loading"},delay:{default:0}},emits:["update:visible","visible-change"],setup(u,{emit:n}){const l=u,r=n,s=(0,e.ref)(l.defaultVisible),d=(0,e.computed)(()=>l.visible===void 0?s.value:l.visible),i=(0,e.ref)(!1);(0,e.watch)([d,()=>l.delay],([t,o],y,c)=>{if(!t||o<=0)return;const v=setTimeout(()=>{i.value=!0},o);c(()=>{clearTimeout(v),i.value=!1})},{immediate:!0});const a=(0,e.computed)(()=>d.value&&(l.delay<=0||i.value));return(0,e.watch)(a,t=>{r("update:visible",t),r("visible-change",t)}),(0,e.watchEffect)(()=>p.announce(a.value?l.loadingLabel:"")),f.useBodyScrollLock((0,e.computed)(()=>a.value&&l.fullScreen)),(0,e.provide)(b.LOADING_OVERLAY_CONTEXT,{visible:a,fullScreen:(0,e.computed)(()=>l.fullScreen),loadingLabel:(0,e.computed)(()=>l.loadingLabel)}),(t,o)=>((0,e.openBlock)(),(0,e.createElementBlock)("div",{class:"skdx-loading-overlay","data-part":"root","data-skdx-component":"loading-overlay","aria-busy":a.value?"true":void 0,inert:a.value||void 0,"data-state":a.value?"visible":"hidden","data-full-screen":u.fullScreen?"":void 0},[(0,e.renderSlot)(t.$slots,"default")],8,m))}});exports.default=_;

package/dist/loading-overlay/LoadingOverlay.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{useBodyScrollLock as e}from"../utils/useBodyScrollLock.js";import{announce as a}from"../utils/liveAnnouncer.js";import{LOADING_OVERLAY_CONTEXT as l}from"./context.js";import{computed as t,createElementBlock as o,defineComponent as i,openBlock as s,provide as d,ref as n,renderSlot as u,watch as r,watchEffect as v}from"vue";var c=["aria-busy","inert","data-state","data-full-screen"],f=/* @__PURE__ */i({__name:"LoadingOverlay",props:{visible:{type:Boolean,default:void 0},defaultVisible:{type:Boolean,default:!1},fullScreen:{type:Boolean,default:!1},loadingLabel:{default:"Loading"},delay:{default:0}},emits:["update:visible","visible-change"],setup(i,{emit:f}){const m=i,p=f,b=n(m.defaultVisible),y=t(()=>void 0===m.visible?b.value:m.visible),g=n(!1);r([y,()=>m.delay],([e,a],l,t)=>{if(!e||a<=0)return;const o=setTimeout(()=>{g.value=!0},a);t(()=>{clearTimeout(o),g.value=!1})},{immediate:!0});const L=t(()=>y.value&&(m.delay<=0||g.value));return r(L,e=>{p("update:visible",e),p("visible-change",e)}),v(()=>a(L.value?m.loadingLabel:"")),e(t(()=>L.value&&m.fullScreen)),d(l,{visible:L,fullScreen:t(()=>m.fullScreen),loadingLabel:t(()=>m.loadingLabel)}),(e,a)=>(s(),o("div",{class:"skdx-loading-overlay","data-part":"root","data-skdx-component":"loading-overlay","aria-busy":L.value?"true":void 0,inert:L.value||void 0,"data-state":L.value?"visible":"hidden","data-full-screen":i.fullScreen?"":void 0},[u(e.$slots,"default")],8,c))}});export{f as default};

package/dist/loading-overlay/LoadingOverlayBackdrop.vue.cjs

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

package/dist/loading-overlay/LoadingOverlayBackdrop.vue.d.cts

@@ -0,0 +1,23 @@
+/**
+ * The scrim that covers the work in progress. Mounted only while the overlay
+ * is *effectively* visible — i.e. after the root's `delay` — so a response
+ * that arrives inside the delay window never paints a scrim at all.
+ *
+ * Renders `aria-hidden` — it is pure decoration, the announcement comes from
+ * the root — and carries `data-state="visible"` plus `data-full-screen` so one
+ * rule set can style both the inline (`position: absolute; inset: 0`) and the
+ * full-screen (`position: fixed; inset: 0`) case.
+ *
+ * Must be used inside `<SkdxLoadingOverlay>`.
+ *
+ * @example
+ * ```vue
+ * <SkdxLoadingOverlay :visible="isFetching">
+ *   <InvoiceTable />
+ *   <SkdxLoadingOverlayBackdrop />
+ * </SkdxLoadingOverlay>
+ * ```
+ */
+type __VLS_Props = {};
+declare const _default: 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>;
+export default _default;

package/dist/loading-overlay/LoadingOverlayBackdrop.vue.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The scrim that covers the work in progress. Mounted only while the overlay
+ * is *effectively* visible — i.e. after the root's `delay` — so a response
+ * that arrives inside the delay window never paints a scrim at all.
+ *
+ * Renders `aria-hidden` — it is pure decoration, the announcement comes from
+ * the root — and carries `data-state="visible"` plus `data-full-screen` so one
+ * rule set can style both the inline (`position: absolute; inset: 0`) and the
+ * full-screen (`position: fixed; inset: 0`) case.
+ *
+ * Must be used inside `<SkdxLoadingOverlay>`.
+ *
+ * @example
+ * ```vue
+ * <SkdxLoadingOverlay :visible="isFetching">
+ *   <InvoiceTable />
+ *   <SkdxLoadingOverlayBackdrop />
+ * </SkdxLoadingOverlay>
+ * ```
+ */
+type __VLS_Props = {};
+declare const _default: 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>;
+export default _default;

package/dist/loading-overlay/LoadingOverlayBackdrop.vue.js

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

package/dist/loading-overlay/LoadingOverlayBackdrop.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const a=require("./context.cjs");let e=require("vue");var t=["data-full-screen"],n=(0,e.defineComponent)({__name:"LoadingOverlayBackdrop",setup(d){const r=(0,e.inject)(a.LOADING_OVERLAY_CONTEXT);if(!r)throw new Error("<SkdxLoadingOverlayBackdrop> must be used inside <SkdxLoadingOverlay>.");return(o,l)=>(0,e.unref)(r).visible.value?((0,e.openBlock)(),(0,e.createElementBlock)("div",{key:0,class:"skdx-loading-overlay__backdrop","data-part":"backdrop","aria-hidden":"true","data-state":"visible","data-full-screen":(0,e.unref)(r).fullScreen.value?"":void 0},null,8,t)):(0,e.createCommentVNode)("",!0)}});exports.default=n;

package/dist/loading-overlay/LoadingOverlayBackdrop.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{LOADING_OVERLAY_CONTEXT as e}from"./context.js";import{createCommentVNode as a,createElementBlock as r,defineComponent as o,inject as t,openBlock as d,unref as n}from"vue";var l=["data-full-screen"],s=/* @__PURE__ */o({__name:"LoadingOverlayBackdrop",setup(o){const s=t(e);if(!s)throw new Error("<SkdxLoadingOverlayBackdrop> must be used inside <SkdxLoadingOverlay>.");return(e,o)=>n(s).visible.value?(d(),r("div",{key:0,class:"skdx-loading-overlay__backdrop","data-part":"backdrop","aria-hidden":"true","data-state":"visible","data-full-screen":n(s).fullScreen.value?"":void 0},null,8,l)):a("",!0)}});export{s as default};

package/dist/loading-overlay/LoadingOverlayContent.vue.cjs

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

package/dist/loading-overlay/LoadingOverlayContent.vue.d.cts

@@ -0,0 +1,39 @@
+/**
+ * The indicator layer sitting on top of the backdrop — a spinner, a message, a
+ * cancel affordance, whatever the overlay needs to say. Mounts alongside the
+ * backdrop, only while the overlay is effectively visible, and carries the same
+ * `data-state="visible"` and `data-full-screen` hooks.
+ *
+ * With no slot content it falls back to the existing `<SkdxSpinner>`, labelled
+ * with the root's `loadingLabel` — composing the indicator the library already
+ * ships rather than growing a second one. Fill the default slot to replace it
+ * entirely.
+ *
+ * The whole overlay sits inside the root's `inert` subtree, so nothing here is
+ * focusable or announced; the "Loading" announcement is made by the root
+ * through the live region.
+ *
+ * Must be used inside `<SkdxLoadingOverlay>`.
+ *
+ * @example
+ * ```vue
+ * <SkdxLoadingOverlay :visible="isFetching" loading-label="Loading invoices">
+ *   <InvoiceTable />
+ *   <SkdxLoadingOverlayBackdrop />
+ *   <SkdxLoadingOverlayContent />
+ * </SkdxLoadingOverlay>
+ * ```
+ */
+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/loading-overlay/LoadingOverlayContent.vue.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The indicator layer sitting on top of the backdrop — a spinner, a message, a
+ * cancel affordance, whatever the overlay needs to say. Mounts alongside the
+ * backdrop, only while the overlay is effectively visible, and carries the same
+ * `data-state="visible"` and `data-full-screen` hooks.
+ *
+ * With no slot content it falls back to the existing `<SkdxSpinner>`, labelled
+ * with the root's `loadingLabel` — composing the indicator the library already
+ * ships rather than growing a second one. Fill the default slot to replace it
+ * entirely.
+ *
+ * The whole overlay sits inside the root's `inert` subtree, so nothing here is
+ * focusable or announced; the "Loading" announcement is made by the root
+ * through the live region.
+ *
+ * Must be used inside `<SkdxLoadingOverlay>`.
+ *
+ * @example
+ * ```vue
+ * <SkdxLoadingOverlay :visible="isFetching" loading-label="Loading invoices">
+ *   <InvoiceTable />
+ *   <SkdxLoadingOverlayBackdrop />
+ *   <SkdxLoadingOverlayContent />
+ * </SkdxLoadingOverlay>
+ * ```
+ */
+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/loading-overlay/LoadingOverlayContent.vue.js

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

package/dist/loading-overlay/LoadingOverlayContent.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const r=require("../spinner/Spinner.vue.cjs"),a=require("./context.cjs");let e=require("vue");var l=["data-full-screen"],o=(0,e.defineComponent)({__name:"LoadingOverlayContent",setup(u){const t=(0,e.inject)(a.LOADING_OVERLAY_CONTEXT);if(!t)throw new Error("<SkdxLoadingOverlayContent> must be used inside <SkdxLoadingOverlay>.");return(n,d)=>(0,e.unref)(t).visible.value?((0,e.openBlock)(),(0,e.createElementBlock)("div",{key:0,class:"skdx-loading-overlay__content","data-part":"content","data-state":"visible","data-full-screen":(0,e.unref)(t).fullScreen.value?"":void 0},[(0,e.renderSlot)(n.$slots,"default",{},()=>[(0,e.createVNode)(r.default,{label:(0,e.unref)(t).loadingLabel.value},null,8,["label"])])],8,l)):(0,e.createCommentVNode)("",!0)}});exports.default=o;

package/dist/loading-overlay/LoadingOverlayContent.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import e from"../spinner/Spinner.vue.js";import{LOADING_OVERLAY_CONTEXT as a}from"./context.js";import{createCommentVNode as t,createElementBlock as n,createVNode as l,defineComponent as o,inject as r,openBlock as s,renderSlot as d,unref as i}from"vue";var u=["data-full-screen"],c=/* @__PURE__ */o({__name:"LoadingOverlayContent",setup(o){const c=r(a);if(!c)throw new Error("<SkdxLoadingOverlayContent> must be used inside <SkdxLoadingOverlay>.");return(a,o)=>i(c).visible.value?(s(),n("div",{key:0,class:"skdx-loading-overlay__content","data-part":"content","data-state":"visible","data-full-screen":i(c).fullScreen.value?"":void 0},[d(a.$slots,"default",{},()=>[l(e,{label:i(c).loadingLabel.value},null,8,["label"])])],8,u)):t("",!0)}});export{c as default};

package/dist/loading-overlay/context.cjs

@@ -0,0 +1 @@
+var O=Symbol("skdx-loading-overlay-context");exports.LOADING_OVERLAY_CONTEXT=O;

package/dist/loading-overlay/context.d.cts

@@ -0,0 +1,14 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+/** @internal Shared state a `SkdxLoadingOverlay` provides to its backdrop and content parts. */
+export interface LoadingOverlayContext {
+    /**
+     * The *effective* visibility — `visible` after `delay` has elapsed, not the
+     * raw prop. This is what the parts mount against, so a request that resolves
+     * inside the delay window never renders an overlay at all.
+     */
+    visible: ComputedRef<boolean>;
+    fullScreen: ComputedRef<boolean>;
+    loadingLabel: ComputedRef<string>;
+}
+/** @internal Injection key a LoadingOverlay provides so its layers share the effective visibility and label. */
+export declare const LOADING_OVERLAY_CONTEXT: InjectionKey<LoadingOverlayContext>;

package/dist/loading-overlay/context.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+/** @internal Shared state a `SkdxLoadingOverlay` provides to its backdrop and content parts. */
+export interface LoadingOverlayContext {
+    /**
+     * The *effective* visibility — `visible` after `delay` has elapsed, not the
+     * raw prop. This is what the parts mount against, so a request that resolves
+     * inside the delay window never renders an overlay at all.
+     */
+    visible: ComputedRef<boolean>;
+    fullScreen: ComputedRef<boolean>;
+    loadingLabel: ComputedRef<string>;
+}
+/** @internal Injection key a LoadingOverlay provides so its layers share the effective visibility and label. */
+export declare const LOADING_OVERLAY_CONTEXT: InjectionKey<LoadingOverlayContext>;

package/dist/loading-overlay/context.js

@@ -0,0 +1 @@
+var o=/* @__PURE__ */Symbol("skdx-loading-overlay-context");export{o as LOADING_OVERLAY_CONTEXT};

package/dist/loading-overlay/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./LoadingOverlay.vue.cjs"),r=require("./LoadingOverlayBackdrop.vue.cjs"),a=require("./LoadingOverlayContent.vue.cjs");exports.SkdxLoadingOverlay=e.default;exports.SkdxLoadingOverlayBackdrop=r.default;exports.SkdxLoadingOverlayContent=a.default;

package/dist/loading-overlay/index.d.cts

@@ -0,0 +1,3 @@
+export { default as SkdxLoadingOverlay } from './LoadingOverlay.vue.cjs';
+export { default as SkdxLoadingOverlayBackdrop } from './LoadingOverlayBackdrop.vue.cjs';
+export { default as SkdxLoadingOverlayContent } from './LoadingOverlayContent.vue.cjs';

package/dist/loading-overlay/index.d.ts

@@ -0,0 +1,3 @@
+export { default as SkdxLoadingOverlay } from './LoadingOverlay.vue.js';
+export { default as SkdxLoadingOverlayBackdrop } from './LoadingOverlayBackdrop.vue.js';
+export { default as SkdxLoadingOverlayContent } from './LoadingOverlayContent.vue.js';

package/dist/loading-overlay/index.js

@@ -0,0 +1 @@
+import a from"./LoadingOverlay.vue.js";import o from"./LoadingOverlayBackdrop.vue.js";import r from"./LoadingOverlayContent.vue.js";export{a as SkdxLoadingOverlay,o as SkdxLoadingOverlayBackdrop,r as SkdxLoadingOverlayContent};

package/dist/menubar/Menubar.vue.cjs

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

package/dist/menubar/Menubar.vue.d.cts

@@ -0,0 +1,35 @@
+/**
+ * Root of an application-style menu bar: owns which `SkdxMenubarMenu` is open
+ * and hands it down via context. Renders a `<div role="menubar">` with
+ * roving-focus, wrapping, typeahead arrow-key navigation (horizontal) across
+ * triggers marked `data-skdx-menubar-trigger`.
+ *
+ * Works controlled (`v-model:value`) or uncontrolled (`default-value`).
+ */
+type __VLS_Props = {
+    /** Value of the currently open menu, for controlled usage via `v-model:value`. */
+    value?: string;
+    /** Initially open menu's value, for uncontrolled usage. */
+    defaultValue?: string;
+};
+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, {
+    "update:value": (value: string) => any;
+    "value-change": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    "onValue-change"?: ((value: string) => any) | undefined;
+}>, {
+    value: string;
+    defaultValue: string;
+}, {}, {}, {}, 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/menubar/Menubar.vue.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Root of an application-style menu bar: owns which `SkdxMenubarMenu` is open
+ * and hands it down via context. Renders a `<div role="menubar">` with
+ * roving-focus, wrapping, typeahead arrow-key navigation (horizontal) across
+ * triggers marked `data-skdx-menubar-trigger`.
+ *
+ * Works controlled (`v-model:value`) or uncontrolled (`default-value`).
+ */
+type __VLS_Props = {
+    /** Value of the currently open menu, for controlled usage via `v-model:value`. */
+    value?: string;
+    /** Initially open menu's value, for uncontrolled usage. */
+    defaultValue?: string;
+};
+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, {
+    "update:value": (value: string) => any;
+    "value-change": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    "onValue-change"?: ((value: string) => any) | undefined;
+}>, {
+    value: string;
+    defaultValue: string;
+}, {}, {}, {}, 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/menubar/Menubar.vue.js

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

package/dist/menubar/Menubar.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const p=require("../utils/useRovingFocus.cjs"),l=require("./context.cjs");let e=require("vue");var f=(0,e.defineComponent)({__name:"Menubar",props:{value:{default:void 0},defaultValue:{default:""}},emits:["update:value","value-change"],setup(d,{emit:s}){const t=d,a=s,o=(0,e.ref)(t.defaultValue),i=(0,e.computed)(()=>t.value??o.value);function v(u){t.value===void 0&&(o.value=u),a("update:value",u),a("value-change",u)}(0,e.provide)(l.MENUBAR_CONTEXT,{value:i,onValueChange:v});const n=p.useRovingFocus({orientation:"horizontal",loop:!0,itemSelector:l.TRIGGER_SELECTOR,typeahead:!0});return(u,r)=>((0,e.openBlock)(),(0,e.createElementBlock)("div",{class:"skdx-menubar","data-part":"root","data-skdx-component":"menubar",role:"menubar",onKeydown:r[0]||(r[0]=(...c)=>(0,e.unref)(n)&&(0,e.unref)(n)(...c))},[(0,e.renderSlot)(u.$slots,"default")],32))}});exports.default=f;

package/dist/menubar/Menubar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{useRovingFocus as e}from"../utils/useRovingFocus.js";import{MENUBAR_CONTEXT as a,TRIGGER_SELECTOR as o}from"./context.js";import{computed as t,createElementBlock as u,defineComponent as n,openBlock as l,provide as s,ref as r,renderSlot as d,unref as i}from"vue";var v=/* @__PURE__ */n({__name:"Menubar",props:{value:{default:void 0},defaultValue:{default:""}},emits:["update:value","value-change"],setup(n,{emit:v}){const m=n,p=v,c=r(m.defaultValue),f=t(()=>m.value??c.value);s(a,{value:f,onValueChange:function(e){void 0===m.value&&(c.value=e),p("update:value",e),p("value-change",e)}});const E=e({orientation:"horizontal",loop:!0,itemSelector:o,typeahead:!0});return(e,a)=>(l(),u("div",{class:"skdx-menubar","data-part":"root","data-skdx-component":"menubar",role:"menubar",onKeydown:a[0]||(a[0]=(...e)=>i(E)&&i(E)(...e))},[d(e.$slots,"default")],32))}});export{v as default};

package/dist/menubar/MenubarArrow.vue.cjs

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

package/dist/menubar/MenubarArrow.vue.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Optional small triangle pointing from a `SkdxMenubarContent` panel back at
+ * its `SkdxMenubarTrigger`. Renders inside the popper-positioned content;
+ * place it as a direct child of `SkdxMenubarContent`.
+ */
+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/menubar/MenubarArrow.vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Optional small triangle pointing from a `SkdxMenubarContent` panel back at
+ * its `SkdxMenubarTrigger`. Renders inside the popper-positioned content;
+ * place it as a direct child of `SkdxMenubarContent`.
+ */
+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/menubar/MenubarArrow.vue.js

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

package/dist/menubar/MenubarArrow.vue_vue_type_script_setup_true_lang.cjs

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

package/dist/menubar/MenubarArrow.vue_vue_type_script_setup_true_lang.js

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

package/dist/menubar/MenubarCheckboxItem.vue.cjs

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

package/dist/menubar/MenubarCheckboxItem.vue.d.cts

@@ -0,0 +1,44 @@
+/**
+ * A togglable `SkdxMenubarItem`: renders a `<div role="menuitemcheckbox">`
+ * with `aria-checked` and `data-state` of `"checked"` or `"unchecked"`.
+ * Selecting it flips `checked` and keeps the menu open (calls
+ * `event.preventDefault()` internally). Bind the state with `v-model:checked`
+ * (or `@checked-change`), or leave `checked` unbound and let the item track
+ * its own from `defaultChecked`. Pair with a `SkdxMenubarItemIndicator` child
+ * to render a checkmark.
+ */
+type __VLS_Props = {
+    /**
+     * Whether the item currently renders as checked, for controlled usage.
+     * Pair with `v-model:checked` or `@checked-change`.
+     */
+    checked?: boolean;
+    /** Initial checked state, for uncontrolled usage. */
+    defaultChecked?: boolean;
+    /** Disables selection and excludes the item from arrow-key/typeahead navigation. */
+    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, {
+    select: (event: Event) => any;
+    "update:checked": (checked: boolean) => any;
+    "checked-change": (checked: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((event: Event) => any) | undefined;
+    "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    "onChecked-change"?: ((checked: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    checked: boolean;
+    defaultChecked: 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;
+    };
+};