@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/internal/feedbackPresentation.js

@@ -0,0 +1,96 @@
+import { UI_KIT_MESSAGES as e, createUiKitTranslate as t } from "../locales/messages.js";
+import { AlertTriangle as n, CheckCircle2 as r, Info as i, LoaderCircle as a, XCircle as o } from "../components/icons/_internal/generatedSputnigUiIconComponents.js";
+//#region src/internal/feedbackPresentation.ts
+var s = {
+	neutral: {
+		icon: i,
+		iconName: "info",
+		fallbackTitleKey: "feedback.titleStatus"
+	},
+	info: {
+		icon: i,
+		iconName: "info",
+		fallbackTitleKey: "feedback.titleInformation"
+	},
+	success: {
+		icon: r,
+		iconName: "check-circle",
+		fallbackTitleKey: "feedback.titleSuccess"
+	},
+	warn: {
+		icon: n,
+		iconName: "alert-triangle",
+		fallbackTitleKey: "feedback.titleWarning"
+	},
+	danger: {
+		icon: o,
+		iconName: "x-circle",
+		fallbackTitleKey: "feedback.titleError"
+	}
+}, c = t(() => e.ru);
+function l(e, t = c) {
+	let n = s[e];
+	return {
+		icon: n.icon,
+		iconName: n.iconName,
+		fallbackTitle: t(n.fallbackTitleKey)
+	};
+}
+function u(e, t = c) {
+	if (e === "progress") return {
+		tone: "info",
+		icon: a,
+		iconName: "loader-circle",
+		fallbackTitle: t("feedback.titleRunning"),
+		motion: "spin"
+	};
+	let n = l(e, t);
+	return {
+		tone: e,
+		icon: n.icon,
+		iconName: n.iconName,
+		fallbackTitle: n.fallbackTitle,
+		motion: "static"
+	};
+}
+function d(e, t) {
+	if (t === "off") return {};
+	let n = t === "auto" ? e === "danger" ? "assertive" : "polite" : t;
+	return {
+		role: n === "assertive" ? "alert" : "status",
+		ariaLive: n,
+		ariaAtomic: "true"
+	};
+}
+function f(e, t = c) {
+	if (e === "loading") {
+		let e = u("progress", t);
+		return {
+			tone: e.tone,
+			icon: e.icon,
+			iconName: e.iconName,
+			fallbackMessage: t("feedback.loading"),
+			busy: !0,
+			live: d(e.tone, "auto")
+		};
+	}
+	if (e === "empty") return {
+		tone: "neutral",
+		icon: null,
+		iconName: null,
+		fallbackMessage: t("feedback.empty"),
+		busy: !1,
+		live: d("neutral", "auto")
+	};
+	let n = u("danger", t);
+	return {
+		tone: "danger",
+		icon: n.icon,
+		iconName: n.iconName,
+		fallbackMessage: n.fallbackTitle,
+		busy: !1,
+		live: d("danger", "auto")
+	};
+}
+//#endregion
+export { f as resolveAsyncFeedbackPresentation, u as resolveFeedbackIndicator, d as resolveFeedbackLive, l as resolveFeedbackPresentation };

package/dist/src/internal/fieldPresentation.d.ts

@@ -0,0 +1,19 @@
+import { ComputedRef } from 'vue';
+export declare const FIELD_REQUIRED_CLASS = "ml-0.5 text-danger-600 dark:text-danger-400";
+export declare const FIELD_SUPPORT_CLASS = "mt-1 min-w-0 whitespace-normal text-xs [overflow-wrap:anywhere]";
+export declare const FIELD_HELP_CLASS = "mt-1 min-w-0 whitespace-normal text-xs [overflow-wrap:anywhere] text-surface-500 dark:text-surface-400";
+export declare const FIELD_ERROR_CLASS = "mt-1 min-w-0 whitespace-normal text-xs [overflow-wrap:anywhere] text-danger-600 dark:text-danger-400";
+export interface FieldSupportingTextOptions {
+    readonly baseId: ComputedRef<string>;
+    readonly hasHelp: () => boolean;
+    readonly hasError: () => boolean;
+}
+/**
+ * Владеет exact ID и aria-describedby contract для help/error у field и fieldset.
+ * Owns the exact help/error ID and aria-describedby contract for fields and fieldsets.
+ */
+export declare function useFieldSupportingText(options: FieldSupportingTextOptions): {
+    readonly describedBy: ComputedRef<string | undefined>;
+    readonly errorId: ComputedRef<string>;
+    readonly helpId: ComputedRef<string>;
+};

