niuma-ui 2.0.4 → 2.1.0

package/dist/components/monaco-editor/src/monaco-editor-utils.js

@@ -0,0 +1,302 @@
+import { MONACO_CLICKHOUSE_LANGUAGE, MONACO_DAMENG_LANGUAGE, MONACO_KINGBASE_LANGUAGE, MONACO_MYSQL_LANGUAGE, MONACO_ORACLE_LANGUAGE, MONACO_POSTGRESQL_LANGUAGE, MONACO_SQLITE_LSP_LANGUAGE, MONACO_SQLSERVER_LANGUAGE } from "../../../monaco/languages/types.js";
+import { MONACO_MONGODB_SHELL_LANGUAGE } from "../../../monaco/languages/mongodb-shell.js";
+import { readCodeFontFamily, readCodeFontSizePx, readCssLengthPx, readCssVar } from "../../../theme/css-token.js";
+//#region src/components/monaco-editor/src/monaco-editor-utils.ts
+var RS_MONACO_THEME_LIGHT = "rs-light";
+var RS_MONACO_THEME_DARK = "rs-dark";
+var RS_MONACO_SCHEMA_PREFIX = "inmemory://rs-monaco/";
+var MANAGED_SQL = /* @__PURE__ */ new Set([
+	MONACO_MYSQL_LANGUAGE,
+	MONACO_DAMENG_LANGUAGE,
+	MONACO_KINGBASE_LANGUAGE,
+	MONACO_POSTGRESQL_LANGUAGE,
+	MONACO_CLICKHOUSE_LANGUAGE,
+	MONACO_SQLITE_LSP_LANGUAGE,
+	MONACO_SQLSERVER_LANGUAGE,
+	MONACO_ORACLE_LANGUAGE
+]);
+var SNIPPET_LANGUAGES = /* @__PURE__ */ new Set([
+	"javascript",
+	"typescript",
+	MONACO_MONGODB_SHELL_LANGUAGE,
+	"plaintext",
+	"sql",
+	"yaml",
+	"json"
+]);
+/** Bridge LSP 接管补全；勿再注册实例级 Provider。 */
+function isManagedSqlDialect(language) {
+	return language != null && MANAGED_SQL.has(language);
+}
+function completionLanguages(language) {
+	if (!language || isManagedSqlDialect(language) || !SNIPPET_LANGUAGES.has(language)) return [];
+	return [language];
+}
+function resolveMonacoHeight(height) {
+	if (typeof height === "number" && Number.isFinite(height)) return `${height}px`;
+	if (typeof height === "string" && height.trim()) return height;
+	return "100%";
+}
+/** 未写 data-rs-theme 时跟全库浅色，不把缺省当成深色。 */
+function readDocumentRsTheme() {
+	if (typeof document === "undefined") return "light";
+	return document.documentElement.dataset.rsTheme === "dark" ? "dark" : "light";
+}
+function resolveMonacoThemeName(theme, documentTheme) {
+	if (theme === "light") return RS_MONACO_THEME_LIGHT;
+	if (theme === "vs-dark") return RS_MONACO_THEME_DARK;
+	return documentTheme === "dark" ? RS_MONACO_THEME_DARK : RS_MONACO_THEME_LIGHT;
+}
+function monacoThemeBase(themeName) {
+	return themeName === "rs-light" ? "vs" : "vs-dark";
+}
+function resolveMonacoLineHeight(fontSize, lineHeightRaw) {
+	const ratio = Number.parseFloat(lineHeightRaw);
+	const safe = Number.isFinite(ratio) && ratio > 0 ? ratio : 1.625;
+	return Math.max(1, Math.round((Number.isFinite(fontSize) && fontSize > 0 ? fontSize : 14) * safe));
+}
+function resolveCompletionPrefix(line, resolver) {
+	if (resolver) return resolver(line);
+	let start = line.length;
+	while (start > 0 && /[\w$.-]/.test(line[start - 1] ?? "")) start -= 1;
+	return line.slice(start);
+}
+function completionReplaceRange(lineNumber, column, prefix) {
+	const safeColumn = Number.isFinite(column) ? Math.max(1, column) : 1;
+	const safeLine = Number.isFinite(lineNumber) ? Math.max(1, lineNumber) : 1;
+	return {
+		startLineNumber: safeLine,
+		endLineNumber: safeLine,
+		startColumn: Math.max(1, safeColumn - prefix.length),
+		endColumn: safeColumn
+	};
+}
+/** 合并业务侧 options；suggest 做一层浅合并，避免整对象覆盖默认。 */
+function mergeMonacoEditorOptions(overrides, language) {
+	if (!overrides) return {};
+	const out = { ...overrides };
+	if (overrides.suggest && typeof overrides.suggest === "object" && !Array.isArray(overrides.suggest)) out.suggest = {
+		snippetsPreventQuickSuggestions: false,
+		filterGraceful: !isManagedSqlDialect(language),
+		matchOnWordStartOnly: isManagedSqlDialect(language),
+		...overrides.suggest
+	};
+	return out;
+}
+function prefersReducedMotion() {
+	if (typeof matchMedia !== "function") return false;
+	return matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function monacoMotionOptions(reduced) {
+	if (reduced) return {
+		smoothScrolling: false,
+		cursorSmoothCaretAnimation: "off"
+	};
+	return {
+		smoothScrolling: true,
+		cursorSmoothCaretAnimation: "on"
+	};
+}
+function expandHex(value) {
+	const body = value.slice(1);
+	if (!/^[0-9a-f]+$/i.test(body)) return null;
+	if (body.length === 3 || body.length === 4) return `#${[...body].map((ch) => ch + ch).join("").toLowerCase()}`;
+	if (body.length === 6 || body.length === 8) return `#${body.toLowerCase()}`;
+	return null;
+}
+function channelByte(raw) {
+	const n = Number(raw);
+	if (!Number.isFinite(n)) return null;
+	return Math.max(0, Math.min(255, Math.round(n)));
+}
+function rgbToHex(value) {
+	const open = value.indexOf("(");
+	const close = value.lastIndexOf(")");
+	if (open < 0 || close <= open) return null;
+	const parts = value.slice(open + 1, close).trim().split(/[,\s/]+/).filter(Boolean);
+	if (parts.length < 3) return null;
+	const r = channelByte(parts[0]);
+	const g = channelByte(parts[1]);
+	const b = channelByte(parts[2]);
+	if (r == null || g == null || b == null) return null;
+	const hex2 = (n) => n.toString(16).padStart(2, "0");
+	const rawAlpha = parts[3];
+	if (!rawAlpha) return `#${hex2(r)}${hex2(g)}${hex2(b)}`;
+	const alpha = rawAlpha.endsWith("%") ? Number(rawAlpha.slice(0, -1)) / 100 : Number(rawAlpha);
+	if (!Number.isFinite(alpha)) return null;
+	const a = Math.max(0, Math.min(255, Math.round(Math.max(0, Math.min(1, alpha)) * 255)));
+	if (a === 255) return `#${hex2(r)}${hex2(g)}${hex2(b)}`;
+	return `#${hex2(r)}${hex2(g)}${hex2(b)}${hex2(a)}`;
+}
+/** Monaco 主题色只收 hex。rgb()/rgba() 在这里转成 #rrggbb / #rrggbbaa。 */
+function cssColorToHex(input) {
+	const value = input.trim();
+	if (value.startsWith("#")) return expandHex(value);
+	if (value.startsWith("rgb")) return rgbToHex(value);
+	return null;
+}
+var THEME_COLOR_IDS = {
+	background: "editor.background",
+	foreground: "editor.foreground",
+	gutter: "editorGutter.background",
+	gutterForeground: "editorLineNumber.foreground",
+	lineHighlight: "editor.lineHighlightBackground",
+	selection: "editor.selectionBackground",
+	widget: "editorWidget.background",
+	widgetBorder: "editorWidget.border"
+};
+function buildMonacoThemeColors(raw) {
+	const colors = {};
+	for (const key of Object.keys(THEME_COLOR_IDS)) {
+		const hex = cssColorToHex(raw[key] ?? "");
+		if (hex) colors[THEME_COLOR_IDS[key]] = hex;
+	}
+	return colors;
+}
+function readMonacoThemeColors(el) {
+	const pick = (token, fallback) => readCssVar(token, el) || readCssVar(fallback, el);
+	return buildMonacoThemeColors({
+		background: pick("--rs-monaco-bg", "--rs-surface-elevated"),
+		foreground: pick("--rs-monaco-fg", "--rs-text-primary"),
+		gutter: pick("--rs-monaco-gutter", "--rs-surface"),
+		gutterForeground: pick("--rs-monaco-gutter-fg", "--rs-text-tertiary"),
+		lineHighlight: pick("--rs-monaco-line-highlight", "--rs-surface-hover"),
+		selection: pick("--rs-monaco-selection", "--rs-primary-container"),
+		widget: pick("--rs-monaco-widget-bg", "--rs-surface-elevated"),
+		widgetBorder: pick("--rs-monaco-widget-border", "--rs-border")
+	});
+}
+function readMonacoMetrics(el) {
+	const fontSize = readCodeFontSizePx(el);
+	const ratio = readCssVar("--rs-code-line-height", el) || readCssVar("--rs-line-height-relaxed", el);
+	return {
+		fontFamily: readCodeFontFamily(el),
+		fontSize,
+		lineHeight: resolveMonacoLineHeight(fontSize, ratio),
+		padding: readCssLengthPx("--rs-monaco-padding", 8, el),
+		scrollbarSize: readCssLengthPx("--rs-monaco-scrollbar-size", 8, el),
+		glyphWidth: readCssLengthPx("--rs-monaco-glyph-width", 16, el),
+		decorationWidth: readCssLengthPx("--rs-monaco-decoration-width", 4, el)
+	};
+}
+var modelUriSeq = 0;
+function createMonacoModelUri() {
+	const cryptoApi = globalThis.crypto;
+	if (typeof cryptoApi?.randomUUID === "function") return `${RS_MONACO_SCHEMA_PREFIX}${cryptoApi.randomUUID()}.json`;
+	modelUriSeq += 1;
+	return `${RS_MONACO_SCHEMA_PREFIX}fallback-${Date.now().toString(36)}-${modelUriSeq.toString(36)}.json`;
+}
+var ownedSchemas = /* @__PURE__ */ new Map();
+function setOwnedMonacoJsonSchema(uri, schema) {
+	if (!uri) return;
+	if (schema) ownedSchemas.set(uri, schema);
+	else ownedSchemas.delete(uri);
+}
+/** 外部 schema 保留；本组件的 uri 只来自这份登记，避免两个编辑器交错写丢。 */
+function mergeMonacoJsonSchemas(existing) {
+	const external = (existing ?? []).filter((item) => !item.uri.startsWith(RS_MONACO_SCHEMA_PREFIX));
+	const owned = [...ownedSchemas.entries()].map(([uri, schema]) => ({
+		uri,
+		fileMatch: [uri],
+		schema
+	}));
+	return [...external, ...owned];
+}
+var themeListeners = /* @__PURE__ */ new Set();
+var themeObserver = null;
+/** 多个编辑器共用一个 MutationObserver，最后一个卸载才断开。 */
+function subscribeDocumentTheme(listener) {
+	themeListeners.add(listener);
+	if (themeListeners.size === 1 && themeObserver == null && typeof document !== "undefined" && typeof MutationObserver !== "undefined") {
+		themeObserver = new MutationObserver(() => {
+			for (const fn of themeListeners) fn();
+		});
+		themeObserver.observe(document.documentElement, {
+			attributes: true,
+			attributeFilter: ["data-rs-theme"]
+		});
+	}
+	let active = true;
+	return () => {
+		if (!active) return;
+		active = false;
+		themeListeners.delete(listener);
+		if (themeListeners.size === 0) {
+			themeObserver?.disconnect();
+			themeObserver = null;
+		}
+	};
+}
+function subscribeReducedMotion(listener) {
+	if (typeof matchMedia !== "function") return () => {};
+	const query = matchMedia("(prefers-reduced-motion: reduce)");
+	const onChange = () => listener(query.matches);
+	query.addEventListener?.("change", onChange);
+	return () => query.removeEventListener?.("change", onChange);
+}
+var appliedThemeSignature = "";
+/** defineTheme 可重复；setTheme 是进程级的，签名没变就不再刷。 */
+function applySharedMonacoTheme(monaco, themeName, colors) {
+	monaco.editor.defineTheme(themeName, {
+		base: monacoThemeBase(themeName),
+		inherit: true,
+		rules: [],
+		colors
+	});
+	const signature = `${themeName}:${JSON.stringify(colors)}`;
+	if (signature === appliedThemeSignature) return;
+	appliedThemeSignature = signature;
+	monaco.editor.setTheme(themeName);
+}
+var completionBridges = /* @__PURE__ */ new Map();
+var completionRegistrations = /* @__PURE__ */ new Map();
+function completionTriggersByLanguage() {
+	const triggersByLanguage = /* @__PURE__ */ new Map();
+	for (const item of completionBridges.values()) {
+		let set = triggersByLanguage.get(item.language);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			triggersByLanguage.set(item.language, set);
+		}
+		for (const ch of item.triggers) if (ch) set.add(ch);
+	}
+	return triggersByLanguage;
+}
+function dropUnusedCompletionLanguages(triggersByLanguage) {
+	for (const [language, registration] of completionRegistrations) if (!triggersByLanguage.has(language)) {
+		registration.dispose();
+		completionRegistrations.delete(language);
+	}
+}
+function ensureCompletionLanguage(monaco, language, triggers) {
+	const signature = [...triggers].sort((left, right) => left.localeCompare(right)).join("\n");
+	const current = completionRegistrations.get(language);
+	if (current?.signature === signature) return;
+	current?.dispose();
+	const disposable = monaco.languages.registerCompletionItemProvider(language, {
+		triggerCharacters: [...triggers],
+		provideCompletionItems: (model, position, context, token) => {
+			const found = completionBridges.get(model.uri.toString());
+			if (found?.language !== language) return { suggestions: [] };
+			return found.provide(model, position, context, token);
+		}
+	});
+	completionRegistrations.set(language, {
+		dispose: () => disposable.dispose(),
+		signature
+	});
+}
+/**
+* 每种语言只注册一个 Provider，按 model uri 分发。
+* 避免 N 个编辑器各挂一个、卸载时只丢掉最后一个。
+*/
+function syncMonacoCompletionProvider(monaco, modelUri, binding) {
+	if (!modelUri) return;
+	if (binding) completionBridges.set(modelUri, binding);
+	else completionBridges.delete(modelUri);
+	const triggersByLanguage = completionTriggersByLanguage();
+	dropUnusedCompletionLanguages(triggersByLanguage);
+	for (const [language, triggers] of triggersByLanguage) ensureCompletionLanguage(monaco, language, triggers);
+}
+//#endregion
+export { RS_MONACO_SCHEMA_PREFIX, RS_MONACO_THEME_DARK, RS_MONACO_THEME_LIGHT, applySharedMonacoTheme, buildMonacoThemeColors, completionLanguages, completionReplaceRange, createMonacoModelUri, cssColorToHex, isManagedSqlDialect, mergeMonacoEditorOptions, mergeMonacoJsonSchemas, monacoMotionOptions, monacoThemeBase, prefersReducedMotion, readDocumentRsTheme, readMonacoMetrics, readMonacoThemeColors, resolveCompletionPrefix, resolveMonacoHeight, resolveMonacoLineHeight, resolveMonacoThemeName, setOwnedMonacoJsonSchema, subscribeDocumentTheme, subscribeReducedMotion, syncMonacoCompletionProvider };

