@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/data-display/table.d.ts

@@ -0,0 +1,45 @@
+import { TableColumnInlineSize, TableColumnMinInlineSize } from '../../../internal/semanticSizing';
+export type STableRowKey = string | number;
+export type STableAlignment = 'left' | 'center' | 'right';
+export type STableRowState = 'default' | 'inserted' | 'updated' | 'deleted';
+export type STableCellState = 'default' | 'pending';
+export type STableSurface = 'bordered' | 'plain';
+export type STableMinWidth = 'content' | 'md' | 'lg';
+export type STableDensity = 'default' | 'compact';
+export type STableColumnContent = 'field' | 'value' | 'slot';
+export type STableColumnHeaderPresentation = 'visible' | 'assistive';
+export type STableSelectionMode = 'none' | 'multiple';
+export type STableSortDirection = 'ascending' | 'descending';
+export type STableSortMode = 'single' | 'multiple';
+/** Controlled sort state; consumer owns data ordering. / Управляемое состояние сортировки; порядок данных принадлежит consumer. */
+export interface STableSort<Field extends string = string> {
+    key: Field;
+    direction: STableSortDirection;
+}
+interface STableColumnBase<Field extends string> {
+    field: Field;
+    header: string;
+    headerPresentation?: STableColumnHeaderPresentation;
+    width?: TableColumnInlineSize;
+    minWidth?: TableColumnMinInlineSize;
+    align?: STableAlignment;
+    sortable?: boolean;
+}
+type STableFieldColumn<Field extends string> = STableColumnBase<Field> & {
+    content?: 'field';
+    value?: never;
+};
+type STableValueColumn<Row extends object, Field extends string> = STableColumnBase<Field> & {
+    content?: 'value';
+    value: (row: Row) => unknown;
+};
+type STableSlotColumn<Field extends string> = STableColumnBase<Field> & {
+    content: 'slot';
+    value?: never;
+};
+/**
+ * Столбец напрямую читает typed field строки; derived field обязан предоставить value resolver.
+ * A column reads a typed row field directly; a derived field must provide a value resolver.
+ */
+export type STableColumn<Row extends object = Record<string, unknown>, Field extends string = Extract<keyof Row, string>> = STableValueColumn<Row, Field> | STableSlotColumn<Field> | (Field extends Extract<keyof Row, string> ? STableFieldColumn<Field> : never);
+export type { STableProps } from './STable.vue';

package/dist/src/components/shared/data-display/toast.d.ts

@@ -0,0 +1,44 @@
+import { SButtonAppearance } from '../controls/SButton.vue';
+import { FeedbackSeverity } from '../../../internal/feedbackPresentation';
+/** Serializable notification identity owned by the consumer. */
+export type SToastId = string | number;
+/** Serializable action identity owned by the consumer. */
+export type SToastActionId = string | number;
+/** Placement of a controlled toast viewport in the application viewport. */
+export declare const S_TOAST_POSITIONS: readonly ["top-start", "top-center", "top-end", "bottom-start", "bottom-center", "bottom-end"];
+export type SToastPosition = (typeof S_TOAST_POSITIONS)[number];
+/** Selects the owner of presentation lifetime without changing data ownership. */
+export declare const S_TOAST_LIFETIME_OWNERS: readonly ["consumer", "viewport"];
+export type SToastLifetimeOwner = (typeof S_TOAST_LIFETIME_OWNERS)[number];
+/** Serializable action rendered by the shared toast presentation. */
+export interface SToastAction<ActionId extends SToastActionId = string> {
+    readonly id: ActionId;
+    readonly label: string;
+    readonly appearance?: SButtonAppearance;
+}
+/** Controlled notification record. The viewport never mutates this record or its source array. */
+export interface SToastPresentation<Id extends SToastId = string, ActionId extends SToastActionId = string> {
+    readonly id: Id;
+    readonly severity: FeedbackSeverity;
+    readonly title?: string;
+    readonly message: string;
+    readonly actions?: readonly SToastAction<ActionId>[];
+    readonly dismissible?: boolean;
+    /** Presentation lifetime in milliseconds. Omitted or zero means persistent. */
+    readonly durationMs?: number;
+}
+export interface SToastDismissIntent<Id extends SToastId = string> {
+    readonly id: Id;
+    readonly reason: 'close';
+}
+export interface SToastActionIntent<Id extends SToastId = string, ActionId extends SToastActionId = string> {
+    readonly notificationId: Id;
+    readonly actionId: ActionId;
+}
+export interface SToastLifetimeExpiredIntent<Id extends SToastId = string> {
+    readonly id: Id;
+}
+/** Runtime-validates a readonly controlled notification list and preserves its generic IDs. */
+export declare function validateToastPresentations<Id extends SToastId, ActionId extends SToastActionId>(owner: string, value: readonly SToastPresentation<Id, ActionId>[]): readonly SToastPresentation<Id, ActionId>[];
+export declare function validateToastPosition(value: unknown): SToastPosition;
+export declare function validateToastLifetimeOwner(value: unknown): SToastLifetimeOwner;

