niuma-ui 2.0.3 → 2.0.9

package/dist/components/menu/src/menu-utils.d.ts

@@ -1,16 +1,72 @@
+export type RsMenuMode = 'vertical' | 'horizontal';
+export type RsMenuTriggerAction = 'click' | 'hover';
+export type RsMenuGetPopupContainer = () => HTMLElement | null | undefined;
 export interface RsMenuItem {
     key: string;
     label: string;
     icon?: string;
     disabled?: boolean;
     children?: RsMenuItem[];
+    /** 叶子可写成原生 a[href]。优先于 to。 */
+    href?: string;
+    /** 未传 href 时写到 a[href]。Vue Router 请在 click 里 preventDefault 后 push。 */
+    to?: string;
+    target?: string;
+    rel?: string;
+    /** 右侧辅助文案（折叠时隐藏） */
+    extra?: string;
+    type?: 'item' | 'divider';
 }
 export interface RsMenuItemGroup {
     label: string;
     children: RsMenuItem[];
 }
 export type RsMenuItems = RsMenuItem[] | RsMenuItemGroup[];
+export interface RsMenuItemSlot {
+    item: RsMenuItem;
+    active: boolean;
+    parentActive: boolean;
+    open: boolean;
+    collapsed: boolean;
+    depth: number;
+}
+export interface RsMenuExpose {
+    focus: () => void;
+    blur: () => void;
+}
+export type RsMenuInstance = RsMenuExpose & {
+    $el: HTMLElement;
+};
 export declare function isMenuItemGroup(item: RsMenuItem | RsMenuItemGroup): item is RsMenuItemGroup;
+export declare function isMenuDivider(item: RsMenuItem): boolean;
+export declare function menuEntryKey(entry: RsMenuItem | RsMenuItemGroup, index: number): string;
+export type RsMenuRenderBlock = {
+    type: 'group';
+    entry: RsMenuItemGroup;
+    key: string;
+} | {
+    type: 'items';
+    items: RsMenuItem[];
+    key: string;
+};
+/** 连续叶子收成一块，分组单独一块，便于同一 ul 内方向键走动。 */
+export declare function partitionMenuEntries(items: RsMenuItems): RsMenuRenderBlock[];
+export declare function collectRootMenuItems(items: RsMenuItems): RsMenuItem[];
 export declare function findMenuParentKeys(items: RsMenuItems, key: string): string[];
 /** 判断菜单项自身或其任意后代是否匹配 key（用于父级高亮） */
 export declare function menuItemContainsKey(item: RsMenuItem, key: string): boolean;
+/** 与 key 同层的子菜单 key（含自身），供 accordion 关兄弟。 */
+export declare function findMenuSiblingKeys(items: RsMenuItems, key: string): string[];
+export declare function collectMenuDescendantKeys(items: RsMenuItems, key: string): string[];
+/** 选中叶子时并入祖先。已全部打开则返回原数组引用，避免多余 emit。 */
+export declare function mergeOpenKeysWithParents(current: string[], parents: string[]): string[];
+export declare function toggleMenuOpenKeys(current: string[], key: string, open: boolean, items: RsMenuItems, accordion: boolean): string[];
+export declare function resolveMenuItemHref(item: RsMenuItem): string | undefined;
+/** `_blank` 时补 noopener / noreferrer，并保留调用方已有 rel。 */
+export declare function mergeMenuLinkRel(rel: string | undefined, target: string | undefined): string | undefined;
+export declare function menuArrowKeys(vertical: boolean, rtl: boolean): {
+    next: string;
+    prev: string;
+    open: string;
+};
+export declare function resolveMenuPortalTarget(getPopupContainer?: RsMenuGetPopupContainer): string | HTMLElement;

package/dist/components/menu/src/menu-utils.js

@@ -2,6 +2,51 @@
 function isMenuItemGroup(item) {
 	return !("key" in item) && "children" in item;
 }
