@bridge-ui/vue 0.0.0

package/dist/Actions/BridgeUIHosts.js

@@ -0,0 +1,5 @@
+import e from "./BridgeUIHosts.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/BridgeUIHosts.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/BridgeUIHosts.vue.d.ts

@@ -0,0 +1,18 @@
+import { BridgeUIHostsProps } from './bridgeUIHosts.types';
+declare var __VLS_20: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_20) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BridgeUIHostsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BridgeUIHostsProps> & Readonly<{}>, {
+    dialog: import('./Dialog').BridgeDialogHostProps;
+    modal: import('./Modal').BridgeModalHostProps;
+    snackbar: import('./Snackbar').BridgeSnackbarHostProps;
+}, {}, {}, {}, 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/Actions/BridgeUIHosts.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,27 @@
+import e from "./Dialog/BridgeDialogHost.js";
+import t from "./Modal/BridgeModalHost.js";
+import n from "./Snackbar/BridgeSnackbarHost.js";
+import { createBlock as r, createVNode as i, defineComponent as a, guardReactiveProps as o, normalizeProps as s, openBlock as c, renderSlot as l, unref as u, withCtx as d } from "vue";
+//#region src/Actions/BridgeUIHosts.vue?vue&type=script&setup=true&lang.ts
+var f = /* @__PURE__ */ a({
+	__name: "BridgeUIHosts",
+	props: {
+		dialog: { default: () => ({}) },
+		modal: { default: () => ({}) },
+		snackbar: { default: () => ({}) }
+	},
+	setup(a) {
+		return (f, p) => (c(), r(u(t), s(o(a.modal)), {
+			default: d(() => [i(u(e), s(o(a.dialog)), {
+				default: d(() => [i(u(n), s(o(a.snackbar)), {
+					default: d(() => [l(f.$slots, "default")]),
+					_: 3
+				}, 16)]),
+				_: 3
+			}, 16)]),
+			_: 3
+		}, 16));
+	}
+});
+//#endregion
+export { f as default };

package/dist/Actions/Dialog/BridgeDialogAction.js

@@ -0,0 +1,5 @@
+import e from "./BridgeDialogAction.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/Dialog/BridgeDialogAction.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/Dialog/BridgeDialogAction.vue.d.ts

