@skdx/vue 0.26.0 → 0.28.0

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

@@ -1,78 +1,54 @@
 /**
- * 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`.
+ * Covers content in the default slot while work is in flight. Renders a plain
+ * `<div>`; give it `position: relative` for local coverage, or set `fullScreen`
+ * for viewport coverage. Always derives Backdrop and Content layers with a spinner.
+ * While visible, sets `aria-busy="true"` and `inert` on the covered wrapper.
  *
  * @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.
+     * Whether work is in flight for controlled usage. Pair with `v-model:visible`.
+     * @default undefined — uncontrolled, tracks 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.
+     * Cover the viewport instead of the root's box. Emits `data-full-screen`
+     * and locks body scroll while visible; inline overlays never lock the body.
+     * @default false — the overlay covers only the root element's box.
      */
     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.
+     * Accessible name of the busy region, announced when the overlay becomes
+     * visible and used as the derived `SkdxSpinner`'s label.
+     * @default 'Loading' — name the work ("Loading invoices") when multiple overlays exist.
      */
     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.
+     * Text announced when the overlay hides, closing the loop the appearance
+     * announcement opens (the region became operable again — a change screen-reader
+     * users cannot see). Omitted: the overlay clears its message, allowing
+     * consecutive identical `loadingLabel`s to announce twice.
+     * @default undefined — hiding announces nothing.
+     */
+    loadedLabel?: string;
+    /**
+     * Milliseconds to wait after `visible` turns true before the overlay renders.
+     * Responses arriving inside this window never render the overlay, preventing
+     * spinner flash on fast requests. The timer cancels if `visible` flips back
+     * to false or on unmount.
+     * @default 0 — shows immediately to avoid hiding slow connections.
      */
     delay?: number;
 };
-declare var __VLS_1: {};
+declare var __VLS_10: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
+    default?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:visible": (visible: boolean) => any;
@@ -82,9 +58,9 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     "onVisible-change"?: ((visible: boolean) => any) | undefined;
 }>, {
     visible: boolean;
-    defaultVisible: boolean;
-    fullScreen: boolean;
     loadingLabel: string;
+    fullScreen: boolean;
+    loadedLabel: string;
     delay: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;

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

@@ -1,78 +1,54 @@
 /**
- * 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`.
+ * Covers content in the default slot while work is in flight. Renders a plain
+ * `<div>`; give it `position: relative` for local coverage, or set `fullScreen`
+ * for viewport coverage. Always derives Backdrop and Content layers with a spinner.
+ * While visible, sets `aria-busy="true"` and `inert` on the covered wrapper.
  *
  * @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.
+     * Whether work is in flight for controlled usage. Pair with `v-model:visible`.
+     * @default undefined — uncontrolled, tracks 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.
+     * Cover the viewport instead of the root's box. Emits `data-full-screen`
+     * and locks body scroll while visible; inline overlays never lock the body.
+     * @default false — the overlay covers only the root element's box.
      */
     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.
+     * Accessible name of the busy region, announced when the overlay becomes
+     * visible and used as the derived `SkdxSpinner`'s label.
+     * @default 'Loading' — name the work ("Loading invoices") when multiple overlays exist.
      */
     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.
+     * Text announced when the overlay hides, closing the loop the appearance
+     * announcement opens (the region became operable again — a change screen-reader
+     * users cannot see). Omitted: the overlay clears its message, allowing
+     * consecutive identical `loadingLabel`s to announce twice.
+     * @default undefined — hiding announces nothing.
+     */
+    loadedLabel?: string;
+    /**
+     * Milliseconds to wait after `visible` turns true before the overlay renders.
+     * Responses arriving inside this window never render the overlay, preventing
+     * spinner flash on fast requests. The timer cancels if `visible` flips back
+     * to false or on unmount.
+     * @default 0 — shows immediately to avoid hiding slow connections.
      */
     delay?: number;
 };
