@pgcorp/ui-kit 0.10.0 → 0.10.1

package/dist/src/components/shared/data-display/SCodeBlock.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,254 @@
+import { Copy as e } from "../../icons/sputnigUiIcons.js";
+import { useClipboard as t } from "../../../composables/useClipboard.js";
+import { useUiKitLocale as n } from "../../../composables/useUiKitLocale.js";
+import { useNotifier as ee } from "../../../composables/useNotifier.js";
+import { useOwnedAttrs as te } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as r, validateBoundedInteger as i, validateExactString as a, validateNonEmptyString as ne } from "../../../internal/runtimeContract.js";
+import re from "../controls/SButton.vue.js";
+import ie from "../feedback/SAsyncState.vue.js";
+import { validateCodeEditorLanguage as o, validateCodeEditorViewport as ae } from "../../../internal/codeEditorContract.js";
+import { resolveCodeLanguageKey as s } from "../../../internal/codeLanguageIdentity.js";
+import c from "./_internal/SCodeTokenLine.vue.js";
+import { Fragment as l, computed as u, createBlock as d, createCommentVNode as f, createElementBlock as p, createElementVNode as m, createVNode as h, defineAsyncComponent as oe, defineComponent as g, mergeProps as _, normalizeStyle as v, onMounted as y, openBlock as b, ref as x, renderList as S, toDisplayString as C, unref as w, watch as T } from "vue";
+//#region src/components/shared/data-display/SCodeBlock.vue?vue&type=script&setup=true&lang.ts
+var se = ["data-presentation"], ce = {
+	key: 0,
+	class: "s-code-block-header"
+}, le = { class: "s-code-block-info" }, ue = {
+	key: 0,
+	class: "s-code-block-filename"
+}, de = { class: "s-code-block-language" }, fe = { class: "s-code-block-actions" }, pe = { class: "s-code-block-editor-region" }, me = [
+	"data-viewport",
+	"data-line-numbers",
+	"aria-label",
+	"aria-labelledby"
+], he = { key: 0 }, ge = {
+	key: 1,
+	class: "s-code-block-plain__lines"
+}, _e = {
+	class: "s-code-block-plain__line-number",
+	"aria-hidden": "true"
+}, E = { class: "s-code-block-plain__line-content" }, D = [
+	"data-viewport",
+	"aria-label",
+	"aria-labelledby"
+], O = { class: "s-code-block-plain__lines" }, k = ["data-line-numbers"], A = {
+	key: 0,
+	class: "s-code-block-plain__line-number",
+	"aria-hidden": "true"
+}, j = { class: "s-code-block-plain__line-content" }, M = /*@__PURE__*/ g({
+	inheritAttrs: !1,
+	__name: "SCodeBlock",
+	props: {
+		ariaLabel: {},
+		ariaLabelledby: {},
+		code: {},
+		language: {},
+		presentation: { default: "editor" },
+		showHeader: {
+			type: Boolean,
+			default: !0
+		},
+		showLineNumbers: {
+			type: Boolean,
+			default: !0
+		},
+		readOnly: {
+			type: Boolean,
+			default: !0
+		},
+		interceptKeys: {
+			type: Function,
+			default: void 0
+		},
+		tabSize: { default: 2 },
+		tabKeyBehavior: { default: "focus-next" },
+		nextSelectionPos: { default: null },
+		surfaceRadius: { default: "default" },
+		viewport: { default: "content" },
+		placeholder: { default: void 0 },
+		errorMessage: { default: void 0 }
+	},
+	emits: [
+		"cursor-activity",
+		"update:code",
+		"selection-applied",
+		"ready"
+	],
+	setup(g, { expose: M, emit: N }) {
+		let P = g, F = x(!1), I = x(null), L = x(null), ve = oe(() => import("../../../internal/lazyCodeEditor.js")), ye = te({
+			component: "SCodeBlock",
+			owner: "code block root"
+		}), be = u(() => P.ariaLabel === void 0 ? { ariaLabelledby: P.ariaLabelledby } : { ariaLabel: P.ariaLabel }), R = N, xe = u(() => r("SCodeBlock", "showHeader", P.showHeader)), z = u(() => r("SCodeBlock", "showLineNumbers", P.showLineNumbers)), B = u(() => r("SCodeBlock", "readOnly", P.readOnly)), V = u(() => a("SCodeBlock", "presentation", P.presentation, [
+			"editor",
+			"plain",
+			"highlighted"
+		])), H = u(() => a("SCodeBlock", "surfaceRadius", P.surfaceRadius, [
+			"default",
+			"none",
+			"xl"
+		])), U = u(() => ae("SCodeBlock", P.viewport)), W = u(() => o("SCodeBlock", P.language)), G = u(() => {
+			if (typeof P.code != "string") throw TypeError("SCodeBlock: code должен быть string. / SCodeBlock: code must be a string.");
+			return P.code;
+		}), K = u(() => i("SCodeBlock", "tabSize", P.tabSize, {
+			minimum: 1,
+			maximum: 16
+		})), Se = u(() => s(W.value)), q = u(() => G.value.split("\n")), J = u(() => P.errorMessage === void 0 ? void 0 : ne("SCodeBlock", "errorMessage", P.errorMessage)), Ce = u(() => ({
+			lineNumbers: z.value,
+			indentation: {
+				tabSize: K.value,
+				keyBehavior: P.tabKeyBehavior
+			},
+			...P.interceptKeys === void 0 ? {} : { keyInterceptor: P.interceptKeys },
+			cursorActivity: "always"
+		})), we = (e) => R("cursor-activity", {
+			pos: e.pos,
+			lineFrom: e.lineFrom,
+			lineTo: e.lineTo,
+			lineText: e.lineText,
+			cursorCol: e.pos - e.lineFrom
+		}), Te = (e) => {
+			F.value = !0, R("ready", e);
+		}, Y = !1, Ee = () => {
+			F.value = !0, R("ready", {
+				documentLength: G.value.length,
+				viewport: U.value,
+				variant: "code",
+				locked: !0
+			});
+		}, X = () => {
+			Y && (V.value === "editor" ? F.value = !1 : Ee());
+		};
+		y(() => {
+			Y = !0, X();
+		}), T(V, X), T([V, B], ([e, t]) => {
+			if (e !== "editor" && !t) throw TypeError(`SCodeBlock: presentation=${JSON.stringify(e)} поддерживает только readOnly=true. / SCodeBlock: presentation=${JSON.stringify(e)} supports readOnly=true only.`);
+			if (e !== "editor" && P.interceptKeys !== void 0) throw TypeError(`SCodeBlock: presentation=${JSON.stringify(e)} не принимает interceptKeys. / SCodeBlock: presentation=${JSON.stringify(e)} does not accept interceptKeys.`);
+			if (e !== "editor" && P.nextSelectionPos !== null) throw TypeError(`SCodeBlock: presentation=${JSON.stringify(e)} не принимает nextSelectionPos. / SCodeBlock: presentation=${JSON.stringify(e)} does not accept nextSelectionPos.`);
+		}, { immediate: !0 });
+		let Z = (e) => {
+			if (e !== null && !(e instanceof HTMLElement)) throw TypeError("SCodeBlock: plain surface ref должен быть HTMLElement. / SCodeBlock: plain surface ref must be an HTMLElement.");
+			L.value = e;
+		};
+		M({
+			applySelection: (e) => {
+				if (V.value !== "editor") throw Error(`SCodeBlock: applySelection недоступен в presentation=${JSON.stringify(V.value)}. / SCodeBlock: applySelection is unavailable in presentation=${JSON.stringify(V.value)}.`);
+				let t = I.value;
+				if (!t) throw Error("SCodeBlock: editor не готов; дождитесь ready. / SCodeBlock: editor is not ready; wait for ready.");
+				t.applySelection(e);
+			},
+			focus: () => {
+				if (V.value !== "editor") {
+					let e = L.value;
+					if (!e) throw Error("SCodeBlock: plain surface не готов; дождитесь ready. / SCodeBlock: plain surface is not ready; wait for ready.");
+					e.focus();
+					return;
+				}
+				let e = I.value;
+				if (!e) throw Error("SCodeBlock: editor не готов; дождитесь ready. / SCodeBlock: editor is not ready; wait for ready.");
+				e.focus();
+			}
+		});
+		let Q = ee(), { t: $ } = n(), { copyText: De } = t(), Oe = async () => {
+			let e = await De(P.code);
+			if (e.status === "copied") {
+				Q.success({ message: $("clipboard.codeCopied") });
+				return;
+			}
+			Q.danger({ message: e.status === "unavailable" ? $("clipboard.codeCopyUnavailable") : e.status === "empty" ? $("clipboard.emptyCode") : `${$("clipboard.codeCopyFailed")} ${e.error.message}` });
+		};
+		return (t, n) => (b(), p("div", _(w(ye).bindings(), {
+			class: ["s-code-block", {
+				"s-code-block--radius-none": H.value === "none",
+				"s-code-block--radius-xl": H.value === "xl",
+				"s-code-block--interactive": V.value === "editor" && !B.value,
+				"s-code-block--viewport": !["content", "document"].includes(U.value)
+			}],
+			"data-presentation": V.value
+		}), [
+			xe.value ? (b(), p("div", ce, [m("div", le, [W.value.mode === "detect" ? (b(), p("span", ue, C(W.value.filePath), 1)) : f("", !0), m("span", de, C(Se.value), 1)]), m("div", fe, [h(re, {
+				appearance: "text",
+				severity: "secondary",
+				size: "xs",
+				"leading-icon": w(e),
+				"icon-only": "",
+				title: w($)("clipboard.copyCode"),
+				"aria-label": w($)("clipboard.copyCode"),
+				label: "",
+				onClick: Oe
+			}, null, 8, [
+				"leading-icon",
+				"title",
+				"aria-label"
+			])])])) : f("", !0),
+			m("div", pe, [V.value === "editor" ? (b(), d(w(ve), _({
+				key: 0,
+				ref_key: "codeEditor",
+				ref: I,
+				"model-value": P.code,
+				language: W.value,
+				capabilities: Ce.value,
+				"read-only": B.value,
+				viewport: U.value
+			}, be.value, {
+				placeholder: P.placeholder,
+				"next-selection-pos": P.nextSelectionPos,
+				"onUpdate:modelValue": n[0] ||= (e) => R("update:code", e),
+				onCursorActivity: we,
+				onSelectionApplied: n[1] ||= (e) => R("selection-applied", e),
+				onReady: Te
+			}), null, 16, [
+				"model-value",
+				"language",
+				"capabilities",
+				"read-only",
+				"viewport",
+				"placeholder",
+				"next-selection-pos"
+			])) : V.value === "plain" ? (b(), p("pre", {
+				key: 1,
+				ref: Z,
+				class: "s-code-block-plain",
+				"data-viewport": U.value,
+				"data-line-numbers": z.value ? "visible" : "hidden",
+				"aria-label": P.ariaLabel,
+				"aria-labelledby": P.ariaLabelledby,
+				style: v({ tabSize: K.value }),
+				tabindex: "0"
+			}, [z.value ? (b(), p("code", ge, [(b(!0), p(l, null, S(q.value, (e, t) => (b(), p("span", {
+				key: t,
+				class: "s-code-block-plain__line"
+			}, [m("span", _e, C(t + 1), 1), m("span", E, C(e || "​"), 1)]))), 128))])) : (b(), p("code", he, C(G.value), 1))], 12, me)) : (b(), p("pre", {
+				key: 2,
+				ref: Z,
+				class: "s-code-block-plain",
+				"data-viewport": U.value,
+				"aria-label": P.ariaLabel,
+				"aria-labelledby": P.ariaLabelledby,
+				style: v({ tabSize: K.value }),
+				tabindex: "0"
+			}, [m("span", O, [(b(!0), p(l, null, S(q.value, (e, t) => (b(), p("span", {
+				key: t,
+				class: "s-code-block-plain__line",
+				"data-line-numbers": z.value ? "visible" : "hidden"
+			}, [z.value ? (b(), p("span", A, C(t + 1), 1)) : f("", !0), m("span", j, [h(c, {
+				text: e || "​",
+				language: W.value,
+				variant: "code-block"
+			}, null, 8, ["text", "language"])])], 8, k))), 128))])], 12, D))]),
+			J.value !== void 0 || V.value === "editor" && !F.value ? (b(), d(ie, {
+				key: 1,
+				state: J.value === void 0 ? {
+					status: "loading",
+					message: w($)("editor.loading")
+				} : {
+					status: "error",
+					message: J.value
+				},
+				presentation: "overlay"
+			}, null, 8, ["state"])) : f("", !0)
+		], 16, se));
+	}
+});
+//#endregion
+export { M as default };

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

