@tita-agent/dsh-data-table 0.0.0-stage → 0.2.0

package/src/univer/fonts.ts

@@ -0,0 +1,148 @@
+import { DEFAULT_SHEET_FONT_FAMILY } from '../contract/snapshots.ts'
+
+export interface DataSheetFontConfig {
+  value: string
+  label: string
+  category: 'sans-serif' | 'serif'
+}
+
+/**
+ * Additional font families exposed by the Datasheet Univer residency.
+ *
+ * This is intentionally a candidate list, not a bundled-font list. The
+ * browser-side probe below removes entries that are not installed on the
+ * current machine, while keeping the dropdown useful across macOS, Windows,
+ * Linux and common Chinese-font setups.
+ */
+export const DATA_SHEET_CUSTOM_FONT_CONFIGS = [
+  {
+    // macOS family name for Simplified Chinese PingFang.
+    value: 'PingFang SC',
+    label: '苹方（简体中文）',
+    category: 'sans-serif' as const,
+  },
+  {
+    // Keep the Traditional Chinese family available on macOS as well.
+    value: 'PingFang TC',
+    label: '苹方（繁体中文）',
+    category: 'sans-serif' as const,
+  },
+  {
+    // The CSS family name used by the JD Lang Zhengti font files.
+    value: 'JingDongLangZhengTi',
+    label: '京东朗正体',
+    category: 'sans-serif' as const,
+  },
+  { value: 'Helvetica', label: 'Helvetica', category: 'sans-serif' as const },
+  { value: 'Helvetica Neue', label: 'Helvetica Neue', category: 'sans-serif' as const },
+  { value: 'Segoe UI', label: 'Segoe UI', category: 'sans-serif' as const },
+  { value: 'Calibri', label: 'Calibri', category: 'sans-serif' as const },
+  { value: 'Cambria', label: 'Cambria', category: 'serif' as const },
+  { value: 'Georgia', label: 'Georgia', category: 'serif' as const },
+  { value: 'Consolas', label: 'Consolas', category: 'sans-serif' as const },
+  { value: 'Courier New', label: 'Courier New', category: 'serif' as const },
+  { value: 'Trebuchet MS', label: 'Trebuchet MS', category: 'sans-serif' as const },
+  { value: 'Gill Sans', label: 'Gill Sans', category: 'sans-serif' as const },
+  { value: 'Avenir Next', label: 'Avenir Next', category: 'sans-serif' as const },
+  { value: 'Menlo', label: 'Menlo', category: 'sans-serif' as const },
+  { value: 'Roboto', label: 'Roboto', category: 'sans-serif' as const },
+  { value: 'Noto Sans', label: 'Noto Sans', category: 'sans-serif' as const },
+  { value: 'Noto Sans CJK SC', label: 'Noto Sans CJK SC', category: 'sans-serif' as const },
+  { value: 'Noto Sans CJK TC', label: 'Noto Sans CJK TC', category: 'sans-serif' as const },
+  { value: 'Noto Serif CJK SC', label: 'Noto Serif CJK SC', category: 'serif' as const },
+  { value: 'Noto Serif CJK TC', label: 'Noto Serif CJK TC', category: 'serif' as const },
+  { value: 'Source Han Sans SC', label: '思源黑体（简体中文）', category: 'sans-serif' as const },
+  { value: 'Source Han Sans TC', label: '思源黑体（繁体中文）', category: 'sans-serif' as const },
+  { value: 'Source Han Serif SC', label: '思源宋体（简体中文）', category: 'serif' as const },
+  { value: 'Source Han Serif TC', label: '思源宋体（繁体中文）', category: 'serif' as const },
+  { value: 'WenQuanYi Zen Hei', label: '文泉驿正黑', category: 'sans-serif' as const },
+  { value: 'Microsoft JhengHei', label: '微软正黑', category: 'sans-serif' as const },
+  { value: 'Microsoft JhengHei UI', label: '微软正黑 UI', category: 'sans-serif' as const },
+  { value: 'DengXian', label: '等线', category: 'sans-serif' as const },
+  { value: 'STHeiti', label: '华文黑体', category: 'sans-serif' as const },
+  { value: 'STSong', label: '华文宋体', category: 'serif' as const },
+  { value: 'STKaiti', label: '华文楷体', category: 'serif' as const },
+  { value: 'STFangsong', label: '华文仿宋', category: 'serif' as const },
+  { value: 'Songti SC', label: '宋体 SC', category: 'serif' as const },
+  { value: 'Songti TC', label: '宋体 TC', category: 'serif' as const },
+  { value: 'Heiti SC', label: '黑体 SC', category: 'sans-serif' as const },
+  { value: 'Hiragino Sans GB', label: '冬青黑体简', category: 'sans-serif' as const },
+  { value: 'Hiragino Mincho ProN', label: '冬青明朝体', category: 'serif' as const },
+  { value: 'MingLiU', label: '细明体', category: 'serif' as const },
+  { value: 'PMingLiU', label: '新细明体', category: 'serif' as const },
+  { value: 'Alibaba PuHuiTi 3.0', label: '阿里巴巴普惠体 3.0', category: 'sans-serif' as const },
+  { value: 'Alibaba PuHuiTi 2.0', label: '阿里巴巴普惠体 2.0', category: 'sans-serif' as const },
+] as const
+
+/**
+ * Univer's built-in list is repeated here so it can be filtered before
+ * Univer creates its FontService. Browsers cannot enumerate every system
+ * font, so this is a candidate list rather than a system-font API.
+ */
+export const DATA_SHEET_FONT_CANDIDATE_CONFIGS: readonly DataSheetFontConfig[] = [
+  { value: 'Arial', label: 'ui.fontFamily.arial', category: 'sans-serif' },
+  { value: 'Times New Roman', label: 'ui.fontFamily.times-new-roman', category: 'serif' },
+  { value: 'Tahoma', label: 'ui.fontFamily.tahoma', category: 'sans-serif' },
+  { value: 'Verdana', label: 'ui.fontFamily.verdana', category: 'sans-serif' },
+  { value: 'Microsoft YaHei', label: 'ui.fontFamily.microsoft-yahei', category: 'sans-serif' },
+  { value: 'SimSun', label: 'ui.fontFamily.simsun', category: 'serif' },
+  { value: 'SimHei', label: 'ui.fontFamily.simhei', category: 'sans-serif' },
+  { value: 'Kaiti', label: 'ui.fontFamily.kaiti', category: 'serif' },
+  { value: 'FangSong', label: 'ui.fontFamily.fangsong', category: 'serif' },
+  { value: 'NSimSun', label: 'ui.fontFamily.nsimsun', category: 'serif' },
+  { value: 'STXinwei', label: 'ui.fontFamily.stxinwei', category: 'serif' },
+  { value: 'STXingkai', label: 'ui.fontFamily.stxingkai', category: 'serif' },
+  { value: 'STLiti', label: 'ui.fontFamily.stliti', category: 'serif' },
+  ...DATA_SHEET_CUSTOM_FONT_CONFIGS,
+]
+
+/**
+ * Filter candidates using the same canvas-metrics check Univer uses for its
+ * unsupported-font indicator. This runs before createUniver(), because
+ * Univer snapshots the configured list while constructing FontService.
+ */
+export function getInstalledFontConfigs(): DataSheetFontConfig[] {
+  if (typeof document === 'undefined') return [...DATA_SHEET_FONT_CANDIDATE_CONFIGS]
+  const context = document.createElement('canvas').getContext('2d')
+  if (context === null) return []
+
+  // Include CJK glyphs as well as Latin glyphs. Many Chinese fonts share
+  // nearly identical Latin metrics, so a Latin-only probe incorrectly hides
+  // installed CJK families from the dropdown.
+  const sample = 'AaBbMmWw0123456789中文汉字测试東京한글'
+  const size = '72px'
+  const baseFonts = ['monospace', 'serif', 'sans-serif'] as const
+  const defaultWidths = new Map<string, number>()
+  for (const base of baseFonts) {
+    context.font = `${size} ${base}`
+    defaultWidths.set(base, context.measureText(sample).width)
+  }
+
+  return DATA_SHEET_FONT_CANDIDATE_CONFIGS.filter(font => baseFonts.some(base => {
+    context.font = `${size} "${font.value}", ${base}`
+    return context.measureText(sample).width !== defaultWidths.get(base)
+  }))
+}
+
+/**
+ * Give every sheet the shared default font family.
+ *
+ * The sheet default is a migration target: this fixes workbooks created before
+ * Datasheet switched from Arial to PingFang SC. Cell-level styles stay untouched,
+ * so an explicit font choice is still respected.
+ */
+export function withDefaultSheetFont(workbookData: object): object {
+  const root = workbookData as { sheets?: Record<string, Record<string, unknown>> }
+  if (root.sheets === undefined || typeof root.sheets !== 'object') return workbookData
+  let changed = false
+  const sheets = Object.fromEntries(Object.entries(root.sheets).map(([id, sheet]) => {
+    const currentStyle = sheet.defaultStyle
+    const defaultStyle = currentStyle !== null && typeof currentStyle === 'object' && !Array.isArray(currentStyle)
+      ? currentStyle as Record<string, unknown>
+      : {}
+    if (defaultStyle.ff === DEFAULT_SHEET_FONT_FAMILY) return [id, sheet]
+    changed = true
+    return [id, { ...sheet, defaultStyle: { ...defaultStyle, ff: DEFAULT_SHEET_FONT_FAMILY } }]
+  }))
+  return changed ? { ...root, sheets } : workbookData
+}