-declare var __VLS_1: {};
+declare var __VLS_10: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
+    default?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:visible": (visible: boolean) => any;
@@ -82,9 +58,9 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     "onVisible-change"?: ((visible: boolean) => any) | undefined;
 }>, {
     visible: boolean;
-    defaultVisible: boolean;
-    fullScreen: boolean;
     loadingLabel: string;
+    fullScreen: boolean;
+    loadedLabel: string;
     delay: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;

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

@@ -1 +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=_;
+const n=require("./LoadingOverlayBackdrop.vue.cjs"),u=require("./LoadingOverlayContent.vue.cjs"),s=require("./LoadingOverlayRoot.vue.cjs");let e=require("vue");var p=(0,e.defineComponent)({__name:"LoadingOverlay",props:{visible:{type:Boolean,default:void 0},fullScreen:{type:Boolean,default:!1},loadingLabel:{default:"Loading"},loadedLabel:{default:void 0},delay:{default:0}},emits:["update:visible","visible-change"],setup(o,{emit:r}){const i=o,l=r;return(d,t)=>((0,e.openBlock)(),(0,e.createBlock)(s.default,(0,e.mergeProps)(i,{"onUpdate:visible":t[0]||(t[0]=a=>l("update:visible",a)),onVisibleChange:t[1]||(t[1]=a=>l("visible-change",a))}),{default:(0,e.withCtx)(()=>[(0,e.renderSlot)(d.$slots,"default"),(0,e.createVNode)(n.default),(0,e.createVNode)(u.default)]),_:3},16))}});exports.default=p;

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

@@ -1 +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};
+import e from"./LoadingOverlayBackdrop.vue.js";import a from"./LoadingOverlayContent.vue.js";import o from"./LoadingOverlayRoot.vue.js";import{createBlock as t,createVNode as l,defineComponent as i,mergeProps as d,openBlock as r,renderSlot as s,withCtx as n}from"vue";var p=/* @__PURE__ */i({__name:"LoadingOverlay",props:{visible:{type:Boolean,default:void 0},fullScreen:{type:Boolean,default:!1},loadingLabel:{default:"Loading"},loadedLabel:{default:void 0},delay:{default:0}},emits:["update:visible","visible-change"],setup(i,{emit:p}){const u=i,v=p;return(i,p)=>(r(),t(o,d(u,{"onUpdate:visible":p[0]||(p[0]=e=>v("update:visible",e)),onVisibleChange:p[1]||(p[1]=e=>v("visible-change",e))}),{default:n(()=>[s(i.$slots,"default"),l(e),l(a)]),_:3},16))}});export{p as default};

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

