@pgcorp/ui-kit 0.10.0 → 0.10.2

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

@@ -0,0 +1,117 @@
+import { SChartBarMode, SChartCategory, SChartCurve, SChartDataLabels, SChartDomain, SChartMarkers, SChartRadialLabel, SChartSeries, SChartSize, SChartTone, SChartType, SChartXLabels } from '../components/shared/data-display/chart';
+interface Point {
+    readonly x: number;
+    readonly y: number;
+    readonly value: number;
+    readonly valueLabel: string;
+    readonly categoryKey: string;
+    readonly categoryLabel: string;
+    readonly seriesKey: string;
+    readonly seriesLabel: string;
+    readonly tone: SChartTone;
+    readonly title: string;
+}
+export interface ChartLineModel {
+    readonly key: string;
+    readonly label: string;
+    readonly tone: SChartTone;
+    readonly path: string;
+    readonly areaPath: string;
+    readonly points: readonly Point[];
+}
+export interface ChartBarModel extends Point {
+    readonly key: string;
+    readonly width: number;
+    readonly height: number;
+}
+export interface ChartSliceModel {
+    readonly key: string;
+    readonly label: string;
+    readonly tone: SChartTone;
+    readonly value: number;
+    readonly valueLabel: string;
+    readonly percentageLabel: string;
+    readonly path: string;
+    readonly labelX: number;
+    readonly labelY: number;
+    readonly dataLabel: string;
+    readonly title: string;
+}
+export interface ChartLegendItem {
+    readonly key: string;
+    readonly label: string;
+    readonly tone: SChartTone;
+}
+export interface ChartTick {
+    readonly value: number;
+    readonly label: string;
+    readonly displayLabel: string;
+    readonly position: number;
+}
+export interface ChartCategoryLabel {
+    readonly key: string;
+    readonly label: string;
+    readonly lines: readonly string[];
+    readonly x: number;
+    readonly textAnchor: 'start' | 'middle' | 'end';
+}
+export interface ChartGridLine {
+    readonly key: string;
+    readonly x1: number;
+    readonly x2: number;
+    readonly y1: number;
+    readonly y2: number;
+}
+export interface ChartTableRow {
+    readonly key: string;
+    readonly label: string;
+    readonly values: readonly string[];
+}
+export interface ChartModel {
+    readonly width: number;
+    readonly height: number;
+    readonly plotX: number;
+    readonly plotY: number;
+    readonly plotWidth: number;
+    readonly plotHeight: number;
+    readonly baselineY: number;
+    readonly empty: boolean;
+    readonly emptyReason: 'no-data' | 'zero-total' | null;
+    readonly lines: readonly ChartLineModel[];
+    readonly bars: readonly ChartBarModel[];
+    readonly slices: readonly ChartSliceModel[];
+    readonly horizontalGrid: readonly ChartGridLine[];
+    readonly verticalGrid: readonly ChartGridLine[];
+    readonly yTicks: readonly ChartTick[];
+    readonly xLabels: readonly ChartCategoryLabel[];
+    readonly legend: readonly ChartLegendItem[];
+    readonly tableRows: readonly ChartTableRow[];
+    readonly centerX: number;
+    readonly centerY: number;
+}
+export interface ResolveChartModelInput {
+    readonly type: SChartType;
+    readonly size: SChartSize;
+    readonly categories: readonly SChartCategory[];
+    readonly series: readonly SChartSeries[];
+    readonly domain: SChartDomain;
+    readonly xAxis: boolean;
+    readonly yAxis: boolean;
+    readonly xLabels: SChartXLabels;
+    readonly yTickCount: number;
+    readonly curve: SChartCurve;
+    readonly barMode: SChartBarMode;
+    readonly dataLabels: SChartDataLabels;
+    readonly markers: SChartMarkers;
+    readonly radialLabel: SChartRadialLabel;
+    readonly valueFormatter: (value: number) => string;
+    /** Фактическая CSS-геометрия viewport сохраняет readable SVG typography при resize. / Actual CSS viewport geometry keeps SVG typography readable while resizing. */
+    readonly dimensions?: ChartDimensions;
+}
+export interface ChartDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+/** Валидирует public data contract и строит детерминированную SVG-модель. / Validates the public data contract and builds deterministic SVG geometry. */
+export declare function resolveChartModel(input: ResolveChartModelInput): ChartModel;
+export {};

