@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/composables/useDialogOverlay.js

@@ -0,0 +1,49 @@
+import { trapFocusInsidePanel as e } from "../components/shared/_internal/focusTrap.js";
+import { registerLayer as t } from "../internal/layerStack.js";
+import { nextTick as n, onBeforeUnmount as r, ref as i, watch as a } from "vue";
+//#region src/composables/useDialogOverlay.ts
+function o(o) {
+	let s = i(null), c = i({}), l = i({}), u = null, d = 0, f = (e) => {
+		if (e === null || e instanceof HTMLElement) {
+			s.value = e;
+			return;
+		}
+		throw TypeError("Dialog overlay panel ref обязан указывать на HTMLElement");
+	}, p = () => {
+		if (u) return;
+		let n = typeof document < "u" && document.activeElement instanceof HTMLElement ? document.activeElement : null;
+		u = t({
+			kind: "dialog",
+			root: () => s.value,
+			modal: !0,
+			restoreTarget: n,
+			dismissOnEscape: () => o.closable.value,
+			dismissOnOutsidePointer: () => o.closable.value,
+			trapFocus: (t) => e(t, s, !0),
+			requestDismiss: () => o.requestClose()
+		}), c.value = { zIndex: u.zIndex }, l.value = { zIndex: `calc(${u.zIndex} + var(--s-layer-overlay-surface-offset))` };
+	}, m = (e = !0) => {
+		u?.unregister({ restoreFocus: e }), u = null, c.value = {}, l.value = {};
+	};
+	return a(o.open, async (e, t) => {
+		d += 1;
+		let r = d;
+		if (e) {
+			if (p(), await n(), r !== d || !o.open.value || u === null) return;
+			let e = s.value;
+			if (!e) return;
+			e.focus(), r === d && o.open.value && u !== null && o.opened?.();
+			return;
+		}
+		m(!!t);
+	}, { immediate: !0 }), r(() => {
+		d += 1, m(!1);
+	}), {
+		panelRef: s,
+		setPanelElement: f,
+		backdropStyle: c,
+		surfaceStyle: l
+	};
+}
+//#endregion
+export { o as useDialogOverlay };

package/dist/src/composables/useDisclosure.d.ts

@@ -0,0 +1,17 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+export interface UseDisclosureOptions {
+    id?: string;
+    open?: Readonly<Ref<boolean>>;
+    defaultOpen?: boolean;
+    disabled?: MaybeRefOrGetter<boolean>;
+    onUpdate?: (open: boolean) => void;
+}
+/** Canonical controlled/uncontrolled state and ID contract for button disclosures. */
+export declare function useDisclosure(options?: UseDisclosureOptions): {
+    isOpen: import('vue').ComputedRef<boolean>;
+    isDisabled: import('vue').ComputedRef<boolean>;
+    triggerId: import('vue').ComputedRef<string>;
+    panelId: import('vue').ComputedRef<string>;
+    setOpen: (nextOpen: boolean) => void;
+    toggle: () => void;
+};

package/dist/src/composables/useDisclosure.js

@@ -0,0 +1,20 @@
+import { computed as e, ref as t, toValue as n, useId as r } from "vue";
+//#region src/composables/useDisclosure.ts
+function i(i = {}) {
+	if (i.id !== void 0 && i.id.trim().length === 0) throw Error("useDisclosure: id must be a non-empty string");
+	if (i.open && !i.onUpdate) throw Error("useDisclosure: controlled open requires onUpdate");
+	if (i.open && i.defaultOpen !== void 0) throw Error("useDisclosure: controlled open cannot be combined with defaultOpen");
+	let a = r(), o = i.id ?? `s-disclosure-${a}`, s = t(i.defaultOpen ?? !1), c = i.open !== void 0, l = e(() => n(i.disabled ?? !1)), u = e(() => c ? i.open.value : s.value), d = e(() => `${o}-trigger`), f = e(() => `${o}-panel`), p = (e) => {
+		l.value || e === u.value || (c ? i.onUpdate(e) : s.value = e);
+	};
+	return {
+		isOpen: u,
+		isDisabled: l,
+		triggerId: d,
+		panelId: f,
+		setOpen: p,
+		toggle: () => p(!u.value)
+	};
+}
+//#endregion
+export { i as useDisclosure };