package/dist/src/internal/fieldPresentation.js

@@ -0,0 +1,16 @@
+import { computed as e } from "vue";
+//#region src/internal/fieldPresentation.ts
+var t = "ml-0.5 text-danger-600 dark:text-danger-400", n = "mt-1 min-w-0 whitespace-normal text-xs [overflow-wrap:anywhere]", r = `${n} text-surface-500 dark:text-surface-400`, i = `${n} text-danger-600 dark:text-danger-400`;
+function a(t) {
+	let n = e(() => `${t.baseId.value}-help`), r = e(() => `${t.baseId.value}-error`);
+	return {
+		describedBy: e(() => {
+			let e = [];
+			return t.hasHelp() && e.push(n.value), t.hasError() && e.push(r.value), e.length > 0 ? e.join(" ") : void 0;
+		}),
+		errorId: r,
+		helpId: n
+	};
+}
+//#endregion
+export { i as FIELD_ERROR_CLASS, r as FIELD_HELP_CLASS, t as FIELD_REQUIRED_CLASS, n as FIELD_SUPPORT_CLASS, a as useFieldSupportingText };

package/dist/src/internal/fieldSurface.d.ts

@@ -0,0 +1,26 @@
+declare const FIELD_SURFACE_KINDS: readonly ["text-input", "textarea", "inline-token-editor", "combobox-trigger"];
+declare const FIELD_SURFACE_APPEARANCES: readonly ["field", "ghost", "embedded"];
+/** Canonical owners sharing one field-surface visual contract. / Канонические владельцы общего визуального контракта field surface. */
+export type FieldSurfaceKind = typeof FIELD_SURFACE_KINDS[number];
+/** Canonical participation mode in the shared field surface. / Режим участия в общей field surface. */
+export type FieldSurfaceAppearance = typeof FIELD_SURFACE_APPEARANCES[number];
+export interface FieldSurfaceContract {
+    kind: FieldSurfaceKind;
+    appearance: FieldSurfaceAppearance;
+    invalid: boolean;
+    disabled: boolean;
+    readonly: boolean;
+}
+export interface FieldSurfaceBindings {
+    'data-s-field-surface': FieldSurfaceKind;
+    'data-s-field-appearance': FieldSurfaceAppearance;
+    'data-s-field-invalid'?: 'true';
+    'data-s-field-disabled'?: 'true';
+    'data-s-field-readonly'?: 'true';
+}
+/**
+ * Создаёт exact DOM bindings единого field-surface foundation без truthy coercion.
+ * Creates exact DOM bindings for the shared field-surface foundation without truthy coercion.
+ */
+export declare function resolveFieldSurfaceBindings(owner: string, contract: FieldSurfaceContract): FieldSurfaceBindings;
+export {};

package/dist/src/internal/fieldSurface.js

@@ -0,0 +1,25 @@
+import { validateBoolean as e, validateExactString as t, validateNonEmptyString as n } from "./runtimeContract.js";
+//#region src/internal/fieldSurface.ts
+var r = [
+	"text-input",
+	"textarea",
+	"inline-token-editor",
+	"combobox-trigger"
+], i = [
+	"field",
+	"ghost",
+	"embedded"
+];
+function a(a, o) {
+	n("fieldSurface", "owner", a);
+	let s = t(a, "field surface kind", o.kind, r), c = t(a, "field surface appearance", o.appearance, i), l = e(a, "field surface invalid", o.invalid), u = e(a, "field surface disabled", o.disabled), d = e(a, "field surface readonly", o.readonly);
+	return {
+		"data-s-field-surface": s,
+		"data-s-field-appearance": c,
+		...l ? { "data-s-field-invalid": "true" } : {},
+		...u ? { "data-s-field-disabled": "true" } : {},
+		...d ? { "data-s-field-readonly": "true" } : {}
+	};
+}
+//#endregion
+export { a as resolveFieldSurfaceBindings };

package/dist/src/internal/focusNavigation.d.ts

@@ -0,0 +1,11 @@
+/** Проверяет programmatic/browser focus owner без layout-эвристик. / Checks a programmatic/browser focus owner without layout heuristics. */
+export declare const isFocusableElement: (element: HTMLElement) => boolean;
+/**
+ * Поднимает произвольный event target до ближайшего canonical focus owner внутри optional boundary.
+ * Lifts an arbitrary event target to the nearest canonical focus owner inside an optional boundary.
+ */
+export declare const findFocusableOwner: (target: EventTarget | null, boundary?: ParentNode | null) => HTMLElement | null;
+export declare const getFocusableElements: (root: ParentNode, options?: {
+    requireLayout?: boolean;
+}) => HTMLElement[];
+export declare const findRelativeTabTarget: (reference: HTMLElement, scope: ParentNode, excludedRoot: HTMLElement | null, reverse: boolean) => HTMLElement | null;

