@feugene/granularity 0.12.0 → 0.16.0

package/dist/components/GrDialogService/chunks/GrDialogService-B4DYWDkA.js

@@ -0,0 +1,656 @@
+import { n as GR_CONFIG_KEY, s as useGrConfig } from "../../../chunks/context-BSYR7RZs.js";
+import { t as GRANULARITY_I18N_KEY } from "../../../chunks/adapter-CAOxmn2G.js";
+import { n as useGranularityTranslations, t as resolveGranularityI18n } from "../../../chunks/granularityI18n-BC5zsj_d.js";
+import { t as ensurePortalRoot } from "../../../chunks/portalRoot-CWD4zHBm.js";
+import { t as GrButton_default } from "../../GrButton/chunks/GrButton-D0m_z0XW.js";
+import { n as coreResponseErrorParsers, r as createResponseErrorClassifier, s as responseErrorParserPresets } from "../../GrResponseErrorBanner/chunks/GrResponseErrorBanner-C7W9mgYN.js";
+import { t as GrConfirmDialog_default } from "../../GrConfirmDialog/chunks/GrConfirmDialog-DaQmlp1_.js";
+import { t as GrPromptDialog_default } from "../../GrPromptDialog/chunks/GrPromptDialog-Ct174NVD.js";
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, getCurrentInstance, inject, markRaw, mergeProps, nextTick, onBeforeUnmount, onMounted, openBlock, provide, reactive, ref, render, renderList, shallowRef, toDisplayString, withCtx } from "vue";
+//#region src/components/GrDialogService/store.ts
+function createDialogServiceState() {
+	return {
+		queue: reactive([]),
+		mounted: false,
+		container: null,
+		appContext: null,
+		lastCapturedContext: null,
+		contextlessWarned: false,
+		inFlight: []
+	};
+}
+var counter = 0;
+function makeDialogId() {
+	counter += 1;
+	return `gr-dialog-${Date.now()}-${counter}`;
+}
+/**
+* Видимая часть очереди: голова и непрерывный хвост вложенных заявок за ней.
+* Всё остальное ждёт — обычные вызовы по-прежнему идут по одному, чтобы три
+* алерта из цикла не легли стопкой.
+*/
+function visibleDialogRequests(state) {
+	const visible = [];
+	for (const request of state.queue) if (visible.length === 0 || request.nested) visible.push(request);
+	else break;
+	return visible;
+}
+/**
+* Ставит заявку в очередь. Единственное место, где решается её позиция:
+*
+* - вложенная (создана, пока `onConfirm` другой заявки в полёте) встаёт сразу
+*   за своим родителем и показывается поверх него;
+* - обычная — перед всеми ожидающими с меньшим приоритетом; показанные окна не
+*   трогаются, выдёргивать фокус-ловушку из-под пользователя нельзя.
+*/
+function enqueueDialogRequest(state, request) {
+	const parent = state.inFlight[state.inFlight.length - 1];
+	if (parent) {
+		request.nested = true;
+		const parentIndex = state.queue.findIndex((item) => item.id === parent.id);
+		state.queue.splice(parentIndex + 1, 0, request);
+		return;
+	}
+	const visibleCount = visibleDialogRequests(state).length;
+	const insertAt = state.queue.findIndex((item, index) => index >= visibleCount && item.priority < request.priority);
+	if (insertAt < 0) state.queue.push(request);
+	else state.queue.splice(insertAt, 0, request);
+}
+/**
+* Заявка входит в «полёт»: пока её `onConfirm` не вернулся, новые вызовы
+* считаются вложенными в неё.
+*/
+function startDialogInFlight(state, request) {
+	state.inFlight.push(request);
+}
+/** Заявка вышла из полёта (колбэк вернулся или окно размонтировано). */
+function finishDialogInFlight(state, request) {
+	const index = state.inFlight.indexOf(request);
+	if (index >= 0) state.inFlight.splice(index, 1);
+}
+/**
+* Единственный способ завершить заявку: идемпотентно резолвит промис и снимает
+* её из очереди.
+*
+* `removeFromQueue: false` нужен окну: оно гасит себя и даёт анимации закрытия
+* доиграть, прежде чем заявка исчезнет из очереди. Корректность от этой
+* отсрочки не зависит: повторное завершение отсекается флагом на заявке.
+*/
+function settleDialogRequest(state, request, result, { removeFromQueue = true } = {}) {
+	if (request.settled) return false;
+	request.settled = true;
+	request.resolve(result);
+	if (removeFromQueue) removeDialogRequest(state, request);
+	return true;
+}
+/** Снимает заявку из очереди, если она ещё там. */
+function removeDialogRequest(state, request) {
+	const index = state.queue.findIndex((item) => item.id === request.id);
+	if (index >= 0) state.queue.splice(index, 1);
+}
+//#endregion
+//#region src/components/GrDialogService/useDialogService.ts
+/**
+* `useDialogService` — императивный сервис диалогов (в духе Element Plus
+* `ElMessageBox`). Позволяет вызывать `confirm`/`alert`/`prompt` из `<script>`
+* или `.ts` без вставки компонента в шаблон.
+*
+* Поверх существующих `GrConfirmDialog`/`GrPromptDialog`: лениво монтирует
+* единый хост (`GrDialogServiceHost`) в `document.body`, наследуя контекст
+* приложения (i18n / тема / `granular-provider`).
+*/
+/** Ключ provide/inject для app-scoped состояния сервиса (устанавливает плагин ниже). */
+var GRANULARITY_DIALOG_SERVICE_STATE = Symbol.for("@feugene/granularity/dialog-service-state");
+/**
+* Инстансы, заведённые плагином. Реестр нужен готовому синглтону
+* `dialogService`: он создаётся на импорте модуля, где `inject` не работает
+* вовсе, и сам до app-scoped состояния не дотянется. Ровно один
+* зарегистрированный — ответ однозначен; несколько — выбирать за пользователя
+* нечего, и он получает предупреждение с модульным фолбэком.
+*/
+var registeredStates = /* @__PURE__ */ new Set();
+/**
+* Vue-плагин: даёт каждому приложению собственное состояние сервиса и снимает
+* его хост вместе с приложением. Обязателен для нескольких Vue-приложений на
+* одной странице (микрофронтенды — иначе они делят одну очередь и один хост) и
+* для HMR, где контейнер прошлого приложения иначе остаётся в `document.body`.
+*
+* ```ts
+* app.use(granularityDialogServicePlugin)
+* ```
+*/
+var granularityDialogServicePlugin = { install(app) {
+	const state = createDialogServiceState();
+	app.provide(GRANULARITY_DIALOG_SERVICE_STATE, state);
+	registeredStates.add(state);
+	app.onUnmount(() => {
+		teardownDialogServiceState(state);
+		registeredStates.delete(state);
+	});
+} };
+var moduleState = null;
+function getModuleState() {
+	if (!moduleState) moduleState = createDialogServiceState();
+	return moduleState;
+}
+var ambiguousStateWarned = false;
+function warnAmbiguousState() {
+	if (ambiguousStateWarned) return;
+	if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+	ambiguousStateWarned = true;
+	console.warn("[granularity] useDialogService: плагин установлен в нескольких приложениях, а сервис запрошен вне `setup` — какое из них имелось в виду, знать неоткуда. Используется модульное состояние. Вызовите `useDialogService()` внутри `setup` нужного приложения.");
+}
+/**
+* Состояние текущего вызова: app-scoped (плагин) → единственный
+* зарегистрированный инстанс → модульный фолбэк.
+*/
+function resolveDialogServiceState() {
+	if (getCurrentInstance()) {
+		const provided = inject(GRANULARITY_DIALOG_SERVICE_STATE, null);
+		if (provided) return provided;
+	}
+	if (registeredStates.size === 1) return registeredStates.values().next().value;
+	if (registeredStates.size > 1) warnAmbiguousState();
+	return getModuleState();
+}
+function ensureMounted(state, appContext) {
+	if (typeof window === "undefined" || typeof document === "undefined") return;
+	if (appContext) state.appContext = appContext;
+	if (state.mounted) return;
+	const container = document.createElement("div");
+	container.setAttribute("data-gr-dialog-service-host", "");
+	container.setAttribute("data-gr-overlay-root", "");
+	(ensurePortalRoot() ?? document.body).appendChild(container);
+	state.container = container;
+	const vnode = createVNode(GrDialogServiceHost_default, { state: markRaw(state) });
+	vnode.appContext = state.appContext ?? null;
+	render(vnode, container);
+	state.mounted = true;
+}
+function warnIfContextless(state, context) {
+	if (state.contextlessWarned || context?.config || context?.i18n) return;
+	if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+	state.contextlessWarned = true;
+	console.warn("[granularity] useDialogService: диалог открыт без контекста приложения — ни `GrConfigProvider`, ни адаптер i18n не найдены, будут использованы дефолты. Вызовите `useDialogService()` внутри `setup` хотя бы один раз или передайте `setAppContext`.");
+}
+/** Снимает смонтированный хост и сбрасывает захваченный контекст одного инстанса. */
+function teardownDialogServiceState(state) {
+	if (state.container) {
+		render(null, state.container);
+		state.container.remove();
+		state.container = null;
+	}
+	state.mounted = false;
+	state.appContext = null;
+	state.lastCapturedContext = null;
+	state.contextlessWarned = false;
+	state.queue.splice(0, state.queue.length);
+	state.inFlight.splice(0, state.inFlight.length);
+}
+/**
+* Тестовая/служебная очистка смонтированного хоста. Работает над тем же
+* состоянием, что и сам сервис: app-scoped при вызове из `setup` или при
+* единственном зарегистрированном приложении, иначе — модульным.
+*/
+function teardownDialogService() {
+	teardownDialogServiceState(resolveDialogServiceState());
+}
+function enqueue(state, kind, message, options, onConfirm, captured) {
+	if (typeof window === "undefined" || typeof document === "undefined") throw new Error("[granularity] useDialogService is client-only and cannot be called during SSR (it mounts a host into document.body). Guard imperative dialog calls behind a client-side check.");
+	ensureMounted(state, options.appContext ?? state.appContext);
+	const id = makeDialogId();
+	let resolveFn;
+	const promise = new Promise((resolve) => {
+		resolveFn = resolve;
+	});
+	const context = captured.config || captured.i18n ? captured : state.lastCapturedContext;
+	warnIfContextless(state, context);
+	const request = {
+		id,
+		kind,
+		message,
+		options: {
+			...options,
+			message
+		},
+		onConfirm,
+		priority: options.priority ?? 0,
+		nested: false,
+		settled: false,
+		resolve: resolveFn,
+		config: context?.config ?? null,
+		i18n: context?.i18n ?? null
+	};
+	enqueueDialogRequest(state, request);
+	const close = () => {
+		settleDialogRequest(state, request, { action: "close" });
+	};
+	return {
+		promise,
+		close
+	};
+}
+function withClose(promise, close) {
+	const result = promise;
+	result.close = close;
+	return result;
+}
+function mergeErrorDefaults(defaults, options) {
+	return {
+		size: defaults.size,
+		confirmText: defaults.confirmText,
+		confirmVariant: defaults.confirmVariant,
+		confirmTone: defaults.confirmTone,
+		cancelText: defaults.cancelText,
+		buttonSize: defaults.buttonSize,
+		closeOnBackdrop: defaults.closeOnBackdrop,
+		closeOnEsc: defaults.closeOnEsc,
+		errorParsers: defaults.errorParsers,
+		errorTexts: defaults.errorTexts,
+		errorMessageKey: defaults.errorMessageKey,
+		fieldLabels: defaults.fieldLabels,
+		...options
+	};
+}
+/**
+* Создаёт сервис диалогов. Опциональные `defaults` применяются ко всем
+* вызовам (можно переопределить в каждом конкретном вызове).
+*
+* Контекст приложения кэшируется автоматически при первом вызове внутри
+* `setup`. Для вызовов вне компонента используйте `setAppContext`.
+*/
+function useDialogService(defaults = {}) {
+	const state = resolveDialogServiceState();
+	const instance = getCurrentInstance();
+	if (instance?.appContext && !state.appContext) state.appContext = instance.appContext;
+	const capturedI18n = instance ? resolveGranularityI18n() : null;
+	const captured = {
+		config: instance ? markRaw(useGrConfig()) : null,
+		i18n: capturedI18n ? markRaw(capturedI18n) : null
+	};
+	if (captured.config || captured.i18n) state.lastCapturedContext = captured;
+	function confirm(message, options = {}) {
+		const merged = mergeErrorDefaults(defaults, options);
+		const { promise, close } = enqueue(state, "confirm", message, merged, options.onConfirm, captured);
+		return withClose(promise.then((r) => r.action === "confirm"), close);
+	}
+	function alert(message, options = {}) {
+		const merged = mergeErrorDefaults(defaults, options);
+		const { promise, close } = enqueue(state, "alert", message, merged, options.onConfirm, captured);
+		return withClose(promise.then(() => void 0), close);
+	}
+	function prompt(message, options = {}) {
+		const merged = mergeErrorDefaults(defaults, options);
+		const { promise, close } = enqueue(state, "prompt", message, merged, options.onConfirm, captured);
+		return withClose(promise.then((r) => r.action === "confirm" ? r.value ?? "" : null), close);
+	}
+	function open(kind, message, options = {}) {
+		const merged = mergeErrorDefaults(defaults, options);
+		const { promise, close } = enqueue(state, kind, message, merged, options.onConfirm, captured);
+		return withClose(promise, close);
+	}
+	function closeAll() {
+		for (const request of [...state.queue]) settleDialogRequest(state, request, { action: "close" });
+	}
+	function setAppContext(ctx) {
+		state.appContext = ctx;
+	}
+	return {
+		confirm,
+		alert,
+		prompt,
+		open,
+		closeAll,
+		setAppContext
+	};
+}
+/** Готовый синглтон-сервис с дефолтными настройками. */
+var dialogService = {
+	confirm: (message, options) => useDialogService().confirm(message, options),
+	alert: (message, options) => useDialogService().alert(message, options),
+	prompt: (message, options) => useDialogService().prompt(message, options),
+	open: (kind, message, options) => useDialogService().open(kind, message, options),
+	closeAll: () => useDialogService().closeAll(),
+	setAppContext: (ctx) => useDialogService().setAppContext(ctx)
+};
+//#endregion
+//#region src/components/GrDialogService/GrDialogServiceItem.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "flex items-center justify-end gap-3" };
+var PROMPT_FIELD = "value";
+//#endregion
+//#region src/components/GrDialogService/GrDialogServiceItem.vue
+var GrDialogServiceItem_default = /* @__PURE__ */ defineComponent({
+	__name: "GrDialogServiceItem",
+	props: { request: {} },
+	setup(__props) {
+		/**
+		* GrDialogServiceItem — одно окно императивного сервиса. Внутренний компонент,
+		* в шаблонах напрямую не используется.
+		*
+		* Всё состояние живёт здесь, а не на хосте, ровно потому, что окон может быть
+		* несколько: вложенный вызов из `onConfirm` показывается поверх родителя, и
+		* общий `loading` с общей ошибкой означали бы, что верхнее окно пишет в нижнее.
+		*/
+		const props = __props;
+		const state = inject(GRANULARITY_DIALOG_SERVICE_STATE);
+		const EMPTY_DEFAULTS = Object.freeze({});
+		provide(GR_CONFIG_KEY, {
+			size: computed(() => props.request.config?.size.value),
+			componentDefaults: computed(() => props.request.config?.componentDefaults.value ?? EMPTY_DEFAULTS)
+		});
+		const hostI18n = resolveGranularityI18n();
+		provide(GRANULARITY_I18N_KEY, {
+			t: (key, params) => {
+				return (props.request.i18n ?? hostI18n)?.t(key, params) ?? key;
+			},
+			get locale() {
+				return (props.request.i18n ?? hostI18n)?.locale;
+			}
+		});
+		const alertConfirmText = computed(() => {
+			const { t } = useGranularityTranslations(props.request.i18n ?? hostI18n);
+			return t("gr.dialog.ok", "OK");
+		});
+		const open = ref(false);
+		const loading = ref(false);
+		const currentError = shallowRef(null);
+		/**
+		* Ошибки по именам полей. Карта, а не одна строка: `setFieldError(field, …)`
+		* обещает адресность, и обещание должно быть правдой ещё до того, как в
+		* диалоге появится второе поле.
+		*/
+		const fieldErrors = ref({});
+		const promptValue = ref(props.request.options && "value" in props.request.options ? props.request.options.value ?? "" : "");
+		/** Единственное поле `GrPromptDialog` называется `value`. */
+		const promptFieldError = computed(() => {
+			const own = fieldErrors.value[PROMPT_FIELD];
+			if (own != null) return own;
+			const entries = Object.values(fieldErrors.value);
+			return entries.length === 1 ? entries[0] : null;
+		});
+		const hasFieldError = computed(() => Object.keys(fieldErrors.value).length > 0);
+		const controller = new AbortController();
+		let externalAbortCleanup = null;
+		function buildClassifier() {
+			const opts = props.request.options;
+			return createResponseErrorClassifier({
+				parsers: typeof opts.errorParsers === "function" ? opts.errorParsers(responseErrorParserPresets) : opts.errorParsers ?? coreResponseErrorParsers,
+				texts: opts.errorTexts,
+				messageKey: opts.errorMessageKey
+			});
+		}
+		onMounted(() => {
+			const sig = props.request.options.signal;
+			if (sig) {
+				if (sig.aborted) {
+					finish("close");
+					return;
+				}
+				const onAbort = () => finish("close");
+				sig.addEventListener("abort", onAbort);
+				externalAbortCleanup = () => sig.removeEventListener("abort", onAbort);
+			}
+			nextTick(() => {
+				open.value = true;
+			});
+		});
+		onBeforeUnmount(() => {
+			externalAbortCleanup?.();
+			externalAbortCleanup = null;
+			controller.abort();
+			finishDialogInFlight(state, props.request);
+		});
+		function finish(action, value) {
+			if (!settleDialogRequest(state, props.request, {
+				action,
+				value
+			}, { removeFromQueue: false })) return;
+			open.value = false;
+			nextTick(() => removeDialogRequest(state, props.request));
+		}
+		function buildContext(value) {
+			let errorSet = false;
+			const setError = (message) => {
+				if (message == null) {
+					currentError.value = null;
+					return;
+				}
+				errorSet = true;
+				currentError.value = {
+					kind: "unknown",
+					message,
+					raw: message
+				};
+			};
+			const setFieldError = (field, message) => {
+				const next = { ...fieldErrors.value };
+				if (message == null) {
+					delete next[field];
+					fieldErrors.value = next;
+					return;
+				}
+				errorSet = true;
+				next[field] = message;
+				fieldErrors.value = next;
+			};
+			const clearErrors = () => {
+				currentError.value = null;
+				fieldErrors.value = {};
+			};
+			const setRawError = async (raw, meta) => {
+				const info = await buildClassifier()(raw, meta);
+				if (info.fieldErrors?.length) {
+					const next = { ...fieldErrors.value };
+					for (const entry of info.fieldErrors) next[entry.field] = entry.messages.join(" ");
+					fieldErrors.value = next;
+				}
+				currentError.value = info;
+				errorSet = true;
+				return info;
+			};
+			return {
+				value,
+				signal: controller.signal,
+				setError,
+				setRawError,
+				setFieldError,
+				clearErrors,
+				setLoading: (v) => {
+					loading.value = v;
+				},
+				close: (action = "close") => finish(action),
+				_errorSet: () => errorSet
+			};
+		}
+		async function handleConfirm() {
+			const req = props.request;
+			const value = req.kind === "prompt" ? promptValue.value : void 0;
+			if (!req.onConfirm) {
+				finish("confirm", value);
+				return;
+			}
+			currentError.value = null;
+			fieldErrors.value = {};
+			loading.value = true;
+			const ctx = buildContext(value);
+			startDialogInFlight(state, req);
+			try {
+				const result = await req.onConfirm(ctx);
+				if (req.settled) return;
+				loading.value = false;
+				if (result === false) return;
+				if (currentError.value || hasFieldError.value || ctx._errorSet()) return;
+				finish("confirm", value);
+			} catch (error) {
+				if (req.settled) return;
+				loading.value = false;
+				if (!ctx._errorSet()) await ctx.setRawError(error);
+			} finally {
+				finishDialogInFlight(state, req);
+			}
+		}
+		function handleCancel() {
+			finish("cancel");
+		}
+		function handleModelUpdate(value) {
+			if (!value) finish("close");
+		}
+		const promptOptions = computed(() => props.request.options);
+		const confirmOptions = computed(() => props.request.options);
+		const sharedProps = computed(() => {
+			const o = props.request.options;
+			return {
+				title: o.title,
+				size: o.size,
+				closeOnBackdrop: o.closeOnBackdrop,
+				closeOnEsc: o.closeOnEsc,
+				persistent: true,
+				showHeader: o.showHeader,
+				showCloseButton: o.showCloseButton,
+				headerConfig: o.headerConfig,
+				footerConfig: o.footerConfig,
+				bodyConfig: o.bodyConfig,
+				closeLabel: o.closeLabel,
+				buttonSize: o.buttonSize,
+				confirmText: o.confirmText,
+				confirmVariant: o.confirmVariant,
+				confirmTone: o.confirmTone
+			};
+		});
+		return (_ctx, _cache) => {
+			return __props.request.kind === "prompt" ? (openBlock(), createBlock(GrPromptDialog_default, mergeProps({ key: 0 }, sharedProps.value, {
+				value: promptValue.value,
+				"onUpdate:value": _cache[0] || (_cache[0] = ($event) => promptValue.value = $event),
+				"model-value": open.value,
+				description: __props.request.options.message ?? __props.request.options.description,
+				label: promptOptions.value.label,
+				placeholder: promptOptions.value.placeholder,
+				required: promptOptions.value.required ?? false,
+				"required-error-text": promptOptions.value.requiredErrorText,
+				"cancel-text": promptOptions.value.cancelText,
+				"input-type": promptOptions.value.inputType,
+				inputmode: promptOptions.value.inputmode,
+				maxlength: promptOptions.value.maxlength,
+				"show-count": promptOptions.value.showCount,
+				multiline: promptOptions.value.multiline,
+				rows: promptOptions.value.rows,
+				autosize: promptOptions.value.autosize,
+				rules: promptOptions.value.rules,
+				error: currentError.value,
+				"field-error": promptFieldError.value,
+				"confirm-loading": loading.value,
+				"close-on-confirm": false,
+				"onUpdate:modelValue": handleModelUpdate,
+				onConfirm: handleConfirm,
+				onCancel: handleCancel
+			}), null, 16, [
+				"value",
+				"model-value",
+				"description",
+				"label",
+				"placeholder",
+				"required",
+				"required-error-text",
+				"cancel-text",
+				"input-type",
+				"inputmode",
+				"maxlength",
+				"show-count",
+				"multiline",
+				"rows",
+				"autosize",
+				"rules",
+				"error",
+				"field-error",
+				"confirm-loading"
+			])) : __props.request.kind === "alert" ? (openBlock(), createBlock(GrConfirmDialog_default, mergeProps({
+				key: 1,
+				"model-value": open.value
+			}, sharedProps.value, {
+				description: __props.request.options.message ?? __props.request.options.description,
+				error: currentError.value,
+				"confirm-loading": loading.value,
+				"close-on-confirm": false,
+				"onUpdate:modelValue": handleModelUpdate,
+				onConfirm: handleConfirm
+			}), {
+				footer: withCtx(() => [createElementVNode("div", _hoisted_1, [createVNode(GrButton_default, {
+					"data-testid": "gr-alert-confirm",
+					variant: sharedProps.value.confirmVariant ?? "primary",
+					tone: sharedProps.value.confirmTone ?? "primary",
+					size: sharedProps.value.buttonSize,
+					loading: loading.value,
+					onClick: handleConfirm
+				}, {
+					default: withCtx(() => [createTextVNode(toDisplayString(sharedProps.value.confirmText ?? alertConfirmText.value), 1)]),
+					_: 1
+				}, 8, [
+					"variant",
+					"tone",
+					"size",
+					"loading"
+				])])]),
+				_: 1
+			}, 16, [
+				"model-value",
+				"description",
+				"error",
+				"confirm-loading"
+			])) : (openBlock(), createBlock(GrConfirmDialog_default, mergeProps({
+				key: 2,
+				"model-value": open.value
+			}, sharedProps.value, {
+				description: __props.request.options.message ?? __props.request.options.description,
+				"cancel-text": confirmOptions.value.cancelText,
+				error: currentError.value,
+				"confirm-loading": loading.value,
+				"close-on-confirm": false,
+				"onUpdate:modelValue": handleModelUpdate,
+				onConfirm: handleConfirm,
+				onCancel: handleCancel
+			}), null, 16, [
+				"model-value",
+				"description",
+				"cancel-text",
+				"error",
+				"confirm-loading"
+			]));
+		};
+	}
+});
+//#endregion
+//#region src/components/GrDialogService/GrDialogServiceHost.vue
+var GrDialogServiceHost_default = /* @__PURE__ */ defineComponent({
+	__name: "GrDialogServiceHost",
+	props: { state: {} },
+	setup(__props) {
+		/**
+		* GrDialogServiceHost — внутренний компонент-оркестратор императивного
+		* `useDialogService`. Не предназначен для прямого использования в шаблонах.
+		*
+		* Держит раскладку очереди и ничего больше: состояние каждой заявки — загрузка,
+		* ошибки, введённое значение, мост конфига и i18n — живёт в
+		* `GrDialogServiceItem`, потому что окон может быть несколько.
+		*
+		* Видимы голова очереди и её вложенные окна (`store.visibleDialogRequests`):
+		* обычные вызовы по-прежнему показываются по одному, а диалог, открытый из
+		* `onConfirm` другого диалога, ложится поверх родителя — иначе он ждал бы в
+		* очереди того, кто ждёт его.
+		*/
+		const props = __props;
+		const injected = inject(GRANULARITY_DIALOG_SERVICE_STATE, null);
+		const activeState = computed(() => props.state ?? injected);
+		const visible = computed(() => activeState.value ? visibleDialogRequests(activeState.value) : []);
+		provide(GRANULARITY_DIALOG_SERVICE_STATE, activeState.value);
+		return (_ctx, _cache) => {
+			return openBlock(true), createElementBlock(Fragment, null, renderList(visible.value, (request) => {
+				return openBlock(), createBlock(GrDialogServiceItem_default, {
+					key: request.id,
+					request
+				}, null, 8, ["request"]);
+			}), 128);
+		};
+	}
+});
+//#endregion
+export { teardownDialogService as a, granularityDialogServicePlugin as i, GRANULARITY_DIALOG_SERVICE_STATE as n, useDialogService as o, dialogService as r, GrDialogServiceHost_default as t };