package/dist/src/composables/useFloatingPosition.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+export type FloatingSide = 'top' | 'bottom' | 'left' | 'right';
+export type FloatingAlignment = 'start' | 'center' | 'end';
+export type FloatingPlacement = `${FloatingSide}-${FloatingAlignment}`;
+export type FloatingWidthMatch = 'none' | 'min' | 'exact';
+export interface FloatingPositionOptions {
+    active: Readonly<Ref<boolean>>;
+    placement: () => FloatingPlacement;
+    anchorElement?: () => HTMLElement | null;
+    anchorRect?: () => DOMRect | null;
+    panelRef?: Ref<HTMLElement | null>;
+    offset?: () => number;
+    boundaryPadding?: () => number;
+    flip?: () => boolean;
+    shift?: () => boolean;
+    constrainMainAxis?: () => boolean;
+    widthMatch?: () => FloatingWidthMatch;
+    zIndex?: () => string;
+    scrollStrategy?: 'reposition' | 'close';
+    requestClose?: () => void;
+}
+export interface FloatingPositionController {
+    anchorRef: Ref<HTMLElement | null>;
+    panelRef: Ref<HTMLElement | null>;
+    floatingStyle: Ref<Record<string, string>>;
+    arrowStyle: Ref<Record<string, string>>;
+    resolvedPlacement: Ref<FloatingPlacement>;
+    coordinates: Ref<FloatingCoordinates>;
+    updatePosition: () => void;
+}
+/** Координаты floating-поверхности во viewport. / Floating-surface viewport coordinates. */
+export interface FloatingCoordinates {
+    left: number;
+    top: number;
+}
+/**
+ * Единый владелец geometry/collision/observer-контракта floating surfaces.
+ * Canonical owner of floating-surface geometry, collision and observers.
+ */
+export declare function useFloatingPosition(options: FloatingPositionOptions): FloatingPositionController;

package/dist/src/composables/useFloatingPosition.js

