@skdx/vue 0.26.0

package/dist/alert/index.d.ts

@@ -0,0 +1,6 @@
+export { default as SkdxAlert } from './Alert.vue.js';
+export { default as SkdxAlertTitle } from './AlertTitle.vue.js';
+export { default as SkdxAlertDescription } from './AlertDescription.vue.js';
+export { default as SkdxAlertIcon } from './AlertIcon.vue.js';
+export { default as SkdxAlertClose } from './AlertClose.vue.js';
+export { default as SkdxAlertAction } from './AlertAction.vue.js';

package/dist/alert/index.js

@@ -0,0 +1 @@
+import r from"./Alert.vue.js";import e from"./AlertTitle.vue.js";import t from"./AlertDescription.vue.js";import o from"./AlertIcon.vue.js";import l from"./AlertClose.vue.js";import s from"./AlertAction.vue.js";export{r as SkdxAlert,s as SkdxAlertAction,l as SkdxAlertClose,t as SkdxAlertDescription,o as SkdxAlertIcon,e as SkdxAlertTitle};

package/dist/alert-dialog/AlertDialog.vue.cjs

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

package/dist/alert-dialog/AlertDialog.vue.d.cts

@@ -0,0 +1,47 @@
+/**
+ * The Vue implementation of the shared AlertDialog contract (see
+ * `@skdx/shared`'s `alertDialogContract`). Root of an always-modal,
+ * interruptive alert dialog (WAI-ARIA `alertdialog` pattern): owns open
+ * state and hands it down to `SkdxAlertDialogTrigger` / `SkdxAlertDialogPortal`
+ * / `SkdxAlertDialogOverlay` / `SkdxAlertDialogContent` / `SkdxAlertDialogTitle`
+ * / `SkdxAlertDialogDescription` / `SkdxAlertDialogAction` /
+ * `SkdxAlertDialogCancel` via context. Renders no DOM of its own.
+ *
+ * Unlike Dialog, it never closes on outside pointer-down — only Escape or an
+ * explicit Action/Cancel click.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after `SkdxAlertDialogContent`'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 alert dialog is open, for controlled usage. Pair with `@update:open`. */
+    open?: boolean;
+    /** Whether the alert dialog is initially open, for uncontrolled usage. */
+    defaultOpen?: 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, {
+    "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;
+}, {}, {}, {}, 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/alert-dialog/AlertDialog.vue.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The Vue implementation of the shared AlertDialog contract (see
+ * `@skdx/shared`'s `alertDialogContract`). Root of an always-modal,
+ * interruptive alert dialog (WAI-ARIA `alertdialog` pattern): owns open
+ * state and hands it down to `SkdxAlertDialogTrigger` / `SkdxAlertDialogPortal`
+ * / `SkdxAlertDialogOverlay` / `SkdxAlertDialogContent` / `SkdxAlertDialogTitle`
+ * / `SkdxAlertDialogDescription` / `SkdxAlertDialogAction` /
+ * `SkdxAlertDialogCancel` via context. Renders no DOM of its own.
+ *
+ * Unlike Dialog, it never closes on outside pointer-down — only Escape or an
+ * explicit Action/Cancel click.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after `SkdxAlertDialogContent`'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 alert dialog is open, for controlled usage. Pair with `@update:open`. */
+    open?: boolean;
+    /** Whether the alert dialog is initially open, for uncontrolled usage. */
+    defaultOpen?: 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, {
+    "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;
+}, {}, {}, {}, 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/alert-dialog/AlertDialog.vue.js

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

package/dist/alert-dialog/AlertDialog.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const g=require("../utils/useOpenChangeComplete.cjs"),u=require("./context.cjs");let t=require("vue");var m=(0,t.defineComponent)({__name:"AlertDialog",props:{open:{type:Boolean,default:void 0},defaultOpen:{type:Boolean,default:!1}},emits:["update:open","open-change","open-change-complete"],setup(a,{emit:c}){const n=a,o=c,s=(0,t.ref)(null),p=(0,t.ref)(null),l=(0,t.ref)(n.defaultOpen),r=(0,t.computed)(()=>n.open??l.value),{contentId:i,titleId:d,descriptionId:f}=u.nextAlertDialogIds();g.useOpenChangeComplete(r,p,e=>o("open-change-complete",e));function _(e){n.open===void 0&&(l.value=e),o("update:open",e),o("open-change",e)}return(0,t.provide)(u.ALERT_DIALOG_CONTEXT,{triggerRef:s,contentRef:p,contentId:i,titleId:d,descriptionId:f,open:r,setOpen:_}),(e,v)=>(0,t.renderSlot)(e.$slots,"default")}});exports.default=m;

package/dist/alert-dialog/AlertDialog.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{useOpenChangeComplete as e}from"../utils/useOpenChangeComplete.js";import{ALERT_DIALOG_CONTEXT as t,nextAlertDialogIds as n}from"./context.js";import{computed as o,defineComponent as p,provide as a,ref as l,renderSlot as s}from"vue";var d=/* @__PURE__ */p({__name:"AlertDialog",props:{open:{type:Boolean,default:void 0},defaultOpen:{type:Boolean,default:!1}},emits:["update:open","open-change","open-change-complete"],setup(p,{emit:d}){const r=p,i=d,u=l(null),c=l(null),m=l(r.defaultOpen),f=o(()=>r.open??m.value),{contentId:g,titleId:I,descriptionId:v}=n();return e(f,c,e=>i("open-change-complete",e)),a(t,{triggerRef:u,contentRef:c,contentId:g,titleId:I,descriptionId:v,open:f,setOpen:function(e){void 0===r.open&&(m.value=e),i("update:open",e),i("open-change",e)}}),(e,t)=>s(e.$slots,"default")}});export{d as default};

package/dist/alert-dialog/AlertDialogAction.vue.cjs

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

package/dist/alert-dialog/AlertDialogAction.vue.d.cts

@@ -0,0 +1,19 @@
+/**
+ * Button that confirms the alert dialog's primary (often destructive) action
+ * and closes the dialog on click. Does not run your handler for you — attach
+ * a `click` listener to actually perform the action. Must be used inside
+ * `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogAction.vue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Button that confirms the alert dialog's primary (often destructive) action
+ * and closes the dialog on click. Does not run your handler for you — attach
+ * a `click` listener to actually perform the action. Must be used inside
+ * `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogAction.vue.js

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

package/dist/alert-dialog/AlertDialogAction.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const r=require("./context.cjs");let e=require("vue");var l=(0,e.defineComponent)({__name:"AlertDialogAction",setup(a){const t=(0,e.inject)(r.ALERT_DIALOG_CONTEXT);if(!t)throw new Error("SkdxAlertDialogAction must be used within SkdxAlertDialog.");function n(){t.setOpen(!1)}return(o,i)=>((0,e.openBlock)(),(0,e.createElementBlock)("button",{class:"skdx-alert-dialog__action","data-part":"action",type:"button",onClick:n},[(0,e.renderSlot)(o.$slots,"default")]))}});exports.default=l;

package/dist/alert-dialog/AlertDialogAction.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{ALERT_DIALOG_CONTEXT as t}from"./context.js";import{createElementBlock as e,defineComponent as o,inject as a,openBlock as n,renderSlot as r}from"vue";var s=/* @__PURE__ */o({__name:"AlertDialogAction",setup(o){const s=a(t);if(!s)throw new Error("SkdxAlertDialogAction must be used within SkdxAlertDialog.");function i(){s.setOpen(!1)}return(t,o)=>(n(),e("button",{class:"skdx-alert-dialog__action","data-part":"action",type:"button",onClick:i},[r(t.$slots,"default")]))}});export{s as default};

package/dist/alert-dialog/AlertDialogCancel.vue.cjs

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

package/dist/alert-dialog/AlertDialogCancel.vue.d.cts

@@ -0,0 +1,19 @@
+/**
+ * Button that dismisses the alert dialog without taking action. Marked with
+ * an internal data attribute so `SkdxAlertDialogContent` can send it initial
+ * focus on open, per the "default to the safe action" alertdialog guidance.
+ * Must be used inside `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogCancel.vue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Button that dismisses the alert dialog without taking action. Marked with
+ * an internal data attribute so `SkdxAlertDialogContent` can send it initial
+ * focus on open, per the "default to the safe action" alertdialog guidance.
+ * Must be used inside `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogCancel.vue.js

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

package/dist/alert-dialog/AlertDialogCancel.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const n=require("./context.cjs");let e=require("vue");var r=(0,e.defineComponent)({__name:"AlertDialogCancel",setup(c){const t=(0,e.inject)(n.ALERT_DIALOG_CONTEXT);if(!t)throw new Error("SkdxAlertDialogCancel must be used within SkdxAlertDialog.");function l(){t.setOpen(!1)}return(a,o)=>((0,e.openBlock)(),(0,e.createElementBlock)("button",{class:"skdx-alert-dialog__cancel","data-part":"cancel",type:"button","data-skdx-alert-dialog-cancel":"",onClick:l},[(0,e.renderSlot)(a.$slots,"default")]))}});exports.default=r;

package/dist/alert-dialog/AlertDialogCancel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{ALERT_DIALOG_CONTEXT as e}from"./context.js";import{createElementBlock as t,defineComponent as a,inject as o,openBlock as l,renderSlot as n}from"vue";var r=/* @__PURE__ */a({__name:"AlertDialogCancel",setup(a){const r=o(e);if(!r)throw new Error("SkdxAlertDialogCancel must be used within SkdxAlertDialog.");function s(){r.setOpen(!1)}return(e,a)=>(l(),t("button",{class:"skdx-alert-dialog__cancel","data-part":"cancel",type:"button","data-skdx-alert-dialog-cancel":"",onClick:s},[n(e.$slots,"default")]))}});export{r as default};

package/dist/alert-dialog/AlertDialogContent.vue.cjs

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

package/dist/alert-dialog/AlertDialogContent.vue.d.cts

@@ -0,0 +1,51 @@
+import { type FocusOutsideEvent, type InteractOutsideEvent } from '../utils/useDismiss.cjs';
+import { type AutoFocusEvent } from '../utils/useFocusTrap.cjs';
+/**
+ * The alert dialog's panel: `role="alertdialog"` with `aria-modal="true"`,
+ * labelled by `SkdxAlertDialogTitle` and described by
+ * `SkdxAlertDialogDescription` via `aria-labelledby`/`aria-describedby`, and
+ * `data-state` (`open`/`closed`) reflecting state. Always traps focus and
+ * locks body scroll while open. Unlike `SkdxDialogContent`, it never closes
+ * on an outside interaction — only Escape (unless `escape-key-down` calls
+ * `event.preventDefault()`) or an explicit `SkdxAlertDialogAction`/
+ * `SkdxAlertDialogCancel` click. Outside interactions are still reported, for
+ * nudging the user back to the decision: `pointer-down-outside`/
+ * `focus-outside`, each preceded by `interact-outside` carrying the same
+ * event; there is simply nothing to veto. Sends initial focus to the
+ * `SkdxAlertDialogCancel` button, announced first as a cancelable
+ * `open-auto-focus`, and announces the focus return on close as
+ * `close-auto-focus`. Mounts only while open unless `forceMount` is set.
+ * Must be used inside `SkdxAlertDialog`.
+ */
+type __VLS_Props = {
+    /** Keep this panel mounted even while the alert dialog 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, {
+    "focus-outside": (event: FocusOutsideEvent) => any;
+    "open-auto-focus": (event: AutoFocusEvent) => any;
+    "close-auto-focus": (event: AutoFocusEvent) => any;
+    "escape-key-down": (event: KeyboardEvent) => any;
+    "pointer-down-outside": (event: PointerEvent) => any;
+    "interact-outside": (event: InteractOutsideEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onFocus-outside"?: ((event: FocusOutsideEvent) => any) | undefined;
+    "onOpen-auto-focus"?: ((event: AutoFocusEvent) => any) | undefined;
+    "onClose-auto-focus"?: ((event: AutoFocusEvent) => any) | undefined;
+    "onEscape-key-down"?: ((event: KeyboardEvent) => any) | undefined;
+    "onPointer-down-outside"?: ((event: PointerEvent) => any) | undefined;
+    "onInteract-outside"?: ((event: InteractOutsideEvent) => any) | undefined;
+}>, {
+    forceMount: 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/alert-dialog/AlertDialogContent.vue.d.ts

@@ -0,0 +1,51 @@
+import { type FocusOutsideEvent, type InteractOutsideEvent } from '../utils/useDismiss.js';
+import { type AutoFocusEvent } from '../utils/useFocusTrap.js';
+/**
+ * The alert dialog's panel: `role="alertdialog"` with `aria-modal="true"`,
+ * labelled by `SkdxAlertDialogTitle` and described by
+ * `SkdxAlertDialogDescription` via `aria-labelledby`/`aria-describedby`, and
+ * `data-state` (`open`/`closed`) reflecting state. Always traps focus and
+ * locks body scroll while open. Unlike `SkdxDialogContent`, it never closes
+ * on an outside interaction — only Escape (unless `escape-key-down` calls
+ * `event.preventDefault()`) or an explicit `SkdxAlertDialogAction`/
+ * `SkdxAlertDialogCancel` click. Outside interactions are still reported, for
+ * nudging the user back to the decision: `pointer-down-outside`/
+ * `focus-outside`, each preceded by `interact-outside` carrying the same
+ * event; there is simply nothing to veto. Sends initial focus to the
+ * `SkdxAlertDialogCancel` button, announced first as a cancelable
+ * `open-auto-focus`, and announces the focus return on close as
+ * `close-auto-focus`. Mounts only while open unless `forceMount` is set.
+ * Must be used inside `SkdxAlertDialog`.
+ */
+type __VLS_Props = {
+    /** Keep this panel mounted even while the alert dialog 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, {
+    "focus-outside": (event: FocusOutsideEvent) => any;
+    "open-auto-focus": (event: AutoFocusEvent) => any;
+    "close-auto-focus": (event: AutoFocusEvent) => any;
+    "escape-key-down": (event: KeyboardEvent) => any;
+    "pointer-down-outside": (event: PointerEvent) => any;
+    "interact-outside": (event: InteractOutsideEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onFocus-outside"?: ((event: FocusOutsideEvent) => any) | undefined;
+    "onOpen-auto-focus"?: ((event: AutoFocusEvent) => any) | undefined;
+    "onClose-auto-focus"?: ((event: AutoFocusEvent) => any) | undefined;
+    "onEscape-key-down"?: ((event: KeyboardEvent) => any) | undefined;
+    "onPointer-down-outside"?: ((event: PointerEvent) => any) | undefined;
+    "onInteract-outside"?: ((event: InteractOutsideEvent) => any) | undefined;
+}>, {
+    forceMount: 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/alert-dialog/AlertDialogContent.vue.js

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

package/dist/alert-dialog/AlertDialogContent.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const v=require("../utils/composeRefs.cjs"),y=require("../utils/useBodyScrollLock.cjs"),q=require("../utils/useDismiss.cjs"),l=require("../utils/useFocusTrap.cjs"),A=require("./context.cjs");let t=require("vue");var g=["id","aria-labelledby","aria-describedby","data-state"],C="[data-skdx-alert-dialog-cancel]",k=(0,t.defineComponent)({__name:"AlertDialogContent",props:{forceMount:{type:Boolean,default:!1}},emits:["escape-key-down","pointer-down-outside","focus-outside","interact-outside","open-auto-focus","close-auto-focus"],setup(d,{emit:f}){const p=["a[href]","button:not([disabled])",'input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])",'[tabindex]:not([tabindex="-1"])'].join(", "),n=f,u=(0,t.inject)(A.ALERT_DIALOG_CONTEXT);if(!u)throw new Error("SkdxAlertDialogContent must be used within SkdxAlertDialog.");const o=u,a=(0,t.ref)(null),_=v.composeRefs(a,o.contentRef);y.useBodyScrollLock(o.open),l.useFocusTrap(a,o.open,{onOpenAutoFocus:e=>e.preventDefault(),onCloseAutoFocus:e=>n("close-auto-focus",e)}),q.useDismiss({enabled:o.open,onEscapeKeyDown:e=>{n("escape-key-down",e),e.defaultPrevented||(o.setOpen(!1),o.triggerRef.value?.focus())},onInteractOutside:e=>n("interact-outside",e),onPointerDownOutside:e=>n("pointer-down-outside",e),onFocusOutside:e=>n("focus-outside",e)},[a,o.triggerRef]);let r;function s(){r!==void 0&&cancelAnimationFrame(r),r=requestAnimationFrame(()=>{const e=a.value;if(!e||!l.autoFocusEvent("open-auto-focus",b=>n("open-auto-focus",b)))return;const i=e.querySelector(C),m=e.querySelector(p),c=i??m??e;c===e&&(e.tabIndex=e.tabIndex>=0?e.tabIndex:-1),c.focus({preventScroll:!0})})}return(0,t.watch)(o.open,e=>{e&&s()}),(0,t.onMounted)(()=>{o.open.value&&s()}),(0,t.onBeforeUnmount)(()=>{r!==void 0&&cancelAnimationFrame(r)}),(e,i)=>d.forceMount||(0,t.unref)(o).open.value?((0,t.openBlock)(),(0,t.createElementBlock)("div",{key:0,class:"skdx-alert-dialog__content","data-part":"content",id:(0,t.unref)(o).contentId,ref:(0,t.unref)(_),role:"alertdialog","aria-modal":"true","aria-labelledby":(0,t.unref)(o).titleId,"aria-describedby":(0,t.unref)(o).descriptionId,"data-state":(0,t.unref)(o).open.value?"open":"closed"},[(0,t.renderSlot)(e.$slots,"default")],8,g)):(0,t.createCommentVNode)("",!0)}});exports.default=k;

package/dist/alert-dialog/AlertDialogContent.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{composeRefs as e}from"../utils/composeRefs.js";import{useBodyScrollLock as o}from"../utils/useBodyScrollLock.js";import{useDismiss as t}from"../utils/useDismiss.js";import{autoFocusEvent as a,useFocusTrap as n}from"../utils/useFocusTrap.js";import{ALERT_DIALOG_CONTEXT as s}from"./context.js";import{createCommentVNode as r,createElementBlock as i,defineComponent as u,inject as d,onBeforeUnmount as l,onMounted as c,openBlock as p,ref as f,renderSlot as m,unref as b,watch as v}from"vue";var y=["id","aria-labelledby","aria-describedby","data-state"],x=/* @__PURE__ */u({__name:"AlertDialogContent",props:{forceMount:{type:Boolean,default:!1}},emits:["escape-key-down","pointer-down-outside","focus-outside","interact-outside","open-auto-focus","close-auto-focus"],setup(u,{emit:x}){const k=["a[href]","button:not([disabled])",'input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])",'[tabindex]:not([tabindex="-1"])'].join(", "),g=x,w=d(s);if(!w)throw new Error("SkdxAlertDialogContent must be used within SkdxAlertDialog.");const A=w,D=f(null),F=e(D,A.contentRef);let I;function S(){void 0!==I&&cancelAnimationFrame(I),I=requestAnimationFrame(()=>{const e=D.value;if(!e||!a("open-auto-focus",e=>g("open-auto-focus",e)))return;const o=e.querySelector("[data-skdx-alert-dialog-cancel]"),t=e.querySelector(k),n=o??t??e;n===e&&(e.tabIndex=e.tabIndex>=0?e.tabIndex:-1),n.focus({preventScroll:!0})})}return o(A.open),n(D,A.open,{onOpenAutoFocus:e=>e.preventDefault(),onCloseAutoFocus:e=>g("close-auto-focus",e)}),t({enabled:A.open,onEscapeKeyDown:e=>{g("escape-key-down",e),e.defaultPrevented||(A.setOpen(!1),A.triggerRef.value?.focus())},onInteractOutside:e=>g("interact-outside",e),onPointerDownOutside:e=>g("pointer-down-outside",e),onFocusOutside:e=>g("focus-outside",e)},[D,A.triggerRef]),v(A.open,e=>{e&&S()}),c(()=>{A.open.value&&S()}),l(()=>{void 0!==I&&cancelAnimationFrame(I)}),(e,o)=>u.forceMount||b(A).open.value?(p(),i("div",{key:0,class:"skdx-alert-dialog__content","data-part":"content",id:b(A).contentId,ref:b(F),role:"alertdialog","aria-modal":"true","aria-labelledby":b(A).titleId,"aria-describedby":b(A).descriptionId,"data-state":b(A).open.value?"open":"closed"},[m(e.$slots,"default")],8,y)):r("",!0)}});export{x as default};

package/dist/alert-dialog/AlertDialogDescription.vue.cjs

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

package/dist/alert-dialog/AlertDialogDescription.vue.d.cts

@@ -0,0 +1,18 @@
+/**
+ * The alert dialog's accessible description: renders a `<p>` wired to
+ * `SkdxAlertDialogContent` via `aria-describedby`. Must be used inside
+ * `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogDescription.vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The alert dialog's accessible description: renders a `<p>` wired to
+ * `SkdxAlertDialogContent` via `aria-describedby`. Must be used inside
+ * `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogDescription.vue.js

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

package/dist/alert-dialog/AlertDialogDescription.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const i=require("./context.cjs");let e=require("vue");var o=["id"],n=(0,e.defineComponent)({__name:"AlertDialogDescription",setup(l){const t=(0,e.inject)(i.ALERT_DIALOG_CONTEXT);if(!t)throw new Error("SkdxAlertDialogDescription must be used within SkdxAlertDialog.");return(r,s)=>((0,e.openBlock)(),(0,e.createElementBlock)("p",{class:"skdx-alert-dialog__description","data-part":"description",id:(0,e.unref)(t).descriptionId},[(0,e.renderSlot)(r.$slots,"default")],8,o))}});exports.default=n;

package/dist/alert-dialog/AlertDialogDescription.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{ALERT_DIALOG_CONTEXT as e}from"./context.js";import{createElementBlock as t,defineComponent as r,inject as o,openBlock as i,renderSlot as s,unref as a}from"vue";var n=["id"],d=/* @__PURE__ */r({__name:"AlertDialogDescription",setup(r){const d=o(e);if(!d)throw new Error("SkdxAlertDialogDescription must be used within SkdxAlertDialog.");return(e,r)=>(i(),t("p",{class:"skdx-alert-dialog__description","data-part":"description",id:a(d).descriptionId},[s(e.$slots,"default")],8,n))}});export{d as default};

package/dist/alert-dialog/AlertDialogOverlay.vue.cjs

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

package/dist/alert-dialog/AlertDialogOverlay.vue.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Backdrop rendered behind `SkdxAlertDialogContent`, typically styled to dim
+ * the page. Exposes `data-state` (`open`/`closed`) for animation and mounts
+ * only while open unless `forceMount` is set. Must be used inside
+ * `SkdxAlertDialog`.
+ *
+ * `pointer-events: auto` matches React's `AlertDialogOverlay`. Here it is inert
+ * — `SkdxAlertDialogContent` is a native `<dialog>` shown with `showModal()`, so
+ * its `::backdrop` is what actually catches outside clicks — but it keeps the
+ * rendered style identical across ports, and it survives an ancestor that sets
+ * `pointer-events: none`. Declared on the element, so a consumer's fallthrough
+ * `style` merges over it and still wins.
+ */
+type __VLS_Props = {
+    /** Keep this overlay mounted even while the alert dialog is closed, instead of unmounting it. */
+    forceMount?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/alert-dialog/AlertDialogOverlay.vue.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Backdrop rendered behind `SkdxAlertDialogContent`, typically styled to dim
+ * the page. Exposes `data-state` (`open`/`closed`) for animation and mounts
+ * only while open unless `forceMount` is set. Must be used inside
+ * `SkdxAlertDialog`.
+ *
+ * `pointer-events: auto` matches React's `AlertDialogOverlay`. Here it is inert
+ * — `SkdxAlertDialogContent` is a native `<dialog>` shown with `showModal()`, so
+ * its `::backdrop` is what actually catches outside clicks — but it keeps the
+ * rendered style identical across ports, and it survives an ancestor that sets
+ * `pointer-events: none`. Declared on the element, so a consumer's fallthrough
+ * `style` merges over it and still wins.
+ */
+type __VLS_Props = {
+    /** Keep this overlay mounted even while the alert dialog is closed, instead of unmounting it. */
+    forceMount?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/alert-dialog/AlertDialogOverlay.vue.js

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

package/dist/alert-dialog/AlertDialogOverlay.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const a=require("./context.cjs");let e=require("vue");var o=["data-state"],l=(0,e.defineComponent)({__name:"AlertDialogOverlay",props:{forceMount:{type:Boolean,default:!1}},setup(r){const t=(0,e.inject)(a.ALERT_DIALOG_CONTEXT);if(!t)throw new Error("SkdxAlertDialogOverlay must be used within SkdxAlertDialog.");return(n,u)=>r.forceMount||(0,e.unref)(t).open.value?((0,e.openBlock)(),(0,e.createElementBlock)("div",{key:0,class:"skdx-alert-dialog__overlay","data-part":"overlay","data-state":(0,e.unref)(t).open.value?"open":"closed",style:{pointerEvents:"auto"}},null,8,o)):(0,e.createCommentVNode)("",!0)}});exports.default=l;

package/dist/alert-dialog/AlertDialogOverlay.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{ALERT_DIALOG_CONTEXT as e}from"./context.js";import{createCommentVNode as t,createElementBlock as a,defineComponent as o,inject as r,openBlock as l,unref as n}from"vue";var s=["data-state"],d=/* @__PURE__ */o({__name:"AlertDialogOverlay",props:{forceMount:{type:Boolean,default:!1}},setup(o){const d=r(e);if(!d)throw new Error("SkdxAlertDialogOverlay must be used within SkdxAlertDialog.");return(e,r)=>o.forceMount||n(d).open.value?(l(),a("div",{key:0,class:"skdx-alert-dialog__overlay","data-part":"overlay","data-state":n(d).open.value?"open":"closed",style:{pointerEvents:"auto"}},null,8,s)):t("",!0)}});export{d as default};

package/dist/alert-dialog/AlertDialogPortal.vue.cjs

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

package/dist/alert-dialog/AlertDialogPortal.vue.d.cts

@@ -0,0 +1,31 @@
+import type { PortalContainer } from '../utils/portal.cjs';
+/**
+ * Teleports `SkdxAlertDialogOverlay` and `SkdxAlertDialogContent` to
+ * `document.body` (or a custom `container`), so the alert dialog escapes any clipping/`overflow`
+ * ancestors. Mounts only while open unless `forceMount` is set. Must be
+ * used inside `SkdxAlertDialog`.
+ */
+type __VLS_Props = {
+    /**
+     * DOM node (or CSS selector) the children are rendered into.
+     * @default document.body
+     */
+    container?: PortalContainer;
+    /** Render the portal even while the alert dialog 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/alert-dialog/AlertDialogPortal.vue.d.ts

@@ -0,0 +1,31 @@
+import type { PortalContainer } from '../utils/portal.js';
+/**
+ * Teleports `SkdxAlertDialogOverlay` and `SkdxAlertDialogContent` to
+ * `document.body` (or a custom `container`), so the alert dialog escapes any clipping/`overflow`
+ * ancestors. Mounts only while open unless `forceMount` is set. Must be
+ * used inside `SkdxAlertDialog`.
+ */
+type __VLS_Props = {
+    /**
+     * DOM node (or CSS selector) the children are rendered into.
+     * @default document.body
+     */
+    container?: PortalContainer;
+    /** Render the portal even while the alert dialog 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/alert-dialog/AlertDialogPortal.vue.js

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

package/dist/alert-dialog/AlertDialogPortal.vue_vue_type_script_setup_true_lang.cjs

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

package/dist/alert-dialog/AlertDialogPortal.vue_vue_type_script_setup_true_lang.js

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

package/dist/alert-dialog/AlertDialogTitle.vue.cjs

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

package/dist/alert-dialog/AlertDialogTitle.vue.d.cts

@@ -0,0 +1,18 @@
+/**
+ * The alert dialog's accessible name: renders an `<h2>` wired to
+ * `SkdxAlertDialogContent` via `aria-labelledby`. Every alert dialog should
+ * include one. Must be used inside `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogTitle.vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The alert dialog's accessible name: renders an `<h2>` wired to
+ * `SkdxAlertDialogContent` via `aria-labelledby`. Every alert dialog should
+ * include one. Must be used inside `SkdxAlertDialog`.
+ */
+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/alert-dialog/AlertDialogTitle.vue.js

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

package/dist/alert-dialog/AlertDialogTitle.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const l=require("./context.cjs");let e=require("vue");var i=["id"],o=(0,e.defineComponent)({__name:"AlertDialogTitle",setup(_){const t=(0,e.inject)(l.ALERT_DIALOG_CONTEXT);if(!t)throw new Error("SkdxAlertDialogTitle must be used within SkdxAlertDialog.");return(r,a)=>((0,e.openBlock)(),(0,e.createElementBlock)("h2",{class:"skdx-alert-dialog__title","data-part":"title",id:(0,e.unref)(t).titleId},[(0,e.renderSlot)(r.$slots,"default")],8,i))}});exports.default=o;

package/dist/alert-dialog/AlertDialogTitle.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{ALERT_DIALOG_CONTEXT as t}from"./context.js";import{createElementBlock as e,defineComponent as a,inject as l,openBlock as r,renderSlot as o,unref as i}from"vue";var s=["id"],n=/* @__PURE__ */a({__name:"AlertDialogTitle",setup(a){const n=l(t);if(!n)throw new Error("SkdxAlertDialogTitle must be used within SkdxAlertDialog.");return(t,a)=>(r(),e("h2",{class:"skdx-alert-dialog__title","data-part":"title",id:i(n).titleId},[o(t.$slots,"default")],8,s))}});export{n as default};

package/dist/alert-dialog/AlertDialogTrigger.vue.cjs

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