package/dist/src/internal/chartGeometry.js

@@ -0,0 +1,463 @@
+//#region src/internal/chartGeometry.ts
+var e = [
+	"series-1",
+	"series-2",
+	"series-3",
+	"series-4",
+	"series-5",
+	"series-6",
+	"series-7",
+	"series-8",
+	"success",
+	"warn",
+	"danger"
+], t = e.slice(0, 8), n = {
+	compact: {
+		width: 360,
+		height: 96
+	},
+	sm: {
+		width: 640,
+		height: 240
+	},
+	md: {
+		width: 800,
+		height: 360
+	},
+	lg: {
+		width: 1e3,
+		height: 480
+	}
+};
+function r(e, t) {
+	if (t === void 0) return n[e];
+	let r = o(t, "dimensions");
+	a(r, ["width", "height"], "dimensions");
+	let s = l(r.width, "dimensions.width"), c = l(r.height, "dimensions.height");
+	return (s <= 0 || c <= 0) && i("dimensions требует width и height больше нуля"), {
+		width: s,
+		height: c
+	};
+}
+function i(e) {
+	throw TypeError(`SChart: ${e}`);
+}
+function a(e, t, n) {
+	let r = Object.keys(e).filter((e) => !t.includes(e));
+	r.length > 0 && i(`${n} не допускает поля ${r.join(", ")}`);
+}
+function o(e, t) {
+	return (typeof e != "object" || !e || Array.isArray(e)) && i(`${t} должен быть object`), e;
+}
+function s(e, t) {
+	return (typeof e != "string" || e.trim().length === 0) && i(`${t} должен быть непустой строкой`), e;
+}
+function c(t, n) {
+	if (t !== void 0) return (typeof t != "string" || !e.includes(t)) && i(`${n} должен быть semantic chart tone`), t;
+}
+function l(e, t) {
+	return (typeof e != "number" || !Number.isFinite(e)) && i(`${t} должен быть конечным числом`), e;
+}
+function u(e) {
+	Array.isArray(e) || i("categories должен быть массивом");
+	let t = /* @__PURE__ */ new Set();
+	return e.map((e, n) => {
+		let r = o(e, `categories[${n}]`);
+		a(r, [
+			"key",
+			"label",
+			"tone"
+		], `categories[${n}]`);
+		let l = s(r.key, `categories[${n}].key`);
+		return t.has(l) && i(`categories содержит повторный key ${JSON.stringify(l)}`), t.add(l), {
+			key: l,
+			label: s(r.label, `categories[${n}].label`),
+			tone: c(r.tone, `categories[${n}].tone`)
+		};
+	});
+}
+function d(e, t) {
+	Array.isArray(e) || i("series должен быть массивом");
+	let n = /* @__PURE__ */ new Set();
+	return e.map((e, r) => {
+		let u = o(e, `series[${r}]`);
+		a(u, [
+			"key",
+			"label",
+			"values",
+			"tone"
+		], `series[${r}]`);
+		let d = s(u.key, `series[${r}].key`);
+		return n.has(d) && i(`series содержит повторный key ${JSON.stringify(d)}`), n.add(d), Array.isArray(u.values) || i(`series[${r}].values должен быть массивом`), u.values.length !== t && i(`series[${r}].values содержит ${u.values.length} значений для ${t} categories`), {
+			key: d,
+			label: s(u.label, `series[${r}].label`),
+			values: u.values.map((e, t) => l(e, `series[${r}].values[${t}]`)),
+			tone: c(u.tone, `series[${r}].tone`)
+		};
+	});
+}
+function f(e, t, n) {
+	let r = e(t);
+	return (typeof r != "string" || r.trim().length === 0) && i(`valueFormatter вернул пустое значение для ${n}`), r;
+}
+function p(e, n) {
+	return e ?? t[n % t.length];
+}
+function m(e) {
+	let t = 10 ** Math.floor(Math.log10(e)), n = e / t;
+	return (n <= 1 ? 1 : n <= 2 ? 2 : n <= 5 ? 5 : 10) * t;
+}
+function h(e, t, n, r) {
+	let s = o(e, "domain");
+	if (s.mode === "fixed") {
+		a(s, [
+			"mode",
+			"minimum",
+			"maximum"
+		], "domain");
+		let e = l(s.minimum, "domain.minimum"), n = l(s.maximum, "domain.maximum");
+		e >= n && i("domain fixed требует minimum < maximum");
+		let o = t.find((t) => t < e || t > n);
+		o !== void 0 && i(`domain fixed [${e}, ${n}] не содержит value ${o}`);
+		let c = (n - e) / (r - 1);
+		return {
+			minimum: e,
+			maximum: n,
+			ticks: Array.from({ length: r }, (t, n) => e + c * n)
+		};
+	}
+	s.mode !== "auto" && i(`неизвестный domain.mode ${JSON.stringify(s.mode)}`), a(s, ["mode", "includeZero"], "domain"), s.includeZero !== void 0 && typeof s.includeZero != "boolean" && i("domain.includeZero должен быть boolean");
+	let c = s.includeZero ?? n, u = Math.min(...t), d = Math.max(...t);
+	if (c && (u = Math.min(0, u), d = Math.max(0, d)), u === d) {
+		let e = Math.abs(u) * .1 || 1;
+		c && u === 0 ? d = 1 : (u -= e, d += e);
+	}
+	let f = m((d - u) / (r - 1)), p = c && u >= 0 ? 0 : Math.floor(u / f) * f, h = c && d <= 0 ? 0 : Math.ceil(d / f) * f, g = [];
+	for (let e = p; e <= h + f / 2 && g.length < 20; e += f) g.push(Object.is(e, -0) ? 0 : e);
+	return {
+		minimum: p,
+		maximum: h,
+		ticks: g
+	};
+}
+function g(e, t) {
+	if (e.length === 0) return "";
+	let [n, ...r] = e, i = `M ${n.x} ${n.y}`;
+	for (let n = 0; n < r.length; n += 1) {
+		let a = e[n], o = r[n];
+		if (t === "linear") {
+			i += ` L ${o.x} ${o.y}`;
+			continue;
+		}
+		let s = (o.x - a.x) / 3;
+		i += ` C ${a.x + s} ${a.y}, ${o.x - s} ${o.y}, ${o.x} ${o.y}`;
+	}
+	return i;
+}
+function _(e, t, n, r) {
+	let i = (r - 90) * Math.PI / 180;
+	return {
+		x: e + n * Math.cos(i),
+		y: t + n * Math.sin(i)
+	};
+}
+function v(e, t, n, r, i, a) {
+	let o = a - i;
+	if (o >= 359.999) {
+		let i = _(e, t, n, 0), a = _(e, t, n, 180);
+		if (r === 0) return `M ${e} ${t} L ${i.x} ${i.y} A ${n} ${n} 0 1 1 ${a.x} ${a.y} A ${n} ${n} 0 1 1 ${i.x} ${i.y} Z`;
+		let o = _(e, t, r, 0), s = _(e, t, r, 180);
+		return `M ${i.x} ${i.y} A ${n} ${n} 0 1 1 ${a.x} ${a.y} A ${n} ${n} 0 1 1 ${i.x} ${i.y} L ${o.x} ${o.y} A ${r} ${r} 0 1 0 ${s.x} ${s.y} A ${r} ${r} 0 1 0 ${o.x} ${o.y} Z`;
+	}
+	let s = _(e, t, n, i), c = _(e, t, n, a), l = +(o > 180);
+	if (r === 0) return `M ${e} ${t} L ${s.x} ${s.y} A ${n} ${n} 0 ${l} 1 ${c.x} ${c.y} Z`;
+	let u = _(e, t, r, a), d = _(e, t, r, i);
+	return `M ${s.x} ${s.y} A ${n} ${n} 0 ${l} 1 ${c.x} ${c.y} L ${u.x} ${u.y} A ${r} ${r} 0 ${l} 0 ${d.x} ${d.y} Z`;
+}
+function y(e, t, n, r, i, a, o) {
+	if (t === "pie" || t === "donut") {
+		let t = n === "compact" ? 4 : 12;
+		return {
+			x: t,
+			y: t,
+			width: e.width - t * 2,
+			height: e.height - t * 2
+		};
+	}
+	let s = a === "none" ? n === "compact" ? 5 : 12 : n === "compact" ? 14 : 24, c = n === "compact" ? 6 : 16, l = r ? n === "compact" ? 32 : 48 : n === "compact" ? 5 : 12, u = i ? n === "compact" ? 34 : 54 : n === "compact" ? 6 : 14, d = n === "compact" ? 9 : 11, f = i ? Math.max(0, ...o.map((e) => b(e, d))) : 0, p = i ? Math.max(u, Math.ceil(f + 16)) : u, m = Math.min(n === "compact" ? 72 : 120, e.width * .4), h = Math.max(0, e.width - c - m), g = Math.min(p, h);
+	return {
+		x: g,
+		y: s,
+		width: e.width - g - c,
+		height: e.height - s - l
+	};
+}
+function b(e, t) {
+	return Array.from(e).reduce((e, t) => /\s/u.test(t) ? e + .36 : /[.,:;!|ilI1'`]/u.test(t) ? e + .34 : /[MW@%ШЩЖЮ]/u.test(t) ? e + .92 : e + .62, 0) * t;
+}
+function x(e, t, n) {
+	if (b(e, n) <= t) return e;
+	let r = Array.from(e);
+	for (; r.length > 0;) {
+		let e = `${r.join("")}…`;
+		if (b(e, n) <= t) return e;
+		r.pop();
+	}
+	return "…";
+}
+function S(e, t) {
+	return e.length <= t ? e : `${e.slice(0, Math.max(1, t - 1))}…`;
+}
+function C(e, t) {
+	let n = Math.max(4, Math.floor((t - 8) / 6.5)), r = e.trim().split(/\s+/u), i = [], a = "";
+	for (let e of r) {
+		let t = a.length === 0 ? e : `${a} ${e}`;
+		if (t.length <= n) {
+			a = t;
+			continue;
+		}
+		if (a.length > 0 && i.push(a), a = e, i.length === 2) break;
+	}
+	return a.length > 0 && i.length < 2 && i.push(a), i.join(" ").split(/\s+/u).length < r.length && i.length > 0 && (i[i.length - 1] = S(`${i[i.length - 1]}…`, n)), i.slice(0, 2).map((e) => S(e, n));
+}
+function w(e, t) {
+	let n = [];
+	for (let r = 0; r < t; r += 1) {
+		let t = 0, i = 0;
+		for (let n of e) {
+			let e = n.values[r];
+			e >= 0 ? t += e : i += e;
+		}
+		n.push(t, i);
+	}
+	return n;
+}
+function T(e, t, n, r, i, a, o) {
+	let s = a.maximum - a.minimum, c = (e) => i.y + i.height - (e - a.minimum) / s * i.height, l = Math.max(i.y, Math.min(i.y + i.height, c(0))), u = i.width / t.length, d = (e) => i.x + u * (e + .5), m = n.map((n, r) => {
+		let i = p(n.tone, r), a = n.values.map((r, a) => {
+			let o = t[a], s = f(e.valueFormatter, r, `${n.key}.${o.key}`);
+			return {
+				x: d(a),
+				y: c(r),
+				value: r,
+				valueLabel: s,
+				categoryKey: o.key,
+				categoryLabel: o.label,
+				seriesKey: n.key,
+				seriesLabel: n.label,
+				tone: i,
+				title: `${n.label}, ${o.label}: ${s}`
+			};
+		}), o = g(a, e.curve), s = a.length === 0 ? "" : `${o} L ${a[a.length - 1].x} ${l} L ${a[0].x} ${l} Z`;
+		return {
+			key: n.key,
+			label: n.label,
+			tone: i,
+			path: o,
+			areaPath: s,
+			points: a
+		};
+	}), h = [];
+	if (e.type === "bar") {
+		let r = u * .72, i = Array.from({ length: t.length }, () => 0), a = Array.from({ length: t.length }, () => 0);
+		for (let o = 0; o < n.length; o += 1) {
+			let s = n[o], l = p(s.tone, o);
+			for (let u = 0; u < t.length; u += 1) {
+				let p = t[u], m = s.values[u], g = 0, _ = m, v = d(u) - r / 2 + o * (r / n.length), y = r / n.length;
+				e.barMode === "stacked" && (g = m >= 0 ? i[u] : a[u], _ = g + m, m >= 0 ? i[u] = _ : a[u] = _, v = d(u) - r * .34, y = r * .68);
+				let b = c(g), x = c(_), S = f(e.valueFormatter, m, `${s.key}.${p.key}`);
+				h.push({
+					key: `${s.key}:${p.key}`,
+					x: v,
+					y: Math.min(b, x),
+					width: y,
+					height: Math.max(1, Math.abs(x - b)),
+					value: m,
+					valueLabel: S,
+					categoryKey: p.key,
+					categoryLabel: p.label,
+					seriesKey: s.key,
+					seriesLabel: s.label,
+					tone: l,
+					title: `${s.label}, ${p.label}: ${S}`
+				});
+			}
+		}
+	}
+	let _ = (n) => e.xLabels === "none" ? !1 : e.xLabels === "all" ? !0 : e.xLabels === "endpoints" ? n === 0 || n === t.length - 1 : t.length <= 6 || n === 0 || n === t.length - 1, v = t.map((e, t) => ({
+		category: e,
+		index: t,
+		x: d(t)
+	})).filter(({ index: e }) => _(e)), y = v.map(({ category: e, x: t }, n) => {
+		let r = v[n - 1], a = v[n + 1];
+		if (v.length === 1) return {
+			key: e.key,
+			label: e.label,
+			lines: C(e.label, i.width),
+			x: i.x + i.width / 2,
+			textAnchor: "middle"
+		};
+		if (!r) {
+			let n = (t + a.x) / 2;
+			return {
+				key: e.key,
+				label: e.label,
+				lines: C(e.label, n - i.x),
+				x: i.x,
+				textAnchor: "start"
+			};
+		}
+		if (!a) {
+			let n = (r.x + t) / 2;
+			return {
+				key: e.key,
+				label: e.label,
+				lines: C(e.label, i.x + i.width - n),
+				x: i.x + i.width,
+				textAnchor: "end"
+			};
+		}
+		let o = (r.x + t) / 2, s = (t + a.x) / 2;
+		return {
+			key: e.key,
+			label: e.label,
+			lines: C(e.label, 2 * Math.min(t - o, s - t)),
+			x: t,
+			textAnchor: "middle"
+		};
+	}), b = e.size === "compact" ? 9 : 11, S = Math.max(1, i.x - 16), w = a.ticks.map((e, t) => ({
+		value: e,
+		label: o[t],
+		displayLabel: x(o[t], S, b),
+		position: c(e)
+	})), T = w.map((e) => ({
+		key: `y:${e.value}`,
+		x1: i.x,
+		x2: i.x + i.width,
+		y1: e.position,
+		y2: e.position
+	})), E = t.map((e, t) => ({
+		key: `x:${e.key}`,
+		x1: d(t),
+		x2: d(t),
+		y1: i.y,
+		y2: i.y + i.height
+	}));
+	return {
+		width: r.width,
+		height: r.height,
+		plotX: i.x,
+		plotY: i.y,
+		plotWidth: i.width,
+		plotHeight: i.height,
+		baselineY: l,
+		lines: m,
+		bars: h,
+		horizontalGrid: T,
+		verticalGrid: E,
+		yTicks: w,
+		xLabels: y,
+		legend: n.map((e, t) => ({
+			key: e.key,
+			label: e.label,
+			tone: p(e.tone, t)
+		})),
+		tableRows: t.map((t, r) => ({
+			key: t.key,
+			label: t.label,
+			values: n.map((n) => f(e.valueFormatter, n.values[r], `${n.key}.${t.key}`))
+		}))
+	};
+}
+function E(e, t, n, r, a) {
+	n.length !== 1 && i(`${e.type} требует ровно одну series`), (e.xAxis || e.yAxis) && i(`${e.type} не поддерживает Cartesian axes`), e.markers !== "none" && i(`${e.type} не поддерживает markers`), e.dataLabels === "latest" && i(`${e.type} поддерживает dataLabels только none или all`);
+	let o = n[0];
+	for (let t = 0; t < o.values.length; t += 1) o.values[t] < 0 && i(`${e.type} не допускает отрицательное series[0].values[${t}]`);
+	let s = o.values.reduce((e, t) => e + t, 0), c = a.x + a.width / 2, l = a.y + a.height / 2, u = Math.max(1, Math.min(a.width, a.height) / 2), d = e.type === "donut" ? u * .58 : 0, m = 0, h = s === 0 ? [] : t.map((t, n) => {
+		let r = o.values[n], i = m, a = m + r / s * 360;
+		m = a;
+		let h = i + (a - i) / 2, g = d + (u - d) * .58, y = _(c, l, g, h), b = f(e.valueFormatter, r, `${o.key}.${t.key}`), x = `${new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(r / s * 100)}%`, S = e.radialLabel === "category" ? t.label : e.radialLabel === "percentage" ? x : b;
+		return {
+			key: t.key,
+			label: t.label,
+			tone: p(t.tone, n),
+			value: r,
+			valueLabel: b,
+			percentageLabel: x,
+			path: v(c, l, u, d, i, a),
+			labelX: y.x,
+			labelY: y.y,
+			dataLabel: S,
+			title: `${t.label}: ${b} (${x})`
+		};
+	});
+	return {
+		width: r.width,
+		height: r.height,
+		plotX: a.x,
+		plotY: a.y,
+		plotWidth: a.width,
+		plotHeight: a.height,
+		baselineY: l,
+		empty: s === 0,
+		emptyReason: s === 0 ? "zero-total" : null,
+		lines: [],
+		bars: [],
+		slices: h,
+		horizontalGrid: [],
+		verticalGrid: [],
+		yTicks: [],
+		xLabels: [],
+		legend: t.map((e, t) => ({
+			key: e.key,
+			label: e.label,
+			tone: p(e.tone, t)
+		})),
+		tableRows: t.map((t, n) => ({
+			key: t.key,
+			label: t.label,
+			values: [f(e.valueFormatter, o.values[n], `${o.key}.${t.key}`)]
+		})),
+		centerX: c,
+		centerY: l
+	};
+}
+function D(e) {
+	let t = u(e.categories), a = d(e.series, t.length);
+	n[e.size] || i(`неизвестный size ${JSON.stringify(e.size)}`);
+	let o = r(e.size, e.dimensions);
+	if (t.length === 0 || a.length === 0) return (t.length !== 0 || a.length !== 0) && i("empty state требует одновременно пустые categories и series"), {
+		width: o.width,
+		height: o.height,
+		plotX: 0,
+		plotY: 0,
+		plotWidth: o.width,
+		plotHeight: o.height,
+		baselineY: o.height,
+		empty: !0,
+		emptyReason: "no-data",
+		lines: [],
+		bars: [],
+		slices: [],
+		horizontalGrid: [],
+		verticalGrid: [],
+		yTicks: [],
+		xLabels: [],
+		legend: [],
+		tableRows: [],
+		centerX: o.width / 2,
+		centerY: o.height / 2
+	};
+	if (e.type === "pie" || e.type === "donut") return E(e, t, a, o, y(o, e.type, e.size, e.xAxis, e.yAxis, e.dataLabels, []));
+	let s = e.type === "bar" && e.barMode === "stacked" ? w(a, t.length) : a.flatMap((e) => [...e.values]), c = h(e.domain, s, e.type === "bar" || e.type === "area", e.yTickCount), l = c.ticks.map((t) => f(e.valueFormatter, t, `yTick.${t}`)), p = y(o, e.type, e.size, e.xAxis, e.yAxis, e.dataLabels, l);
+	return {
+		...T(e, t, a, o, p, c, l),
+		empty: !1,
+		emptyReason: null,
+		slices: [],
+		centerX: p.x + p.width / 2,
+		centerY: p.y + p.height / 2
+	};
+}
+//#endregion
+export { D as resolveChartModel };

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

@@ -0,0 +1,31 @@
+export declare const CODE_EDITOR_VIEWPORTS: readonly ["content", "document", "compact", "standard", "expanded", "fill"];
+export declare const CODE_EDITOR_VARIANTS: readonly ["code", "sql"];
+export declare const CODE_EDITOR_KEY_BEHAVIORS: readonly ["indent", "focus-next"];
+export declare const CODE_EDITOR_CURSOR_ACTIVITY_MODES: readonly ["editable", "always"];
+/**
+ * Язык задаётся явно либо определяется только из обязательного пути файла.
+ * Language is either explicit or detected exclusively from a required file path.
+ */
+export type CodeEditorLanguageContract = {
+    mode: 'explicit';
+    id: string;
+    filePath?: never;
+} | {
+    mode: 'detect';
+    filePath: string;
+    id?: never;
+};
+/** Явные CodeMirror-возможности без вывода опций из presentation. / Explicit CodeMirror capabilities; no option is inferred from presentation. */
+export interface CodeEditorCapabilitiesContract {
+    lineNumbers: boolean;
+    indentation: {
+        tabSize: number;
+        keyBehavior: typeof CODE_EDITOR_KEY_BEHAVIORS[number];
+    };
+    keyInterceptor?: (event: KeyboardEvent) => boolean;
+    cursorActivity: typeof CODE_EDITOR_CURSOR_ACTIVITY_MODES[number];
+}
+export declare function validateCodeEditorLanguage(owner: string, value: unknown): CodeEditorLanguageContract;
+export declare function validateCodeEditorCapabilities(owner: string, value: unknown): CodeEditorCapabilitiesContract;
+export declare function validateCodeEditorViewport(owner: string, value: unknown): typeof CODE_EDITOR_VIEWPORTS[number];
+export declare function validateCodeEditorVariant(owner: string, value: unknown): typeof CODE_EDITOR_VARIANTS[number];

package/dist/src/internal/codeEditorContract.js

@@ -0,0 +1,63 @@
+import { validateBoolean as e, validateBoundedInteger as t, validateExactString as n, validateNonEmptyString as r } from "./runtimeContract.js";
+//#region src/internal/codeEditorContract.ts
+var i = [
+	"content",
+	"document",
+	"compact",
+	"standard",
+	"expanded",
+	"fill"
+], a = ["code", "sql"], o = ["indent", "focus-next"], s = ["editable", "always"];
+function c(e) {
+	return typeof e == "function";
+}
+function l(e, t, n, r) {
+	if (typeof n != "object" || !n || Array.isArray(n) || Object.getPrototypeOf(n) !== Object.prototype) throw TypeError(`${e}: ${t} должен быть plain object. / ${e}: ${t} must be a plain object.`);
+	let i = n, a = Object.keys(i).filter((e) => !r.includes(e));
+	if (a.length > 0) throw TypeError(`${e}.${t}: неизвестные поля ${a.map((e) => JSON.stringify(e)).join(", ")}. / ${e}.${t}: unknown fields ${a.map((e) => JSON.stringify(e)).join(", ")}.`);
+	return i;
+}
+function u(e, t) {
+	let i = l(e, "language", t, [
+		"mode",
+		"id",
+		"filePath"
+	]), a = n(e, "language.mode", i.mode, ["explicit", "detect"]), o = a === "explicit" ? ["mode", "id"] : ["mode", "filePath"], s = Object.keys(i).filter((e) => !o.includes(e));
+	if (s.length > 0) throw TypeError(`${e}.language: неизвестные поля ${s.map((e) => JSON.stringify(e)).join(", ")}. / ${e}.language: unknown fields ${s.map((e) => JSON.stringify(e)).join(", ")}.`);
+	return a === "explicit" ? {
+		mode: a,
+		id: r(e, "language.id", i.id)
+	} : {
+		mode: a,
+		filePath: r(e, "language.filePath", i.filePath)
+	};
+}
+function d(r, i) {
+	let a = l(r, "capabilities", i, [
+		"lineNumbers",
+		"indentation",
+		"keyInterceptor",
+		"cursorActivity"
+	]), u = l(r, "capabilities.indentation", a.indentation, ["tabSize", "keyBehavior"]), d = a.keyInterceptor;
+	if (d !== void 0 && !c(d)) throw TypeError(`${r}: capabilities.keyInterceptor должен быть функцией. / ${r}: capabilities.keyInterceptor must be a function.`);
+	return {
+		lineNumbers: e(r, "capabilities.lineNumbers", a.lineNumbers),
+		indentation: {
+			tabSize: t(r, "capabilities.indentation.tabSize", u.tabSize, {
+				minimum: 1,
+				maximum: 16
+			}),
+			keyBehavior: n(r, "capabilities.indentation.keyBehavior", u.keyBehavior, o)
+		},
+		...d === void 0 ? {} : { keyInterceptor: d },
+		cursorActivity: n(r, "capabilities.cursorActivity", a.cursorActivity, s)
+	};
+}
+function f(e, t) {
+	return n(e, "viewport", t, i);
+}
+function p(e, t) {
+	return n(e, "variant", t, a);
+}
+//#endregion
+export { s as CODE_EDITOR_CURSOR_ACTIVITY_MODES, o as CODE_EDITOR_KEY_BEHAVIORS, a as CODE_EDITOR_VARIANTS, i as CODE_EDITOR_VIEWPORTS, d as validateCodeEditorCapabilities, u as validateCodeEditorLanguage, p as validateCodeEditorVariant, f as validateCodeEditorViewport };

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

@@ -0,0 +1,12 @@
+import { ComputedRef } from 'vue';
+import { Extension } from '@codemirror/state';
+export type TrustedCodeEditorExtensionOwner = 'SSqlEditor';
+interface TrustedCodeEditorExtensionChannel {
+    owner: TrustedCodeEditorExtensionOwner;
+    extensions: ComputedRef<readonly Extension[]>;
+}
+/** Internal-only CodeMirror extension channel for audited UI-kit adapters. */
+export declare function provideTrustedCodeEditorExtensions(owner: TrustedCodeEditorExtensionOwner, extensions: ComputedRef<readonly Extension[]>): void;
+/** Consumes extensions supplied by the nearest audited UI-kit adapter. */
+export declare function useTrustedCodeEditorExtensions(): TrustedCodeEditorExtensionChannel | null;
+export {};