@@ -0,0 +1,58 @@
+import { CODE_EDITOR_VARIANTS, CODE_EDITOR_VIEWPORTS, CodeEditorCapabilitiesContract, CodeEditorLanguageContract } from '../../../internal/codeEditorContract';
+import { SCodeEditorDiagnostic, SCodeEditorDiagnosticId } from './codeEditor';
+export type SCodeEditorViewport = typeof CODE_EDITOR_VIEWPORTS[number];
+export type SCodeEditorVariant = typeof CODE_EDITOR_VARIANTS[number];
+/** Явный язык либо детектирование из обязательного filePath. / Explicit language or detection from a required filePath. */
+export type SCodeEditorLanguage = CodeEditorLanguageContract;
+/** Явные возможности leaf-редактора. / Explicit capabilities of the leaf editor. */
+export type SCodeEditorCapabilities = CodeEditorCapabilitiesContract;
+/** Exact-координаты документа для cursor activity. / Exact document coordinates emitted for cursor activity. */
+export interface SCodeEditorCursorActivity {
+    pos: number;
+    line: number;
+    column: number;
+    lineFrom: number;
+    lineTo: number;
+    lineText: string;
+}
+/** Public readiness snapshot без раскрытия third-party EditorView. / Public readiness snapshot without exposing the third-party EditorView instance. */
+export interface SCodeEditorReadyPayload {
+    documentLength: number;
+    viewport: SCodeEditorViewport;
+    variant: SCodeEditorVariant;
+    locked: boolean;
+}
+/** Подтверждённое применение selection и источник вызова. / Confirmed selection application and its initiating API. */
+export interface SCodeEditorSelectionAppliedPayload {
+    position: number;
+    source: 'controlled' | 'imperative';
+}
+type AccessibleName = {
+    ariaLabel: string;
+    ariaLabelledby?: never;
+} | {
+    ariaLabel?: never;
+    ariaLabelledby: string;
+};
+/** Public SCodeEditor contract; размер задаёт только semantic viewport. / Public SCodeEditor contract; sizing is expressed only by semantic viewport. */
+export type Props = AccessibleName & {
+    modelValue: string;
+    language: SCodeEditorLanguage;
+    capabilities: SCodeEditorCapabilities;
+    readOnly?: boolean;
+    disabled?: boolean;
+    autofocus?: boolean;
+    placeholder?: string;
+    viewport?: SCodeEditorViewport;
+    variant?: SCodeEditorVariant;
+    nextSelectionPos?: number | null;
+    /** Controlled diagnostics expressed only through serializable UI-kit ranges. */
+    diagnostics?: readonly SCodeEditorDiagnostic<SCodeEditorDiagnosticId>[];
+    /** DOM id supplemental status/diagnostic owner. / DOM id of a supplemental status/diagnostic owner. */
+    ariaDescribedby?: string;
+    /** Помечает editor content невалидным без владения presentation диагностики. / Marks the editor content as invalid without owning diagnostic presentation. */
+    invalid?: boolean;
+};
+declare const __VLS_export: import('vue').DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import('vue').PublicProps>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/shared/data-display/SCodeEditor.vue.js

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