@@ -0,0 +1,124 @@
+import { nextTick as e, onBeforeUnmount as t, onMounted as n, ref as r, watch as i } from "vue";
+//#region src/composables/useFloatingPosition.ts
+var a = {
+	top: "bottom",
+	bottom: "top",
+	left: "right",
+	right: "left"
+};
+function o(e) {
+	return e.split("-");
+}
+function s(e, t, n, r) {
+	return r === "start" ? e : r === "end" ? e + t - n : e + (t - n) / 2;
+}
+function c(e, t, n, r, i, a) {
+	return e === "top" || e === "bottom" ? {
+		left: s(n.left, n.width, r, t),
+		top: e === "top" ? n.top - i - a : n.bottom + a
+	} : {
+		left: e === "left" ? n.left - r - a : n.right + a,
+		top: s(n.top, n.height, i, t)
+	};
+}
+function l(e, t, n, r, i, a, o) {
+	return e === "top" ? Math.max(0, o - t.top) : e === "bottom" ? Math.max(0, t.top + r - (a - o)) : e === "left" ? Math.max(0, o - t.left) : Math.max(0, t.left + n - (i - o));
+}
+function u(e, t) {
+	let n = Math.min(10, t / 2);
+	return Math.max(n, Math.min(e, t - n));
+}
+function d(s) {
+	let d = r(null), f = s.panelRef ?? r(null), p = r({}), m = r({}), h = r(s.placement()), g = r({
+		left: -1e4,
+		top: -1e4
+	}), _ = null, v = !1, y = () => {
+		if (!s.active.value || typeof window > "u") return;
+		let e = s.anchorElement?.() ?? d.value, t = f.value, n = s.anchorRect?.() ?? e?.getBoundingClientRect() ?? null;
+		if (!n || !t) return;
+		let r = t.getBoundingClientRect(), i = r.width || t.offsetWidth, _ = r.height || t.offsetHeight, v = s.offset?.() ?? 6, y = s.boundaryPadding?.() ?? 8, b = window.innerWidth, x = window.innerHeight, [S, C] = o(s.placement()), w = S, T = c(w, C, n, i, _, v);
+		if (s.flip?.() ?? !0) {
+			let e = a[w], t = c(e, C, n, i, _, v), r = l(w, T, i, _, b, x, y);
+			l(e, t, i, _, b, x, y) < r && (w = e, T = t);
+		}
+		let E = i, D = _, O = {};
+		if (s.constrainMainAxis?.() ?? !1) {
+			if (w === "top" || w === "bottom") {
+				let e = w === "top" ? n.top - v - y : x - y - n.bottom - v;
+				D = Math.min(_, Math.max(0, Math.floor(e))), O.maxHeight = `${D}px`, O.overflowY = "auto";
+			} else {
+				let e = w === "left" ? n.left - v - y : b - y - n.right - v;
+				E = Math.min(i, Math.max(0, Math.floor(e))), O.maxWidth = `${E}px`, O.overflowX = "auto";
+			}
+			T = c(w, C, n, E, D, v);
+		}
+		(s.shift?.() ?? !0) && (T.left = Math.max(y, Math.min(T.left, b - E - y)), T.top = Math.max(y, Math.min(T.top, x - D - y)));
+		let k = `${w}-${C}`;
+		h.value = k, g.value = {
+			left: Math.round(T.left),
+			top: Math.round(T.top)
+		};
+		let A = s.widthMatch?.() ?? "none";
+		if (p.value = {
+			position: "fixed",
+			left: `${g.value.left}px`,
+			top: `${g.value.top}px`,
+			zIndex: s.zIndex?.() ?? "var(--s-layer-root-floating)",
+			...O,
+			...A === "min" ? { minWidth: `${Math.round(n.width)}px` } : {},
+			...A === "exact" ? { width: `${Math.round(n.width)}px` } : {}
+		}, w === "top" || w === "bottom") {
+			let e = n.left + n.width / 2 - T.left;
+			m.value = { left: `${Math.round(u(e, i))}px` };
+		} else {
+			let e = n.top + n.height / 2 - T.top;
+			m.value = { top: `${Math.round(u(e, _))}px` };
+		}
+	}, b = () => {
+		if (s.active.value) {
+			if (s.scrollStrategy === "close") {
+				s.requestClose?.();
+				return;
+			}
+			y();
+		}
+	}, x = () => {
+		if (!(v || typeof window > "u") && (v = !0, window.addEventListener("resize", y, { passive: !0 }), window.addEventListener("scroll", b, {
+			passive: !0,
+			capture: !0
+		}), typeof ResizeObserver < "u")) {
+			_ = new ResizeObserver(y);
+			let e = s.anchorElement?.() ?? d.value;
+			e && _.observe(e), f.value && _.observe(f.value);
+		}
+	}, S = () => {
+		v && typeof window < "u" && (v = !1, window.removeEventListener("resize", y), window.removeEventListener("scroll", b, !0), _?.disconnect(), _ = null);
+	};
+	return i(s.active, async (t) => {
+		if (!t) {
+			S(), p.value = {}, m.value = {}, g.value = {
+				left: -1e4,
+				top: -1e4
+			};
+			return;
+		}
+		p.value = {
+			position: "fixed",
+			left: "-10000px",
+			top: "-10000px",
+			zIndex: s.zIndex?.() ?? "var(--s-layer-root-floating)"
+		}, await e(), x(), y();
+	}, { immediate: !0 }), n(() => {
+		s.active.value && (x(), y());
+	}), t(S), {
+		anchorRef: d,
+		panelRef: f,
+		floatingStyle: p,
+		arrowStyle: m,
+		resolvedPlacement: h,
+		coordinates: g,
+		updatePosition: y
+	};
+}
+//#endregion
+export { d as useFloatingPosition };

package/dist/src/composables/useNotifier.d.ts

@@ -0,0 +1,10 @@
+import { NotificationInput } from '../stores/useNotifierStore';
+export type NotifyOptions = Pick<NotificationInput, 'title' | 'message' | 'duration'>;
+type NotifyArg = NotifyOptions | string;
+export declare function useNotifier(): {
+    info: (options: NotifyArg) => void;
+    success: (options: NotifyArg) => void;
+    warn: (options: NotifyArg) => void;
+    danger: (options: NotifyArg) => void;
+};
+export {};

package/dist/src/composables/useNotifier.js