@@ -1,12 +1,5 @@
 /**
- * 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.
+ * The scrim layer. Reads visibility from the root's context.
  *
  * Must be used inside `<SkdxLoadingOverlay>`.
  *

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

@@ -1,12 +1,5 @@
 /**
- * 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.
+ * The scrim layer. Reads visibility from the root's context.
  *
  * Must be used inside `<SkdxLoadingOverlay>`.
  *

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

@@ -1,17 +1,12 @@
 /**
- * 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.
+ * The centered indicator layer. Reads visibility and label from the root's
+ * context.
  *
- * 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.
+ * With no slot content it falls back to `<SkdxSpinner>`, labelled with the
+ * root's `loadingLabel`. 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.
+ * Sits inside the root's `inert` `covered` wrapper, so nothing here is
+ * focusable or announced — the root announces through the live region.
  *
  * Must be used inside `<SkdxLoadingOverlay>`.
  *

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

@@ -1,17 +1,12 @@
 /**
- * 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.
+ * The centered indicator layer. Reads visibility and label from the root's
+ * context.
  *
- * 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.
+ * With no slot content it falls back to `<SkdxSpinner>`, labelled with the
+ * root's `loadingLabel`. 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.
+ * Sits inside the root's `inert` `covered` wrapper, so nothing here is
+ * focusable or announced — the root announces through the live region.
  *
  * Must be used inside `<SkdxLoadingOverlay>`.
  *

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

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

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

@@ -0,0 +1,102 @@
+/**
+ * The headless root of a loading overlay (see `@skdx/shared`'s
+ * `loadingOverlayContract`). Wraps the covered content, owns visibility
+ * (`visible`/`visible-change`), and shares it with `<SkdxLoadingOverlayBackdrop>`
+ * and `<SkdxLoadingOverlayContent>` via `provide`. Renders a plain `<div>`:
+ * `position: relative` scopes the backdrop to this box; `fullScreen` covers
+ * the viewport instead.
+ *
+ * While visible the root is `aria-busy="true"` and its `covered` wrapper
+ * carries `inert`, so pointer and keyboard both stop at the overlay instead
+ * of reaching the hidden controls. Deliberately **not** a focus trap — there
+ * is nothing inside to focus or dismiss, so trapping would strand the
+ * keyboard on a spinner.
+ *
+ * The two attributes sit on two elements on purpose: `inert` removes its
+ * subtree from the accessibility tree, so `aria-busy` beside it would vanish
+ * too and the busy state would announce to nobody. The same reasoning routes
+ * the announcement through the process-wide live region (see
+ * `utils/liveAnnouncer`) instead of the `<SkdxSpinner>` inside, where
+ * `role="status"` announces nothing.
+ *
+ * `delay` exists for the same reason `SkdxTooltip` has one: a request
+ * resolving in 80ms should never paint a spinner. The timer cancels if
+ * `visible` flips back to false first, or on unmount.
+ *
+ * `data-state` is `"visible"`/`"hidden"` and reflects the *effective*
+ * visibility, i.e. after `delay`.
+ *
+ * Renders its default slot verbatim inside `covered` and derives nothing —
+ * `SkdxLoadingOverlay` is this root plus the derived Backdrop and Content.
+ *
+ * @example With `import * as LoadingOverlay from '@skdx/vue/primitives/loading-overlay'`:
+ * ```vue
+ * <LoadingOverlay.Root :visible="isFetching" :delay="150" loading-label="Loading invoices">
+ *   <InvoiceTable />
+ *   <LoadingOverlay.Backdrop />
+ *   <LoadingOverlay.Content><ProgressBar :value="percent" /></LoadingOverlay.Content>
+ * </LoadingOverlay.Root>
+ * ```
+ */
+type __VLS_Props = {
+    /**
+     * Whether work is in flight for controlled usage. Pair with
+     * `v-model:visible` or `@visible-change`.
+     * @default undefined — uncontrolled, tracks internally.
+     */
+    visible?: boolean;
+    /**
+     * Cover the viewport instead of the root's box. Emits `data-full-screen`
+     * and locks body scroll while visible; inline overlays never lock the
+     * body.
+     * @default false — covers only the root's box; body scroll is untouched.
+     */
+    fullScreen?: boolean;
+    /**
+     * Accessible name of the busy region, announced when the overlay becomes
+     * visible and used as the derived `Spinner`'s label.
+     * @default 'Loading' — announced as "Loading"; name the work when the page has more than one.
+     */
+    loadingLabel?: string;
+    /**
+     * Text announced when the overlay hides, closing the loop the appearance
+     * announcement opens (the region became operable again — a change
+     * screen-reader users cannot see). Omitted: the overlay clears its
+     * message from the live region, allowing consecutive loads to announce
+     * twice.
+     * @default undefined — hiding announces nothing.
+     */
+    loadedLabel?: string;
+    /**
+     * Milliseconds to wait after `visible` turns true before the overlay
+     * renders. Responses arriving inside this window never render the
+     * overlay, preventing spinner flash on fast requests. The timer cancels
+     * if `visible` flips back to false or on unmount.
+     * @default 0 — shows immediately; nothing is hidden from a slow connection.
+     */
+    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;
+    loadingLabel: string;
+    fullScreen: boolean;
+    loadedLabel: 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/LoadingOverlayRoot.vue.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The headless root of a loading overlay (see `@skdx/shared`'s
+ * `loadingOverlayContract`). Wraps the covered content, owns visibility
+ * (`visible`/`visible-change`), and shares it with `<SkdxLoadingOverlayBackdrop>`
+ * and `<SkdxLoadingOverlayContent>` via `provide`. Renders a plain `<div>`:
+ * `position: relative` scopes the backdrop to this box; `fullScreen` covers
+ * the viewport instead.
+ *
+ * While visible the root is `aria-busy="true"` and its `covered` wrapper
+ * carries `inert`, so pointer and keyboard both stop at the overlay instead
+ * of reaching the hidden controls. Deliberately **not** a focus trap — there
+ * is nothing inside to focus or dismiss, so trapping would strand the
+ * keyboard on a spinner.
+ *
+ * The two attributes sit on two elements on purpose: `inert` removes its
+ * subtree from the accessibility tree, so `aria-busy` beside it would vanish
+ * too and the busy state would announce to nobody. The same reasoning routes
+ * the announcement through the process-wide live region (see
+ * `utils/liveAnnouncer`) instead of the `<SkdxSpinner>` inside, where
+ * `role="status"` announces nothing.
+ *
+ * `delay` exists for the same reason `SkdxTooltip` has one: a request
+ * resolving in 80ms should never paint a spinner. The timer cancels if
+ * `visible` flips back to false first, or on unmount.
+ *
+ * `data-state` is `"visible"`/`"hidden"` and reflects the *effective*
+ * visibility, i.e. after `delay`.
+ *
+ * Renders its default slot verbatim inside `covered` and derives nothing —
+ * `SkdxLoadingOverlay` is this root plus the derived Backdrop and Content.
+ *
+ * @example With `import * as LoadingOverlay from '@skdx/vue/primitives/loading-overlay'`:
+ * ```vue
+ * <LoadingOverlay.Root :visible="isFetching" :delay="150" loading-label="Loading invoices">
+ *   <InvoiceTable />
+ *   <LoadingOverlay.Backdrop />
+ *   <LoadingOverlay.Content><ProgressBar :value="percent" /></LoadingOverlay.Content>
+ * </LoadingOverlay.Root>
+ * ```
+ */
+type __VLS_Props = {
+    /**
+     * Whether work is in flight for controlled usage. Pair with
+     * `v-model:visible` or `@visible-change`.
+     * @default undefined — uncontrolled, tracks internally.
+     */
+    visible?: boolean;
+    /**
+     * Cover the viewport instead of the root's box. Emits `data-full-screen`
+     * and locks body scroll while visible; inline overlays never lock the
+     * body.
+     * @default false — covers only the root's box; body scroll is untouched.
+     */
+    fullScreen?: boolean;
+    /**
+     * Accessible name of the busy region, announced when the overlay becomes
+     * visible and used as the derived `Spinner`'s label.
+     * @default 'Loading' — announced as "Loading"; name the work when the page has more than one.
+     */
+    loadingLabel?: string;
+    /**
+     * Text announced when the overlay hides, closing the loop the appearance
+     * announcement opens (the region became operable again — a change
+     * screen-reader users cannot see). Omitted: the overlay clears its
+     * message from the live region, allowing consecutive loads to announce
+     * twice.
+     * @default undefined — hiding announces nothing.
+     */
+    loadedLabel?: string;
+    /**
+     * Milliseconds to wait after `visible` turns true before the overlay
+     * renders. Responses arriving inside this window never render the
+     * overlay, preventing spinner flash on fast requests. The timer cancels
+     * if `visible` flips back to false or on unmount.
+     * @default 0 — shows immediately; nothing is hidden from a slow connection.
+     */
+    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;
+    loadingLabel: string;
+    fullScreen: boolean;
+    loadedLabel: 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/LoadingOverlayRoot.vue.js

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

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

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

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

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

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

@@ -2,9 +2,7 @@ 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.
+     * The effective visibility — `visible` after `delay` elapses, not the raw prop.
      */
     visible: ComputedRef<boolean>;
     fullScreen: ComputedRef<boolean>;

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

@@ -2,9 +2,7 @@ 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.
+     * The effective visibility — `visible` after `delay` elapses, not the raw prop.
      */
     visible: ComputedRef<boolean>;
     fullScreen: ComputedRef<boolean>;

package/dist/loading-overlay/index.cjs

@@ -1 +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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./LoadingOverlay.vue.cjs");exports.SkdxLoadingOverlay=e.default;

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

@@ -1,3 +1 @@
 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

@@ -1,3 +1 @@
 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

@@ -1 +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};
+import a from"./LoadingOverlay.vue.js";export{a as SkdxLoadingOverlay};

package/dist/loading-overlay/primitives.cjs

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