package/dist/src/internal/focusNavigation.js

@@ -0,0 +1,26 @@
+//#region src/internal/focusNavigation.ts
+var e = [
+	"a[href]",
+	"button:not([disabled])",
+	"textarea:not([disabled])",
+	"input:not([disabled])",
+	"select:not([disabled])",
+	"[contenteditable=\"true\"]",
+	"[tabindex]:not([tabindex=\"-1\"])"
+].join(", "), t = (e) => {
+	if (e.hidden || e.closest("[inert]") || e.closest("[aria-hidden=\"true\"]")) return !1;
+	let t = window.getComputedStyle(e);
+	return t.display !== "none" && t.visibility !== "hidden";
+}, n = (n) => n.matches(e) && t(n), r = (t, r) => {
+	let i = (t instanceof Element ? t : t instanceof Node ? t.parentElement : null)?.closest(e) ?? null;
+	return !i || !n(i) || r instanceof Node && !r.contains(i) ? null : i;
+}, i = (t, r = {}) => [...t.querySelectorAll(e)].filter((e) => n(e) ? !r.requireLayout || e.offsetParent !== null || e.getClientRects().length > 0 : !1), a = (e, t, n, r) => {
+	let a = i(t).filter((e) => !n?.contains(e));
+	if (a.length === 0) return null;
+	let o = a.indexOf(e);
+	if (o >= 0) return a[(o + (r ? -1 : 1) + a.length) % a.length] ?? null;
+	let s = r ? [...a].reverse() : a, c = r ? Node.DOCUMENT_POSITION_PRECEDING : Node.DOCUMENT_POSITION_FOLLOWING;
+	return s.find((t) => !!(e.compareDocumentPosition(t) & c)) ?? s[0] ?? null;
+};
+//#endregion
+export { r as findFocusableOwner, a as findRelativeTabTarget, i as getFocusableElements, n as isFocusableElement };

package/dist/src/internal/inlineTokenEditorContract.d.ts

@@ -0,0 +1,20 @@
+export type InlineTokenEditorSegmentContract = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'token';
+    readonly occurrenceId: string;
+    readonly id: string;
+    readonly label: string;
+    readonly title?: string;
+};
+/** Собирает plain-text mirror без нормализации сегментов. / Builds the plain-text mirror without normalizing segments. */
+export declare function inlineTokenSegmentsToText(segments: readonly InlineTokenEditorSegmentContract[]): string;
+/** Проверяет canonical external segment source и его exact model mirror. / Validates the canonical external segment source and its exact model mirror. */
+export declare function parseInlineTokenEditorSource(modelValue: unknown, segments: unknown): readonly InlineTokenEditorSegmentContract[];
+/** Проверяет cursor offset относительно exact logical text. / Validates a cursor offset against exact logical text. */
+export declare function validateInlineTokenCursorOffset(value: unknown, textLength: number, coordinate: string): number;
+/** Запрещает cursor внутри atomic token label; разрешены только его границы. / Rejects cursor positions inside an atomic token label; only its boundaries are addressable. */
+export declare function validateInlineTokenCursorBoundary(segments: readonly InlineTokenEditorSegmentContract[], value: unknown, coordinate: string): number;
+/** Создаёт canonical internally-generated sequence; external invalid input сюда не попадает. / Creates a canonical internally-generated sequence; external invalid input never enters this path. */
+export declare function composeInlineTokenSegments(segments: readonly InlineTokenEditorSegmentContract[]): InlineTokenEditorSegmentContract[];

package/dist/src/internal/inlineTokenEditorContract.js