+function isMenuDivider(item) {
+	return item.type === "divider";
+}
+function menuEntryKey(entry, index) {
+	if (isMenuItemGroup(entry)) return `group:${entry.label}:${index}`;
+	return entry.key || `item:${index}`;
+}
+/** 连续叶子收成一块，分组单独一块，便于同一 ul 内方向键走动。 */
+function partitionMenuEntries(items) {
+	const out = [];
+	let batch = [];
+	let batchIndex = 0;
+	items.forEach((entry, index) => {
+		if (isMenuItemGroup(entry)) {
+			if (batch.length) {
+				out.push({
+					type: "items",
+					items: batch,
+					key: `items:${batchIndex}`
+				});
+				batch = [];
+				batchIndex += 1;
+			}
+			out.push({
+				type: "group",
+				entry,
+				key: menuEntryKey(entry, index)
+			});
+			return;
+		}
+		batch.push(entry);
+	});
+	if (batch.length) out.push({
+		type: "items",
+		items: batch,
+		key: `items:${batchIndex}`
+	});
+	return out;
+}
+function collectRootMenuItems(items) {
+	const out = [];
+	for (const entry of items) if (isMenuItemGroup(entry)) out.push(...entry.children);
+	else out.push(entry);
+	return out;
+}
 function findMenuParentKeys(items, key) {
 	function walk(list, ancestors) {
 		for (const item of list) {
@@ -13,11 +58,7 @@ function findMenuParentKeys(items, key) {
 		}
 		return null;
 	}
-	for (const entry of items) {
-		const found = isMenuItemGroup(entry) ? walk(entry.children, []) : walk([entry], []);
-		if (found) return found;
-	}
-	return [];
+	return walk(collectRootMenuItems(items), []) ?? [];
 }
 /** 判断菜单项自身或其任意后代是否匹配 key（用于父级高亮） */
 function menuItemContainsKey(item, key) {
@@ -25,5 +66,97 @@ function menuItemContainsKey(item, key) {
 	if (!item.children?.length) return false;
 	return item.children.some((child) => menuItemContainsKey(child, key));
 }
+/** 与 key 同层的子菜单 key（含自身），供 accordion 关兄弟。 */
+function findMenuSiblingKeys(items, key) {
+	function walk(list) {
+		const keys = list.filter((item) => !isMenuDivider(item) && Boolean(item.children?.length)).map((item) => item.key);
+		if (keys.includes(key)) return keys;
+		for (const item of list) if (item.children?.length) {
+			const found = walk(item.children);
+			if (found) return found;
+		}
+		return null;
+	}
+	return walk(collectRootMenuItems(items)) ?? [];
+}
+function collectMenuDescendantKeys(items, key) {
+	function find(list) {
+		for (const item of list) {
+			if (item.key === key) return item;
+			if (item.children?.length) {
+				const found = find(item.children);
+				if (found) return found;
+			}
+		}
+		return null;
+	}
+	function collect(item, acc) {
+		if (!item.children?.length) return acc;
+		for (const child of item.children) if (child.children?.length && !isMenuDivider(child)) {
+			acc.push(child.key);
+			collect(child, acc);
+		}
+		return acc;
+	}
+	const node = find(collectRootMenuItems(items));
+	return node ? collect(node, []) : [];
+}
+/** 选中叶子时并入祖先。已全部打开则返回原数组引用，避免多余 emit。 */
+function mergeOpenKeysWithParents(current, parents) {
+	if (!parents.length) return current;
+	if (parents.every((key) => current.includes(key))) return current;
+	const next = new Set(current);
+	for (const key of parents) next.add(key);
+	return [...next];
+}
+function toggleMenuOpenKeys(current, key, open, items, accordion) {
+	if (!open) {
+		const drop = /* @__PURE__ */ new Set([key, ...collectMenuDescendantKeys(items, key)]);
+		return current.filter((item) => !drop.has(item));
+	}
+	if (!accordion) {
+		if (current.includes(key)) return current;
+		return [...current, key];
+	}
+	const siblings = findMenuSiblingKeys(items, key);
+	const drop = /* @__PURE__ */ new Set();
+	for (const sibling of siblings) {
+		if (sibling === key) continue;
+		drop.add(sibling);
+		for (const descendant of collectMenuDescendantKeys(items, sibling)) drop.add(descendant);
+	}
+	const next = current.filter((item) => !drop.has(item));
+	if (!next.includes(key)) next.push(key);
+	return next;
+}
+function resolveMenuItemHref(item) {
+	if (item.href) return item.href;
+	if (item.to) return item.to;
+}
+/** `_blank` 时补 noopener / noreferrer，并保留调用方已有 rel。 */
+function mergeMenuLinkRel(rel, target) {
+	const parts = (rel ?? "").split(/\s+/).map((item) => item.trim()).filter(Boolean);
+	if (target === "_blank") {
+		if (!parts.includes("noopener")) parts.push("noopener");
+		if (!parts.includes("noreferrer")) parts.push("noreferrer");
+	}
+	return parts.length > 0 ? parts.join(" ") : void 0;
+}
+function menuArrowKeys(vertical, rtl) {
+	if (vertical) return {
+		next: "ArrowDown",
+		prev: "ArrowUp",
+		open: rtl ? "ArrowLeft" : "ArrowRight"
+	};
+	return {
+		next: rtl ? "ArrowLeft" : "ArrowRight",
+		prev: rtl ? "ArrowRight" : "ArrowLeft",
+		open: "ArrowDown"
+	};
+}
+function resolveMenuPortalTarget(getPopupContainer) {
+	if (typeof document === "undefined") return "body";
+	return getPopupContainer?.() ?? document.body;
+}
 //#endregion
-export { findMenuParentKeys, isMenuItemGroup, menuItemContainsKey };
+export { collectMenuDescendantKeys, collectRootMenuItems, findMenuParentKeys, findMenuSiblingKeys, isMenuDivider, isMenuItemGroup, menuArrowKeys, menuEntryKey, menuItemContainsKey, mergeMenuLinkRel, mergeOpenKeysWithParents, partitionMenuEntries, resolveMenuItemHref, resolveMenuPortalTarget, toggleMenuOpenKeys };

package/dist/components/monaco-editor/index.d.ts

@@ -1,2 +1,2 @@
 export { default as RsMonacoEditor } from './src/RsMonacoEditor.js';
-export type { MonacoCompletionContext, MonacoCompletionPrefixResolver, MonacoCompletionRequest, MonacoCompletionSnippet, RsMonacoEditorExpose, } from './src/RsMonacoEditor.js';
+export type { MonacoCompletionContext, MonacoCompletionPrefixResolver, MonacoCompletionRequest, MonacoCompletionSnippet, RsMonacoEditorContextMenu, RsMonacoEditorExpose, RsMonacoEditorInstance, RsMonacoEditorTheme, } from './src/RsMonacoEditor.js';

package/dist/components/monaco-editor/src/RsMonacoEditor.css

@@ -1,28 +1,40 @@
 
-.rs-monaco[data-v-1366fa31] {
-  /* hover tooltip 的定位上下文；勿加 overflow:hidden，否则会裁剪 Find Widget 的 tooltip */
+.rs-monaco[data-v-b3d8e08a] {
   position: relative;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
   width: 100%;
-  border: 1px solid var(--rs-border);
-  border-radius: var(--rs-radius);
-  background: var(--rs-surface-elevated);
+  overflow: hidden;
+  border: 1px solid var(--rs-monaco-border, var(--rs-border));
+  border-radius: var(--rs-monaco-radius, var(--rs-radius));
+  background: var(--rs-monaco-bg, var(--rs-surface-elevated));
+  color: var(--rs-monaco-fg, var(--rs-text-primary));
+}
+.rs-monaco[data-v-b3d8e08a]:not(.rs-monaco--embedded):focus-within {
+  outline: var(--rs-focus-ring-width, 2px) solid var(--rs-focus-border);
+  outline-offset: 1px;
 }
-.rs-monaco--embedded[data-v-1366fa31] {
+.rs-monaco--embedded[data-v-b3d8e08a] {
   border: 0;
-  border-radius: 0;
+  background: transparent;
   flex: 1 1 auto;
-  min-height: 0;
-  height: 100%;
+  min-block-size: 0;
 }
-[data-v-1366fa31] .monaco-editor {
-  border-radius: inherit;
+.rs-monaco--disabled[data-v-b3d8e08a] {
+  opacity: var(--rs-monaco-disabled-opacity, 0.72);
 }
-[data-v-1366fa31] .monaco-editor .overflow-guard {
+[data-v-b3d8e08a] .monaco-editor,[data-v-b3d8e08a] .monaco-editor .overflow-guard,[data-v-b3d8e08a] .monaco-editor .monaco-scrollable-element {
   border-radius: inherit;
+}
+[data-v-b3d8e08a] .monaco-editor .overflow-guard {
   overflow: hidden;
 }
-
-/* Find Widget z-index:35；Monaco hover 内联 z-index≈2575，层级本身足够 */
-[data-v-1366fa31] .monaco-editor .find-widget {
-  z-index: 40;
+[data-v-b3d8e08a] .monaco-editor .find-widget {
+  z-index: var(--rs-z-dropdown);
+}
+@media (prefers-reduced-motion: reduce) {
+.rs-monaco[data-v-b3d8e08a]:not(.rs-monaco--embedded):focus-within {
+    outline-offset: 0;
+}
 }

package/dist/components/monaco-editor/src/RsMonacoEditor.d.ts

@@ -1,45 +1,16 @@
-import type { MonacoLanguage } from '../../../monaco/languages';
+import type { RsRadius } from '../../../theme/types';
 /** VS Code 式调试装饰样式（断点 / 当前行）；业务组件勿再自定义 glyph CSS */
 import '../../../monaco/debug-decorations.css';
-/** 实例级补全片段（仅作用于当前编辑器 Model）。 */
-export interface MonacoCompletionSnippet {
-    label: string;
-    insertText: string;
-    detail?: string;
-    documentation?: string;
-    filterText?: string;
-    sortText?: string;
-    kind?: 'snippet' | 'keyword' | 'property' | 'field' | 'function' | 'value';
-    preselect?: boolean;
-}
-/**
- * RsMonacoEditor 模板 ref 请用此类型。
- * 不要写 `InstanceType<typeof RsMonacoEditor>`：组件实例类型过深，vue-tsc 会报 Excessive stack depth。
- */
-export interface RsMonacoEditorExpose {
-    format: () => void;
-    getEditor: () => import('monaco-editor').editor.IStandaloneCodeEditor | null;
-    revealLine: (line: number) => void;
-}
-/** MonacoCompletionContext 描述一次补全请求的编辑器上下文。 */
-export interface MonacoCompletionContext {
-    text: string;
-    offset: number;
-    line: number;
-    column: number;
-    prefix: string;
-    triggerCharacter?: string;
-}
-/** MonacoCompletionRequest 按当前文本和光标位置返回实例级候选。 */
-export type MonacoCompletionRequest = (context: MonacoCompletionContext) => MonacoCompletionSnippet[] | Promise<MonacoCompletionSnippet[]>;
-/** 补全前缀解析：由业务侧按方言注入，默认按标识符切词。 */
-export type MonacoCompletionPrefixResolver = (linePrefix: string) => string;
+import { type MonacoCompletionSnippet, type RsMonacoEditorContextMenu, type RsMonacoEditorExpose } from './monaco-editor-utils';
+export type { MonacoCompletionContext, MonacoCompletionPrefixResolver, MonacoCompletionRequest, MonacoCompletionSnippet, RsMonacoEditorContextMenu, RsMonacoEditorExpose, RsMonacoEditorInstance, RsMonacoEditorTheme, } from './monaco-editor-utils';
 type __VLS_Props = {
-    language?: MonacoLanguage;
+    language?: import('../../../monaco/languages').MonacoLanguage;
     /** px 整数或 CSS 字符串如 '100%' / '20rem' */
     height?: number | string;
     readonly?: boolean;
-    /** 深色/浅色主题：auto 跟随 data-rs-theme 属性 */
+    /** 不可编辑，且不再弹出只读提示。与 readonly 可同时开，disabled 优先锁 DOM。 */
+    disabled?: boolean;
+    /** 深色/浅色：auto 跟随 documentElement 的 data-rs-theme。Monaco 主题是进程级的。 */
     theme?: 'auto' | 'vs-dark' | 'light';
     /** 是否显示 minimap */
     minimap?: boolean;
@@ -54,47 +25,74 @@ type __VLS_Props = {
     debugCurrentLine?: number;
     /** 调试：断点行号列表（1-based，编辑器行号） */
     debugBreakpoints?: number[];
-    /** 嵌入面板：无边框/圆角，铺满父级（调试/源码等） */
+    /**
+     * 嵌入面板：去掉自己的边框和底色，圆角跟父级，铺满父级。
+     * height 仍生效；父级是 flex 时也会 flex: 1。
+     */
     embedded?: boolean;
+    /** 外框圆角。embedded 时忽略，改跟父级。 */
+    radius?: RsRadius;
     /**
      * JSON Schema 对象（仅 language="json" 有效）。
      * 每个编辑器实例使用独立的 Model URI，schema 通过 fileMatch 精确绑定，
      * 不会污染其他 JSON 编辑器。
      */
     jsonSchema?: object;
-    /** 实例级补全片段（language="json" 时 Ctrl+Space / 触发字符生效）。 */
+    /** 实例级补全片段（Ctrl+Space / 触发字符生效）。 */
     snippets?: MonacoCompletionSnippet[];
     /** 按光标上下文动态生成候选；设置后与 snippets 合并。 */
-    completionRequest?: MonacoCompletionRequest;
+    completionRequest?: import('./monaco-editor-utils').MonacoCompletionRequest;
     /** 自动触发动态补全的字符。 */
     completionTriggerCharacters?: string[];
     /**
      * 自定义补全前缀（决定替换范围）。
      * 默认按标识符字符切词；Mongo Shell / SQL 等方言由业务 composable 注入，勿写进本组件。
      */
-    completionPrefixResolver?: MonacoCompletionPrefixResolver;
+    completionPrefixResolver?: import('./monaco-editor-utils').MonacoCompletionPrefixResolver;
     /**
      * 覆盖/合并 Monaco Editor 构造选项（如 automaticLayout、suggest）。
      * 浅合并顶层；`suggest` 会与默认 suggest 再浅合并一层。
+     * 请保持对象引用稳定，不要在模板里每次新建。
      */
     options?: Record<string, unknown>;
+    /** 空文档时的占位。不进 v-model。 */
+    placeholder?: string;
+    /** 传给 Monaco 文本框的可访问名称。缺省走 monaco.label。 */
+    ariaLabel?: string;
+    /** 根节点 id。不传时用 useId。 */
+    id?: string;
+    /**
+     * 原生右键菜单。默认开。
+     * 关掉后不再弹出 Monaco 菜单，contextmenu 仍给出行、列和指针坐标。
+     */
+    contextMenu?: boolean;
 };
 type __VLS_ModelProps = {
     modelValue?: string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, RsMonacoEditorExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur: () => any;
+    contextmenu: (event: RsMonacoEditorContextMenu) => any;
+    focus: () => any;
     "update:modelValue": (value: string) => any;
+    ready: () => any;
     glyphMarginClick: (line: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onBlur?: (() => any) | undefined;
+    onContextmenu?: ((event: RsMonacoEditorContextMenu) => any) | undefined;
+    onFocus?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onReady?: (() => any) | undefined;
     onGlyphMarginClick?: ((line: number) => any) | undefined;
 }>, {
     theme: "auto" | "vs-dark" | "light";
     height: number | string;
+    disabled: boolean;
     readonly: boolean;
+    contextMenu: boolean;
     embedded: boolean;
-    language: MonacoLanguage;
+    language: import("../../../monaco/languages").MonacoLanguage;
     minimap: boolean;
     glyphMargin: boolean;
     debugCurrentLine: number;