package/src/univer/overrides.css

@@ -0,0 +1,33 @@
+/* Keep every horizontal Univer menu bar anchored to the left. */
+
+[data-u-comp="ribbon-header-menu"] [role="tablist"],
+[data-u-comp="ribbon-toolbar"],
+[data-u-comp="mobile-ribbon-toolbar"],
+[data-u-comp="slide-tab-bar"] {
+  justify-content: flex-start !important;
+}
+
+/* Make Univer read as the canvas inside the shell, not as a second app bar. */
+[data-u-comp="ribbon-header-menu"],
+[data-u-comp="ribbon-toolbar"],
+[data-u-comp="mobile-ribbon-toolbar"],
+[data-u-comp="slide-tab-bar"] {
+  border-color: var(--tita-line) !important;
+  background: var(--tita-surface) !important;
+}
+
+[data-u-comp="ribbon-toolbar"] {
+  min-height: 36px !important;
+}
+
+[data-u-comp="ribbon-header-menu"] {
+  min-height: 34px !important;
+}
+
+[data-u-comp="ribbon-header-menu"] [role="tablist"] {
+  min-height: 34px !important;
+}
+
+[data-u-comp="slide-tab-bar"] {
+  min-height: 28px !important;
+}

package/src/univer/plugins/collaboration.ts