@@ -0,0 +1,87 @@
+import { hasOwn as e, lastItem as t } from "./es2020.js";
+import { validateBoundedInteger as n, validateNonEmptyString as r } from "./runtimeContract.js";
+//#region src/internal/inlineTokenEditorContract.ts
+function i(e, t) {
+	if (typeof t != "object" || !t || Array.isArray(t) || Object.getPrototypeOf(t) !== Object.prototype) throw TypeError(`${e}: значение должно быть plain object. / ${e}: value must be a plain object.`);
+	return t;
+}
+function a(e, t, n) {
+	let r = Object.keys(t).filter((e) => !n.includes(e));
+	if (r.length > 0) throw TypeError(`${e}: неизвестные поля ${r.map((e) => JSON.stringify(e)).join(", ")}. / ${e}: unknown fields ${r.map((e) => JSON.stringify(e)).join(", ")}.`);
+}
+function o(e) {
+	return e.map((e) => e.kind === "text" ? e.text : e.label).join("");
+}
+function s(n, s) {
+	if (typeof n != "string") throw TypeError("SInlineTokenEditor: modelValue должен быть строкой. / SInlineTokenEditor: modelValue must be a string.");
+	if (!Array.isArray(s)) throw TypeError("SInlineTokenEditor: segments должен быть массивом. / SInlineTokenEditor: segments must be an array.");
+	let c = [], l = /* @__PURE__ */ new Map();
+	for (let n = 0; n < s.length; n += 1) {
+		if (!e(s, n)) throw TypeError(`SInlineTokenEditor: segments[${n}] отсутствует в sparse array. / SInlineTokenEditor: segments[${n}] is missing from a sparse array.`);
+		let o = i(`SInlineTokenEditor.segments[${n}]`, s[n]);
+		if (o.kind === "text") {
+			if (a(`SInlineTokenEditor.segments[${n}]`, o, ["kind", "text"]), typeof o.text != "string" || o.text.length === 0) throw TypeError(`SInlineTokenEditor: segments[${n}].text должен быть непустой строкой. / SInlineTokenEditor: segments[${n}].text must be a non-empty string.`);
+			let e = o.text;
+			if (t(c)?.kind === "text") throw TypeError(`SInlineTokenEditor: segments[${n}] является смежным text segment; объедините его в источнике. / SInlineTokenEditor: segments[${n}] is an adjacent text segment; merge it at the source.`);
+			c.push({
+				kind: "text",
+				text: e
+			});
+			continue;
+		}
+		if (o.kind !== "token") throw TypeError(`SInlineTokenEditor: segments[${n}].kind должен быть "text" или "token". / SInlineTokenEditor: segments[${n}].kind must be "text" or "token".`);
+		a(`SInlineTokenEditor.segments[${n}]`, o, [
+			"kind",
+			"occurrenceId",
+			"id",
+			"label",
+			"title"
+		]);
+		let u = r("SInlineTokenEditor", `segments[${n}].occurrenceId`, o.occurrenceId), d = l.get(u);
+		if (d !== void 0) throw TypeError(`SInlineTokenEditor: segments[${n}].occurrenceId дублирует ${JSON.stringify(u)} из segments[${d}].occurrenceId. / SInlineTokenEditor: segments[${n}].occurrenceId duplicates ${JSON.stringify(u)} from segments[${d}].occurrenceId.`);
+		l.set(u, n);
+		let f = o.title === void 0 ? void 0 : r("SInlineTokenEditor", `segments[${n}].title`, o.title);
+		c.push({
+			kind: "token",
+			occurrenceId: u,
+			id: r("SInlineTokenEditor", `segments[${n}].id`, o.id),
+			label: r("SInlineTokenEditor", `segments[${n}].label`, o.label),
+			...f === void 0 ? {} : { title: f }
+		});
+	}
+	let u = o(c);
+	if (n !== u) throw TypeError(`SInlineTokenEditor: modelValue не совпадает с text mirror segments; ожидалось ${JSON.stringify(u)}, получено ${JSON.stringify(n)}. / SInlineTokenEditor: modelValue does not match the segments text mirror; expected ${JSON.stringify(u)}, received ${JSON.stringify(n)}.`);
+	return c;
+}
+function c(e, t, r) {
+	return n("SInlineTokenEditor", r, e, {
+		minimum: 0,
+		maximum: t
+	});
+}
+function l(e, t, n) {
+	let r = c(t, o(e).length, n), i = 0;
+	for (let t of e) {
+		let e = i + (t.kind === "text" ? t.text.length : t.label.length);
+		if (t.kind === "token" && r > i && r < e) throw RangeError(`SInlineTokenEditor: ${n}=${r} попадает внутрь atomic token occurrence ${JSON.stringify(t.occurrenceId)}; допустимы ${i} или ${e}. / SInlineTokenEditor: ${n}=${r} falls inside atomic token occurrence ${JSON.stringify(t.occurrenceId)}; use ${i} or ${e}.`);
+		i = e;
+	}
+	return r;
+}
+function u(e) {
+	let n = [];
+	for (let r of e) if (r.kind === "text") {
+		if (r.text.length === 0) continue;
+		let e = t(n);
+		e?.kind === "text" ? n[n.length - 1] = {
+			kind: "text",
+			text: e.text + r.text
+		} : n.push({
+			kind: "text",
+			text: r.text
+		});
+	} else n.push({ ...r });
+	return [...s(o(n), n)];
+}
+//#endregion
+export { u as composeInlineTokenSegments, o as inlineTokenSegmentsToText, s as parseInlineTokenEditorSource, l as validateInlineTokenCursorBoundary, c as validateInlineTokenCursorOffset };