@@ -0,0 +1,19 @@
+import { useNotifierStore as e } from "../stores/useNotifierStore.js";
+//#region src/composables/useNotifier.ts
+function t() {
+	let t = e(), n = (e, n) => {
+		let r = typeof n == "string" ? { message: n } : n;
+		t.add({
+			severity: e,
+			...r
+		});
+	};
+	return {
+		info: (e) => n("info", e),
+		success: (e) => n("success", e),
+		warn: (e) => n("warn", e),
+		danger: (e) => n("danger", e)
+	};
+}
+//#endregion
+export { t as useNotifier };

package/dist/src/composables/useSidebarPanelState.d.ts

@@ -0,0 +1,86 @@
+import { SectionState } from '../components/shared/containers/sidebar';
+import { UiPreferencesResetController } from './uiPreferencesReset';
+declare const MEMORY_STATE_RECOVERY: "continue-with-memory-state";
+export declare const SIDEBAR_PANEL_STATE_SCHEMA_VERSION: 2;
+/**
+ * Дефолтный layout-contract секции sidebar.
+ * Default layout contract for a sidebar section.
+ */
+export interface SectionDefaultConfig {
+    defaultIsOpen: boolean;
+    defaultSize: number | null;
+    minSize?: number;
+}
+/**
+ * Точный storage-contract, нужный owner состояния sidebar.
+ * Exact storage contract required by the sidebar state owner.
+ */
+export interface SidebarPanelStateStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export type SidebarPanelStatePersistenceErrorCode = 'storage-resolution-failed' | 'read-failed' | 'invalid-json' | 'invalid-schema' | 'write-failed' | 'remove-failed';
+/**
+ * Диагностируемая ошибка persistence с точными operation, storage key и path.
+ * Diagnosable persistence error with exact operation, storage key, and path.
+ */
+export declare class SidebarPanelStatePersistenceError extends Error {
+    readonly code: SidebarPanelStatePersistenceErrorCode;
+    readonly storageKey: string;
+    readonly path: string;
+    readonly cause: unknown;
+    constructor(options: {
+        code: SidebarPanelStatePersistenceErrorCode;
+        storageKey: string;
+        path?: string;
+        message: string;
+        cause: unknown;
+    });
+}
+/**
+ * Ошибка публичного runtime/config contract sidebar state.
+ * Error in the public sidebar state runtime or configuration contract.
+ */
+export declare class SidebarPanelStateContractError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+/**
+ * Явное решение consumer продолжить с in-memory state после диагностики persistence-ошибки.
+ * Explicit consumer decision to continue with in-memory state after diagnosing a persistence error.
+ */
+export type SidebarPanelStatePersistenceRecovery = typeof MEMORY_STATE_RECOVERY;
+/**
+ * Явные runtime dependencies для persistence и scoped reset.
+ * Explicit runtime dependencies for persistence and scoped reset.
+ */
+export interface SidebarPanelStateRuntime {
+    resolveStorage(): SidebarPanelStateStorage | null;
+    resetController: UiPreferencesResetController;
+    recoverFromPersistenceError(error: SidebarPanelStatePersistenceError): SidebarPanelStatePersistenceRecovery;
+}
+/**
+ * Управляет disclosure/size state всех секций sidebar через один validated owner.
+ * Owns disclosure/size state for every sidebar section through one validated owner.
+ *
+ * Persisted v2 document содержит exact `{ version, sections }`. Валидный unversioned v1 record
+ * мигрирует один раз по объявленным default/min layout values; невалидный v2 целиком удаляется
+ * только после явного recovery-решения runtime.
+ * The persisted v2 document is exact `{ version, sections }`. A valid unversioned v1 record is
+ * migrated once from declared default/min layout values; invalid v2 data is removed as a whole
+ * only after the runtime explicitly accepts memory-state recovery.
+ */
+export declare function useSidebarPanelState(storageKey: string, defaultConfig: Record<string, SectionDefaultConfig>, runtime: SidebarPanelStateRuntime): {
+    sectionsState: {
+        readonly [x: string]: {
+            readonly isOpen: boolean;
+            readonly size: number | null;
+            readonly minSize: number;
+        };
+    };
+    updateSections: (newState: Record<string, SectionState>) => void;
+    toggleSection: (sectionKey: string) => void;
+    resetSections: () => void;
+};
+export {};

package/dist/src/composables/useSidebarPanelState.js