package/dist/src/components/shared/data-display/SCodeEditor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,248 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as t, validateBoundedInteger as n, validateDomId as r, validateNonEmptyString as i } from "../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as a } from "../../../internal/passiveContentContract.js";
+import { validateCodeEditorCapabilities as ee, validateCodeEditorLanguage as te, validateCodeEditorVariant as ne, validateCodeEditorViewport as re } from "../../../internal/codeEditorContract.js";
+import { resolveCodeLanguageKey as ie } from "../../../internal/codeLanguageIdentity.js";
+import { useRuntimeTheme as ae } from "../../../internal/runtimeTheme.js";
+import { useTrustedCodeEditorExtensions as o } from "../../../internal/codeEditorExtensions.js";
+import { getCodeMirrorLanguageExtension as s } from "../codeLanguages.js";
+import { validateCodeEditorDiagnostics as c, validateCodeEditorRange as l, validateCodeEditorViewState as u } from "./codeEditor.js";
+import { Fragment as d, computed as f, createCommentVNode as oe, createElementBlock as p, createElementVNode as m, createVNode as se, defineComponent as h, mergeProps as ce, onBeforeUnmount as le, openBlock as g, ref as ue, renderList as de, shallowRef as fe, toDisplayString as _, unref as v, useId as y, watch as b } from "vue";
+import { Codemirror as x } from "vue-codemirror";
+import { oneDark as pe } from "@codemirror/theme-one-dark";
+import { EditorSelection as S, EditorState as me } from "@codemirror/state";
+import { lintGutter as he, setDiagnostics as ge } from "@codemirror/lint";
+import { EditorView as C, lineNumbers as _e, placeholder as ve } from "@codemirror/view";
+//#region src/components/shared/data-display/SCodeEditor.vue?vue&type=script&setup=true&lang.ts
+var w = /*@__PURE__*/ h({
+	inheritAttrs: !1,
+	__name: "SCodeEditor",
+	props: {
+		ariaLabel: {},
+		ariaLabelledby: {},
+		modelValue: {},
+		language: {},
+		capabilities: {},
+		readOnly: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		autofocus: {
+			type: Boolean,
+			default: !1
+		},
+		placeholder: { default: void 0 },
+		viewport: { default: "content" },
+		variant: { default: "code" },
+		nextSelectionPos: { default: null },
+		diagnostics: { default: () => [] },
+		ariaDescribedby: { default: void 0 },
+		invalid: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"cursor-activity",
+		"selection-change",
+		"view-state-change",
+		"selection-applied",
+		"ready"
+	],
+	setup(h, { expose: w, emit: ye }) {
+		let T = h, E = ye, D = e({
+			component: "SCodeEditor",
+			owner: "CodeMirror root adapter"
+		});
+		a({ owner: "SCodeEditor" });
+		let O = ae(), k = o(), A = fe(null), j = ue(null), M = `s-code-editor-diagnostics-${y()}`, N = null, P = null, F = null, I = f(() => {
+			if (typeof T.modelValue == "string") return T.modelValue;
+			throw TypeError("SCodeEditor: modelValue должен быть строкой. / SCodeEditor: modelValue must be a string.");
+		}), L = f(() => re("SCodeEditor", T.viewport)), R = f(() => ne("SCodeEditor", T.variant)), be = f(() => t("SCodeEditor", "autofocus", T.autofocus)), z = f(() => t("SCodeEditor", "readOnly", T.readOnly)), B = f(() => t("SCodeEditor", "disabled", T.disabled)), xe = f(() => t("SCodeEditor", "invalid", T.invalid)), V = f(() => z.value || B.value), H = f(() => c("SCodeEditor", T.diagnostics, I.value.length)), Se = f(() => {
+			let e = te("SCodeEditor", T.language), t = s(e), n = ie(e);
+			if (!t && n !== "plaintext" && n !== "text") {
+				let t = e.mode === "explicit" ? `language.id ${JSON.stringify(e.id)}` : `language.filePath ${JSON.stringify(e.filePath)}`;
+				throw RangeError(`SCodeEditor: ${t} не поддерживается. / SCodeEditor: ${t} is not supported.`);
+			}
+			return e;
+		}), U = f(() => ee("SCodeEditor", T.capabilities)), Ce = f(() => {
+			if (T.ariaLabel !== void 0 && T.ariaLabelledby !== void 0) throw TypeError("SCodeEditor: задайте только ariaLabel или ariaLabelledby. / SCodeEditor: provide only ariaLabel or ariaLabelledby.");
+			let e = {};
+			if (T.ariaLabel !== void 0) e["aria-label"] = i("SCodeEditor", "ariaLabel", T.ariaLabel);
+			else if (T.ariaLabelledby !== void 0) e["aria-labelledby"] = r("SCodeEditor", "ariaLabelledby", T.ariaLabelledby);
+			else throw TypeError("SCodeEditor: требуется ariaLabel или ariaLabelledby. / SCodeEditor: ariaLabel or ariaLabelledby is required.");
+			e.tabindex = B.value ? "-1" : "0";
+			let t = T.ariaDescribedby === void 0 ? [] : [r("SCodeEditor", "ariaDescribedby", T.ariaDescribedby)];
+			return H.value.length > 0 && t.push(M), t.length > 0 && (e["aria-describedby"] = t.join(" ")), xe.value && (e["aria-invalid"] = "true"), z.value && (e["aria-readonly"] = "true"), B.value && (e["aria-disabled"] = "true"), e;
+		}), we = f(() => {
+			let e = U.value, n = Se.value, r = [...k?.extensions.value ?? []];
+			L.value === "document" && (r.push(C.theme({
+				"&.cm-editor": {
+					height: "auto",
+					maxHeight: "none",
+					overflow: "visible"
+				},
+				".cm-scroller": {
+					height: "auto",
+					overflow: "visible"
+				}
+			})), r.push(C.lineWrapping));
+			let a = s(n);
+			return a && r.push(a), O.value.mode === "dark" && r.push(pe), e.lineNumbers && r.push(_e()), H.value.length > 0 && r.push(he()), T.placeholder !== void 0 && r.push(ve(i("SCodeEditor", "placeholder", T.placeholder))), r.push(me.readOnly.of(V.value)), r.push(C.editable.of(!V.value)), r.push(C.contentAttributes.of(Ce.value)), e.keyInterceptor && !V.value && r.push(C.domEventHandlers({ keydown: (n) => {
+				let r = e.keyInterceptor?.(n);
+				return t("SCodeEditor", "capabilities.keyInterceptor return value", r) ? (n.preventDefault(), !0) : !1;
+			} })), r.push(C.updateListener.of((t) => {
+				if (A.value = t.view, (t.selectionSet || t.docChanged) && X(t.view), V.value && e.cursorActivity !== "always" || !t.selectionSet && !t.docChanged) return;
+				let n = t.state.selection.main.head, r = t.state.doc.lineAt(n);
+				E("cursor-activity", {
+					pos: n,
+					line: r.number,
+					column: n - r.from + 1,
+					lineFrom: r.from,
+					lineTo: r.to,
+					lineText: t.state.doc.sliceString(r.from, r.to)
+				});
+			})), r;
+		}), Te = (e, t, r) => n("SCodeEditor", r, e, {
+			minimum: 0,
+			maximum: t
+		}), W = (e, t) => {
+			let n = A.value;
+			if (!n) throw Error("SCodeEditor: editor не готов; дождитесь ready. / SCodeEditor: editor is not ready; wait for ready.");
+			let r = Te(e, n.state.doc.length, `${t} selection position`);
+			n.dispatch({
+				selection: S.single(r),
+				scrollIntoView: !0
+			}), n.focus(), E("selection-applied", {
+				position: r,
+				source: t
+			});
+		}, G = () => {
+			let e = A.value;
+			if (!e) throw Error("SCodeEditor: editor не готов; дождитесь ready. / SCodeEditor: editor is not ready; wait for ready.");
+			return e;
+		}, K = (e) => {
+			let t = e.state.selection.main;
+			return Object.freeze({
+				anchor: t.anchor,
+				head: t.head,
+				from: t.from,
+				to: t.to,
+				empty: t.empty
+			});
+		}, q = (e) => Object.freeze({
+			selection: K(e),
+			scrollTop: e.scrollDOM.scrollTop,
+			scrollLeft: e.scrollDOM.scrollLeft
+		}), J = (e, t) => e !== null && e.anchor === t.anchor && e.head === t.head && e.from === t.from && e.to === t.to && e.empty === t.empty, Y = (e, t) => e !== null && J(e.selection, t.selection) && e.scrollTop === t.scrollTop && e.scrollLeft === t.scrollLeft, X = (e) => {
+			let t = K(e);
+			J(P, t) || (P = t, E("selection-change", t));
+			let n = q(e);
+			Y(F, n) || (F = n, E("view-state-change", n));
+		}, Z = () => {
+			let e = A.value;
+			if (!e) return;
+			let t = q(e);
+			Y(F, t) || (F = t, E("view-state-change", t));
+		}, Q = () => {
+			N?.removeEventListener("scroll", Z), N = null;
+		}, Ee = (e) => {
+			Q(), N = e.scrollDOM, N.addEventListener("scroll", Z, { passive: !0 });
+		}, De = (e) => e.map((e) => ({
+			from: e.from,
+			to: e.to,
+			severity: e.severity,
+			message: e.message,
+			...e.source === void 0 ? {} : { source: e.source }
+		})), $ = (e) => {
+			let t = c("SCodeEditor", T.diagnostics, e.state.doc.length);
+			e.dispatch(ge(e.state, De(t)));
+		}, Oe = (e) => {
+			if (typeof e != "string") throw TypeError("SCodeEditor: CodeMirror update payload должен быть строкой. / SCodeEditor: CodeMirror update payload must be a string.");
+			V.value || E("update:modelValue", e);
+		}, ke = (e) => {
+			if (typeof e != "object" || !e || !("view" in e) || !(e.view instanceof C)) throw TypeError("SCodeEditor: CodeMirror ready payload должен содержать EditorView. / SCodeEditor: CodeMirror ready payload must contain EditorView.");
+			A.value = e.view, Ee(A.value), $(A.value);
+			let t = {
+				documentLength: A.value.state.doc.length,
+				viewport: L.value,
+				variant: R.value,
+				locked: V.value
+			};
+			if (E("ready", t), j.value !== null) {
+				let e = j.value;
+				j.value = null, W(e, "controlled");
+			}
+		};
+		return b(() => T.nextSelectionPos, (e) => {
+			if (e != null) {
+				if (!Number.isInteger(e)) throw TypeError(`SCodeEditor: nextSelectionPos должен быть целым числом; получено ${String(e)}. / SCodeEditor: nextSelectionPos must be an integer; received ${String(e)}.`);
+				if (!A.value) {
+					j.value = e;
+					return;
+				}
+				W(e, "controlled");
+			}
+		}, { immediate: !0 }), b(H, () => {
+			A.value && $(A.value);
+		}), le(() => {
+			Q(), A.value = null, P = null, F = null;
+		}), w({
+			applySelection: (e) => W(e, "imperative"),
+			revealRange: (e) => {
+				let t = G(), n = l("SCodeEditor", "revealRange", e, t.state.doc.length), r = C.scrollIntoView(S.range(n.from, n.to), { y: "nearest" });
+				t.dispatch({ effects: r });
+			},
+			getSelection: () => {
+				let e = G(), t = K(e);
+				return Object.freeze({
+					...t,
+					text: e.state.doc.sliceString(t.from, t.to)
+				});
+			},
+			captureViewState: () => q(G()),
+			applyViewState: (e) => {
+				let t = G(), n = u("SCodeEditor", e, t.state.doc.length);
+				t.dispatch({ selection: S.range(n.selection.anchor, n.selection.head) }), t.scrollDOM.scrollTop = n.scrollTop, t.scrollDOM.scrollLeft = n.scrollLeft, X(t);
+			},
+			focus: () => {
+				G().focus();
+			}
+		}), (e, t) => (g(), p(d, null, [se(v(x), ce(v(D).bindings(), {
+			class: "s-code-editor",
+			"data-variant": R.value,
+			"data-viewport": L.value,
+			"data-line-numbers": U.value.lineNumbers ? "visible" : "hidden",
+			"model-value": I.value,
+			autofocus: be.value,
+			"indent-with-tab": U.value.indentation.keyBehavior === "indent",
+			"tab-size": U.value.indentation.tabSize,
+			extensions: we.value,
+			onReady: ke,
+			"onUpdate:modelValue": Oe
+		}), null, 16, [
+			"data-variant",
+			"data-viewport",
+			"data-line-numbers",
+			"model-value",
+			"autofocus",
+			"indent-with-tab",
+			"tab-size",
+			"extensions"
+		]), H.value.length > 0 ? (g(), p("div", {
+			key: 0,
+			id: M,
+			class: "s-code-editor__diagnostics",
+			role: "status",
+			"aria-live": "polite",
+			"aria-atomic": "true"
+		}, [m("ul", null, [(g(!0), p(d, null, de(H.value, (e) => (g(), p("li", { key: e.id }, _(e.message), 1))), 128))])])) : oe("", !0)], 64));
+	}
+});
+//#endregion
+export { w as default };

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