package/dist/src/internal/interactiveElement.d.ts

@@ -0,0 +1,15 @@
+import { ComponentPublicInstance } from 'vue';
+/**
+ * Типизированная element/focus-поверхность UI-kit leaf для составных владельцев.
+ * Typed element/focus surface exposed by a UI-kit leaf to composite owners.
+ */
+export interface ElementApi<TElement extends HTMLElement = HTMLElement> {
+    getElement: () => TElement;
+}
+export interface InteractiveElementApi<TElement extends HTMLElement = HTMLElement> extends ElementApi<TElement> {
+    focus: (options?: FocusOptions) => void;
+}
+export type ElementRefTarget = Element | ElementApi | ComponentPublicInstance | null;
+export type InteractiveElementRefTarget = Element | InteractiveElementApi | ComponentPublicInstance | null;
+/** Разрешает callback-ref только через native HTMLElement или публичный leaf API. / Resolves a callback ref only through a native HTMLElement or a public leaf API. */
+export declare function resolveInteractiveElement(owner: string, target: ElementRefTarget): HTMLElement | null;

package/dist/src/internal/interactiveElement.js

@@ -0,0 +1,12 @@
+//#region src/internal/interactiveElement.ts
+function e(e, t) {
+	if (t === null) return null;
+	if (t instanceof HTMLElement) return t;
+	let n = Reflect.get(t, "getElement");
+	if (typeof n != "function") throw TypeError(`${e}: ref must resolve to an HTMLElement or ElementApi`);
+	let r = Reflect.apply(n, t, []);
+	if (!(r instanceof HTMLElement)) throw TypeError(`${e}: ElementApi.getElement() must return an HTMLElement`);
+	return r;
+}
+//#endregion
+export { e as resolveInteractiveElement };

package/dist/src/internal/layerStack.d.ts

@@ -0,0 +1,28 @@
+export type LayerKind = 'dialog' | 'listbox' | 'menu' | 'popover' | 'tooltip';
+export type LayerDismissReason = 'escape' | 'outside-contextmenu' | 'outside-pointer';
+export interface LayerRegistrationOptions {
+    kind: LayerKind;
+    root: () => HTMLElement | null;
+    anchor?: () => HTMLElement | null;
+    branches?: () => readonly HTMLElement[];
+    modal?: boolean;
+    restoreTarget?: HTMLElement | null;
+    dismissOnEscape?: () => boolean;
+    dismissOnOutsidePointer?: () => boolean;
+    blocksParentFocusTrap?: boolean;
+    trapFocus?: (event: KeyboardEvent) => void;
+    requestDismiss: (reason: LayerDismissReason, event: Event) => void;
+}
+export interface LayerRegistration {
+    readonly id: symbol;
+    readonly zIndex: string;
+    readonly focusScope: () => ParentNode;
+    unregister: (options?: {
+        restoreFocus?: boolean;
+    }) => void;
+}
+/**
+ * Регистрирует одну открытую overlay-поверхность в общем dismiss/focus/body-lock стеке.
+ * Registers one open overlay surface in the shared dismiss/focus/body-lock stack.
+ */
+export declare function registerLayer(options: LayerRegistrationOptions): LayerRegistration;

package/dist/src/internal/layerStack.js

