@raxium/vue 0.1.0 → 0.1.1

package/dist/components/dialog/DialogContent.js

@@ -0,0 +1,112 @@
+import { Teleport, computed, createBlock, createCommentVNode, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, openBlock, renderSlot, unref, useAttrs, useSlots, withCtx } from "vue";
+import { Dialog } from "@ark-ui/vue/dialog";
+import { ark } from "@ark-ui/vue/factory";
+import { clsx, cn } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { hasChildVNodeByName } from "../../utils/vnode.js";
+import { X } from "lucide-vue-next";
+import { DialogBackdrop, DialogCloseTrigger } from "./index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    inheritAttrs: false,
+    __name: "DialogContent",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        ui: {},
+        showClose: {
+            type: Boolean,
+            default: true
+        },
+        theme: {}
+    },
+    setup (__props) {
+        const slots = useSlots();
+        const defaultSlots = computed(()=>slots.default?.());
+        const hasDialogHeader = computed(()=>hasChildVNodeByName(defaultSlots.value, "DialogHeader"));
+        const showContentClose = computed(()=>__props.showClose && !hasDialogHeader.value);
+        const attrs = useAttrs();
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvDialog());
+        return (_ctx, _cache)=>(openBlock(), createBlock(Teleport, {
+                to: "body"
+            }, [
+                createVNode(unref(DialogBackdrop), {
+                    class: normalizeClass(unref(clsx)(__props.ui?.backdrop)),
+                    theme: unref(theme)
+                }, null, 8, [
+                    "class",
+                    "theme"
+                ]),
+                createVNode(unref(Dialog).Positioner, {
+                    class: normalizeClass(crafts.value.positioner({
+                        class: unref(clsx)(__props.ui?.positioner),
+                        ...unref(theme)
+                    }))
+                }, {
+                    default: withCtx(()=>[
+                            createVNode(unref(Dialog).Content, mergeProps(unref(attrs), {
+                                class: crafts.value.content({
+                                    class: unref(clsx)(__props.ui?.content, __props.class),
+                                    ...unref(theme)
+                                })
+                            }), {
+                                default: withCtx(()=>[
+                                        renderSlot(_ctx.$slots, "default"),
+                                        renderSlot(_ctx.$slots, "close", {}, ()=>[
+                                                showContentClose.value ? (openBlock(), createBlock(unref(DialogCloseTrigger), {
+                                                    key: 0,
+                                                    "as-child": ""
+                                                }, {
+                                                    default: withCtx(()=>[
+                                                            createVNode(unref(ark).button, {
+                                                                class: normalizeClass(unref(cn)([
+                                                                    "absolute",
+                                                                    "top-0",
+                                                                    "right-0"
+                                                                ], crafts.value.close({
+                                                                    class: unref(clsx)(__props.ui?.close),
+                                                                    ...unref(theme)
+                                                                }))),
+                                                                "data-variant": "content-close"
+                                                            }, {
+                                                                default: withCtx(()=>[
+                                                                        createVNode(unref(X), {
+                                                                            style: {
+                                                                                width: "1lh",
+                                                                                height: "1lh"
+                                                                            }
+                                                                        }),
+                                                                        _cache[0] || (_cache[0] = createElementVNode("span", {
+                                                                            class: "sr-only"
+                                                                        }, "Close", -1))
+                                                                    ]),
+                                                                _: 1
+                                                            }, 8, [
+                                                                "class"
+                                                            ])
+                                                        ]),
+                                                    _: 1
+                                                })) : createCommentVNode("", true)
+                                            ])
+                                    ]),
+                                _: 3
+                            }, 16, [
+                                "class"
+                            ])
+                        ]),
+                    _: 3
+                }, 8, [
+                    "class"
+                ])
+            ]));
+    }
+});
+const DialogContent = _sfc_main;
+export default DialogContent;

package/dist/components/dialog/DialogContent.vue.d.ts