@@ -0,0 +1,47 @@
+/**
+ * Univer-side collaboration seam used by Datasheet.
+ *
+ * Univer exposes `onMutationExecutedForCollab` specifically for collaboration
+ * implementations.  We use that native seam, but keep the transport and
+ * persistence outside Univer so the plugin does not depend on Univer Pro.
+ */
+
+import {
+  IUniverInstanceService,
+  Inject,
+  ICommandService,
+  Injector,
+  Plugin,
+  UniverInstanceType,
+  type ICommandInfo,
+  type IExecutionOptions,
+} from '@univerjs/presets'
+import { UNIVER_PLUGIN_VERSION } from './version.ts'
+
+export interface DataSheetCollaborationConfig {
+  onMutation?: (commandInfo: Readonly<ICommandInfo>, options?: IExecutionOptions) => void
+}
+
+/** Connects Univer's native mutation stream to the Datasheet session. */
+export class DataSheetCollaborationPlugin extends Plugin {
+  static override pluginName = 'dsh.data-sheet.collaboration'
+  static override packageName = 'dsh-data-table'
+  static override version = UNIVER_PLUGIN_VERSION
+  static override type = UniverInstanceType.UNIVER_SHEET
+
+  constructor(
+    private readonly _config: DataSheetCollaborationConfig | undefined,
+    @Inject(Injector) protected readonly _injector: Injector,
+    @ICommandService private readonly _commandService: ICommandService,
+    @IUniverInstanceService _univerInstanceService: IUniverInstanceService,
+  ) {
+    super()
+  }
+
+  override onStarting(): void {
+    this.disposeWithMe(this._commandService.onMutationExecutedForCollab((commandInfo, options) => {
+      if (options?.onlyLocal || options?.fromChangeset || options?.fromCollab) return
+      this._config?.onMutation?.(commandInfo, options)
+    }))
+  }
+}

package/src/univer/plugins/export.ts