@@ -0,0 +1,82 @@
+import { isFocusableElement as e } from "./focusNavigation.js";
+//#region src/internal/layerStack.ts
+var t = [], n = !1, r = 0, i = "", a = (e, t) => e.root()?.contains(t) || e.anchor?.()?.contains(t) ? !0 : e.branches?.().some((e) => e.contains(t)) ?? !1, o = (e) => {
+	let n = e.anchor?.() ?? e.restoreTarget ?? (typeof document < "u" && document.activeElement instanceof HTMLElement ? document.activeElement : null);
+	return n ? [...t].reverse().find((e) => a(e, n))?.id ?? null : null;
+}, s = () => t[t.length - 1], c = (e) => {
+	let n = e.parentId;
+	for (; n;) {
+		let e = t.find((e) => e.id === n);
+		if (!e) break;
+		if (e.modal || e.trapFocus) return e.root() ?? document;
+		n = e.parentId;
+	}
+	return document;
+}, l = (e) => {
+	let n = s();
+	if (!n) return;
+	if (e.key === "Escape") {
+		(n.dismissOnEscape?.() ?? !0) && (e.preventDefault(), e.stopPropagation(), n.requestDismiss("escape", e));
+		return;
+	}
+	if (e.key !== "Tab") return;
+	let r = -1;
+	for (let e = t.length - 1; e >= 0; --e) if (t[e]?.trapFocus) {
+		r = e;
+		break;
+	}
+	r < 0 || t.slice(r + 1).some((e) => e.blocksParentFocusTrap ?? !0) || t[r]?.trapFocus?.(e);
+}, u = (e, t) => {
+	let n = s();
+	if (!n) return;
+	let r = e.target;
+	r instanceof Node && a(n, r) || (n.dismissOnOutsidePointer?.() ?? !0) && n.requestDismiss(t, e);
+}, d = (e) => {
+	u(e, "outside-pointer");
+}, f = (e) => {
+	u(e, "outside-contextmenu");
+}, p = () => {
+	n || typeof window > "u" || typeof document > "u" || (n = !0, window.addEventListener("keydown", l, !0), document.addEventListener("pointerdown", d, !0), document.addEventListener("contextmenu", f, !0));
+}, m = () => {
+	!n || t.length > 0 || typeof window > "u" || typeof document > "u" || (n = !1, window.removeEventListener("keydown", l, !0), document.removeEventListener("pointerdown", d, !0), document.removeEventListener("contextmenu", f, !0));
+}, h = () => {
+	typeof document < "u" && (r === 0 && (i = document.body.style.overflow, document.body.style.overflow = "hidden"), r += 1);
+}, g = () => {
+	typeof document < "u" && (r = Math.max(0, r - 1), r === 0 && (document.body.style.overflow = i));
+}, _ = (t) => {
+	queueMicrotask(() => {
+		if (t.restoreTarget?.isConnected && e(t.restoreTarget)) {
+			t.restoreTarget.focus();
+			return;
+		}
+		s()?.root()?.focus();
+	});
+};
+function v(e) {
+	let n = s(), r = e.modal || n?.tier === "overlay" ? "overlay" : "floating", i = n && n.tier === r ? `calc(${n.zIndex} + var(--s-layer-overlay-step))` : r === "overlay" ? "var(--s-layer-root-overlay-backdrop)" : "var(--s-layer-root-floating)", a = {
+		...e,
+		id: Symbol(e.kind),
+		parentId: o(e),
+		restoreTarget: e.restoreTarget ?? null,
+		tier: r,
+		zIndex: i
+	}, l = !0;
+	return t.push(a), a.modal && h(), p(), {
+		id: a.id,
+		zIndex: a.zIndex,
+		focusScope: () => c(a),
+		unregister: ({ restoreFocus: e = !1 } = {}) => {
+			if (!l) return;
+			l = !1;
+			let n = t.findIndex((e) => e.id === a.id), r = n === t.length - 1;
+			if (n >= 0) {
+				let e = a.root();
+				for (let r of t.slice(n + 1)) r.parentId === a.id && (r.parentId = a.parentId), e?.contains(r.restoreTarget) && (r.restoreTarget = a.restoreTarget);
+				t.splice(n, 1);
+			}
+			a.modal && g(), m(), e && r && _(a);
+		}
+	};
+}
+//#endregion
+export { v as registerLayer };

package/dist/src/internal/lazyCodeEditor.js

@@ -0,0 +1,2 @@
+import e from "../components/shared/data-display/SCodeEditor.vue.js";
+export { e as default };

package/dist/src/internal/linkTarget.d.ts