@@ -0,0 +1,16 @@
+import type { DialogContentProps } from '.';
+declare var __VLS_24: {}, __VLS_26: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_24) => any;
+} & {
+    close?: (props: typeof __VLS_26) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogContentProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogFooter.js

@@ -0,0 +1,101 @@
+import { computed, createBlock, createTextVNode, createVNode, defineComponent, mergeProps, normalizeClass, openBlock, renderSlot, toDisplayString, unref, useId, withCtx } from "vue";
+import { ark } from "@ark-ui/vue/factory";
+import { clsx } from "@raxium/themes/utils";
+import { Button } from "../button/index.js";
+import { useTheme } from "../../composables/useTheme.js";
+import { DialogCloseTrigger, TriggerFrom } from "./index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogFooter",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        ui: {},
+        widget: {},
+        theme: {}
+    },
+    emits: [
+        "ok",
+        "cancel"
+    ],
+    setup (__props, { emit: __emit }) {
+        const emits = __emit;
+        const id = useId();
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvDialog());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(ark).div, {
+                id: `dialog:${unref(id)}:footer`,
+                "data-scope": "dialog",
+                "data-part": "footer",
+                class: normalizeClass(crafts.value.footer({
+                    class: unref(clsx)(__props.ui?.root, __props.class),
+                    ...unref(theme)
+                }))
+            }, {
+                default: withCtx(()=>[
+                        renderSlot(_ctx.$slots, "default", {}, ()=>[
+                                createVNode(unref(DialogCloseTrigger), {
+                                    "as-child": "",
+                                    from: unref(TriggerFrom).CANCEL_BUTTON
+                                }, {
+                                    default: withCtx(()=>[
+                                            createVNode(unref(Button), mergeProps({
+                                                variant: "text"
+                                            }, __props.widget?.cancel, {
+                                                class: unref(clsx)(__props.ui?.cancel),
+                                                theme: unref(theme),
+                                                onClick: _cache[0] || (_cache[0] = ($event)=>emits("cancel", $event))
+                                            }), {
+                                                default: withCtx(()=>[
+                                                        createTextVNode(toDisplayString(__props.widget?.cancel?.text ?? "Cancel"), 1)
+                                                    ]),
+                                                _: 1
+                                            }, 16, [
+                                                "class",
+                                                "theme"
+                                            ])
+                                        ]),
+                                    _: 1
+                                }, 8, [
+                                    "from"
+                                ]),
+                                createVNode(unref(DialogCloseTrigger), {
+                                    "as-child": "",
+                                    from: unref(TriggerFrom).OK_BUTTON
+                                }, {
+                                    default: withCtx(()=>[
+                                            createVNode(unref(Button), mergeProps(__props.widget?.ok, {
+                                                class: unref(clsx)(__props.ui?.ok),
+                                                theme: unref(theme),
+                                                onClick: _cache[1] || (_cache[1] = ($event)=>emits("ok", $event))
+                                            }), {
+                                                default: withCtx(()=>[
+                                                        createTextVNode(toDisplayString(__props.widget?.ok?.text ?? "OK"), 1)
+                                                    ]),
+                                                _: 1
+                                            }, 16, [
+                                                "class",
+                                                "theme"
+                                            ])
+                                        ]),
+                                    _: 1
+                                }, 8, [
+                                    "from"
+                                ])
+                            ])
+                    ]),
+                _: 3
+            }, 8, [
+                "id",
+                "class"
+            ]));
+    }
+});
+const DialogFooter = _sfc_main;
+export default DialogFooter;

package/dist/components/dialog/DialogFooter.vue.d.ts