@@ -0,0 +1,63 @@
+export interface Props {
+    searchValue: string;
+    replaceValue: string;
+    caseSensitive: boolean;
+    regexp: boolean;
+    wholeWord: boolean;
+    canReplace?: boolean;
+    findPlaceholder?: string;
+    replacePlaceholder?: string;
+    nextLabel?: string;
+    previousLabel?: string;
+    selectAllLabel?: string;
+    matchCaseLabel?: string;
+    regexpLabel?: string;
+    wholeWordLabel?: string;
+    replaceLabel?: string;
+    replaceAllLabel?: string;
+    closeLabel?: string;
+    searchError?: string;
+    replaceError?: string;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    replace: () => any;
+    close: () => any;
+    selectAll: () => any;
+    previous: () => any;
+    next: () => any;
+    replaceAll: () => any;
+    "update:searchValue": (value: string) => any;
+    "update:replaceValue": (value: string) => any;
+    "update:caseSensitive": (value: boolean) => any;
+    "update:regexp": (value: boolean) => any;
+    "update:wholeWord": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onReplace?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onSelectAll?: (() => any) | undefined;
+    onPrevious?: (() => any) | undefined;
+    onNext?: (() => any) | undefined;
+    onReplaceAll?: (() => any) | undefined;
+    "onUpdate:searchValue"?: ((value: string) => any) | undefined;
+    "onUpdate:replaceValue"?: ((value: string) => any) | undefined;
+    "onUpdate:caseSensitive"?: ((value: boolean) => any) | undefined;
+    "onUpdate:regexp"?: ((value: boolean) => any) | undefined;
+    "onUpdate:wholeWord"?: ((value: boolean) => any) | undefined;
+}>, {
+    closeLabel: string;
+    canReplace: boolean;
+    findPlaceholder: string;
+    replacePlaceholder: string;
+    nextLabel: string;
+    previousLabel: string;
+    selectAllLabel: string;
+    matchCaseLabel: string;
+    regexpLabel: string;
+    wholeWordLabel: string;
+    replaceLabel: string;
+    replaceAllLabel: string;
+    searchError: string;
+    replaceError: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/shared/data-display/SCodeSearchPanel.vue.js

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