@@ -0,0 +1,264 @@
+import { hasOwn as e, lastItem as t } from "../internal/es2020.js";
+import { assertSidebarSectionsState as n } from "../components/shared/containers/sidebar.js";
+import { computed as r, getCurrentScope as i, onScopeDispose as a, reactive as o, readonly as s, watch as c } from "vue";
+//#region src/composables/useSidebarPanelState.ts
+var l = 40, u = "continue-with-memory-state", d = 2, f = class extends Error {
+	constructor(e) {
+		super(e.message), this.name = "SidebarPanelStatePersistenceError", this.code = e.code, this.storageKey = e.storageKey, this.path = e.path ?? "$", this.cause = e.cause;
+	}
+}, p = class extends Error {
+	constructor(e, t) {
+		super(`Sidebar panel state contract violation at ${e}: ${t}`), this.name = "SidebarPanelStateContractError", this.path = e;
+	}
+}, m = (e) => typeof e == "object" && !!e && !Array.isArray(e), h = (e) => e === null || typeof e == "number" && Number.isFinite(e) && e >= 0;
+function g(e, t, n) {
+	let r = Object.keys(e).sort(), i = [...t].sort();
+	if (r.length !== i.length || r.some((e, t) => e !== i[t])) throw new p(n, `expected keys [${i.join(", ")}], received [${r.join(", ")}]`);
+}
+function _(e, t) {
+	try {
+		n(e, "useSidebarPanelState");
+	} catch (e) {
+		throw new p(t, e instanceof Error ? e.message : "invalid sidebar layout state");
+	}
+}
+function v(e) {
+	if (!m(e)) throw new p("defaultConfig", "expected an object");
+	let t = Object.keys(e);
+	if (t.length === 0) throw new p("defaultConfig", "at least one section is required");
+	for (let n of t) {
+		if (n.trim().length === 0) throw new p("defaultConfig", "section keys must not be empty");
+		let t = e[n], r = `defaultConfig.${n}`;
+		if (!m(t)) throw new p(r, "expected an object");
+		if (g(t, t.minSize === void 0 ? ["defaultIsOpen", "defaultSize"] : [
+			"defaultIsOpen",
+			"defaultSize",
+			"minSize"
+		], r), typeof t.defaultIsOpen != "boolean") throw new p(`${r}.defaultIsOpen`, "expected a boolean");
+		if (!h(t.defaultSize)) throw new p(`${r}.defaultSize`, "expected null or a finite non-negative number");
+		if (t.minSize !== void 0 && (typeof t.minSize != "number" || !Number.isFinite(t.minSize) || t.minSize <= 0)) throw new p(`${r}.minSize`, "expected a finite positive number");
+	}
+	return _(E(e, t, {}), "defaultConfig"), t;
+}
+function y(e) {
+	if (!m(e)) throw new p("runtime", "expected an object");
+	if (g(e, [
+		"recoverFromPersistenceError",
+		"resetController",
+		"resolveStorage"
+	], "runtime"), typeof e.resolveStorage != "function") throw new p("runtime.resolveStorage", "expected a function");
+	if (typeof e.recoverFromPersistenceError != "function") throw new p("runtime.recoverFromPersistenceError", "expected a function");
+	if (!m(e.resetController)) throw new p("runtime.resetController", "expected an object");
+	if (typeof e.resetController.subscribe != "function") throw new p("runtime.resetController.subscribe", "expected a function");
+	if (typeof e.resetController.requestReset != "function") throw new p("runtime.resetController.requestReset", "expected a function");
+}
+function b(e, t, n = "$") {
+	if (!m(e)) throw new p(n, "expected an object");
+	let r = new Set(t), i = {};
+	for (let [t, a] of Object.entries(e)) {
+		let e = `${n}.${t}`;
+		if (!r.has(t)) throw new p(e, "unknown section");
+		if (!m(a)) throw new p(e, "expected an object");
+		if (g(a, ["isOpen", "size"], e), typeof a.isOpen != "boolean") throw new p(`${e}.isOpen`, "expected a boolean");
+		if (!h(a.size)) throw new p(`${e}.size`, "expected null or a finite non-negative number");
+		i[t] = {
+			isOpen: a.isOpen,
+			size: a.size
+		};
+	}
+	return i;
+}
+function x(e) {
+	return {
+		version: 2,
+		sections: e
+	};
+}
+function S(e, n, r) {
+	let i = r.filter((t) => e[t]?.isOpen);
+	if (i.length === 0) return null;
+	let a = r.find((e) => {
+		let t = n[e];
+		return t?.defaultIsOpen === !0 && t.defaultSize === null;
+	});
+	return a && e[a]?.isOpen ? a : t(i) ?? null;
+}
+function C(e, t, n) {
+	let r = E(t, n, e), i = S(r, t, n), a = Object.fromEntries(n.map((e) => {
+		let n = r[e], a = t[e], o = n.isOpen && e === i ? null : n.isOpen && n.size === null ? a.defaultSize ?? a.minSize ?? l : n.size;
+		return [e, {
+			...n,
+			size: o
+		}];
+	}));
+	return _(a, "$.sections"), Object.fromEntries(n.map((e) => {
+		let t = a[e];
+		return [e, {
+			isOpen: t.isOpen,
+			size: t.size
+		}];
+	}));
+}
+function w(t, n, r) {
+	if (!m(t)) throw new p("$", "expected an object");
+	if (e(t, "version") || e(t, "sections")) {
+		if (g(t, ["sections", "version"], "$"), t.version !== 2) throw new p("$.version", `expected 2, received ${String(t.version)}`);
+		let e = b(t.sections, r, "$.sections");
+		return _(E(n, r, e), "$.sections"), {
+			sections: e,
+			migratedFromVersion: null
+		};
+	}
+	return {
+		sections: C(b(t, r), n, r),
+		migratedFromVersion: 1
+	};
+}
+function T(e, t, n) {
+	if (!m(e)) throw new p("newState", "expected an object");
+	g(e, n, "newState");
+	for (let r of n) {
+		let n = e[r], i = `newState.${r}`;
+		if (!m(n)) throw new p(i, "expected an object");
+		if (g(n, [
+			"isOpen",
+			"size",
+			"minSize"
+		], i), typeof n.isOpen != "boolean") throw new p(`${i}.isOpen`, "expected a boolean");
+		if (!h(n.size)) throw new p(`${i}.size`, "expected null or a finite non-negative number");
+		let a = t[r]?.minSize ?? l;
+		if (n.minSize !== a) throw new p(`${i}.minSize`, `expected configured value ${a}, received ${String(n.minSize)}`);
+	}
+	_(e, "newState");
+}
+function E(e, t, n) {
+	return Object.fromEntries(t.map((t) => {
+		let r = e[t], i = n[t];
+		return [t, {
+			isOpen: i?.isOpen ?? r.defaultIsOpen,
+			size: i === void 0 ? r.defaultSize : i.size,
+			minSize: r.minSize ?? l
+		}];
+	}));
+}
+function D(e, t, n) {
+	if (typeof e != "string" || e.trim().length === 0) throw new p("storageKey", "expected a non-empty string");
+	if (y(n), !i()) throw new p("runtime.scope", "useSidebarPanelState must run inside an active Vue effect scope");
+	let d = v(t), m = (e) => {
+		let t = n.recoverFromPersistenceError(e);
+		if (t !== u) throw new p("runtime.recoverFromPersistenceError", `expected "${u}", received ${String(t)}`);
+	}, h = null;
+	try {
+		h = n.resolveStorage();
+	} catch (t) {
+		m(new f({
+			code: "storage-resolution-failed",
+			storageKey: e,
+			message: `Unable to resolve sidebar state storage for "${e}".`,
+			cause: t
+		}));
+	}
+	let g = () => {
+		if (h) try {
+			h.removeItem(e);
+		} catch (t) {
+			m(new f({
+				code: "remove-failed",
+				storageKey: e,
+				message: `Unable to remove sidebar state for "${e}".`,
+				cause: t
+			}));
+		}
+	}, _ = (t) => {
+		if (h) try {
+			h.setItem(e, JSON.stringify(x(t)));
+		} catch (t) {
+			m(new f({
+				code: "write-failed",
+				storageKey: e,
+				message: `Unable to write sidebar state for "${e}".`,
+				cause: t
+			}));
+		}
+	}, b = o(E(t, d, (() => {
+		if (!h) return {};
+		let n;
+		try {
+			n = h.getItem(e);
+		} catch (t) {
+			return m(new f({
+				code: "read-failed",
+				storageKey: e,
+				message: `Unable to read sidebar state for "${e}".`,
+				cause: t
+			})), {};
+		}
+		if (n === null) return {};
+		let r;
+		try {
+			r = JSON.parse(n);
+		} catch (t) {
+			return m(new f({
+				code: "invalid-json",
+				storageKey: e,
+				message: `Persisted sidebar state for "${e}" is not valid JSON.`,
+				cause: t
+			})), g(), {};
+		}
+		try {
+			let e = w(r, t, d);
+			return e.migratedFromVersion === 1 && _(e.sections), e.sections;
+		} catch (t) {
+			return m(new f({
+				code: "invalid-schema",
+				storageKey: e,
+				path: t instanceof p ? t.path : "$",
+				message: `Persisted sidebar state for "${e}" does not match its schema.`,
+				cause: t
+			})), g(), {};
+		}
+	})())), S = r(() => x(Object.fromEntries(d.map((e) => {
+		let t = b[e];
+		return [e, {
+			isOpen: t.isOpen,
+			size: t.size
+		}];
+	}))));
+	c(S, (e) => {
+		_(e.sections);
+	}, { deep: !0 });
+	let C = (e) => {
+		T(e, t, d);
+		for (let t of d) b[t] = { ...e[t] };
+	}, D = (e) => {
+		if (!b[e]) throw new p(`sectionsState.${e}`, "cannot toggle an unknown section");
+		let n = Object.fromEntries(d.map((e) => [e, { ...b[e] }])), r = n[e], i = d.filter((t) => t !== e && n[t]?.isOpen);
+		if (r.isOpen) {
+			if (r.isOpen = !1, r.size === null && i.length > 0) {
+				let t = d.indexOf(e), r = [...i].sort((e, n) => Math.abs(d.indexOf(e) - t) - Math.abs(d.indexOf(n) - t))[0];
+				n[r] = {
+					...n[r],
+					size: null
+				};
+			}
+		} else if (r.isOpen = !0, i.length === 0) r.size = null;
+		else if (r.size === null) {
+			let n = t[e];
+			r.size = n.defaultSize ?? n.minSize ?? l;
+		}
+		T(n, t, d);
+		for (let e of d) b[e] = n[e];
+	}, O = () => {
+		g();
+		let e = E(t, d, {});
+		for (let t of d) b[t] = e[t];
+	}, k = n.resetController.subscribe(O);
+	return a(k), {
+		sectionsState: s(b),
+		updateSections: C,
+		toggleSection: D,
+		resetSections: O
+	};
+}
+//#endregion
+export { d as SIDEBAR_PANEL_STATE_SCHEMA_VERSION, p as SidebarPanelStateContractError, f as SidebarPanelStatePersistenceError, D as useSidebarPanelState };