@@ -0,0 +1,20 @@
+import type { DialogFooterProps } from '.';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogFooterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: (event: MouseEvent) => any;
+    ok: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<DialogFooterProps> & Readonly<{
+    onCancel?: ((event: MouseEvent) => any) | undefined;
+    onOk?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogHeader.js

@@ -0,0 +1,87 @@
+import { computed, createBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, unref, useId, withCtx } from "vue";
+import { Dialog } from "@ark-ui/vue/dialog";
+import { ark } from "@ark-ui/vue/factory";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { X } from "lucide-vue-next";
+import { DialogCloseTrigger } from "./index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogHeader",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        ui: {},
+        theme: {}
+    },
+    setup (__props) {
+        const id = useId();
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvDialog());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(ark).div, {
+                id: `dialog:${unref(id)}:header`,
+                "data-scope": "dialog",
+                "data-part": "header",
+                class: normalizeClass(crafts.value.header({
+                    class: unref(clsx)(__props.ui?.root, __props.class),
+                    ...unref(theme)
+                }))
+            }, {
+                default: withCtx(()=>[
+                        createVNode(unref(Dialog).Title, {
+                            class: normalizeClass(crafts.value.title({
+                                class: unref(clsx)(__props.ui?.title),
+                                ...unref(theme)
+                            }))
+                        }, {
+                            default: withCtx(()=>[
+                                    renderSlot(_ctx.$slots, "default")
+                                ]),
+                            _: 3
+                        }, 8, [
+                            "class"
+                        ]),
+                        createVNode(unref(DialogCloseTrigger), {
+                            "as-child": ""
+                        }, {
+                            default: withCtx(()=>[
+                                    createVNode(unref(ark).button, {
+                                        class: normalizeClass(crafts.value.close({
+                                            class: unref(clsx)(__props.ui?.close),
+                                            ...unref(theme)
+                                        }))
+                                    }, {
+                                        default: withCtx(()=>[
+                                                createVNode(unref(X), {
+                                                    style: {
+                                                        width: "1lh",
+                                                        height: "1lh"
+                                                    }
+                                                }),
+                                                _cache[0] || (_cache[0] = createElementVNode("span", {
+                                                    class: "sr-only"
+                                                }, "Close", -1))
+                                            ]),
+                                        _: 1
+                                    }, 8, [
+                                        "class"
+                                    ])
+                                ]),
+                            _: 1
+                        })
+                    ]),
+                _: 3
+            }, 8, [
+                "id",
+                "class"
+            ]));
+    }
+});
+const DialogHeader = _sfc_main;
+export default DialogHeader;

package/dist/components/dialog/DialogHeader.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DialogHeaderProps } from '.';
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogHeaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogInterceptProvider.js

@@ -0,0 +1,15 @@
+import { computed, defineComponent, renderSlot } from "vue";
+import { provideDialogInterceptContext } from "./dialog-intercept-context.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogInterceptProvider",
+    props: {
+        value: {}
+    },
+    setup (__props) {
+        const props = __props;
+        provideDialogInterceptContext(computed(()=>props.value));
+        return (_ctx, _cache)=>renderSlot(_ctx.$slots, "default");
+    }
+});
+const DialogInterceptProvider = _sfc_main;
+export default DialogInterceptProvider;

package/dist/components/dialog/DialogInterceptProvider.vue.d.ts

@@ -0,0 +1,17 @@
+import type { DialogInterceptContext } from './dialog-intercept-context';
+type __VLS_Props = {
+    value: DialogInterceptContext;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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 __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogTrigger.js

@@ -0,0 +1,47 @@
+import { computed, createBlock, createPropsRestProxy, defineComponent, mergeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+import { useForwardExpose, useForwardProps } from "@ark-ui/vue";
+import { useDialogContext } from "@ark-ui/vue/dialog";
+import { ark } from "@ark-ui/vue/factory";
+import { TriggerFrom, injectDialogInterceptContext } from "./dialog-intercept-context.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogTrigger",
+    props: {
+        from: {
+            default: ()=>TriggerFrom.OPEN_TRIGGER
+        },
+        asChild: {
+            type: Boolean
+        }
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "from",
+            "asChild"
+        ]);
+        const forwarded = useForwardProps(props);
+        const context = useDialogContext();
+        const interceptContext = injectDialogInterceptContext();
+        const triggerProps = computed(()=>{
+            const contextProps = context.value.getTriggerProps();
+            return Object.assign({}, contextProps, forwarded.value, {
+                onClick: (e)=>{
+                    interceptContext.value.triggerFrom.value = __props.from;
+                    contextProps.onClick?.(e);
+                }
+            });
+        });
+        useForwardExpose();
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(ark).button, mergeProps(triggerProps.value, {
+                "as-child": __props.asChild
+            }), {
+                default: withCtx(()=>[
+                        renderSlot(_ctx.$slots, "default")
+                    ]),
+                _: 3
+            }, 16, [
+                "as-child"
+            ]));
+    }
+});
+const DialogTrigger = _sfc_main;
+export default DialogTrigger;

