niuma-ui 1.1.11 → 1.2.0

package/dist/components/RsVirtualList.impl.js

@@ -0,0 +1,138 @@
+import { rsRadiusCss, useResolvedRsRadius } from "./resolve-radius.js";
+import { isVirtualListFillHeight, resolveItemSize, resolveVirtualListHeight } from "./virtual-list-utils.js";
+import { Fragment, computed, createElementBlock, createElementVNode, createTextVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, onActivated, onMounted, onUnmounted, openBlock, ref, renderList, renderSlot, toDisplayString, watch } from "vue";
+//#region src/components/RsVirtualList.vue?vue&type=script&setup=true&lang.ts
+var RsVirtualList_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "RsVirtualList",
+	props: {
+		items: {},
+		itemSize: {
+			type: [Number, Function],
+			default: 32
+		},
+		height: { default: 240 },
+		overscan: { default: 4 },
+		activeIndex: { default: null },
+		layoutActive: { type: Boolean },
+		radius: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const resolvedRadius = useResolvedRsRadius(() => props.radius, "sm");
+		const rootRef = ref(null);
+		const scrollTop = ref(0);
+		const measuredHeight = ref(0);
+		const fillHeight = computed(() => isVirtualListFillHeight(props.height));
+		const heightStyle = computed(() => {
+			const resolved = resolveVirtualListHeight(props.height);
+			return resolved ? { height: resolved } : void 0;
+		});
+		const rootStyle = computed(() => ({
+			...heightStyle.value,
+			"--rs-virtual-list-radius": rsRadiusCss(resolvedRadius.value)
+		}));
+		const fixedItemSize = computed(() => resolveItemSize(props.itemSize));
+		const viewportHeightPx = computed(() => {
+			if (typeof props.height === "number" && props.height > 0) return props.height;
+			if (typeof props.height === "string") {
+				const parsed = Number.parseInt(props.height, 10);
+				if (Number.isFinite(parsed) && parsed > 0 && !props.height.includes("%")) return parsed;
+			}
+			if (measuredHeight.value > 0) return measuredHeight.value;
+			const el = rootRef.value;
+			if (el && el.clientHeight > 0) return el.clientHeight;
+			return 240;
+		});
+		let resizeObserver = null;
+		function syncMeasuredHeight() {
+			const el = rootRef.value;
+			if (!el) return;
+			const next = el.clientHeight;
+			if (next > 0 && next !== measuredHeight.value) measuredHeight.value = next;
+		}
+		function syncLayoutFromDom() {
+			syncMeasuredHeight();
+			const el = rootRef.value;
+			if (el) scrollTop.value = el.scrollTop;
+		}
+		function scheduleLayoutSync() {
+			syncLayoutFromDom();
+			nextTick(() => {
+				syncLayoutFromDom();
+				requestAnimationFrame(() => {
+					syncLayoutFromDom();
+				});
+			});
+		}
+		onMounted(() => {
+			scheduleLayoutSync();
+			const el = rootRef.value;
+			if (!el || typeof ResizeObserver === "undefined") return;
+			resizeObserver = new ResizeObserver(() => syncMeasuredHeight());
+			resizeObserver.observe(el);
+		});
+		onActivated(() => {
+			scheduleLayoutSync();
+		});
+		watch(() => props.layoutActive, (active) => {
+			if (active) scheduleLayoutSync();
+		}, { flush: "post" });
+		onUnmounted(() => {
+			resizeObserver?.disconnect();
+			resizeObserver = null;
+		});
+		const startIndex = computed(() => Math.max(0, Math.floor(scrollTop.value / fixedItemSize.value) - props.overscan));
+		const visibleCount = computed(() => Math.ceil(viewportHeightPx.value / fixedItemSize.value) + props.overscan * 2);
+		const visibleItems = computed(() => props.items.slice(startIndex.value, startIndex.value + visibleCount.value).map((item, index) => ({
+			item,
+			index: startIndex.value + index
+		})));
+		const totalHeight = computed(() => props.items.length * fixedItemSize.value);
+		const offsetY = computed(() => startIndex.value * fixedItemSize.value);
+		function scrollToIndex(index) {
+			const el = rootRef.value;
+			if (!el || index < 0 || index >= props.items.length) return;
+			const itemTop = index * fixedItemSize.value;
+			const itemBottom = itemTop + fixedItemSize.value;
+			const viewTop = el.scrollTop;
+			const viewBottom = viewTop + el.clientHeight;
+			if (itemTop >= viewTop && itemBottom <= viewBottom) return;
+			const maxScroll = Math.max(0, totalHeight.value - el.clientHeight);
+			const centered = itemTop - (el.clientHeight - fixedItemSize.value) / 2;
+			el.scrollTop = Math.min(maxScroll, Math.max(0, centered));
+			scrollTop.value = el.scrollTop;
+		}
+		watch(() => [props.activeIndex, props.items.length], async ([index, length]) => {
+			if (index == null || index < 0 || length === 0) return;
+			await nextTick();
+			requestAnimationFrame(() => scrollToIndex(index));
+		}, { immediate: true });
+		__expose({ scrollToIndex });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: normalizeClass(["rs-virtual-list", { "rs-virtual-list--fill": fillHeight.value }]),
+				style: normalizeStyle(rootStyle.value),
+				onScroll: _cache[0] || (_cache[0] = ($event) => scrollTop.value = $event.target.scrollTop)
+			}, [createElementVNode("div", {
+				class: "rs-virtual-list__spacer",
+				style: normalizeStyle({ height: `${totalHeight.value}px` })
+			}, [createElementVNode("div", {
+				class: "rs-virtual-list__items",
+				style: normalizeStyle({ transform: `translateY(${offsetY.value}px)` })
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(visibleItems.value, (entry) => {
+				return openBlock(), createElementBlock("div", {
+					key: entry.index,
+					class: normalizeClass(["rs-virtual-list__item", { "rs-virtual-list__item--active": __props.activeIndex === entry.index }]),
+					style: normalizeStyle({ height: `${fixedItemSize.value}px` })
+				}, [renderSlot(_ctx.$slots, "default", {
+					item: entry.item,
+					index: entry.index
+				}, () => [createTextVNode(toDisplayString(entry.item), 1)], true)], 6);
+			}), 128))], 4)], 4)], 38);
+		};
+	}
+});
+//#endregion
+export { RsVirtualList_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/RsVirtualList.js

@@ -0,0 +1,8 @@
+import './RsVirtualList.css'
+import _plugin_vue_export_helper_default from "../_virtual/_plugin-vue_export-helper.js";
+import RsVirtualList_vue_vue_type_script_setup_true_lang_default from "./RsVirtualList.impl.js";
+
+//#region src/components/RsVirtualList.vue
+var RsVirtualList_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsVirtualList_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-c2c4b7ba"]]);
+//#endregion
+export { RsVirtualList_default as default };

package/dist/components/avatar-utils.d.ts

@@ -0,0 +1,11 @@
+/** 头像尺寸 */
+export type RsAvatarSize = 'sm' | 'md' | 'lg';
+/** 头像形状 */
+export type RsAvatarShape = 'circle' | 'square';
+/** 头像占位色调 */
+export type RsAvatarTone = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+/**
+ * 从姓名提取缩写（最多 2 个字符）。
+ * @param name 显示名称
+ */
+export declare function getAvatarInitials(name: string): string;

package/dist/components/avatar-utils.js

@@ -0,0 +1,13 @@
+//#region src/components/avatar-utils.ts
+/**
+* 从姓名提取缩写（最多 2 个字符）。
+* @param name 显示名称
+*/
+function getAvatarInitials(name) {
+	const parts = name.trim().split(/\s+/).filter(Boolean);
+	if (!parts.length) return "?";
+	if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+	return `${parts[0][0] ?? ""}${parts[1][0] ?? ""}`.toUpperCase();
+}
+//#endregion
+export { getAvatarInitials };

package/dist/components/breadcrumb-utils.d.ts

@@ -0,0 +1,12 @@
+export interface RsBreadcrumbRenderItem {
+    key: string;
+    label: string;
+    href?: string;
+    isLink: boolean;
+    isCurrent: boolean;
+}
+export declare function buildBreadcrumbRenderItems(items: Array<{
+    label: string;
+    to?: string;
+    href?: string;
+}>): RsBreadcrumbRenderItem[];

package/dist/components/breadcrumb-utils.js

@@ -0,0 +1,12 @@
+//#region src/components/breadcrumb-utils.ts
+function buildBreadcrumbRenderItems(items) {
+	return items.map((item, index) => ({
+		key: `${item.label}-${index}`,
+		label: item.label,
+		href: item.href,
+		isLink: Boolean(item.to || item.href),
+		isCurrent: index === items.length - 1
+	}));
+}
+//#endregion
+export { buildBreadcrumbRenderItems };

package/dist/components/button-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * RsButton 外观变体
+ * - primary / default / ghost / danger：常规控件按钮
+ * - link：行内链接态（可带下划线）
+ * - text：工具栏/表格操作等 quaternary 文字按钮（无底无边，靠 tone 着色）
+ */
+export type RsButtonVariant = 'primary' | 'default' | 'secondary' | 'ghost' | 'danger' | 'link' | 'text';
+/**
+ * RsButton 语义色调
+ * 主要用于 text / ghost / link：只改文字与图标色，不改变填充形态。
+ * 对 primary / default / danger 等填充变体将被忽略。
+ */
+export type RsButtonTone = 'neutral' | 'primary' | 'danger' | 'success' | 'warning' | 'info';
+/** 填充类变体：已自带语义色，不再叠加 tone */
+export declare function isRsButtonFilledVariant(variant: RsButtonVariant): boolean;
+/** text / ghost / link 可叠加 tone */
+export declare function supportsRsButtonTone(variant: RsButtonVariant): boolean;

package/dist/components/button-utils.js

@@ -0,0 +1,13 @@
+//#region src/components/button-utils.ts
+/** 填充类变体：已自带语义色，不再叠加 tone */
+function isRsButtonFilledVariant(variant) {
+	const resolved = variant === "secondary" ? "default" : variant;
+	return resolved === "primary" || resolved === "default" || resolved === "danger";
+}
+/** text / ghost / link 可叠加 tone */
+function supportsRsButtonTone(variant) {
+	const resolved = variant === "secondary" ? "default" : variant;
+	return resolved === "text" || resolved === "ghost" || resolved === "link";
+}
+//#endregion
+export { isRsButtonFilledVariant, supportsRsButtonTone };

package/dist/components/class-utils.d.ts

@@ -0,0 +1,2 @@
+export type RsClassValue = string | number | false | null | undefined | Record<string, boolean | null | undefined> | RsClassValue[];
+export declare function rsCn(...values: RsClassValue[]): string;

package/dist/components/code-editor-utils.d.ts

@@ -0,0 +1,33 @@
+export type RsCodeEditorLanguage = 'plaintext' | 'json' | 'typescript' | 'javascript' | 'css' | 'html' | 'xml' | 'sql' | 'go' | 'python' | 'rust' | 'java' | 'cpp' | 'c' | 'shell' | 'yaml' | 'toml' | 'markdown' | 'vue';
+export type RsCodeEditorTheme = 'auto' | 'light' | 'dark';
+export type RsResolvedCodeEditorTheme = 'light' | 'dark';
+export interface RsCodeEditorDiagnostic {
+    message: string;
+    line?: number;
+    column?: number;
+    severity?: 'error' | 'warning' | 'info';
+}
+/** CodeMirror SQL 字段/表补全（对应 @codemirror/lang-sql SQLConfig 子集） */
+export type RsCodeEditorSqlDialect = 'postgresql' | 'standard' | 'mysql';
+export interface RsCodeEditorSqlColumn {
+    label: string;
+    /** 展示用类型，如 integer / text */
+    detail?: string;
+    type?: string;
+    boost?: number;
+}
+export type RsCodeEditorSqlNamespace = readonly (string | RsCodeEditorSqlColumn)[] | {
+    [name: string]: RsCodeEditorSqlNamespace;
+};
+export interface RsCodeEditorSqlConfig {
+    dialect?: RsCodeEditorSqlDialect;
+    schema?: RsCodeEditorSqlNamespace;
+    /** 顶层直接补全该表列（适合 WHERE 片段） */
+    defaultTable?: string;
+    defaultSchema?: string;
+}
+export declare function resolveCodeEditorLanguage(language?: string): RsCodeEditorLanguage;
+export declare function codeEditorLanguageLabel(language?: string): string;
+export declare function readDocumentTheme(): RsResolvedCodeEditorTheme;
+export declare function resolveCodeEditorTheme(theme?: RsCodeEditorTheme): RsResolvedCodeEditorTheme;
+export declare function resolveCodeEditorSize(height?: number | string): string;

package/dist/components/code-editor-utils.js

@@ -0,0 +1,64 @@
+//#region src/components/code-editor-utils.ts
+var SUPPORTED_LANGUAGES = [
+	"plaintext",
+	"json",
+	"typescript",
+	"javascript",
+	"css",
+	"html",
+	"xml",
+	"sql",
+	"go",
+	"python",
+	"rust",
+	"java",
+	"cpp",
+	"c",
+	"shell",
+	"yaml",
+	"toml",
+	"markdown",
+	"vue"
+];
+/** 语言 → 工具栏展示名称映射 */
+var LANGUAGE_DISPLAY_NAME = {
+	plaintext: "Plain Text",
+	json: "JSON",
+	typescript: "TypeScript",
+	javascript: "JavaScript",
+	css: "CSS",
+	html: "HTML",
+	xml: "XML",
+	sql: "SQL",
+	go: "Go",
+	python: "Python",
+	rust: "Rust",
+	java: "Java",
+	cpp: "C++",
+	c: "C",
+	shell: "Shell",
+	yaml: "YAML",
+	toml: "TOML",
+	markdown: "Markdown",
+	vue: "Vue"
+};
+function resolveCodeEditorLanguage(language) {
+	return SUPPORTED_LANGUAGES.includes(language ?? "") ? language : "plaintext";
+}
+function codeEditorLanguageLabel(language) {
+	const lang = resolveCodeEditorLanguage(language);
+	return LANGUAGE_DISPLAY_NAME[lang] ?? lang;
+}
+function readDocumentTheme() {
+	if (typeof document === "undefined") return "dark";
+	return document.documentElement.dataset.rsTheme === "light" ? "light" : "dark";
+}
+function resolveCodeEditorTheme(theme = "auto") {
+	return theme === "auto" ? readDocumentTheme() : theme;
+}
+function resolveCodeEditorSize(height) {
+	if (height === void 0) return "20rem";
+	return typeof height === "number" ? `${height}px` : height;
+}
+//#endregion
+export { codeEditorLanguageLabel, readDocumentTheme, resolveCodeEditorLanguage, resolveCodeEditorSize, resolveCodeEditorTheme };

package/dist/components/code-mirror-completion.d.ts

@@ -0,0 +1,5 @@
+import type { Extension } from '@codemirror/state';
+export interface CodeMirrorCompletionHandlers {
+    completionRequest?: (prefix: string, suffix: string, line: number, column: number) => Promise<string | null>;
+}
+export declare function codeMirrorCompletionExtensions(handlers: () => CodeMirrorCompletionHandlers): Extension[];

package/dist/components/code-mirror-completion.js

@@ -0,0 +1,37 @@
+import { posToLineColumn } from "./code-mirror-intel.js";
+import { clearGhostCompletion, setGhostCompletion } from "./code-mirror-ghost.js";
+import { keymap } from "@codemirror/view";
+//#region src/components/code-mirror-completion.ts
+function codeMirrorCompletionExtensions(handlers) {
+	return [keymap.of([{
+		key: "Ctrl-Space",
+		mac: "Cmd-Space",
+		run: (view) => {
+			const h = handlers();
+			if (!h.completionRequest) return false;
+			clearGhostCompletion(view);
+			const pos = view.state.selection.main.head;
+			const prefix = view.state.doc.sliceString(0, pos);
+			const suffix = view.state.doc.sliceString(pos);
+			const { line, column } = posToLineColumn(view, pos);
+			h.completionRequest(prefix, suffix, line, column).then((text) => {
+				if (!text?.trim()) return;
+				const latestPos = view.state.selection.main.head;
+				if (view.state.doc.sliceString(latestPos) !== suffix) return;
+				view.dispatch({
+					changes: {
+						from: latestPos,
+						to: latestPos,
+						insert: text
+					},
+					selection: { anchor: latestPos + text.length },
+					effects: setGhostCompletion.of(null)
+				});
+				view.focus();
+			});
+			return true;
+		}
+	}])];
+}
+//#endregion
+export { codeMirrorCompletionExtensions };

package/dist/components/code-mirror-diagnostics.d.ts

@@ -0,0 +1,6 @@
+import { Compartment } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import type { RsCodeEditorDiagnostic } from './code-editor-utils';
+export declare const diagnosticCompartment: Compartment;
+export declare function diagnosticExtensions(): import("@codemirror/state").Extension;
+export declare function setEditorDiagnostics(view: EditorView, diags: RsCodeEditorDiagnostic[]): void;

package/dist/components/code-mirror-diagnostics.js

@@ -0,0 +1,35 @@
+import { Compartment, RangeSetBuilder, StateEffect, StateField } from "@codemirror/state";
+import { Decoration, EditorView } from "@codemirror/view";
+//#region src/components/code-mirror-diagnostics.ts
+var setDiagnosticsEffect = StateEffect.define();
+function buildLineDecorations(doc, diags) {
+	const builder = new RangeSetBuilder();
+	for (const d of diags) {
+		const lineNo = d.line ?? 1;
+		if (lineNo < 1 || lineNo > doc.lines) continue;
+		const line = doc.line(lineNo);
+		const cls = d.severity === "warning" ? "cm-lintRange cm-lintRange-warning" : d.severity === "info" ? "cm-lintRange cm-lintRange-info" : "cm-lintRange cm-lintRange-error";
+		builder.add(line.from, line.from, Decoration.line({ class: cls }));
+	}
+	return builder.finish();
+}
+var diagnosticField = StateField.define({
+	create() {
+		return Decoration.none;
+	},
+	update(deco, tr) {
+		for (const e of tr.effects) if (e.is(setDiagnosticsEffect)) return buildLineDecorations(tr.state.doc, e.value);
+		if (tr.docChanged) return deco.map(tr.changes);
+		return deco;
+	},
+	provide: (f) => EditorView.decorations.from(f)
+});
+var diagnosticCompartment = new Compartment();
+function diagnosticExtensions() {
+	return diagnosticCompartment.of([diagnosticField]);
+}
+function setEditorDiagnostics(view, diags) {
+	view.dispatch({ effects: setDiagnosticsEffect.of(diags) });
+}
+//#endregion
+export { diagnosticCompartment, diagnosticExtensions, setEditorDiagnostics };

package/dist/components/code-mirror-ghost.d.ts

@@ -0,0 +1,8 @@
+import { type Extension } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+export declare const setGhostCompletion: import("@codemirror/state").StateEffectType<string | null>;
+export interface CodeMirrorGhostHandlers {
+    completionRequest?: (prefix: string, suffix: string, line: number, column: number) => Promise<string | null>;
+}
+export declare function codeMirrorGhostExtensions(handlers: () => CodeMirrorGhostHandlers, scheduleDebounced: (fn: () => void) => void, cancelScheduled?: () => void): Extension[];
+export declare function clearGhostCompletion(view: EditorView): void;

package/dist/components/code-mirror-ghost.js

@@ -0,0 +1,133 @@
+import { posToLineColumn } from "./code-mirror-intel.js";
+import { Prec, StateEffect, StateField } from "@codemirror/state";
+import { Decoration, EditorView, WidgetType, keymap } from "@codemirror/view";
+//#region src/components/code-mirror-ghost.ts
+var setGhostCompletion = StateEffect.define();
+var GhostWidget = class extends WidgetType {
+	text;
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+	eq(other) {
+		return other.text === this.text;
+	}
+	toDOM() {
+		const span = document.createElement("span");
+		span.className = "rs-code-editor__ghost";
+		span.textContent = this.text;
+		return span;
+	}
+	ignoreEvent() {
+		return true;
+	}
+};
+var ghostMetaField = StateField.define({
+	create() {
+		return null;
+	},
+	update(value, tr) {
+		for (const effect of tr.effects) if (effect.is(setGhostCompletion)) {
+			if (!effect.value) return null;
+			return {
+				text: effect.value,
+				pos: tr.state.selection.main.head
+			};
+		}
+		if (tr.docChanged) return null;
+		if (tr.selection && !tr.effects.some((e) => e.is(setGhostCompletion))) return null;
+		return value;
+	}
+});
+var ghostField = StateField.define({
+	create() {
+		return Decoration.none;
+	},
+	update(deco, tr) {
+		deco = deco.map(tr.changes);
+		for (const effect of tr.effects) if (effect.is(setGhostCompletion)) {
+			if (!effect.value) return Decoration.none;
+			const pos = tr.state.selection.main.head;
+			return Decoration.set([Decoration.widget({
+				widget: new GhostWidget(effect.value),
+				side: 1
+			}).range(pos)]);
+		}
+		if (tr.docChanged || tr.selection) {
+			if (!tr.effects.some((e) => e.is(setGhostCompletion))) return Decoration.none;
+		}
+		return deco;
+	},
+	provide: (field) => EditorView.decorations.from(field)
+});
+function readGhostAtCursor(view) {
+	const meta = view.state.field(ghostMetaField, false);
+	if (!meta) return null;
+	if (meta.pos !== view.state.selection.main.head) return null;
+	return meta;
+}
+function codeMirrorGhostExtensions(handlers, scheduleDebounced, cancelScheduled) {
+	let seq = 0;
+	return [
+		ghostMetaField,
+		ghostField,
+		EditorView.updateListener.of((update) => {
+			if (!update.docChanged) return;
+			const h = handlers();
+			if (!h.completionRequest) return;
+			cancelScheduled?.();
+			const id = ++seq;
+			scheduleDebounced(() => {
+				const view = update.view;
+				const pos = view.state.selection.main.head;
+				const prefix = view.state.doc.sliceString(0, pos);
+				const suffix = view.state.doc.sliceString(pos);
+				const { line, column } = posToLineColumn(view, pos);
+				h.completionRequest(prefix, suffix, line, column).then((text) => {
+					if (id !== seq) return;
+					if (!text?.trim()) {
+						view.dispatch({ effects: setGhostCompletion.of(null) });
+						return;
+					}
+					const current = view.state.selection.main.head;
+					if (view.state.doc.sliceString(current) !== suffix) return;
+					view.dispatch({ effects: setGhostCompletion.of(text) });
+				});
+			});
+		}),
+		Prec.highest(keymap.of([{
+			key: "Tab",
+			run: (view) => {
+				const ghost = readGhostAtCursor(view);
+				if (!ghost) return false;
+				cancelScheduled?.();
+				seq += 1;
+				const pos = view.state.selection.main.head;
+				view.dispatch({
+					changes: {
+						from: pos,
+						to: pos,
+						insert: ghost.text
+					},
+					selection: { anchor: pos + ghost.text.length },
+					effects: setGhostCompletion.of(null)
+				});
+				return true;
+			}
+		}, {
+			key: "Escape",
+			run: (view) => {
+				if (!readGhostAtCursor(view)) return false;
+				cancelScheduled?.();
+				seq += 1;
+				view.dispatch({ effects: setGhostCompletion.of(null) });
+				return true;
+			}
+		}]))
+	];
+}
+function clearGhostCompletion(view) {
+	view.dispatch({ effects: setGhostCompletion.of(null) });
+}
+//#endregion
+export { clearGhostCompletion, codeMirrorGhostExtensions, setGhostCompletion };

package/dist/components/code-mirror-inline-edit.d.ts

@@ -0,0 +1,11 @@
+import { type Extension } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+export interface InlineEditTrigger {
+    selection: string;
+    from: number;
+    to: number;
+}
+/** 提取选区上下各若干行，供 Inline Edit 理解作用域（不含重复包裹选区）。 */
+export declare function extractSurroundingContext(doc: string, from: number, to: number, lineRadius?: number): string;
+export declare function codeMirrorInlineEditExtension(onTrigger: (view: EditorView, info: InlineEditTrigger) => void): Extension;
+export declare function replaceEditorRange(view: EditorView, from: number, to: number, insert: string): void;

package/dist/components/code-mirror-inline-edit.js

@@ -0,0 +1,51 @@
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+//#region src/components/code-mirror-inline-edit.ts
+/** 提取选区上下各若干行，供 Inline Edit 理解作用域（不含重复包裹选区）。 */
+function extractSurroundingContext(doc, from, to, lineRadius = 20) {
+	if (!doc) return "";
+	const lines = doc.split("\n");
+	let pos = 0;
+	let startLine = 0;
+	let endLine = lines.length - 1;
+	for (let i = 0; i < lines.length; i++) {
+		const lineStart = pos;
+		const lineEnd = pos + lines[i].length;
+		if (from >= lineStart && from <= lineEnd + (i < lines.length - 1 ? 1 : 0)) startLine = i;
+		if (to >= lineStart && to <= lineEnd + (i < lines.length - 1 ? 1 : 0)) endLine = i;
+		pos = lineEnd + 1;
+	}
+	const contextStart = Math.max(0, startLine - lineRadius);
+	const contextEnd = Math.min(lines.length - 1, endLine + lineRadius);
+	return lines.slice(contextStart, contextEnd + 1).join("\n");
+}
+function codeMirrorInlineEditExtension(onTrigger) {
+	return Prec.highest(keymap.of([{
+		key: "Mod-k",
+		run: (view) => {
+			const { from, to } = view.state.selection.main;
+			if (from === to) return false;
+			const selection = view.state.sliceDoc(from, to);
+			if (!selection.trim()) return false;
+			onTrigger(view, {
+				selection,
+				from,
+				to
+			});
+			return true;
+		}
+	}]));
+}
+function replaceEditorRange(view, from, to, insert) {
+	view.dispatch({
+		changes: {
+			from,
+			to,
+			insert
+		},
+		selection: { anchor: from + insert.length }
+	});
+	view.focus();
+}
+//#endregion
+export { codeMirrorInlineEditExtension, extractSurroundingContext, replaceEditorRange };

package/dist/components/code-mirror-intel.d.ts

@@ -0,0 +1,22 @@
+import { EditorView } from '@codemirror/view';
+import type { Extension } from '@codemirror/state';
+export interface CodeMirrorIntelHandlers {
+    hoverRequest?: (line: number, column: number) => Promise<string | null>;
+    definitionRequest?: (line: number, column: number) => Promise<{
+        file: string;
+        line: number;
+        column?: number;
+    } | null>;
+    currentFilePath?: string;
+    onGotoDefinition?: (loc: {
+        file: string;
+        line: number;
+        column?: number;
+    }) => void;
+}
+export declare function posToLineColumn(view: EditorView, pos: number): {
+    line: number;
+    column: number;
+};
+export declare function goToPosition(view: EditorView, line: number, column?: number): void;
+export declare function codeMirrorIntelExtensions(handlers: () => CodeMirrorIntelHandlers): Extension[];