package/dist/src/components/shared/data-display/toast.js

@@ -0,0 +1,81 @@
+import { validateBoolean as e, validateBoundedInteger as t, validateExactString as n, validateNonEmptyString as r } from "../../../internal/runtimeContract.js";
+//#region src/components/shared/data-display/toast.ts
+var i = [
+	"top-start",
+	"top-center",
+	"top-end",
+	"bottom-start",
+	"bottom-center",
+	"bottom-end"
+], a = ["consumer", "viewport"], o = [
+	"info",
+	"success",
+	"warn",
+	"danger"
+], s = [
+	"solid",
+	"soft",
+	"outline",
+	"ghost",
+	"text"
+], c = /* @__PURE__ */ new Set([
+	"id",
+	"severity",
+	"title",
+	"message",
+	"actions",
+	"dismissible",
+	"durationMs"
+]), l = /* @__PURE__ */ new Set([
+	"id",
+	"label",
+	"appearance"
+]);
+function u(e, t, n) {
+	if (typeof n != "object" || !n || Array.isArray(n)) throw TypeError(`${e}: ${t} должен быть object. / ${e}: ${t} must be an object.`);
+}
+function d(e, t, n, r) {
+	let i = Object.keys(n).filter((e) => !r.has(e));
+	if (i.length !== 0) throw TypeError(`${e}: ${t} содержит неизвестные поля ${i.map((e) => JSON.stringify(e)).join(", ")}. / ${e}: ${t} contains unknown fields ${i.map((e) => JSON.stringify(e)).join(", ")}.`);
+}
+function f(e, t, n) {
+	if (typeof n == "string") return r(e, t, n);
+	if (typeof n == "number" && Number.isFinite(n)) return n;
+	throw TypeError(`${e}: ${t} должен быть непустой строкой или конечным числом. / ${e}: ${t} must be a non-empty string or finite number.`);
+}
+function p(e, t, i) {
+	u(e, t, i), d(e, t, i, l), f(e, `${t}.id`, i.id), r(e, `${t}.label`, i.label), i.appearance !== void 0 && n(e, `${t}.appearance`, i.appearance, s);
+}
+function m(i, a) {
+	if (!Array.isArray(a)) throw TypeError(`${i}: notifications должен быть массивом. / ${i}: notifications must be an array.`);
+	let s = /* @__PURE__ */ new Set();
+	return a.forEach((a, l) => {
+		let m = `notifications[${l}]`;
+		u(i, m, a), d(i, m, a, c);
+		let h = f(i, `${m}.id`, a.id);
+		if (s.has(h)) throw TypeError(`${i}: ${m}.id дублирует ${JSON.stringify(h)}. / ${i}: ${m}.id duplicates ${JSON.stringify(h)}.`);
+		if (s.add(h), n(i, `${m}.severity`, a.severity, o), a.title !== void 0 && r(i, `${m}.title`, a.title), typeof a.message != "string") throw TypeError(`${i}: ${m}.message должен быть строкой. / ${i}: ${m}.message must be a string.`);
+		if (a.dismissible !== void 0 && e(i, `${m}.dismissible`, a.dismissible), a.durationMs !== void 0 && t(i, `${m}.durationMs`, a.durationMs, {
+			minimum: 0,
+			maximum: 2147483647
+		}), a.actions !== void 0) {
+			if (!Array.isArray(a.actions)) throw TypeError(`${i}: ${m}.actions должен быть массивом. / ${i}: ${m}.actions must be an array.`);
+			let e = /* @__PURE__ */ new Set();
+			a.actions.forEach((t, n) => {
+				let r = `${m}.actions[${n}]`;
+				p(i, r, t);
+				let a = f(i, `${r}.id`, t.id);
+				if (e.has(a)) throw TypeError(`${i}: ${r}.id дублирует ${JSON.stringify(a)}. / ${i}: ${r}.id duplicates ${JSON.stringify(a)}.`);
+				e.add(a);
+			});
+		}
+	}), a;
+}
+function h(e) {
+	return n("SControlledToastViewport", "position", e, i);
+}
+function g(e) {
+	return n("SControlledToastViewport", "lifetimeOwner", e, a);
+}
+//#endregion
+export { a as S_TOAST_LIFETIME_OWNERS, i as S_TOAST_POSITIONS, g as validateToastLifetimeOwner, h as validateToastPosition, m as validateToastPresentations };