package/dist/components/dialog/DialogTrigger.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DialogTriggerProps } from '.';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/dialog-functional.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 函数式唤起Dialog
+ */
+import type { UseDialogContext } from '@ark-ui/vue/dialog';
+import type { ThemeProps } from '../../providers/theme';
+import type { ComponentProps } from 'vue-component-type-helpers';
+import type { DialogTriggerFrom, OpenChangeDetails } from './dialog-intercept-context';
+import { DialogBody, DialogContent, DialogFooter, DialogHeader } from '.';
+type OpenChangeDetailsWithFrom = OpenChangeDetails & {
+    from: DialogTriggerFrom;
+};
+interface DialogOptions extends ThemeProps {
+    title?: string | ((context: UseDialogContext) => any);
+    content?: string | ((context: UseDialogContext) => any);
+    footer?: boolean | ((context: UseDialogContext) => any);
+    render?: (context: UseDialogContext) => any;
+    widget?: {
+        header?: ComponentProps<typeof DialogHeader>;
+        content?: ComponentProps<typeof DialogContent>;
+        body?: ComponentProps<typeof DialogBody>;
+        footer?: ComponentProps<typeof DialogFooter>;
+    };
+    onOpenChange?: (details: OpenChangeDetailsWithFrom) => void;
+    onAfterClose?: (details: OpenChangeDetailsWithFrom) => void;
+    onOk?: (event: MouseEvent) => void;
+    onCancel?: (event: MouseEvent) => void;
+}
+export declare function dialog(options: DialogOptions): {
+    close: () => void;
+};
+export {};

package/dist/components/dialog/dialog-functional.js

@@ -0,0 +1,81 @@
+import { createApp, createVNode, defineComponent, isVNode, mergeProps, reactive, ref } from "vue";
+import { Dialog, DialogBody, DialogContent, DialogFooter, DialogHeader } from "./index.js";
+function _isSlot(s) {
+    return 'function' == typeof s || '[object Object]' === Object.prototype.toString.call(s) && !isVNode(s);
+}
+function dialog(options) {
+    const { title, content, footer = true, render, widget, onOk, onCancel, onOpenChange, onAfterClose } = reactive(options);
+    const open = ref(false);
+    const DialogComponent = defineComponent({
+        name: 'Dialog',
+        props: {
+            onAfterClose: {
+                type: Function,
+                default: ()=>{}
+            }
+        },
+        setup (props) {
+            const openChangeDetail = ref();
+            return ()=>createVNode(Dialog, {
+                    open: open.value,
+                    "onUpdate:open": ($event)=>open.value = $event,
+                    "lazy-mount": true,
+                    "unmount-on-exit": true,
+                    onOpenChange: (details)=>{
+                        openChangeDetail.value = details;
+                        onOpenChange?.(details);
+                    },
+                    onExitComplete: ()=>{
+                        const details = openChangeDetail.value ?? {
+                            open: false,
+                            from: void 0
+                        };
+                        props.onAfterClose?.(details);
+                        onAfterClose?.(details);
+                    }
+                }, {
+                    default: (context)=>{
+                        if (render) {
+                            let _slot;
+                            return createVNode(DialogContent, widget?.content, _isSlot(_slot = render(context)) ? _slot : {
+                                default: ()=>[
+                                        _slot
+                                    ]
+                            });
+                        }
+                        return createVNode(DialogContent, widget?.content, {
+                            default: ()=>[
+                                    title && createVNode(DialogHeader, widget?.header, {
+                                        default: ()=>'function' == typeof title ? title(context) : title
+                                    }),
+                                    content && createVNode(DialogBody, widget?.body, {
+                                        default: ()=>'function' == typeof content ? content(context) : content
+                                    }),
+                                    footer && createVNode(DialogFooter, mergeProps(widget?.footer, {
+                                        onOk: onOk,
+                                        onCancel: onCancel
+                                    }), {
+                                        default: ()=>'function' == typeof footer ? footer(context) : null
+                                    })
+                                ]
+                        });
+                    }
+                });
+        }
+    });
+    let dialogRootEl = document.createElement('div');
+    const dialogVueInstance = createApp(DialogComponent, {
+        onAfterClose: ()=>{
+            dialogRootEl = null;
+            dialogVueInstance.unmount();
+        }
+    });
+    dialogVueInstance.mount(dialogRootEl);
+    open.value = true;
+    return {
+        close: ()=>{
+            open.value = false;
+        }
+    };
+}
+export { dialog };

