intable 0.0.5 → 0.0.7

package/packages/intable/src/index.tsx

@@ -0,0 +1,481 @@
+import { createContext, createMemo, createSignal, For, useContext, createEffect, type JSX, type Component, createComputed, onMount, mergeProps, mapArray, onCleanup, getOwner, runWithOwner, on, untrack, batch, Index, $PROXY } from 'solid-js'
+import { createMutable, reconcile } from 'solid-js/store'
+import { combineProps } from '@solid-primitives/props'
+import { createLazyMemo } from '@solid-primitives/memo'
+import { createElementSize, createResizeObserver } from '@solid-primitives/resize-observer'
+import { createScrollPosition } from '@solid-primitives/scroll'
+import { difference, mapValues, memoize, sumBy } from 'es-toolkit'
+import { toReactive, useMemo, useMemoState } from './hooks'
+import { log, unFn } from './utils'
+
+import 'virtual:uno.css'
+import './style.scss'
+
+import { CellSelectionPlugin } from './plugins/CellSelectionPlugin'
+import { ClipboardPlugin } from './plugins/CopyPastePlugin'
+import { EditablePlugin } from './plugins/EditablePlugin'
+import { RenderPlugin } from './plugins/RenderPlugin'
+import { MenuPlugin } from './plugins/MenuPlugin'
+import { CommandPlugin } from './plugins/CommandPlugin'
+import { RowSelectionPlugin } from './plugins/RowSelectionPlugin'
+import { ResizePlugin } from './plugins/ResizePlugin'
+import { DragPlugin } from './plugins/DragPlugin'
+import { solidComponent } from './components/utils'
+import { RowGroupPlugin } from './plugins/RowGroupPlugin'
+import { ExpandPlugin } from './plugins/ExpandPlugin'
+import { CellMergePlugin } from './plugins/CellMergePlugin'
+import { TreePlugin } from './plugins/TreePlugin'
+import { HeaderGroupPlugin } from './plugins/HeaderGroup'
+
+export const Ctx = createContext({
+  props: {} as TableProps2,
+  store: {} as TableStore,
+})
+
+type Requireds<T, K extends keyof T> = Pri<Omit<T, K> & Required<Pick<T, K>>>
+type Pri<T> = { [K in keyof T]: T[K] }
+type TableProps2 = Requireds<TableProps, (
+  'Table' | 'Thead' | 'Tbody' | 'Tr' | 'Th' | 'Td' | 'EachRows' | 'EachCells' |
+  'rowKey' | 'data' | 'columns' |
+  'newRow'
+)>
+
+type Each<T = any> = (props: { each: T[]; children: (e: () => any, i: () => number) => JSX.Element }) => JSX.Element
+
+type ProcessProps = {
+  [K in keyof TableProps]?: (prev: TableProps2, ctx: { store: TableStore }) => TableProps[K]
+}
+
+export interface Plugin {
+  name: string
+  priority?: number
+  store?: (store: TableStore) => Partial<TableStore> | void
+  rewriteProps?: ProcessProps
+  layers?: Component<TableStore>[]
+  onMount?: (store: TableStore) => void
+  /**
+   * Declare keyboard shortcuts for this plugin.
+   * Collected and registered as a **single** keydown listener by CommandPlugin.
+   * Keys use tinykeys syntax, e.g. `'$mod+Z'`, `'$mod+Shift+K'`.
+   */
+  keybindings?: (store: TableStore) => Record<string, (e?: KeyboardEvent) => void>
+}
+
+export type Plugin$0 = Plugin | ((store: TableStore) => Plugin)
+
+export interface TableProps {
+  columns?: TableColumn[]
+  data?: any[]
+  index?: boolean
+  border?: boolean
+  stickyHeader?: boolean
+  class?: any
+  style?: any
+  rowKey?: any
+  size?: string
+  newRow?: (i: number) => any
+  // Component
+  Table?: Component<any>
+  Thead?: Component<any>
+  Tbody?: Component<any>
+  Td?: TD
+  Th?: Component<THProps>
+  Tr?: Component<{ y?: number; data?: any; style?: any; children: JSX.Element }>
+  EachRows?: Each
+  EachCells?: Each<TableColumn>
+  // 
+  cellClass?: ((props: Omit<TDProps, 'y' | 'data'> & { y?:number, data? }) => string) | string
+  cellStyle?: ((props: Omit<TDProps, 'y' | 'data'> & { y?:number, data? }) => string) | string
+  // 
+  renderer?: (comp: (props) => JSX.Element) => ((props) => JSX.Element)
+  // Plugin
+  plugins?: Plugin$0[]
+  /**
+   * Override or disable individual plugin keybindings.
+   * - Override: `{ '$mod+Z': (e) => myUndo() }`
+   * - Disable:  `{ '$mod+Z': false }`
+   */
+  keybindings?: Record<string, ((e?: KeyboardEvent) => void) | false>
+
+  onDataChange?: (data: any[]) => void
+}
+
+export type THProps = { x: number; col: TableColumn; children: JSX.Element; rowspan?: number; colspan?: number; style?: any }
+export type TDProps = { x: number; y: number; data: any; col: TableColumn; children: JSX.Element; rowspan?: number; colspan?: number }
+export type TD = Component<TDProps>
+
+type Obj = Record<string | symbol, any>
+
+export interface TableColumn extends Obj {
+  id?: any
+  name?: string
+  width?: number
+  fixed?: 'left' | 'right'
+  class?: any
+  style?: any
+  props?: (props) => JSX.HTMLAttributes<any>
+}
+
+type Nullable<T> = T | undefined
+
+export interface TableStore extends Obj {
+  scroll_el?: HTMLElement
+  table: HTMLElement
+  thead: HTMLElement
+  tbody: HTMLElement
+  ths: Nullable<Element>[]
+  thSizes: Nullable<{ width: number; height: number }>[]
+  trs: Nullable<Element>[]
+  trSizes: Nullable<{ width: number; height: number }>[]
+  internal: symbol
+  raw: symbol
+  props: TableProps2
+  rawProps: TableProps
+  plugins: Plugin[]
+}
+
+export const Intable = (props: TableProps) => {
+  props = mergeProps({ rowKey: 'id' } as Partial<TableProps>, props)
+  const owner = getOwner()!
+
+  const store = createMutable({
+    get rawProps() { return props },
+    get plugins() { return plugins() }
+  } as TableStore)
+
+  const unplugin = memoize((e: Plugin$0) => runWithOwner(owner, () => unFn(e, store)) as Plugin)
+
+  const plugins = createMemo(() => [
+    ...defaultsPlugins,
+    ...props.plugins || [],
+    RenderPlugin
+  ].map(unplugin).sort((a, b) => (b.priority || 0) - (a.priority || 0)))
+  
+  // init store
+  createComputed((old: Plugin[]) => {
+    const added = difference(plugins(), old)
+    runWithOwner(owner, () => {
+      added.forEach(e => Object.assign(store, e.store?.(store)))
+    })
+    return plugins()
+  }, [])
+  
+  // init processProps
+  const pluginsProps = mapArray(plugins, () => createSignal<Partial<TableProps>>())
+  store.props = toReactive(createMemo(() => pluginsProps()[pluginsProps().length - 1][0]() || props)) as TableProps2
+  // store.props = useMemoState(createMemo(() => pluginsProps()[pluginsProps().length - 1][0]() || props)) as TableProps2
+
+  createComputed(mapArray(plugins, (e, i) => {
+    const prev = createMemo(() => pluginsProps()[i() - 1]?.[0]() || props)
+    const ret = mergeProps(prev, toReactive(mapValues(e.rewriteProps || {}, v => useMemo(() => v(prev(), { store })) )))
+    pluginsProps()[i()][1](ret)
+  }))
+
+  // on mount
+  onMount(() => {
+    createEffect(mapArray(plugins, e => e.onMount?.(store)))
+  })
+  
+  const ctx = createMutable({ props: store.props, store })
+
+  window.store = store
+  window.ctx = ctx
+
+  return (
+    <Ctx.Provider value={ctx}>
+      <ctx.props.Table>
+        <THead />
+        <TBody />
+      </ctx.props.Table>
+    </Ctx.Provider>
+  )
+}
+
+const THead = () => {
+  const { props } = useContext(Ctx)
+  return (
+    <props.Thead>
+      <props.Tr>
+        <props.EachCells each={props.columns || []}>
+          {(col, colIndex) => <props.Th col={col()} x={colIndex()}>{col().name}</props.Th>}
+        </props.EachCells>
+      </props.Tr>
+    </props.Thead>
+  )
+}
+
+const TBody = () => {
+  const { props } = useContext(Ctx)
+  return (
+    <props.Tbody>
+      <props.EachRows each={props.data}>{(row, rowIndex) => (
+        <props.Tr y={rowIndex()} data={row()}>
+          <props.EachCells each={props.columns}>{(col, colIndex) => (
+            <props.Td col={col()} x={colIndex()} y={rowIndex()} data={row()}>
+              {row()[col().id]}
+            </props.Td>
+          )}</props.EachCells>
+        </props.Tr>
+      )}</props.EachRows>
+    </props.Tbody>
+  )
+}
+
+export default Intable
+
+// process ===================================================================================================================================================================================================
+
+function BasePlugin(): Plugin$0 {
+  const omits = { col: null, data: null }
+
+  const table = o => <table {...o} /> as any
+  const thead = o => <thead {...o} /> as any
+  const tbody = o => <tbody {...o} /> as any
+  const tr = o => <tr {...o} {...omits} /> as any
+  const th = o => <th {...o} {...omits} /> as any
+  const td = o => <td {...o} {...omits} /> as any
+
+  return {
+    name: 'base',
+    priority: Infinity,
+    store: (store) => {
+      // 共享一个 ResizeObserver 观察所有 th，回调按 index 分发，替代每列独立 createElementSize
+      createResizeObserver(
+        () => store.ths?.filter(Boolean) as Element[] || [],
+        (_, el, e) => {
+          const { inlineSize: width, blockSize: height } = e.borderBoxSize[0]
+          const x = store.ths?.indexOf(el as HTMLElement)
+          if (x >= 0 && el.parentElement) store.thSizes[x] = { width, height }
+        }
+      )
+      // 共享一个 ResizeObserver 观察所有 tr，回调按 index 分发，替代每行独立 createElementSize
+      createResizeObserver(
+        () => store.trs?.filter(Boolean) as Element[] || [],
+        (_, el, e) => {
+          const { inlineSize: width, blockSize: height } = e.borderBoxSize[0]
+          const y = store.trs?.indexOf(el as HTMLElement)
+          if (y >= 0 && el.parentElement) store.trSizes[y] = { width, height }
+        }
+      )
+      return {
+        ths: [],
+        thSizes: [],
+        trs: [],
+        trSizes: [],
+        internal: Symbol('internal'),
+        raw: Symbol('raw'),
+      }
+    },
+    rewriteProps: {
+      data: ({ data = [] }) => data,
+      columns: ({ columns = [] }) => columns,
+      newRow: ({ newRow = () => ({}) }) => newRow,
+      Table: ({ Table = table }, { store }) => o => {
+        const [el, setEl] = createSignal<HTMLElement>()
+        const { props } = useContext(Ctx)
+        o = combineProps({
+          ref: setEl,
+          get class() { return `data-table ${props.class} ${props.border && 'data-table--border'} data-table--${props.size}` },
+          get style() { return props.style }
+        }, o)
+        return <Table {...o} />
+      },
+      Thead: ({ Thead = thead }, { store }) => o => {
+        o = combineProps({ ref: el => store.thead = el }, o)
+        return <Thead {...o} />
+      },
+      Tbody: ({ Tbody = tbody }, { store }) => o => {
+        o = combineProps({ ref: el => store.tbody = el }, o)
+        return <Tbody {...o} />
+      },
+      Tr: ({ Tr = tr }, { store }) => o => {
+        const [el, setEl] = createSignal<HTMLElement>()
+        o = combineProps({ ref: setEl }, o)
+
+        createEffect(() => {
+          const { y } = o
+          if (y == null) return
+          store.trs[y] = el()
+          onCleanup(() => { store.trSizes[y] = store.trs[y] = void 0 })
+        })
+
+        return <Tr {...o} />
+      },
+      Th: ({ Th = th }, { store }) => o => {
+        const [el, setEl] = createSignal<HTMLElement>()
+        
+        const { props } = useContext(Ctx)
+        const mProps = combineProps(
+          o,
+          { ref: setEl },
+          { get class() { return unFn(props.cellClass, o) }, get style() { return unFn(props.cellStyle, o) } },
+          { get class() { return o.col.class }, get style() { return o.col.style } },
+          { get style() { return o.col.width ? `width: ${o.col.width}px` : '' } },
+        )
+
+        createEffect(() => {
+          if (o.covered) return
+          if ((o.colspan ?? 1) != 1) return
+          const { x } = o
+          store.ths[x] = el()
+          onCleanup(() => { store.thSizes[x] = store.ths[x] = void 0 })
+        })
+        
+        return <Th {...mProps}>{o.children}</Th>
+      },
+      Td: ({ Td = td }, { store }) => o => {
+        const { props } = useContext(Ctx)
+        const mProps = combineProps(
+          o,
+          { get class() { return unFn(props.cellClass, o) }, get style() { return unFn(props.cellStyle, o) } },
+          { get class() { return o.col.class }, get style() { return o.col.style } },
+          { get style() { return o.col.width ? `width: ${o.col.width}px` : '' } },
+          // todo
+          () => store.props.tdProps?.(o) || {}
+        )
+        return <Td {...mProps}>{o.children}</Td>
+      },
+      EachRows: ({ EachRows }) => EachRows || (o => <For each={o.each}>{(e, i) => o.children(() => e, i)}</For>),
+      EachCells: ({ EachCells }) => EachCells || (o => <For each={o.each}>{(e, i) => o.children(() => e, i)}</For>),
+      // EachRows: ({ EachRows }) => EachRows || (o => <Index each={o.each}>{(e, i) => o.children(e, () => i)}</Index>),
+      // EachCells: ({ EachCells }) => EachCells || (o => <Index each={o.each}>{(e, i) => o.children(e, () => i)}</Index>),
+      renderer: ({ renderer = a => a }) => renderer
+    }
+  }
+}
+
+const IndexPlugin: Plugin = {
+  name: 'index',
+  priority: -Infinity,
+  store: (store) => ({
+    $index: { name: '', id: Symbol('index'), fixed: 'left', [store.internal]: 1, width: 40, style: 'text-align: center', class: 'index', render: solidComponent((o) => <>{o.y + 1}</>) } as TableColumn
+  }),
+  rewriteProps: {
+    columns: ({ columns }, { store }) => store.props?.index ? [store.$index, ...columns || []] : columns
+  }
+}
+
+const StickyHeaderPlugin: Plugin = {
+  name: 'sticky-header',
+  rewriteProps: {
+    Thead: ({ Thead }) => o => {
+      const { props } = useContext(Ctx)
+      o = combineProps({ get class() { return props.stickyHeader ? 'sticky-header' : '' } }, o)
+      return <Thead {...o} />
+    },
+  }
+}
+
+const FixedColumnPlugin: Plugin$0 = store => {
+  const fixedOffsets = createLazyMemo(() => {
+    const offsets = {}
+    for (const [i, col] of store.props.columns.entries()) {
+      if (col.fixed === 'left') offsets[i] = sumBy(store.thSizes.slice(0, i), s => s?.width || 0)
+      if (col.fixed === 'right') offsets[i] = sumBy(store.thSizes.slice(i + 1), s => s?.width || 0)
+    }
+    return offsets
+  })
+  const last = createLazyMemo(() => store.props.columns.filter(e => e.fixed == 'left').length - 1)
+  const first = createLazyMemo(() => store.props.columns.length - store.props.columns.filter(e => e.fixed == 'right').length)
+  return {
+    name: 'fixed-column',
+    rewriteProps: {
+      columns: ({ columns }) => [
+        ...columns?.filter(e => e.fixed == 'left') || [],
+        ...columns?.filter(e => !e.fixed) || [],
+        ...columns?.filter(e => e.fixed == 'right') || [],
+      ],
+      cellClass: ({ cellClass }) => o => (unFn(cellClass, o) || '') + (o.col.fixed ? ` fixed-${o.col.fixed} ${o.x == last() ? 'is-last' : ''} ${o.x == first() ? 'is-first' : ''}` : ''),
+      cellStyle: ({ cellStyle }) => o => (unFn(cellStyle, o) || '') + (o.col.fixed ? `; ${o.col.fixed}: ${fixedOffsets()[o.x]}px` : '')
+    }
+  }
+}
+
+const FitColWidthPlugin: Plugin$0 = store => {
+  const size = createMutable({ width: 0 })
+  createResizeObserver(() => store.scroll_el!, (_, el, e) => size.width = e.contentBoxSize[0].inlineSize)
+  const __fit_col_width__cols_temp = createMutable([] as any[])
+
+  let lock = false
+  createEffect(on(() => [size.width, store.props.columns.map(e => e.width)], async () => {
+    if (!size.width) return
+    if (lock) return
+    __fit_col_width__cols_temp.length = 0
+    lock = true
+    await Promise.resolve()
+    const gap = (size.width - store.table.getBoundingClientRect().width) / store.props!.columns.filter(e => !e.width).length
+    const cols = store.props!.columns.map((e, i) => (e.width ? null : { width: Math.max((store.ths[i]?.getBoundingClientRect().width || 0) + gap, 80) }))
+    __fit_col_width__cols_temp.push(...cols)
+    lock = false
+  }))
+  return {
+    name: 'fit-col-width',
+    priority: -Infinity,
+    rewriteProps: {
+      columns: ({ columns }, { store }) => (
+        columns = columns.map((e, i) => ({ ...e, ...__fit_col_width__cols_temp?.[i], [store.raw]: e[store.raw] ?? e })),
+        untrack(() => batch(() => reconcile(columns, { key: store.raw })(store.__fit_col_width__cols ??= [])))
+      )
+    }
+  }
+}
+
+export const ScrollPlugin: Plugin = {
+  name: 'scroll',
+  priority: Infinity,
+  rewriteProps: {
+    Table: (prev, { store }) => o => {
+      const pos = createScrollPosition(() => store.scroll_el)
+      const size = createElementSize(() => store.scroll_el)
+
+      const clazz = createMemo(() => {
+        const el = store.scroll_el
+        if (!el) return
+        const isleft = pos.x == 0
+        const isright = pos.x >= el.scrollWidth - (size.width || 0)
+        return (
+          isleft && isright ? '' :
+          !isleft && !isright ? 'is-scroll-mid' :
+          isleft ? 'is-scroll-left' : 
+          isright ? 'is-scroll-right' :
+          ''
+        )
+      })
+      
+      o = combineProps(o, { ref: el => store.scroll_el = el, class: 'data-table--scroll-view' }, { get class() { return clazz() } })
+
+      const layers = mapArray(() => store.plugins.flatMap(e => e.layers ?? []), Layer => <Layer {...store} />)
+      
+      return (
+        <div tabindex={-1} {...o}>
+          <div class='data-table__layers'>
+            {layers()}
+          </div>
+          <table ref={el => store.table = el} class={`data-table--table`}>{o.children}</table>
+        </div>
+      )
+    }
+  }
+}
+
+export const defaultsPlugins = [
+  ScrollPlugin,
+  BasePlugin,
+  CommandPlugin,
+  MenuPlugin,
+  CellSelectionPlugin,
+  StickyHeaderPlugin,
+  HeaderGroupPlugin,
+  FixedColumnPlugin,
+  DragPlugin,
+  ClipboardPlugin,
+  ExpandPlugin,
+  RowSelectionPlugin,
+  IndexPlugin,
+  EditablePlugin,
+  CellMergePlugin,
+  TreePlugin,
+  FitColWidthPlugin,
+  RowGroupPlugin,
+  ResizePlugin,
+]