package/dist/src/composables/useUiKitLocale.d.ts

@@ -0,0 +1,6 @@
+import { UiKitLocaleContext } from '../internal/localeContext';
+/** Returns the immutable locale contract scoped to the current Vue application subtree. */
+export declare function useUiKitLocale(): UiKitLocaleContext;
+export type { UiKitLocale, UiKitMessageKey, UiKitMessageParameters, UiKitMessages, UiKitMessagesOverride, UiKitTranslate, } from '../locales/locale';
+export { UI_KIT_LOCALES } from '../locales/locale';
+export { UI_KIT_MESSAGES, UI_KIT_MESSAGE_KEYS } from '../locales/messages';

package/dist/src/composables/useUiKitLocale.js

@@ -0,0 +1,9 @@
+import { UI_KIT_MESSAGES as e, UI_KIT_MESSAGE_KEYS as t } from "../locales/messages.js";
+import { resolveUiKitLocaleContext as n } from "../internal/localeContext.js";
+import { UI_KIT_LOCALES as r } from "../locales/locale.js";
+//#region src/composables/useUiKitLocale.ts
+function i() {
+	return n();
+}
+//#endregion
+export { r as UI_KIT_LOCALES, e as UI_KIT_MESSAGES, t as UI_KIT_MESSAGE_KEYS, i as useUiKitLocale };