@@ -0,0 +1,26 @@
+import { LinkBrowsingTarget, LinkRouterTarget } from '../components/shared/controls/SLink';
+/** Runtime input accepts unknown fields so every public owner validates the actual payload. */
+export interface LinkTargetInput {
+    readonly href?: unknown;
+    readonly to?: unknown;
+    readonly target?: unknown;
+    readonly rel?: unknown;
+    readonly owner: string;
+}
+export type ResolvedLinkTarget = {
+    readonly kind: 'anchor';
+    readonly bindings: {
+        readonly href: string;
+        readonly target: LinkBrowsingTarget;
+        readonly rel?: string;
+    };
+} | {
+    readonly kind: 'router';
+    readonly bindings: {
+        readonly to: LinkRouterTarget;
+        readonly target: LinkBrowsingTarget;
+        readonly rel?: string;
+    };
+};
+/** Validates the sole link-target boundary and secures new browsing contexts. */
+export declare function resolveLinkTarget(input: LinkTargetInput): ResolvedLinkTarget;

package/dist/src/internal/linkTarget.js

@@ -0,0 +1,131 @@
+import { LINK_BROWSING_TARGETS as e } from "../components/shared/controls/SLink.js";
+//#region src/internal/linkTarget.ts
+var t = /* @__PURE__ */ new Set([
+	"name",
+	"path",
+	"params",
+	"query",
+	"hash",
+	"replace",
+	"force",
+	"state"
+]);
+function n(e) {
+	if (typeof e != "object" || !e || Array.isArray(e)) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
+}
+function r(e, t) {
+	return Object.prototype.hasOwnProperty.call(e, t);
+}
+function i(e) {
+	return e == null || typeof e == "string" || typeof e == "number" && Number.isFinite(e);
+}
+function a(e, t, n) {
+	let r = [];
+	for (let i of Reflect.ownKeys(n)) {
+		if (typeof i != "string") throw TypeError(`${e}: ${t} не допускает symbol keys / ${t} does not allow symbol keys`);
+		let a = Object.getOwnPropertyDescriptor(n, i);
+		if (!a?.enumerable || !("value" in a)) throw TypeError(`${e}: ${t}.${i} должен быть enumerable data property / ${t}.${i} must be an enumerable data property`);
+		r.push([i, a.value]);
+	}
+	return r;
+}
+function o(e, t) {
+	for (let n = 0; n < e.length; n += 1) {
+		let r = Object.getOwnPropertyDescriptor(e, String(n));
+		if (!r?.enumerable || !("value" in r) || !i(r.value) || !t && (r.value === null || r.value === void 0)) return !1;
+	}
+	return Reflect.ownKeys(e).every((t) => t === "length" || typeof t == "string" && /^(0|[1-9]\d*)$/u.test(t) && Number(t) < e.length);
+}
+function s(e, t, r, s) {
+	if (!n(r)) throw TypeError(`${e}: ${t} должен быть plain object / ${t} must be a plain object`);
+	for (let [n, c] of a(e, t, r)) {
+		let r = Array.isArray(c) && o(c, s);
+		if (!i(c) && !r) throw TypeError(`${e}: ${t}.${n} должен быть scalar или массивом scalar / ${t}.${n} must be a scalar or scalar array`);
+	}
+}
+function c(e, t, r, i) {
+	if (!(r == null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof r))) {
+		if (typeof r != "object") throw TypeError(`${e}: ${t} содержит неподдерживаемое state value / ${t} contains an unsupported state value`);
+		if (i.has(r)) throw TypeError(`${e}: ${t} содержит cycle / ${t} contains a cycle`);
+		if (!Array.isArray(r) && !n(r)) throw TypeError(`${e}: ${t} должен содержать только plain objects/arrays / ${t} must contain only plain objects/arrays`);
+		if (i.add(r), Array.isArray(r)) {
+			if (!Reflect.ownKeys(r).every((e) => e === "length" || typeof e == "string" && /^(0|[1-9]\d*)$/u.test(e) && Number(e) < r.length)) throw TypeError(`${e}: ${t} не должен быть sparse / ${t} must not be sparse`);
+			for (let n = 0; n < r.length; n += 1) {
+				let a = Object.getOwnPropertyDescriptor(r, String(n));
+				if (!a?.enumerable || !("value" in a)) throw TypeError(`${e}: ${t} не должен быть sparse/accessor / ${t} must not be sparse/accessor`);
+				c(e, `${t}[${n}]`, a.value, i);
+			}
+		} else for (let [n, o] of a(e, t, r)) c(e, `${t}.${n}`, o, i);
+		i.delete(r);
+	}
+}
+function l(e, i) {
+	if (typeof i == "string") {
+		if (i.trim().length > 0 && i === i.trim()) return !0;
+		throw TypeError(`${e}: to должен быть непустой строкой или route object / to must be a non-empty string or route object`);
+	}
+	if (!n(i)) throw TypeError(`${e}: to должен быть plain route object / to must be a plain route object`);
+	let o = a(e, "to", i);
+	for (let [n] of o) if (!t.has(n)) throw TypeError(`${e}: to route object содержит неподдерживаемое поле ${JSON.stringify(n)} / to route object contains unsupported field ${JSON.stringify(n)}`);
+	let l = r(i, "name"), u = r(i, "path");
+	if (l === u) throw TypeError(`${e}: to route object должен содержать ровно один explicit name/path / to route object must contain exactly one explicit name/path`);
+	if (l && !(typeof i.name == "symbol" || typeof i.name == "string" && i.name.trim().length > 0)) throw TypeError(`${e}: to.name должен быть непустой строкой или symbol / to.name must be a non-empty string or symbol`);
+	if (u && (typeof i.path != "string" || i.path.trim().length === 0)) throw TypeError(`${e}: to.path должен быть непустой строкой / to.path must be a non-empty string`);
+	if (u && i.params !== void 0) throw TypeError(`${e}: to.params допустим только для named route / to.params is only supported for a named route`);
+	if (i.params !== void 0 && s(e, "to.params", i.params, !1), i.query !== void 0 && s(e, "to.query", i.query, !0), i.hash !== void 0 && typeof i.hash != "string") throw TypeError(`${e}: to.hash должен быть строкой / to.hash must be a string`);
+	for (let t of ["replace", "force"]) if (i[t] !== void 0 && typeof i[t] != "boolean") throw TypeError(`${e}: to.${t} должен быть boolean / to.${t} must be a boolean`);
+	if (i.state !== void 0) {
+		if (!n(i.state)) throw TypeError(`${e}: to.state должен быть plain object / to.state must be a plain object`);
+		c(e, "to.state", i.state, /* @__PURE__ */ new Set());
+	}
+	return !0;
+}
+function u(t) {
+	for (let n of e) if (t === n) return !0;
+	return !1;
+}
+function d(t, n) {
+	if (n === void 0) return "_self";
+	if (u(n)) return n;
+	throw TypeError(`${t}: target должен быть одним из ${e.join(", ")} / target must be one of ${e.join(", ")}`);
+}
+function f(e, t, n) {
+	if (t === void 0) return n === "_blank" ? "noopener noreferrer" : void 0;
+	if (typeof t != "string" || t.trim().length === 0) throw TypeError(`${e}: rel должен быть непустой строкой / rel must be a non-empty string`);
+	if (n !== "_blank") return t;
+	let r = t.trim().split(/\s+/u), i = new Set(r.map((e) => e.toLowerCase()));
+	return i.has("noopener") || r.push("noopener"), i.has("noreferrer") || r.push("noreferrer"), r.join(" ");
+}
+function p(e) {
+	let t = e.href !== void 0;
+	if (t === (e.to !== void 0)) throw TypeError(`${e.owner}: передайте ровно один target — href или to`);
+	let n = d(e.owner, e.target), r = f(e.owner, e.rel, n);
+	if (t) {
+		if (typeof e.href != "string" || e.href.trim().length === 0 || e.href !== e.href.trim()) throw TypeError(`${e.owner}: href должен быть непустой строкой / href must be a non-empty string`);
+		return {
+			kind: "anchor",
+			bindings: {
+				href: e.href,
+				target: n,
+				...r === void 0 ? {} : { rel: r }
+			}
+		};
+	}
+	if (l(e.owner, e.to)) return {
+		kind: "router",
+		bindings: {
+			to: e.to,
+			target: n,
+			...r === void 0 ? {} : { rel: r }
+		}
+	};
+	throw TypeError(`${e.owner}: недостижимый router target / unreachable router target`);
+}
+//#endregion
+export { p as resolveLinkTarget };

package/dist/src/internal/localeContext.d.ts

@@ -0,0 +1,10 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { UiKitLocale, UiKitMessages, UiKitTranslate } from '../locales/locale';
+export interface UiKitLocaleContext {
+    readonly locale: ComputedRef<UiKitLocale>;
+    readonly messages: ComputedRef<Readonly<UiKitMessages>>;
+    readonly t: UiKitTranslate;
+}
+export declare const UI_KIT_LOCALE_CONTEXT: InjectionKey<UiKitLocaleContext>;
+export declare function createDefaultUiKitLocaleContext(): UiKitLocaleContext;
+export declare function resolveUiKitLocaleContext(): UiKitLocaleContext;