package/dist/src/components/shared/database/SDataGrid.vue.d.ts

@@ -0,0 +1,68 @@
+import { SDataGridCell, SDataGridCommitInput, SDataGridEditPayload, SDataGridColumn, SDataGridColumnKey, SDataGridRow } from './dataGrid';
+import { ScrollableViewportMaxBlockSize } from '../../../internal/semanticSizing';
+export type { SDataGridCell, SDataGridCellKind, SDataGridColumn, SDataGridColumnKey, SDataGridCommitInput, SDataGridEditPayload, SDataGridRow, SDataGridRowState, } from './dataGrid';
+/** Публичный контракт data grid принадлежит source-SFC runtime. / The public data-grid contract is owned by the source-SFC runtime. */
+export interface SDataGridProps<Key extends SDataGridColumnKey = SDataGridColumnKey> {
+    columns: readonly SDataGridColumn<Key>[];
+    rows: readonly SDataGridRow<Key>[];
+    title?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    errorMessage?: string;
+    emptyMessage?: string;
+    selectedRowId?: string;
+    maxHeight?: ScrollableViewportMaxBlockSize;
+    /** Surface chrome для самостоятельного или вложенного grid. / Surface chrome for a standalone or embedded grid. */
+    presentation?: 'panel' | 'embedded';
+    /** Accessible name без visible title. / Accessible name when there is no visible title. */
+    ariaLabel?: string;
+    /** DOM id external visible title. / DOM id of an external visible title. */
+    ariaLabelledby?: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <ColumnKey extends string = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<SDataGridProps<ColumnKey> & {
+        "onCell-edit"?: ((payload: SDataGridEditPayload<ColumnKey>) => any) | undefined;
+        "onCell-commit"?: ((payload: SDataGridEditPayload<ColumnKey>) => any) | undefined;
+        "onCell-cancel"?: ((payload: Omit<SDataGridEditPayload<ColumnKey>, "value">) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        actions?: (props: {
+            pendingCount: number;
+            readonly: boolean;
+            disabled: boolean;
+        }) => any;
+    } & {
+        column?: (props: {
+            column: SDataGridColumn<ColumnKey>;
+        }) => any;
+    } & {
+        cell?: (props: {
+            row: SDataGridRow<ColumnKey>;
+            column: SDataGridColumn<ColumnKey>;
+            cell: SDataGridCell;
+            editable: boolean;
+            edit: (value: string) => void;
+            commit: (input: SDataGridCommitInput) => void;
+            cancel: () => void;
+        }) => any;
+    } & {
+        status?: (props: {
+            pendingCount: number;
+        }) => any;
+    };
+    emit: ((evt: "cell-edit", payload: SDataGridEditPayload<ColumnKey>) => void) & ((evt: "cell-commit", payload: SDataGridEditPayload<ColumnKey>) => void) & ((evt: "cell-cancel", payload: Omit<SDataGridEditPayload<ColumnKey>, "value">) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/src/components/shared/database/SDataGrid.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/database/SDataGrid.css_vue_type_style_index_0_src_09e3ea65_scoped_09e3ea65_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SDataGrid.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                       */
+//#region src/components/shared/database/SDataGrid.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-09e3ea65"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/database/SDataGrid.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,317 @@
+import { hasOwn as e } from "../../../internal/es2020.js";
+import { useUiKitLocale as t } from "../../../composables/useUiKitLocale.js";
+import { useOwnedAttrs as n } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as r, validateDomId as i, validateExactString as a, validateNonEmptyString as o } from "../../../internal/runtimeContract.js";
+import s from "../containers/SPanel.vue.js";
+import c from "../data-display/SStatus.vue.js";
+import ee from "../controls/SInputText.vue.js";
+import { validateScrollableViewportMaxBlockSize as te, validateTableColumnInlineSize as ne, validateTableColumnMinInlineSize as re } from "../../../internal/semanticSizing.js";
+import ie from "../data-display/STable.vue.js";
+import { computed as l, createBlock as u, createElementBlock as ae, createSlots as oe, createTextVNode as se, createVNode as d, defineComponent as f, mergeProps as ce, openBlock as p, reactive as m, renderSlot as h, toDisplayString as g, unref as _, useId as v, useSlots as y, watch as le, withCtx as b, withKeys as x, withModifiers as S } from "vue";
+//#region src/components/shared/database/SDataGrid.vue?vue&type=script&setup=true&lang.ts
+var C = ["title"], w = /*@__PURE__*/ f({
+	inheritAttrs: !1,
+	__name: "SDataGrid",
+	props: {
+		columns: {},
+		rows: {},
+		title: { default: void 0 },
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readOnly: {
+			type: Boolean,
+			default: !1
+		},
+		errorMessage: { default: "" },
+		emptyMessage: { default: void 0 },
+		selectedRowId: { default: void 0 },
+		maxHeight: { default: "none" },
+		presentation: { default: "panel" },
+		ariaLabel: { default: void 0 },
+		ariaLabelledby: { default: void 0 }
+	},
+	emits: [
+		"cell-edit",
+		"cell-commit",
+		"cell-cancel"
+	],
+	setup(f, { emit: w }) {
+		let T = f, { t: E } = t(), ue = l(() => T.emptyMessage ?? E("table.dataGridEmpty")), D = n({
+			component: "SDataGrid",
+			owner: "data grid adapter root"
+		}), O = y(), k = w, A = [
+			"text",
+			"number",
+			"boolean",
+			"json",
+			"datetime",
+			"binary"
+		], de = [
+			"left",
+			"center",
+			"right"
+		], fe = [
+			"clean",
+			"inserted",
+			"updated",
+			"deleted"
+		], pe = ["draft", "value"], me = ["panel", "embedded"];
+		function j(e, t) {
+			if (!Array.isArray(e)) throw TypeError(`SDataGrid: ${t} должен быть array. / SDataGrid: ${t} must be an array.`);
+		}
+		function M(e, t) {
+			if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError(`SDataGrid: ${t} должен быть object. / SDataGrid: ${t} must be an object.`);
+		}
+		function N(e, t) {
+			t !== void 0 && r("SDataGrid", e, t);
+		}
+		function P(e, t, n) {
+			let r = `rows[${JSON.stringify(e)}].cells[${JSON.stringify(t.key)}]`;
+			if (M(n, r), typeof n.display != "string") throw TypeError(`SDataGrid: ${r}.display должен быть string. / SDataGrid: ${r}.display must be a string.`);
+			if (n.kind !== void 0) {
+				let e = a("SDataGrid", `${r}.kind`, n.kind, A);
+				if (t.type !== void 0 && e !== t.type) throw TypeError(`SDataGrid: ${r}.kind ${JSON.stringify(e)} не совпадает с column.type ${JSON.stringify(t.type)}. / SDataGrid: ${r}.kind ${JSON.stringify(e)} does not match column.type ${JSON.stringify(t.type)}.`);
+			}
+			N(`${r}.pending`, n.pending), N(`${r}.readonly`, n.readonly);
+		}
+		let F = l(() => {
+			j(T.columns, "columns"), j(T.rows, "rows");
+			let t = /* @__PURE__ */ new Map();
+			for (let e of T.columns) {
+				M(e, "columns[]");
+				let n = e, r = o("SDataGrid", "columns[].key", n.key);
+				if (o("SDataGrid", `columns[${JSON.stringify(r)}].label`, n.label), t.has(r)) throw TypeError(`SDataGrid: columns содержит duplicate key ${JSON.stringify(r)}. / SDataGrid: columns contains duplicate key ${JSON.stringify(r)}.`);
+				n.type !== void 0 && a("SDataGrid", `columns[${JSON.stringify(r)}].type`, n.type, A), n.width !== void 0 && ne("SDataGrid", `columns[${JSON.stringify(r)}].width`, n.width), n.minWidth !== void 0 && re("SDataGrid", `columns[${JSON.stringify(r)}].minWidth`, n.minWidth), n.align !== void 0 && a("SDataGrid", `columns[${JSON.stringify(r)}].align`, n.align, de), N(`columns[${JSON.stringify(r)}].editable`, n.editable), t.set(r, n);
+			}
+			let n = /* @__PURE__ */ new Map();
+			for (let r of T.rows) {
+				M(r, "rows[]");
+				let i = r, s = o("SDataGrid", "rows[].id", i.id);
+				if (n.has(s)) throw TypeError(`SDataGrid: rows содержит duplicate id ${JSON.stringify(s)}. / SDataGrid: rows contains duplicate id ${JSON.stringify(s)}.`);
+				i.state !== void 0 && a("SDataGrid", `rows[${JSON.stringify(s)}].state`, i.state, fe), M(i.cells, `rows[${JSON.stringify(s)}].cells`);
+				let c = Object.keys(i.cells);
+				for (let e of c) if (!t.has(e)) throw TypeError(`SDataGrid: row ${JSON.stringify(s)} содержит unknown cell ${JSON.stringify(e)}. / SDataGrid: row ${JSON.stringify(s)} contains unknown cell ${JSON.stringify(e)}.`);
+				for (let [n, r] of t) {
+					if (!e(i.cells, n)) throw TypeError(`SDataGrid: row ${JSON.stringify(s)} не содержит cell ${JSON.stringify(n)}. / SDataGrid: row ${JSON.stringify(s)} is missing cell ${JSON.stringify(n)}.`);
+					P(s, r, i.cells[n]);
+				}
+				n.set(s, i);
+			}
+			return {
+				columns: T.columns,
+				rows: T.rows,
+				columnByKey: t,
+				rowById: n
+			};
+		}), I = l(() => T.title === void 0 ? void 0 : o("SDataGrid", "title", T.title)), L = `s-data-grid-title-${v()}`, R = `s-data-grid-status-${v()}`, z = l(() => {
+			if (I.value !== void 0) {
+				if (T.ariaLabel !== void 0 || T.ariaLabelledby !== void 0) throw TypeError("SDataGrid: title уже задаёт accessible name; не передавайте ariaLabel/ariaLabelledby. / SDataGrid: title already provides the accessible name; do not provide ariaLabel/ariaLabelledby.");
+				return {
+					ariaLabel: void 0,
+					ariaLabelledby: L
+				};
+			}
+			if (T.ariaLabel !== void 0 && T.ariaLabelledby !== void 0) throw TypeError("SDataGrid: задайте только ariaLabel или ariaLabelledby. / SDataGrid: provide only ariaLabel or ariaLabelledby.");
+			return T.ariaLabelledby === void 0 ? {
+				ariaLabel: T.ariaLabel === void 0 ? E("table.accessibleName") : o("SDataGrid", "ariaLabel", T.ariaLabel),
+				ariaLabelledby: void 0
+			} : {
+				ariaLabel: void 0,
+				ariaLabelledby: i("SDataGrid", "ariaLabelledby", T.ariaLabelledby)
+			};
+		}), he = l(() => r("SDataGrid", "loading", T.loading)), B = l(() => r("SDataGrid", "disabled", T.disabled)), V = l(() => r("SDataGrid", "readOnly", T.readOnly)), H = l(() => a("SDataGrid", "presentation", T.presentation, me)), ge = l(() => te("SDataGrid", "maxHeight", T.maxHeight)), _e = l(() => F.value.columns.map((e) => ({
+			field: e.key,
+			header: e.label,
+			width: e.width,
+			minWidth: e.minWidth,
+			align: e.align,
+			value: (t) => q(t, e.key)
+		}))), U = m(/* @__PURE__ */ new Map());
+		le(() => [T.columns, T.rows], () => U.clear(), { flush: "sync" });
+		let W = l(() => F.value.rows.filter((e) => e.state !== void 0 && e.state !== "clean").length), G = l(() => !!O.status || W.value > 0);
+		function ve(e) {
+			return e.id;
+		}
+		function K(e) {
+			let t = F.value.columnByKey.get(e);
+			if (t) return t;
+			throw TypeError(`SDataGrid: table adapter получил unknown column ${JSON.stringify(e)}. / SDataGrid: table adapter received unknown column ${JSON.stringify(e)}.`);
+		}
+		function q(t, n) {
+			let r = K(n).key;
+			if (e(t.cells, r)) return t.cells[r];
+			throw TypeError(`SDataGrid: row ${JSON.stringify(t.id)} не содержит cell ${JSON.stringify(r)}. / SDataGrid: row ${JSON.stringify(t.id)} is missing cell ${JSON.stringify(r)}.`);
+		}
+		function J(e) {
+			return U.get(e);
+		}
+		function ye(e, t) {
+			let n = J(e.id);
+			if (n?.has(t.key)) {
+				let r = n.get(t.key);
+				if (r !== void 0) return r;
+				throw Error(`SDataGrid: draft ${JSON.stringify(e.id)}/${JSON.stringify(t.key)} нарушил string invariant. / SDataGrid: draft ${JSON.stringify(e.id)}/${JSON.stringify(t.key)} violated the string invariant.`);
+			}
+			return q(e, t.key).display;
+		}
+		function Y(e, t) {
+			return !B.value && !V.value && e.state !== "deleted" && t.editable === !0 && q(e, t.key).readonly !== !0;
+		}
+		function X(e, t, n) {
+			if (!Y(e, t)) return;
+			let r = J(e.id);
+			r || (r = /* @__PURE__ */ new Map(), U.set(e.id, r)), r.set(t.key, n), k("cell-edit", {
+				rowId: e.id,
+				columnKey: t.key,
+				value: n
+			});
+		}
+		function be(t) {
+			M(t, "commit input");
+			let n = a("SDataGrid", "commit input.source", t.source, pe), r = e(t, "value");
+			if (n === "draft" && r) throw TypeError("SDataGrid: draft commit не должен содержать value. / SDataGrid: draft commit must not contain value.");
+			if (n === "value" && !r) throw TypeError("SDataGrid: value commit должен содержать value. / SDataGrid: value commit must contain value.");
+			return n === "draft" ? { source: n } : {
+				source: n,
+				value: t.value
+			};
+		}
+		function Z(e, t) {
+			let n = J(e);
+			n && (n.delete(t), n.size === 0 && U.delete(e));
+		}
+		function Q(e, t, n) {
+			if (!Y(e, t)) return;
+			let r = be(n), i = J(e.id);
+			if (r.source === "draft" && !i?.has(t.key)) return;
+			let a = r.source === "value" ? r.value : i?.get(t.key);
+			if (r.source === "draft" && a === void 0) throw Error(`SDataGrid: draft ${JSON.stringify(e.id)}/${JSON.stringify(t.key)} исчез до commit. / SDataGrid: draft ${JSON.stringify(e.id)}/${JSON.stringify(t.key)} disappeared before commit.`);
+			Z(e.id, t.key), k("cell-commit", {
+				rowId: e.id,
+				columnKey: t.key,
+				value: a
+			});
+		}
+		function $(e, t) {
+			Y(e, t) && J(e.id)?.has(t.key) && (Z(e.id, t.key), k("cell-cancel", {
+				rowId: e.id,
+				columnKey: t.key
+			}));
+		}
+		function xe(e) {
+			return e.state === void 0 || e.state === "clean" ? "default" : e.state;
+		}
+		function Se(e, t) {
+			return q(e, t.field).pending === !0 ? "pending" : "default";
+		}
+		return (e, t) => (p(), u(s, ce(_(D).bindings(), {
+			title: I.value,
+			"title-id": I.value ? L : void 0,
+			"footer-id": G.value ? R : void 0,
+			"heading-level": 3,
+			"no-content-padding": "",
+			"content-layout": "block",
+			"surface-overflow": "clip",
+			"surface-tone": H.value === "embedded" ? "transparent" : "default",
+			"surface-border": H.value === "embedded" ? "none" : "default",
+			"surface-radius": H.value === "embedded" ? "none" : "default"
+		}), oe({
+			default: b(() => [d(ie, {
+				columns: _e.value,
+				data: F.value.rows,
+				"get-row-key": ve,
+				loading: he.value,
+				"loading-message": _(E)("table.dataGridLoading"),
+				"error-message": f.errorMessage,
+				"empty-message": ue.value,
+				"selected-row-key": f.selectedRowId,
+				"max-height": ge.value,
+				density: "compact",
+				"row-state": xe,
+				"cell-state": Se,
+				surface: "plain",
+				"aria-label": z.value.ariaLabel,
+				"aria-labelledby": z.value.ariaLabelledby,
+				"aria-describedby": G.value ? R : void 0
+			}, {
+				column: b(({ column: t }) => [h(e.$slots, "column", { column: K(t.field) }, () => [se(g(t.header), 1)], !0)]),
+				cell: b(({ row: t, column: n }) => [h(e.$slots, "cell", {
+					row: t,
+					column: K(n.field),
+					cell: q(t, n.field),
+					editable: Y(t, K(n.field)),
+					edit: (e) => X(t, K(n.field), e),
+					commit: (e) => Q(t, K(n.field), e),
+					cancel: () => $(t, K(n.field))
+				}, () => [Y(t, K(n.field)) ? (p(), u(ee, {
+					key: 0,
+					"model-value": ye(t, K(n.field)),
+					appearance: "grid-cell",
+					size: "sm",
+					disabled: B.value,
+					"aria-label": `${K(n.field).label}: ${t.id}`,
+					"onUpdate:modelValue": (e) => X(t, K(n.field), e),
+					onBlur: (e) => Q(t, K(n.field), { source: "draft" }),
+					onKeydown: [x(S((e) => Q(t, K(n.field), { source: "draft" }), ["prevent"]), ["enter"]), x(S((e) => $(t, K(n.field)), ["prevent"]), ["escape"])]
+				}, null, 8, [
+					"model-value",
+					"disabled",
+					"aria-label",
+					"onUpdate:modelValue",
+					"onBlur",
+					"onKeydown"
+				])) : (p(), ae("span", {
+					key: 1,
+					class: "s-data-grid__value",
+					title: q(t, n.field).display
+				}, g(q(t, n.field).display), 9, C))], !0)]),
+				_: 3
+			}, 8, [
+				"columns",
+				"data",
+				"loading",
+				"loading-message",
+				"error-message",
+				"empty-message",
+				"selected-row-key",
+				"max-height",
+				"aria-label",
+				"aria-labelledby",
+				"aria-describedby"
+			])]),
+			_: 2
+		}, [e.$slots.actions ? {
+			name: "actions",
+			fn: b(() => [h(e.$slots, "actions", {
+				pendingCount: W.value,
+				readonly: V.value,
+				disabled: B.value
+			}, void 0, !0)]),
+			key: "0"
+		} : void 0, G.value ? {
+			name: "footer",
+			fn: b(() => [h(e.$slots, "status", { pendingCount: W.value }, () => [d(c, {
+				label: `Ожидают применения: ${W.value}`,
+				tone: "warn",
+				size: "sm",
+				live: "polite"
+			}, null, 8, ["label"])], !0)]),
+			key: "1"
+		} : void 0]), 1040, [
+			"title",
+			"title-id",
+			"footer-id",
+			"surface-tone",
+			"surface-border",
+			"surface-radius"
+		]));
+	}
+});
+//#endregion
+export { w as default };

package/dist/src/components/shared/database/SSqlEditor.vue.d.ts

@@ -0,0 +1,98 @@
+import { SCodeEditorReadyPayload, SCodeEditorSelectionAppliedPayload, SCodeEditorViewport } from '../data-display/SCodeEditor.vue';
+interface SSqlEditorDiagnosticBase {
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+}
+/** Exact SQL diagnostic range через offsets либо line/column. / Exact SQL diagnostic range expressed either as offsets or line/column. */
+export type SSqlEditorDiagnostic = SSqlEditorDiagnosticBase & ({
+    from: number;
+    to?: number;
+    line?: never;
+    column?: never;
+} | {
+    line: number;
+    column: number;
+    from?: never;
+    to?: never;
+});
+/** Typed completion item для private SQL extension adapter. / Typed completion item transformed by the private SQL extension adapter. */
+export interface SSqlEditorCompletionItem {
+    label: string;
+    apply?: string;
+    detail?: string;
+    kind?: 'keyword' | 'schema' | 'table' | 'view' | 'column' | 'function';
+}
+/** Public SQL-editor adapter contract; CodeMirror extensions остаются private. / Public SQL-editor adapter contract; CodeMirror extensions remain private. */
+export interface Props {
+    modelValue: string;
+    title?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    errorMessage?: string;
+    diagnostics?: readonly SSqlEditorDiagnostic[];
+    completionItems?: readonly SSqlEditorCompletionItem[];
+    showLineNumbers?: boolean;
+    autofocus?: boolean;
+    viewport?: SCodeEditorViewport;
+    tabSize?: number;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    nextSelectionPos?: number | null;
+}
+declare var __VLS_9: {}, __VLS_24: {
+    diagnostics: SSqlEditorDiagnostic[];
+    errorMessage: string;
+};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_9) => any;
+} & {
+    status?: (props: typeof __VLS_24) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {
+    applySelection: (pos: number) => void;
+    focus: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    ready: (payload: SCodeEditorReadyPayload) => any;
+    "cursor-activity": (payload: {
+        pos: number;
+        line: number;
+        column: number;
+    }) => any;
+    "selection-applied": (payload: SCodeEditorSelectionAppliedPayload) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onReady?: ((payload: SCodeEditorReadyPayload) => any) | undefined;
+    "onCursor-activity"?: ((payload: {
+        pos: number;
+        line: number;
+        column: number;
+    }) => any) | undefined;
+    "onSelection-applied"?: ((payload: SCodeEditorSelectionAppliedPayload) => any) | undefined;
+}>, {
+    loading: boolean;
+    title: string;
+    autofocus: boolean;
+    placeholder: string;
+    disabled: boolean;
+    ariaLabel: string;
+    errorMessage: string;
+    tabSize: number;
+    viewport: SCodeEditorViewport;
+    diagnostics: readonly SSqlEditorDiagnostic[];
+    readOnly: boolean;
+    showLineNumbers: boolean;
+    ariaLabelledby: string;
+    nextSelectionPos: number | null;
+    completionItems: readonly SSqlEditorCompletionItem[];
+}, {}, {}, {}, 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/src/components/shared/database/SSqlEditor.vue.js

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