@@ -0,0 +1,236 @@
+/**
+ * Univer-side export plugin for dsh-data-table.
+ *
+ * This follows Univer's normal plugin shape: commands are registered with
+ * ICommandService. The browser-facing exporter stays a small adapter over
+ * the live Workbook model, so menu actions always export the current
+ * in-memory edits.
+ * @module dsh-data-table/univer-export-plugin
+ */
+
+import {
+  CommandType,
+  Inject,
+  ICommandService,
+  IUniverInstanceService,
+  Injector,
+  Plugin,
+  UniverInstanceType,
+  type Workbook,
+} from '@univerjs/presets'
+import { downloadBlob, downloadWorkbookCsv, downloadWorkbookXlsx, readWorkbookXlsx } from '../../xlsx-export.ts'
+import { UNIVER_PLUGIN_VERSION } from './version.ts'
+
+function dataSheetAssetPath(path: string): string {
+  const transport = (globalThis as { __DSH_TRANSPORT__?: { ownsHost?: boolean } }).__DSH_TRANSPORT__
+  return transport?.ownsHost === true
+    ? `/api/data-sheet?path=${encodeURIComponent(path)}`
+    : path
+}
+
+export const EXPORT_CSV_COMMAND_ID = 'dsh.data-sheet.export-csv'
+export const EXPORT_XLSX_COMMAND_ID = 'dsh.data-sheet.export-xlsx'
+export const IMPORT_XLSX_COMMAND_ID = 'dsh.data-sheet.import-xlsx'
+
+/** Univer plugin that owns the datasheet export commands and DSH menu bridge. */
+export class DataSheetExportPlugin extends Plugin {
+  static override pluginName = 'dsh.data-sheet.export'
+  static override packageName = 'dsh-data-table'
+  static override version = UNIVER_PLUGIN_VERSION
+  static override type = UniverInstanceType.UNIVER_SHEET
+
+  constructor(
+    _config: undefined,
+    @Inject(Injector) protected readonly _injector: Injector,
+    @ICommandService private readonly _commandService: ICommandService,
+    @IUniverInstanceService private readonly _univerInstanceService: IUniverInstanceService,
+  ) {
+    super()
+  }
+
+  override onStarting(): void {
+    this.disposeWithMe(this._commandService.registerCommand({
+      id: EXPORT_CSV_COMMAND_ID,
+      type: CommandType.COMMAND,
+      handler: () => this.export('csv'),
+    }))
+    this.disposeWithMe(this._commandService.registerCommand({
+      id: EXPORT_XLSX_COMMAND_ID,
+      type: CommandType.COMMAND,
+      handler: () => this.export('xlsx'),
+    }))
+    this.disposeWithMe(this._commandService.registerCommand({
+      id: IMPORT_XLSX_COMMAND_ID,
+      type: CommandType.COMMAND,
+      handler: () => {
+        this.importFile('xlsx')
+        return true
+      },
+    }))
+    // The compact DSH header owns import/export. Keep the bridge event-based
+    // so the React shell does not depend on Univer's private Injector or
+    // command service implementation.
+    const onExportCsv = (): void => { void this.export('csv') }
+    const onExportXlsx = (): void => { void this.export('xlsx') }
+    const onExportJson = (): void => { void this.export('json') }
+    const onImportXlsx = (): void => { this.importFile('xlsx') }
+    // The project chooser read the file's bytes on the Host side; parsing is the
+    // same pipeline, so it enters here rather than in a second implementation.
+    const onImportBytes = (event: Event): void => {
+      const detail = (event as CustomEvent<{ data?: ArrayBuffer; name?: string }>).detail
+      if (detail?.data === undefined) return
+      void this.importBuffer(detail.data, detail.name ?? '导入文件')
+    }
+    document.addEventListener('data-sheet:import-bytes', onImportBytes)
+    const onImportCsv = (): void => { this.importFile('csv') }
+    window.addEventListener('data-sheet:request-export-csv', onExportCsv)
+    window.addEventListener('data-sheet:request-export-xlsx', onExportXlsx)
+    window.addEventListener('data-sheet:request-export-json', onExportJson)
+    window.addEventListener('data-sheet:request-import-xlsx', onImportXlsx)
+    window.addEventListener('data-sheet:request-import-csv', onImportCsv)
+    window.addEventListener('data-sheet:import-bytes', onImportBytes)
+    this.disposeWithMe({
+      dispose: () => {
+        window.removeEventListener('data-sheet:request-export-csv', onExportCsv)
+        window.removeEventListener('data-sheet:request-export-xlsx', onExportXlsx)
+        window.removeEventListener('data-sheet:request-export-json', onExportJson)
+        window.removeEventListener('data-sheet:request-import-xlsx', onImportXlsx)
+        window.removeEventListener('data-sheet:request-import-csv', onImportCsv)
+        window.removeEventListener('data-sheet:import-bytes', onImportBytes)
+      },
+    })
+  }
+
+  private async export(format: 'csv' | 'xlsx' | 'json'): Promise<boolean> {
+    const workbook = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET)
+    if (workbook == null) return false
+    const snapshot = workbook.getSnapshot()
+    const filename = snapshotWorkbookName(snapshot) || workbook.name || 'workbook'
+    if (format === 'json') {
+      // The workbook snapshot is already the plugin's own persistence format,
+      // so a JSON export is a lossless, round-trippable dump.
+      downloadBlob(new Blob([JSON.stringify(snapshot, null, 2)], { type: 'application/json;charset=utf-8' }), `${safeFilename(filename)}.json`)
+      return true
+    }
+    try {
+      const result = await exportInWorker(format, snapshot)
+      if (result === null) return false
+      if (format === 'csv') {
+        downloadBlob(new Blob([result as string], { type: 'text/csv;charset=utf-8' }), `${safeFilename(filename)}.csv`)
+      } else {
+        downloadBlob(new Blob([result as ArrayBuffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }), `${safeFilename(filename)}.xlsx`)
+      }
+    } catch {
+      // A server started before the worker route existed, or a restricted
+      // browser, still gets a functional export through the synchronous path.
+      if (format === 'csv') downloadWorkbookCsv(snapshot, filename)
+      else downloadWorkbookXlsx(snapshot, filename)
+    }
+    return true
+  }
+
+  private importFile(format: 'xlsx' | 'csv'): void {
+    const input = document.createElement('input')
+    input.type = 'file'
+    input.accept = format === 'csv'
+      ? '.csv,text/csv'
+      : '.xlsx,.xls,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,application/vnd.ms-excel'
+    input.addEventListener('change', () => {
+      const file = input.files?.[0]
+      if (file === undefined) return
+      if (file.size > 25 * 1024 * 1024) {
+        window.dispatchEvent(new CustomEvent('data-sheet:import-error', { detail: { message: `${format === 'csv' ? 'CSV' : 'Excel'} 文件过大（最大 25 MB）` } }))
+        return
+      }
+      void file.arrayBuffer().then(data => this.importBuffer(data, file.name))
+    })
+    input.click()
+  }
+
+  /**
+   * Parse one buffer and hand the workbook to the panel.
+   *
+   * Shared by both ways in — the OS file dialog and the project chooser, which
+   * reads the bytes over HTTP because a browser cannot open a path. Everything
+   * after the bytes arrive is one pipeline, so the two entry points cannot drift
+   * into two imports.
+   *
+   * @param data - The file's bytes.
+   * @param name - The name the panel reports and the worker partly decides from.
+   */
+  private async importBuffer(data: ArrayBuffer, name: string): Promise<void> {
+    try {
+      const compatibilityCopy = data.slice(0)
+      const snapshot = await importInWorker(data, name).catch(error => {
+        // Older servers may not expose the worker route. Keep import
+        // functional with a synchronous compatibility fallback in that case.
+        if (error instanceof Error && /Worker/.test(error.message)) return readWorkbookXlsx(compatibilityCopy, name)
+        throw error
+      })
+      window.dispatchEvent(new CustomEvent('data-sheet:import', { detail: { snapshot, filename: name } }))
+    } catch (error) {
+      window.dispatchEvent(new CustomEvent('data-sheet:import-error', { detail: { message: error instanceof Error ? error.message : String(error) } }))
+    }
+  }
+}
+
+function importInWorker(data: ArrayBuffer, filename: string): Promise<object> {
+  if (typeof Worker === 'undefined') return Promise.reject(new Error('当前浏览器不支持 Worker'))
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(dataSheetAssetPath('/data-sheet/xlsx-import-worker.js'))
+    const timeout = window.setTimeout(() => {
+      worker.terminate()
+      reject(new Error('导入超时'))
+    }, 60_000)
+    worker.onmessage = event => {
+      window.clearTimeout(timeout)
+      worker.terminate()
+      const result = event.data as { ok?: boolean; snapshot?: unknown; error?: string }
+      if (result.ok !== true || typeof result.snapshot !== 'object' || result.snapshot === null) {
+        reject(new Error(result.error ?? '导入失败'))
+      } else {
+        resolve(result.snapshot as object)
+      }
+    }
+    worker.onerror = event => {
+      window.clearTimeout(timeout)
+      worker.terminate()
+      reject(new Error(event.message || '导入 Worker 加载失败'))
+    }
+    worker.postMessage({ data, filename }, [data])
+  })
+}
+
+function snapshotWorkbookName(snapshot: unknown): string | null {
+  if (typeof snapshot !== 'object' || snapshot === null) return null
+  const name = (snapshot as { name?: unknown }).name
+  return typeof name === 'string' && name.trim().length > 0 ? name.trim() : null
+}
+
+function exportInWorker(format: 'csv' | 'xlsx', snapshot: unknown): Promise<string | ArrayBuffer | null> {
+  if (typeof Worker === 'undefined') return Promise.reject(new Error('当前浏览器不支持 Worker'))
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(dataSheetAssetPath('/data-sheet/xlsx-export-worker.js'))
+    const timeout = window.setTimeout(() => {
+      worker.terminate()
+      reject(new Error('导出超时'))
+    }, 60_000)
+    worker.onmessage = event => {
+      window.clearTimeout(timeout)
+      worker.terminate()
+      const data = event.data as { ok?: boolean; value?: unknown; error?: string }
+      if (data.ok !== true) reject(new Error(data.error ?? '导出失败'))
+      else resolve((data.value ?? null) as string | ArrayBuffer | null)
+    }
+    worker.onerror = event => {
+      window.clearTimeout(timeout)
+      worker.terminate()
+      reject(new Error(event.message || '导出 Worker 加载失败'))
+    }
+    worker.postMessage({ format, snapshot })
+  })
+}
+
+function safeFilename(value: string): string {
+  return value.replace(/[\\/:*?"<>|]/g, '-').trim() || 'workbook'
+}

package/src/univer/plugins/history.ts

@@ -0,0 +1,49 @@
+/**
+ * Datasheet edit-history entry point for the open-source Univer canvas.
+ *
+ * Univer Pro's history viewer is intentionally not used. The DSH host owns
+ * durable operation logs/checkpoints and opens its own history panel when the
+ * command is executed.
+ */
+
+import {
+  CommandType,
+  Inject,
+  ICommandService,
+  Injector,
+  Plugin,
+  UniverInstanceType,
+} from '@univerjs/presets'
+import { UNIVER_PLUGIN_VERSION } from './version.ts'
+export const SHOW_HISTORY_COMMAND_ID = 'dsh.data-sheet.show-history'
+
+export interface DataSheetHistoryPluginConfig {
+  onOpenHistory?: () => void
+}
+
+/** Registers the DSH history panel command on the Univer ribbon. */
+export class DataSheetHistoryPlugin extends Plugin {
+  static override pluginName = 'dsh.data-sheet.history'
+  static override packageName = 'dsh-data-table'
+  static override version = UNIVER_PLUGIN_VERSION
+  static override type = UniverInstanceType.UNIVER_SHEET
+
+  constructor(
+    private readonly _config: DataSheetHistoryPluginConfig | undefined,
+    @Inject(Injector) protected readonly _injector: Injector,
+    @ICommandService private readonly _commandService: ICommandService,
+  ) {
+    super()
+  }
+
+  override onStarting(): void {
+    this.disposeWithMe(this._commandService.registerCommand({
+      id: SHOW_HISTORY_COMMAND_ID,
+      type: CommandType.COMMAND,
+      handler: () => {
+        this._config?.onOpenHistory?.()
+        return true
+      },
+    }))
+  }
+}

package/src/univer/plugins/version.ts

@@ -0,0 +1,13 @@
+/**
+ * The version every Data Sheet Univer plugin declares.
+ *
+ * Univer's `PluginService` compares a plugin's declared `version` against its
+ * core version and logs `Plugin version mismatch` when they differ. Our three
+ * adapters are not `@univerjs/*` packages, but declaring the pinned core
+ * version is what keeps that warning out of the console.
+ *
+ * `tests/univer-plugin-version.test.mjs` pins this constant to the installed
+ * `@univerjs/presets` version, so upgrading Univer cannot silently bring the
+ * warning back.
+ */
+export const UNIVER_PLUGIN_VERSION = '0.25.1'