@@ -0,0 +1,8 @@
+import { BridgeDialogActionProps } from './bridgeDialog.types';
+declare const __VLS_export: import('vue').DefineComponent<BridgeDialogActionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    run: () => any;
+}, string, import('vue').PublicProps, Readonly<BridgeDialogActionProps> & Readonly<{
+    onRun?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Actions/Dialog/BridgeDialogAction.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,62 @@
+import e from "../../Components/Button/Button.js";
+import t from "../../Components/Link/Link.js";
+import { computed as n, createBlock as r, createTextVNode as i, defineComponent as a, mergeProps as o, openBlock as s, toDisplayString as c, unref as l, withCtx as u } from "vue";
+import { cn as d } from "@bridge-ui/core";
+//#region src/Actions/Dialog/BridgeDialogAction.vue?vue&type=script&setup=true&lang.ts
+var f = /* @__PURE__ */ a({
+	__name: "BridgeDialogAction",
+	props: {
+		acceptColor: {},
+		action: {},
+		role: {}
+	},
+	emits: ["run"],
+	setup(a, { emit: f }) {
+		let p = a, m = f, h = n(() => p.role === "accept" ? p.acceptColor : "secondary"), g = n(() => h.value), _ = n(() => {
+			if (!p.action.link) return {};
+			let { onClick: e, ...t } = p.action.link;
+			return t;
+		});
+		function v() {
+			m("run");
+		}
+		function y(e) {
+			e.preventDefault(), p.action.link?.onClick?.(e), v();
+		}
+		return (n, f) => a.action.link ? (s(), r(l(t), o({
+			key: 0,
+			size: "sm",
+			underline: "hover",
+			color: g.value
+		}, _.value, {
+			onClick: y,
+			classes: {
+				...a.action.link.classes,
+				root: l(d)(a.action.className, a.action.link.classes?.root)
+			}
+		}), {
+			default: u(() => [i(c(a.action.label), 1)]),
+			_: 1
+		}, 16, ["color", "classes"])) : (s(), r(l(e), o({
+			key: 1,
+			size: "sm",
+			onClick: v,
+			color: h.value
+		}, a.action.button, {
+			variant: a.action.solid ? "outline" : "flat",
+			classes: {
+				...a.action.button?.classes,
+				root: l(d)(a.action.className, a.action.button?.classes?.root)
+			}
+		}), {
+			default: u(() => [i(c(a.action.label), 1)]),
+			_: 1
+		}, 16, [
+			"color",
+			"variant",
+			"classes"
+		]));
+	}
+});
+//#endregion
+export { f as default };

package/dist/Actions/Dialog/BridgeDialogHost.js

@@ -0,0 +1,5 @@
+import e from "./BridgeDialogHost.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/Dialog/BridgeDialogHost.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/Dialog/BridgeDialogHost.vue.d.ts

@@ -0,0 +1,14 @@
+import { BridgeDialogHostProps } from './bridgeDialog.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BridgeDialogHostProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BridgeDialogHostProps> & 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/Actions/Dialog/BridgeDialogHost.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,26 @@
+import { BRIDGE_DIALOG_INJECTION_KEY as e } from "./bridgeDialogInjectionKey.js";
+import t from "./BridgeDialogItem.js";
+import { createBridgeDialogApi as n } from "./createBridgeDialogApi.js";
+import { Fragment as r, computed as i, createBlock as a, createElementBlock as o, defineComponent as s, inject as c, openBlock as l, provide as u, renderList as d, renderSlot as f, unref as p } from "vue";
+//#region src/Actions/Dialog/BridgeDialogHost.vue?vue&type=script&setup=true&lang.ts
+var m = "[Bridge UI] Nested <BridgeDialogHost /> detected. useDialogAction() will target the nearest host only. Remove the extra host.", h = /* @__PURE__ */ s({
+	__name: "BridgeDialogHost",
+	props: { modal: {} },
+	setup(s) {
+		let h = s;
+		c(e, null) && process.env.NODE_ENV !== "production" && console.warn(m);
+		let g = n(), _ = i(() => g.entries.value);
+		return u(e, g), (e, n) => (l(), o(r, null, [f(e.$slots, "default"), (l(!0), o(r, null, d(_.value, (e) => (l(), a(t, {
+			api: p(g),
+			entry: e,
+			key: e.id,
+			"host-modal": h.modal
+		}, null, 8, [
+			"api",
+			"entry",
+			"host-modal"
+		]))), 128))], 64));
+	}
+});
+//#endregion
+export { h as default };

package/dist/Actions/Dialog/BridgeDialogItem.js

@@ -0,0 +1,5 @@
+import e from "./BridgeDialogItem.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/Dialog/BridgeDialogItem.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/Dialog/BridgeDialogItem.vue.d.ts

@@ -0,0 +1,4 @@
+import { BridgeDialogItemProps } from './bridgeDialog.types';
+declare const __VLS_export: import('vue').DefineComponent<BridgeDialogItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BridgeDialogItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Actions/Dialog/BridgeDialogItem.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,47 @@
+import e from "../../Components/Card/Card.js";
+import t from "../../Components/Modal/Modal.js";
+import n from "./ResolveBridgeDialogFooter.js";
+import { computed as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createSlots as s, createVNode as c, defineComponent as l, mergeProps as u, openBlock as d, toDisplayString as f, unref as p, withCtx as m } from "vue";
+import { completeLayerHide as h, invokeLayerDismiss as g, mergeLayerShellProps as _ } from "@bridge-ui/core";
+//#region src/Actions/Dialog/BridgeDialogItem.vue?vue&type=script&setup=true&lang.ts
+var v = {
+	key: 0,
+	class: "text-sm text-dark-500 dark:text-dark-400"
+}, y = /* @__PURE__ */ l({
+	__name: "BridgeDialogItem",
+	props: {
+		api: {},
+		entry: {},
+		hostModal: {}
+	},
+	setup(l) {
+		let y = l, b = r(() => y.entry.props.color ?? "primary"), x = r(() => _(y.hostModal, y.entry.modal)), S = () => {
+			g(y.api.entries.value, y.entry.id);
+		}, C = () => {
+			y.api.close(y.entry.id);
+		};
+		return (r, g) => (d(), i(p(t), u(x.value, {
+			"stack-id": l.entry.id,
+			"model-value": l.entry.show,
+			onClose: S,
+			"onUpdate:modelValue": g[0] ||= (e) => l.api.syncShow(l.entry.id, e),
+			onShowChange: g[1] ||= (e) => p(h)(l.api.entries.value, l.entry.id, e, l.api.removeEntry)
+		}), {
+			default: m(() => [c(p(e), u({ title: l.entry.props.title }, l.entry.props.card), s({
+				default: m(() => [l.entry.props.description ? (d(), o("p", v, f(l.entry.props.description), 1)) : a("", !0)]),
+				_: 2
+			}, [l.entry.props.actions?.accept || l.entry.props.actions?.reject ? {
+				name: "footer",
+				fn: m(() => [c(n, {
+					"accept-color": b.value,
+					dismiss: C,
+					actions: l.entry.props.actions
+				}, null, 8, ["accept-color", "actions"])]),
+				key: "0"
+			} : void 0]), 1040, ["title"])]),
+			_: 1
+		}, 16, ["stack-id", "model-value"]));
+	}
+});
+//#endregion
+export { y as default };

package/dist/Actions/Dialog/ResolveBridgeDialogFooter.js

@@ -0,0 +1,5 @@
+import e from "./ResolveBridgeDialogFooter.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/Dialog/ResolveBridgeDialogFooter.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/Dialog/ResolveBridgeDialogFooter.vue.d.ts

@@ -0,0 +1,4 @@
+import { ResolveBridgeDialogFooterOptions } from './bridgeDialog.types';
+declare const __VLS_export: import('vue').DefineComponent<ResolveBridgeDialogFooterOptions, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ResolveBridgeDialogFooterOptions> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Actions/Dialog/ResolveBridgeDialogFooter.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,35 @@
+import e from "./BridgeDialogAction.js";
+import { createBlock as t, createCommentVNode as n, createElementBlock as r, defineComponent as i, openBlock as a } from "vue";
+//#region src/Actions/Dialog/ResolveBridgeDialogFooter.vue?vue&type=script&setup=true&lang.ts
+var o = {
+	key: 0,
+	class: "flex justify-end gap-2"
+}, s = /* @__PURE__ */ i({
+	__name: "ResolveBridgeDialogFooter",
+	props: {
+		acceptColor: {},
+		actions: {},
+		dismiss: { type: Function }
+	},
+	setup(i) {
+		let s = i;
+		function c(e) {
+			e?.(), s.dismiss();
+		}
+		return (i, l) => s.actions?.accept || s.actions?.reject ? (a(), r("div", o, [s.actions?.reject?.label ? (a(), t(e, {
+			key: 0,
+			role: "reject",
+			action: s.actions.reject,
+			"accept-color": s.acceptColor,
+			onRun: l[0] ||= () => c(s.actions?.reject?.onClick)
+		}, null, 8, ["action", "accept-color"])) : n("", !0), s.actions?.accept?.label ? (a(), t(e, {
+			key: 1,
+			role: "accept",
+			action: s.actions.accept,
+			"accept-color": s.acceptColor,
+			onRun: l[1] ||= () => c(s.actions?.accept?.onClick)
+		}, null, 8, ["action", "accept-color"])) : n("", !0)])) : n("", !0);
+	}
+});
+//#endregion
+export { s as default };

package/dist/Actions/Dialog/bridgeDialog.types.d.ts

@@ -0,0 +1,128 @@
+import { ButtonColor, LayerId } from '@bridge-ui/core';
+import { Ref } from 'vue';
+import { ButtonOwnProps } from '../../Components/Button/button.types';
+import { CardOwnProps } from '../../Components/Card/card.types';
+import { LinkProps } from '../../Components/Link/link.types';
+import { ModalOwnProps } from '../../Components/Modal/modal.types';
+export interface DialogAction {
+    /**
+     * Props merged into the default `Button` (ignored when `link` is set).
+     */
+    button?: Partial<Omit<ButtonOwnProps, "children">>;
+    /**
+     * Extra Tailwind classes merged into the action root (`classes.root`).
+     */
+    className?: string;
+    /**
+     * Footer button or link label.
+     */
+    label: string;
+    /**
+     * When set, renders a `Link` instead of a `Button`.
+     */
+    link?: Partial<Omit<LinkProps, "children">>;
+    /**
+     * Called when the action is activated, before the dialog dismisses.
+     */
+    onClick?: () => void;
+    /**
+     * When `true`, renders the button with the `outline` variant instead of `flat`.
+     */
+    solid?: boolean;
+}
+export interface DialogActions {
+    /**
+     * Primary footer action (e.g. Confirm, Save). Uses the dialog `color` by default.
+     */
+    accept?: DialogAction;
+    /**
+     * Secondary footer action (e.g. Cancel, Dismiss). Uses `secondary` by default.
+     */
+    reject?: DialogAction;
+}
+export type ResolveBridgeDialogFooterOptions = {
+    acceptColor: keyof ButtonColor;
+    actions?: DialogActions;
+    dismiss: () => void;
+};
+export type BridgeDialogActionProps = {
+    /**
+     * Color for the accept action. Reject always uses `secondary`.
+     */
+    acceptColor: keyof ButtonColor;
+    /**
+     * Footer action configuration (label, button/link, handlers).
+     */
+    action: DialogAction;
+    /**
+     * Whether this control renders the primary or secondary footer action.
+     */
+    role: "accept" | "reject";
+};
+export type BridgeDialogHostProps = {
+    /**
+     * Default Modal shell options merged into every dialog opened via `useDialogAction()`.
+     * Per-call `open({ modal })` overrides these.
+     */
+    modal?: BridgeDialogShellProps;
+};
+export type BridgeDialogItemProps = {
+    api: BridgeDialogController;
+    entry: BridgeDialogEntry;
+    hostModal?: BridgeDialogShellProps;
+};
+export type BridgeDialogShellProps = Partial<Omit<ModalOwnProps, "stackId">>;
+export type BridgeDialogContentProps = {
+    /**
+     * Footer actions (accept = primary, reject = secondary by default).
+     */
+    actions?: DialogActions;
+    /**
+     * Extra Card shell options (padding, variant, classes, etc.).
+     */
+    card?: Partial<Omit<CardOwnProps, "slots" | "title" | "children">>;
+    /**
+     * Color for the accept action button.
+     *
+     * @default "primary"
+     */
+    color?: keyof ButtonColor;
+    /**
+     * Optional body text below the title.
+     */
+    description?: string;
+    /**
+     * Dialog title (rendered in the Card header).
+     */
+    title: string;
+};
+export type BridgeDialogEntry = {
+    id: LayerId;
+    modal?: Partial<ModalOwnProps>;
+    onClose?: () => void;
+    onClosed?: () => void;
+    props: BridgeDialogContentProps;
+    show: boolean;
+};
+export type BridgeDialogOpenOptions = BridgeDialogContentProps & {
+    modal?: BridgeDialogShellProps;
+    onClose?: () => void;
+    onClosed?: () => void;
+};
+export type BridgeDialogUpdateOptions = {
+    modal?: Partial<ModalOwnProps>;
+    props?: Partial<BridgeDialogContentProps>;
+};
+export type BridgeDialogController = {
+    close: (id: LayerId) => void;
+    closeTop: () => void;
+    entries: Ref<BridgeDialogEntry[]>;
+    isOpen: (id: LayerId) => boolean;
+    open: (options: BridgeDialogOpenOptions) => LayerId;
+    removeEntry: (id: LayerId) => void;
+    syncShow: (id: LayerId, show: boolean) => void;
+    update: (id: LayerId, options: BridgeDialogUpdateOptions) => void;
+};
+export type BridgeDialogApi = Omit<BridgeDialogController, "entries" | "syncShow" | "removeEntry"> & {
+    stackSize: number;
+};

package/dist/Actions/Dialog/bridgeDialogInjectionKey.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { BridgeDialogController } from './bridgeDialog.types';
+export declare const BRIDGE_DIALOG_INJECTION_KEY: InjectionKey<BridgeDialogController>;

package/dist/Actions/Dialog/bridgeDialogInjectionKey.js

@@ -0,0 +1,4 @@
+//#region src/Actions/Dialog/bridgeDialogInjectionKey.ts
+var e = Symbol("bridge-dialog");
+//#endregion
+export { e as BRIDGE_DIALOG_INJECTION_KEY };

package/dist/Actions/Dialog/createBridgeDialogApi.d.ts

@@ -0,0 +1,2 @@
+import { BridgeDialogController } from './bridgeDialog.types';
+export declare function createBridgeDialogApi(): BridgeDialogController;

package/dist/Actions/Dialog/createBridgeDialogApi.js

@@ -0,0 +1,49 @@
+import { shallowRef as e } from "vue";
+import { closeLayer as t, closeTopLayer as n, createLayerId as r, createOpenLayerEntry as i, isLayerMounted as a, removeLayer as o, syncLayerShow as s, updateLayerMerged as c } from "@bridge-ui/core";
+//#region src/Actions/Dialog/createBridgeDialogApi.ts
+function l(e, t) {
+	let { modal: n, onClose: r, onClosed: a, ...o } = t;
+	return i(e, {
+		modal: n,
+		props: o,
+		onClose: r,
+		onClosed: a
+	});
+}
+function u() {
+	let i = e([]);
+	function u(e) {
+		let t = r();
+		return i.value = [...i.value, l(t, e)], t;
+	}
+	function d(e) {
+		i.value = t(i.value, e);
+	}
+	function f() {
+		i.value = n(i.value);
+	}
+	function p(e) {
+		return a(i.value, e);
+	}
+	function m(e) {
+		i.value = o(i.value, e);
+	}
+	function h(e, t) {
+		i.value = c(i.value, e, t, ["props", "modal"]);
+	}
+	function g(e, t) {
+		i.value = s(i.value, e, t);
+	}
+	return {
+		open: u,
+		close: d,
+		isOpen: p,
+		update: h,
+		entries: i,
+		closeTop: f,
+		syncShow: g,
+		removeEntry: m
+	};
+}
+//#endregion
+export { u as createBridgeDialogApi };

package/dist/Actions/Dialog/index.d.ts

@@ -0,0 +1,3 @@
+export type { BridgeDialogActionProps, BridgeDialogApi, BridgeDialogContentProps, BridgeDialogEntry, BridgeDialogHostProps, BridgeDialogItemProps, BridgeDialogOpenOptions, BridgeDialogShellProps, BridgeDialogUpdateOptions, DialogAction, DialogActions, } from './bridgeDialog.types';
+export { default as BridgeDialogHost } from './BridgeDialogHost.vue';
+export { BridgeDialogHostMissingError, useDialogAction, } from './useDialogAction';

package/dist/Actions/Dialog/index.js

@@ -0,0 +1,3 @@
+import e from "./BridgeDialogHost.js";
+import { BridgeDialogHostMissingError as t, useDialogAction as n } from "./useDialogAction.js";
+export { e as BridgeDialogHost, t as BridgeDialogHostMissingError, n as useDialogAction };

package/dist/Actions/Dialog/useDialogAction.d.ts

@@ -0,0 +1,5 @@
+import { BridgeDialogApi } from './bridgeDialog.types';
+export declare class BridgeDialogHostMissingError extends Error {
+    constructor();
+}
+export declare function useDialogAction(): BridgeDialogApi;

package/dist/Actions/Dialog/useDialogAction.js

@@ -0,0 +1,26 @@
+import { BRIDGE_DIALOG_INJECTION_KEY as e } from "./bridgeDialogInjectionKey.js";
+import { computed as t, inject as n } from "vue";
+import { getLayerCount as r } from "@bridge-ui/core";
+//#region src/Actions/Dialog/useDialogAction.ts
+var i = class extends Error {
+	constructor() {
+		super("useDialogAction() requires <BridgeDialogHost /> in the app tree."), this.name = "BridgeDialogHostMissingError";
+	}
+};
+function a() {
+	let a = n(e, null);
+	if (!a) throw new i();
+	let o = t(() => r(a.entries.value));
+	return {
+		open: a.open,
+		close: a.close,
+		isOpen: a.isOpen,
+		update: a.update,
+		closeTop: a.closeTop,
+		get stackSize() {
+			return o.value;
+		}
+	};
+}
+//#endregion
+export { i as BridgeDialogHostMissingError, a as useDialogAction };

package/dist/Actions/Modal/BridgeModalHost.js

@@ -0,0 +1,5 @@
+import e from "./BridgeModalHost.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/Modal/BridgeModalHost.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/Modal/BridgeModalHost.vue.d.ts

@@ -0,0 +1,14 @@
+import { BridgeModalHostProps } from './bridgeModal.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BridgeModalHostProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BridgeModalHostProps> & 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/Actions/Modal/BridgeModalHost.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,35 @@
+import e from "../../Components/Modal/Modal.js";
+import { BRIDGE_MODAL_INJECTION_KEY as t } from "./bridgeModalInjectionKey.js";
+import { createBridgeModalApi as n } from "./createBridgeModalApi.js";
+import { Fragment as r, computed as i, createBlock as a, createElementBlock as o, defineComponent as s, inject as c, mergeProps as l, openBlock as u, provide as d, renderList as f, renderSlot as p, resolveDynamicComponent as m, unref as h, withCtx as g } from "vue";
+import { completeLayerHide as _, invokeLayerDismiss as v, mergeLayerShellProps as y } from "@bridge-ui/core";
+//#region src/Actions/Modal/BridgeModalHost.vue?vue&type=script&setup=true&lang.ts
+var b = "[Bridge UI] Nested <BridgeModalHost /> detected. useModalAction() will target the nearest host only. Remove the extra host.", x = /* @__PURE__ */ s({
+	__name: "BridgeModalHost",
+	props: { modal: {} },
+	setup(s) {
+		let x = s;
+		c(t, null) && process.env.NODE_ENV !== "production" && console.warn(b);
+		let S = n(), C = i(() => S.entries.value);
+		return d(t, S), (t, n) => (u(), o(r, null, [p(t.$slots, "default"), (u(!0), o(r, null, f(C.value, (t) => (u(), a(h(e), l({
+			key: t.id,
+			"stack-id": t.id,
+			"model-value": t.show
+		}, { ref_for: !0 }, h(y)(x.modal, t.modal), {
+			"onUpdate:modelValue": (e) => h(S).syncShow(t.id, e),
+			onClose: (e) => h(v)(h(S).entries.value, t.id),
+			onShowChange: (e) => h(_)(h(S).entries.value, t.id, e, h(S).removeEntry)
+		}), {
+			default: g(() => [(u(), a(m(t.component), l({ ref_for: !0 }, t.props), null, 16))]),
+			_: 2
+		}, 1040, [
+			"stack-id",
+			"model-value",
+			"onUpdate:modelValue",
+			"onClose",
+			"onShowChange"
+		]))), 128))], 64));
+	}
+});
+//#endregion
+export { x as default };

package/dist/Actions/Modal/bridgeModal.types.d.ts

@@ -0,0 +1,44 @@
+import { LayerId } from '@bridge-ui/core';
+import { Component, Ref } from 'vue';
+import { ModalOwnProps } from '../../Components/Modal/modal.types';
+export type BridgeModalShellProps = Partial<Omit<ModalOwnProps, "stackId">>;
+export type BridgeModalHostProps = {
+    /**
+     * Default shell options merged into every modal opened via `useModalAction()`.
+     * Per-call `open({ modal })` overrides these.
+     */
+    modal?: BridgeModalShellProps;
+};
+export type BridgeModalEntry = {
+    component: Component;
+    id: LayerId;
+    modal?: Partial<ModalOwnProps>;
+    onClose?: () => void;
+    onClosed?: () => void;
+    props?: Record<string, unknown>;
+    show: boolean;
+};
+export type BridgeModalOpenOptions<TProps = Record<string, unknown>> = {
+    component: Component;
+    modal?: Partial<ModalOwnProps>;
+    onClose?: () => void;
+    onClosed?: () => void;
+    props?: TProps;
+};
+export type BridgeModalUpdateOptions = {
+    modal?: Partial<ModalOwnProps>;
+    props?: Record<string, unknown>;
+};
+export type BridgeModalController = {
+    close: (id: LayerId) => void;
+    closeTop: () => void;
+    entries: Ref<BridgeModalEntry[]>;
+    isOpen: (id: LayerId) => boolean;
+    open: <TProps = Record<string, unknown>>(options: BridgeModalOpenOptions<TProps>) => LayerId;
+    removeEntry: (id: LayerId) => void;
+    syncShow: (id: LayerId, show: boolean) => void;
+    update: (id: LayerId, options: BridgeModalUpdateOptions) => void;
+};
+export type BridgeModalApi = Omit<BridgeModalController, "entries" | "syncShow" | "removeEntry"> & {
+    stackSize: number;
+};

package/dist/Actions/Modal/bridgeModalInjectionKey.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { BridgeModalController } from './bridgeModal.types';
+export declare const BRIDGE_MODAL_INJECTION_KEY: InjectionKey<BridgeModalController>;

package/dist/Actions/Modal/bridgeModalInjectionKey.js

@@ -0,0 +1,4 @@
+//#region src/Actions/Modal/bridgeModalInjectionKey.ts
+var e = Symbol.for("@bridge-ui/vue/bridge-modal");
+//#endregion
+export { e as BRIDGE_MODAL_INJECTION_KEY };

package/dist/Actions/Modal/createBridgeModalApi.d.ts

@@ -0,0 +1,2 @@
+import { BridgeModalController } from './bridgeModal.types';
+export declare function createBridgeModalApi(): BridgeModalController;