package/packages/intable/src/plugins/CellChangeHighlightPlugin.tsx

@@ -0,0 +1,5 @@
+import type { Plugin } from '..'
+
+export function CellChangeHighlightPlugin(): Plugin {
+  return {}
+}

package/packages/intable/src/plugins/CellMergePlugin.tsx

@@ -0,0 +1,153 @@
+import { createMemo, Show } from 'solid-js'
+import { combineProps } from '@solid-primitives/props'
+import { type Plugin, type TableColumn, type TableStore } from '../index'
+
+declare module '../index' {
+  interface TableProps {
+    /**
+     * Per-cell merge config. Return `{ rowspan?, colspan? }` for an anchor cell.
+     * Covered cells are hidden automatically.
+     *
+     * @example
+     * merge={(row, col, y, x) => {
+     *   if (col.id === 'name' && row.name === data[y - 1]?.name) return null
+     *   if (col.id === 'name') {
+     *     let rowspan = 1
+     *     while (data[y + rowspan]?.name === row.name) rowspan++
+     *     return rowspan > 1 ? { rowspan } : null
+     *   }
+     * }}
+     */
+    merge?: (row: any, col: TableColumn, y: number, x: number) => { rowspan?: number; colspan?: number } | null | void
+  }
+  interface TableColumn {
+    /**
+     * Shorthand: auto-merge consecutive rows in this column that share the same cell value.
+     * Equivalent to writing a `merge` function that compares adjacent row values.
+     */
+    mergeRow?: boolean
+  }
+  interface TableStore {
+    /** Pre-computed merge result: anchor spans and covered cell keys. */
+    _mergeMap?: ReturnType<typeof createMemo<MergeMap>>
+  }
+}
+
+type CellKey = `${number},${number}`
+interface MergeMap {
+  spans: Map<CellKey, { rowspan: number; colspan: number }>
+  covered: Set<CellKey>
+}
+
+/** Build a { spans, covered } map in O(rows × cols) from the merge function. */
+function buildMergeMap(
+  data: any[],
+  columns: TableColumn[],
+  merge: TableStore['props']['merge'],
+): MergeMap {
+  const spans = new Map<CellKey, { rowspan: number; colspan: number }>()
+  const covered = new Set<CellKey>()
+
+  for (let y = 0; y < data.length; y++) {
+    for (let x = 0; x < columns.length; x++) {
+      const key: CellKey = `${y},${x}`
+      if (covered.has(key)) continue
+
+      const col = columns[x]
+      const row = data[y]
+
+      // Resolve span: explicit `merge` prop wins, then column.mergeRow shorthand
+      let rs = 1, cs = 1
+      if (merge) {
+        const r = merge(row, col, y, x)
+        if (r) { rs = r.rowspan ?? 1; cs = r.colspan ?? 1 }
+      } else if (col.mergeRow) {
+        // Count forward while consecutive rows have the equal value
+        while (y + rs < data.length && data[y + rs]?.[col.id] === row[col.id]) rs++
+      }
+
+      if (rs > 1 || cs > 1) {
+        spans.set(key, { rowspan: rs, colspan: cs })
+        for (let dy = 0; dy < rs; dy++) {
+          for (let dx = 0; dx < cs; dx++) {
+            if (dy === 0 && dx === 0) continue
+            covered.add(`${y + dy},${x + dx}`)
+          }
+        }
+      }
+    }
+  }
+
+  return { spans, covered }
+}
+
+export const CellMergePlugin: Plugin = {
+  name: 'cell-merge',
+  rewriteProps: {
+    /**
+     * Build the merge map once per data/columns change inside the Table wrapper
+     * so it's available to every Td without redundant recomputation.
+     */
+    Table: ({ Table }, { store }) => o => {
+      store._mergeMap ??= createMemo<MergeMap>(() => {
+        const { merge, data, columns } = store.props!
+        if ((!merge && !columns?.some(c => c.mergeRow)) || !data?.length || !columns?.length) {
+          return { spans: new Map(), covered: new Set() }
+        }
+        return buildMergeMap(data, columns, merge)
+      })
+      return <Table {...o} />
+    },
+
+    Td: ({ Td }, { store }) => o => {
+      const key = (): CellKey => `${o.y},${o.x}`
+      const isCovered = () => store._mergeMap?.().covered.has(key()) ?? false
+      const span = () => store._mergeMap?.().spans.get(key())
+
+      o = combineProps(o, {
+        get rowspan() { return span()?.rowspan },
+        get colspan() { return span()?.colspan },
+      })
+
+      return (
+        // Covered cells must not render any DOM node — HTML collapses the layout automatically
+        <Show when={!isCovered()}>
+          <Td {...o} />
+        </Show>
+      )
+    },
+
+    newRow: ({ newRow }, { store }) => function (i) {
+      const row = newRow(i)
+      const { data, columns, merge } = store.props!
+      if (!data?.length || !columns?.length) return row
+
+      columns.forEach((col, x) => {
+        // mergeRow shorthand: copy the value from the row at the insertion point
+        // so the new row automatically joins the same merge group.
+        if (col.mergeRow) {
+          const ref = data[i] ?? data[i - 1]
+          if (ref != null) row[col.id] ??= ref[col.id]
+          return
+        }
+
+        // Explicit merge function: if (i, x) is covered by a span, walk up to
+        // find the anchor row and inherit its cell value.
+        if (merge && store._mergeMap) {
+          const key: CellKey = `${i},${x}`
+          if (!store._mergeMap().covered.has(key) || !store._mergeMap().spans.has(key)) return
+          for (let ay = i; ay >= 0; ay--) {
+            const anchorKey: CellKey = `${ay},${x}`
+            const span = store._mergeMap().spans.get(anchorKey)
+            if (span && span.rowspan > 1) {
+              row[col.id] ??= data[ay]?.[col.id]
+              break
+            }
+          }
+        }
+      })
+
+      return row
+    }
+  },
+}