package/dist/components/pagination/index.d.ts

@@ -1,3 +1,3 @@
 export { default as RsPagination } from './src/RsPagination.js';
-export type { RsPaginationSize } from './src/RsPagination.js';
-export { clampPage, createPageSizeSelectOptions, DEFAULT_PAGE_SIZE_OPTIONS, getPageCount, getPaginationRange, slicePageData, } from './src/pagination-utils';
+export type { RsPaginationAlign, RsPaginationExpose, RsPaginationInstance, RsPaginationItemSlot, RsPaginationItemType, RsPaginationSize, RsPaginationSummarySlot, } from './src/pagination-utils';
+export { buildPaginationPagerItems, clampPage, createPageSizeSelectOptions, DEFAULT_PAGE_SIZE_OPTIONS, getPageCount, getPaginationRange, paginationItemKey, resolveAdjacentPagerKey, resolveFocusablePagerKeys, resolvePaginationKeyboardMove, resolvePaginationSize, shouldHidePagination, slicePageData, } from './src/pagination-utils';

package/dist/components/pagination/src/RsPagination.css

@@ -1,83 +1,130 @@
 
-.rs-pagination[data-v-6db615ba] {
+.rs-pagination[data-v-84ae3155] {
   display: flex;
   flex-wrap: wrap;
   align-items: center;
-  gap: var(--rs-space-sm);
-  color: var(--rs-muted);
+  justify-content: start;
+  gap: var(--rs-pagination-gap);
+  color: var(--rs-pagination-text);
   font-size: var(--rs-font-size-sm);
-  /*
-   * 跳转输入 / 每页条数与页码按钮同档高度（随 size）。
-   * 高度走 token；仅用属性选择器对齐外壳，避免业务 :deep 改控件内部。
-   */
   --rs-pagination-control-height: var(--rs-control-height-md);
 }
-.rs-pagination--sm[data-v-6db615ba] {
+.rs-pagination--align-center[data-v-84ae3155] {
+  justify-content: center;
+}
+.rs-pagination--align-end[data-v-84ae3155] {
+  justify-content: end;
+}
+.rs-pagination--sm[data-v-84ae3155] {
   --rs-pagination-control-height: var(--rs-control-height-sm);
   font-size: var(--rs-font-size-xs);
 }
-.rs-pagination--md[data-v-6db615ba] {
+.rs-pagination--md[data-v-84ae3155] {
   --rs-pagination-control-height: var(--rs-control-height-md);
 }
-.rs-pagination--lg[data-v-6db615ba] {
+.rs-pagination--lg[data-v-84ae3155] {
   --rs-pagination-control-height: var(--rs-control-height-lg);
   font-size: var(--rs-font-size-base);
 }
-.rs-pagination__summary[data-v-6db615ba] {
+.rs-pagination--disabled[data-v-84ae3155] {
+  opacity: var(--rs-pagination-disabled-opacity);
+}
+.rs-pagination__summary[data-v-84ae3155],
+.rs-pagination__simple[data-v-84ae3155] {
   flex-shrink: 0;
   line-height: var(--rs-pagination-control-height);
 }
-.rs-pagination__buttons[data-v-6db615ba] {
+.rs-pagination__buttons[data-v-84ae3155] {
   display: inline-flex;
   align-items: center;
-  gap: var(--rs-space-xs);
-}
-/* 当前页：仅主色文字高亮，无填充底（对齐部分 Ant / Element 轻量分页） */
-.rs-pagination__buttons[data-v-6db615ba] .rs-pagination__page--active {
-  font-weight: var(--rs-font-weight-semibold);
-  background: transparent !important;
-  box-shadow: none;
+  gap: var(--rs-pagination-item-gap);
 }
-.rs-pagination__buttons[data-v-6db615ba] .rs-pagination__page--active:hover:not(:disabled),
-.rs-pagination__buttons[data-v-6db615ba] .rs-pagination__page--active:active:not(:disabled) {
-  background: transparent !important;
-}
-.rs-pagination__ellipsis[data-v-6db615ba] {
-  padding: 0 var(--rs-space-xs);
+.rs-pagination__item[data-v-84ae3155] {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  min-width: var(--rs-pagination-control-height);
+  height: var(--rs-pagination-control-height);
+  margin: 0;
+  padding-block: 0;
+  padding-inline: var(--rs-pagination-item-pad-inline);
+  border: 0;
+  border-radius: var(--rs-pagination-radius);
+  background: transparent;
+  color: var(--rs-pagination-item);
+  font: inherit;
+  transition:
+    background var(--rs-transition-fast),
+    color var(--rs-transition-fast);
+  line-height: 1;
+  cursor: pointer;
+}
+.rs-pagination__item[data-v-84ae3155]:hover:not(:disabled) {
+  background: var(--rs-pagination-item-hover);
+}
+.rs-pagination__item[data-v-84ae3155]:focus-visible {
+  outline: var(--rs-focus-ring-width) solid var(--rs-focus-ring);
+  outline-offset: 2px;
+}
+.rs-pagination__page--active[data-v-84ae3155],
+.rs-pagination__item--active[data-v-84ae3155] {
+  color: var(--rs-pagination-item-active);
+  font-weight: var(--rs-pagination-active-weight);
+  background: transparent;
+}
+.rs-pagination__page--active[data-v-84ae3155]:hover:not(:disabled),
+.rs-pagination__item--active[data-v-84ae3155]:hover:not(:disabled) {
+  background: transparent;
+}
+.rs-pagination__item[data-v-84ae3155]:disabled {
+  cursor: not-allowed;
+}
+.rs-pagination__ellipsis[data-v-84ae3155] {
+  padding-inline: var(--rs-space-xs);
+  color: var(--rs-pagination-ellipsis);
   font-size: var(--rs-font-size-xs);
   line-height: var(--rs-pagination-control-height);
 }
-.rs-pagination__jumper[data-v-6db615ba] {
+.rs-pagination__jumper[data-v-84ae3155] {
   display: inline-flex;
   align-items: center;
-  gap: var(--rs-space-xs);
+  gap: var(--rs-pagination-item-gap);
 }
-.rs-pagination__jumper-label[data-v-6db615ba],
-.rs-pagination__jumper-suffix[data-v-6db615ba] {
+.rs-pagination__jumper-label[data-v-84ae3155],
+.rs-pagination__jumper-suffix[data-v-84ae3155] {
   flex-shrink: 0;
-  color: var(--rs-muted);
+  color: var(--rs-pagination-text);
   font-size: inherit;
   line-height: var(--rs-line-height-tight);
 }
-.rs-pagination__jumper-input[data-v-6db615ba] {
-  width: 3rem;
-}
-.rs-pagination__jumper-input[data-v-6db615ba] .rs-input-group {
-  width: 100%;
-  height: var(--rs-pagination-control-height);
-  min-height: var(--rs-pagination-control-height);
+.rs-pagination__jumper-input[data-v-84ae3155],
+.rs-pagination__size[data-v-84ae3155] {
+  display: flex;
+  align-items: stretch;
   box-sizing: border-box;
+  height: var(--rs-pagination-control-height);
+  /*
+   * Input / Select 按 size 读 --rs-control-height-*。
+   * 四档都改写成分页控件高，跳转、每页条数与页码按钮同一条基线。
+   */
+  --rs-control-height-ssm: var(--rs-pagination-control-height);
+  --rs-control-height-sm: var(--rs-pagination-control-height);
+  --rs-control-height-md: var(--rs-pagination-control-height);
+  --rs-control-height-lg: var(--rs-pagination-control-height);
+}
+.rs-pagination__jumper-input[data-v-84ae3155] {
+  width: var(--rs-pagination-jumper-width);
 }
-.rs-pagination__jumper-btn[data-v-6db615ba] {
+.rs-pagination__jumper-btn[data-v-84ae3155] {
   flex-shrink: 0;
 }
-.rs-pagination__size[data-v-6db615ba] {
-  width: 7.25rem;
-  min-width: 7.25rem;
+.rs-pagination__size[data-v-84ae3155] {
+  width: var(--rs-pagination-size-width);
+  min-width: var(--rs-pagination-size-width);
+}
+@media (prefers-reduced-motion: reduce) {
+.rs-pagination__item[data-v-84ae3155] {
+    transition: none;
 }
-.rs-pagination__size[data-v-6db615ba] .rs-select__trigger {
-  width: 100%;
-  height: var(--rs-pagination-control-height);
-  min-height: var(--rs-pagination-control-height);
-  box-sizing: border-box;
 }

package/dist/components/pagination/src/RsPagination.d.ts

@@ -1,9 +1,4 @@
-import type { RsComponentSize } from '../../../theme/types';
-/**
- * 分页尺寸（对齐 Ant Design Pagination：small / medium / large）。
- * 不提供 ssm：页码按钮过小不利于点击。
- */
-export type RsPaginationSize = Extract<RsComponentSize, 'sm' | 'md' | 'lg'>;
+import { type RsPaginationAlign, type RsPaginationItemType, type RsPaginationSize } from './pagination-utils';
 type __VLS_Props = {
     total: number;
     siblingCount?: number;
@@ -15,30 +10,95 @@ type __VLS_Props = {
      * 默认 false：回车 / 失焦跳转（对齐 Ant Design showQuickJumper 默认无 goButton）。
      */
     showJumpConfirm?: boolean;
+    /** 首页 / 末页按钮。默认关，避免改现有底栏密度。 */
+    showFirstLast?: boolean;
+    /** 只显示上一页 / 当前页 / 下一页。 */
+    simple?: boolean;
+    /** 只有一页时不渲染。 */
+    hideOnSinglePage?: boolean;
     pageSizeOptions?: readonly number[];
     disabled?: boolean;
     size?: RsPaginationSize;
+    align?: RsPaginationAlign;
+    ariaLabel?: string;
+    id?: string;
 };
+declare function goTo(next: number): boolean;
+declare function prev(): number | undefined;
+declare function next(): number | undefined;
+declare function first(): number | undefined;
+declare function last(): number | undefined;
+declare function focus(targetPage?: number): void;
 type __VLS_ModelProps = {
     'page'?: number;
     'pageSize'?: number;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare var __VLS_1: {
+    total: number;
+    page: number;
+    pageSize: number;
+    pageCount: number;
+}, __VLS_3: {
+    type: RsPaginationItemType;
+    page: number;
+    active: boolean;
+    disabled: boolean;
+}, __VLS_5: {
+    type: RsPaginationItemType;
+    page: number;
+    active: boolean;
+    disabled: boolean;
+}, __VLS_7: {
+    type: RsPaginationItemType;
+    page: number;
+    active: boolean;
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    summary?: (props: typeof __VLS_1) => any;
+} & {
+    item?: (props: typeof __VLS_3) => any;
+} & {
+    item?: (props: typeof __VLS_5) => any;
+} & {
+    item?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    goTo: typeof goTo;
+    prev: typeof prev;
+    next: typeof next;
+    first: typeof first;
+    last: typeof last;
+    focus: typeof focus;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (page: number, pageSize: number) => any;
+    pageSizeChange: (pageSize: number, page: number) => any;
     "update:page": (value: number) => any;
     "update:pageSize": (value: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((page: number, pageSize: number) => any) | undefined;
+    onPageSizeChange?: ((pageSize: number, page: number) => any) | undefined;
     "onUpdate:page"?: ((value: number) => any) | undefined;
     "onUpdate:pageSize"?: ((value: number) => any) | undefined;
 }>, {
-    size: RsPaginationSize;
     disabled: boolean;
+    simple: boolean;
+    align: RsPaginationAlign;
     showSummary: boolean;
+    showFirstLast: boolean;
     siblingCount: number;
     showPageSize: boolean;
     showQuickJumper: boolean;
     showJumpConfirm: boolean;
+    hideOnSinglePage: boolean;
     pageSizeOptions: readonly number[];
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};