package/dist/components/dialog/dialog-intercept-context.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef, Ref } from 'vue';
+export interface OpenChangeDetails {
+    open: boolean;
+}
+export type FocusOutsideEvent = CustomEvent<EventDetails<FocusEvent>>;
+export type InteractOutsideEvent = CustomEvent<EventDetails<FocusEvent>>;
+export type PointerDownOutsideEvent = CustomEvent<EventDetails<PointerEvent>>;
+export type RequestDismissEvent = CustomEvent<LayerDismissEventDetail>;
+export declare enum TriggerFrom {
+    ESCAPE = "escape",
+    OPEN_TRIGGER = "open_trigger",
+    CLOSE_TRIGGER = "close_trigger",
+    CANCEL_BUTTON = "cancel_button",
+    OK_BUTTON = "ok_button",
+    OUTSIDE = "outside"
+}
+export type DialogTriggerFrom = TriggerFrom | string | null | undefined;
+export interface DialogInterceptContext {
+    triggerFrom: Ref<DialogTriggerFrom>;
+}
+export declare const provideDialogInterceptContext: (opts: ComputedRef<DialogInterceptContext>) => void, injectDialogInterceptContext: (fallback?: ComputedRef<DialogInterceptContext> | undefined) => ComputedRef<DialogInterceptContext>;

package/dist/components/dialog/dialog-intercept-context.js

@@ -0,0 +1,12 @@
+import { createContext } from "@ark-ui/vue";
+var dialog_intercept_context_TriggerFrom = /*#__PURE__*/ function(TriggerFrom) {
+    TriggerFrom["ESCAPE"] = "escape";
+    TriggerFrom["OPEN_TRIGGER"] = "open_trigger";
+    TriggerFrom["CLOSE_TRIGGER"] = "close_trigger";
+    TriggerFrom["CANCEL_BUTTON"] = "cancel_button";
+    TriggerFrom["OK_BUTTON"] = "ok_button";
+    TriggerFrom["OUTSIDE"] = "outside";
+    return TriggerFrom;
+}({});
+const [provideDialogInterceptContext, injectDialogInterceptContext] = createContext('DialogInterceptContext');
+export { dialog_intercept_context_TriggerFrom as TriggerFrom, injectDialogInterceptContext, provideDialogInterceptContext };

package/dist/components/dialog/index.d.ts

@@ -0,0 +1,12 @@
+export { dialog } from './dialog-functional';
+export { TriggerFrom } from './dialog-intercept-context';
+export { default as Dialog } from './Dialog.vue';
+export { default as DialogBackdrop } from './DialogBackdrop.vue';
+export { default as DialogBody } from './DialogBody.vue';
+export { default as DialogCloseTrigger } from './DialogCloseTrigger.vue';
+export { default as DialogContent } from './DialogContent.vue';
+export { default as DialogFooter } from './DialogFooter.vue';
+export { default as DialogHeader } from './DialogHeader.vue';
+export { default as DialogTrigger } from './DialogTrigger.vue';
+export * from './props';
+export { DialogContext } from '@ark-ui/vue/dialog';

package/dist/components/dialog/index.js

@@ -0,0 +1,12 @@
+export * from "./props.js";
+export { dialog } from "./dialog-functional.js";
+export { TriggerFrom } from "./dialog-intercept-context.js";
+export { default as Dialog } from "./Dialog.js";
+export { default as DialogBackdrop } from "./DialogBackdrop.js";
+export { default as DialogBody } from "./DialogBody.js";
+export { default as DialogCloseTrigger } from "./DialogCloseTrigger.js";
+export { default as DialogContent } from "./DialogContent.js";
+export { default as DialogFooter } from "./DialogFooter.js";
+export { default as DialogHeader } from "./DialogHeader.js";
+export { default as DialogTrigger } from "./DialogTrigger.js";
+export { DialogContext } from "@ark-ui/vue/dialog";