@rozie-ui/data-table-solid 0.7.4 → 0.8.1

package/src/helpers/activeFollow.ts

@@ -0,0 +1,42 @@
+// activeFollow.ts — the active cell follows its record (design doc 2026-11-06, Part 3).
+// Sigil-free, self-contained: no $props/$data/$emit/$computed/$onMount/$refs/$el/$expose/
+// $watch, and no cross-partial host-symbol calls. Pure decisions over row-id lists; the
+// DataTable wiring (refreshRowModel → followActiveCell) applies them.
+
+export type FollowResult =
+  | { kind: 'stay' } // same index, nothing to do
+  | { kind: 'move'; index: number } // follow to the new index
+  | { kind: 'park' } // row gone after a view change / table write
+  | { kind: 'clamp' } // row gone after navigation / reset → existing D-05 + B25
+
+// resolveFollow: where does the active row (index `activeRow` in the PREVIOUS visible model,
+// whose row ids are `prevIds`) live in the NEXT model (`nextIds`)?
+//   • found at the same index → stay; found elsewhere → move there.
+//   • not found → park on the header when the rows changed because of a view change (sort /
+//     filter / refreshView) or one of the table's own writes — the next keystroke would
+//     otherwise edit whichever record now sits at the old index — else clamp (paging, page
+//     size, expand/collapse, an external data swap: navigation or reset).
+//   • no previous model, or an index outside it → clamp (nothing to follow).
+export function resolveFollow(
+  prevIds: readonly string[] | null,
+  activeRow: number,
+  nextIds: readonly string[],
+  viewChangeOrWrite: boolean,
+): FollowResult {
+  if (!prevIds || !Number.isInteger(activeRow) || activeRow < 0 || activeRow >= prevIds.length) {
+    return { kind: 'clamp' }
+  }
+  const id = prevIds[activeRow]
+  if (nextIds[activeRow] === id) return { kind: 'stay' }
+  const index = nextIds.indexOf(id)
+  if (index >= 0) return { kind: 'move', index }
+  return viewChangeOrWrite ? { kind: 'park' } : { kind: 'clamp' }
+}
+
+// sameIdSequence: are both models the same rows in the same order? (A range can only survive
+// a re-derive that keeps row membership AND order.)
+export function sameIdSequence(a: readonly string[] | null, b: readonly string[]): boolean {
+  if (!a || a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false
+  return true
+}

package/src/helpers/columnRuleUtils.ts

@@ -0,0 +1,105 @@
+// columnRuleUtils.ts — per-column filterFn / sortingFn rule resolution. Sigil-free,
+// self-contained: no $props/$data/$emit/$computed/$onMount/$refs/$el/$expose/$watch, no
+// host-symbol calls, and no @tanstack/table-core import (the name lists below mirror
+// table-core's `filterFns` / `sortingFns` keys; a test pins them to the real maps).
+//
+// A rule is a built-in NAME, 'auto', or a consumer FUNCTION. `columnRuleKeys` returns an
+// object with NO key for a rule that resolves to undefined: table-core builds columns as
+// `{...defaultColumn, ...columnDef}`, so an explicit `filterFn: undefined` would override
+// the default 'auto' (silently dropping filters; `sortingFn: undefined` throws in
+// getSortedRowModel).
+
+export const FILTER_FN_NAMES: readonly string[] = [
+  'includesString',
+  'includesStringSensitive',
+  'equalsString',
+  'arrIncludes',
+  'arrIncludesAll',
+  'arrIncludesSome',
+  'equals',
+  'weakEquals',
+  'inNumberRange',
+]
+
+export const SORTING_FN_NAMES: readonly string[] = [
+  'alphanumeric',
+  'alphanumericCaseSensitive',
+  'text',
+  'textCaseSensitive',
+  'datetime',
+  'basic',
+]
+
+// Module-level dedupe: warn once per (columnId, name) pair.
+const warned = new Set<string>()
+
+const resolveName = (
+  value: string,
+  names: readonly string[],
+  kind: string,
+  columnId: string,
+  warn: (msg: string) => void,
+): string => {
+  if (value === 'auto' || names.includes(value)) return value
+  const key = kind + '\u0000' + columnId + '\u0000' + value
+  if (!warned.has(key)) {
+    warned.add(key)
+    warn(`[data-table] column "${columnId}": unknown ${kind} "${value}"; falling back to "auto".`)
+  }
+  return 'auto'
+}
+
+export const resolveFilterFn = (
+  value: unknown,
+  columnId: string,
+  warn: (msg: string) => void = console.warn,
+): string | Function | undefined => {
+  if (value == null) return undefined
+  if (typeof value === 'string') return resolveName(value, FILTER_FN_NAMES, 'filterFn', columnId, warn)
+  if (typeof value !== 'function') return undefined
+  const fn: any = value
+  // A consumer fn runs per row, so a throw is coerced to "row passes" and can never
+  // crash getFilteredRowModel.
+  const adapter: any = (row: any, colId: string, filterValue: any) => {
+    try {
+      return fn(row.getValue(colId), filterValue, row.original)
+    } catch (err) {
+      return true
+    }
+  }
+  if (fn.autoRemove !== undefined) adapter.autoRemove = fn.autoRemove
+  if (fn.resolveFilterValue !== undefined) adapter.resolveFilterValue = fn.resolveFilterValue
+  return adapter
+}
+
+export const resolveSortingFn = (
+  value: unknown,
+  columnId: string,
+  warn: (msg: string) => void = console.warn,
+): string | Function | undefined => {
+  if (value == null) return undefined
+  if (typeof value === 'string') return resolveName(value, SORTING_FN_NAMES, 'sortingFn', columnId, warn)
+  if (typeof value !== 'function') return undefined
+  const fn: any = value
+  // A throw is coerced to 0 ("equal") so getSortedRowModel can never crash.
+  return (rowA: any, rowB: any, colId: string) => {
+    try {
+      return fn(rowA.getValue(colId), rowB.getValue(colId), rowA.original, rowB.original)
+    } catch (err) {
+      return 0
+    }
+  }
+}
+
+export const columnRuleKeys = (
+  spec: { filterFn?: unknown; sortingFn?: unknown },
+  columnId: string,
+  warn?: (msg: string) => void,
+): { filterFn?: string | Function; sortingFn?: string | Function } => {
+  const out: { filterFn?: string | Function; sortingFn?: string | Function } = {}
+  const f = resolveFilterFn(spec?.filterFn, columnId, warn)
+  if (f !== undefined) out.filterFn = f
+  const s = resolveSortingFn(spec?.sortingFn, columnId, warn)
+  if (s !== undefined) out.sortingFn = s
+  return out
+}

package/src/helpers/heldView.ts

@@ -0,0 +1,185 @@
+// heldView.ts — the hold controller behind `holdView` (held filter membership + sort
+// order through the table's own writes). Sigil-free, self-contained: no $props/$data/
+// $emit/$computed/$onMount/$refs/$el/$expose/$watch, no host-symbol calls, and no
+// @tanstack/table-core import (the tests drive it against the real table-core).
+//
+// Seam: the hold lives INSIDE table-core's row pipeline. `wrapFiltered` / `wrapSorted`
+// wrap the built-in row-model factories (shape `(table) => () => RowModel`). While not
+// holding they return the base model unchanged (same identity). While holding:
+//   - filtered stage: the current core rows whose id is in the held membership, in core
+//     order (fresh rows, so new values render in place). The base (live) filtered id set
+//     is kept for counting.
+//   - sorted stage: the base output is the live sort of the held set (its upstream is the
+//     held filtered model); its id order is kept for counting, and the rows are returned
+//     reordered to the held order. Mapped by id — getSortedRowModel shallow-copies rows.
+// Each wrapper memoizes on [base result identity, controller version], so downstream
+// table-core memos (keyed on upstream model identity) see a stable model.
+//
+// Limits worth knowing:
+//   - The held filtered stage returns the CORE rows (not the rows table-core's filtered stage
+//     produced), so they do not carry table-core's per-row `columnFilters` / `columnFiltersMeta`
+//     bookkeeping. Nothing in DataTable reads those; a future reader would have to take them
+//     from the base (live) model instead.
+//   - One controller per table: it holds a single membership / order / written-row set, so
+//     never share one controller (or its wrapped factories) between two table instances.
+
+export interface ViewState {
+  held: boolean
+  filterMismatches: number
+  sortMismatches: number
+}
+
+export const CLEAN_VIEW_STATE: ViewState = Object.freeze({
+  held: false,
+  filterMismatches: 0,
+  sortMismatches: 0,
+}) as ViewState
+
+export const viewStatesEqual = (a: ViewState, b: ViewState): boolean =>
+  a.held === b.held && a.filterMismatches === b.filterMismatches && a.sortMismatches === b.sortMismatches
+
+// Index-aligned reference comparison. Differing lengths → every index of the longer
+// (the shape changed, so every position is suspect).
+export const changedIndices = (prev: readonly unknown[], next: readonly unknown[]): number[] => {
+  const out: number[] = []
+  if (prev.length !== next.length) {
+    const n = Math.max(prev.length, next.length)
+    for (let i = 0; i < n; i++) out.push(i)
+    return out
+  }
+  for (let i = 0; i < next.length; i++) if (prev[i] !== next[i]) out.push(i)
+  return out
+}
+
+export interface HoldController {
+  setActive(active: boolean): void
+  isActive(): boolean
+  isHolding(): boolean
+  capture(table: any): void
+  release(): void
+  noteWrite(prev: readonly unknown[], next: readonly unknown[]): void
+  wrapFiltered(base: (table: any) => () => any): (table: any) => () => any
+  wrapSorted(base: (table: any) => () => any): (table: any) => () => any
+  viewState(table: any): ViewState
+}
+
+const rowIds = (model: any): string[] => (model?.rows ?? []).map((r: any) => r.id)
+
+export const createHoldController = (): HoldController => {
+  let active = false
+  // Snapshot — null when not holding.
+  let heldMembership: Set<string> | null = null
+  let heldOrder: string[] | null = null
+  const written = new Set<number>()
+  let version = 0
+  // Live (unheld) results observed by the wrappers while holding, for counting.
+  let liveFilteredIds: Set<string> = new Set()
+  let liveSortedIds: string[] = []
+
+  const release = () => {
+    heldMembership = null
+    heldOrder = null
+    written.clear()
+    version++
+  }
+
+  const wrapFiltered = (base: (table: any) => () => any) => (table: any) => {
+    const getBase = base(table)
+    let lastBase: any = undefined
+    let lastVersion = -1
+    let lastOut: any = undefined
+    return () => {
+      const baseModel = getBase()
+      if (!heldMembership) return baseModel
+      if (baseModel === lastBase && version === lastVersion) return lastOut
+      liveFilteredIds = new Set(rowIds(baseModel))
+      const held = heldMembership
+      const coreRows: any[] = table.getCoreRowModel().rows
+      const rows = coreRows.filter((r: any) => held.has(r.id))
+      const rowsById: Record<string, any> = {}
+      for (const r of rows) rowsById[r.id] = r
+      lastBase = baseModel
+      lastVersion = version
+      lastOut = { rows, flatRows: rows, rowsById }
+      return lastOut
+    }
+  }
+
+  const wrapSorted = (base: (table: any) => () => any) => (table: any) => {
+    const getBase = base(table)
+    let lastBase: any = undefined
+    let lastVersion = -1
+    let lastOut: any = undefined
+    return () => {
+      const baseModel = getBase()
+      if (!heldOrder) return baseModel
+      if (baseModel === lastBase && version === lastVersion) return lastOut
+      const baseRows: any[] = baseModel?.rows ?? []
+      liveSortedIds = baseRows.map((r: any) => r.id)
+      const byId = new Map<string, any>()
+      for (const r of baseRows) byId.set(r.id, r)
+      const rows: any[] = []
+      for (const id of heldOrder) {
+        const r = byId.get(id)
+        if (r) {
+          rows.push(r)
+          byId.delete(id)
+        }
+      }
+      // Defensive: anything the held order does not know keeps its live position at the end.
+      for (const r of baseRows) if (byId.has(r.id)) rows.push(r)
+      lastBase = baseModel
+      lastVersion = version
+      lastOut = { rows, flatRows: rows, rowsById: baseModel?.rowsById ?? {} }
+      return lastOut
+    }
+  }
+
+  return {
+    setActive(next: boolean) {
+      const was = active
+      active = !!next
+      if (!active && was) release()
+    },
+    isActive: () => active,
+    isHolding: () => heldMembership !== null,
+    capture(table: any) {
+      if (!active || heldMembership) return
+      const filtered = table.getFilteredRowModel()
+      const sorted = typeof table.getSortedRowModel === 'function' ? table.getSortedRowModel() : filtered
+      heldMembership = new Set(rowIds(filtered))
+      heldOrder = rowIds(sorted)
+      written.clear()
+      version++
+    },
+    release,
+    noteWrite(prev: readonly unknown[], next: readonly unknown[]) {
+      if (!heldMembership) return
+      for (const i of changedIndices(prev, next)) written.add(i)
+    },
+    wrapFiltered,
+    wrapSorted,
+    viewState(table: any): ViewState {
+      if (!active) return CLEAN_VIEW_STATE
+      if (!heldMembership || !heldOrder) return { held: true, filterMismatches: 0, sortMismatches: 0 }
+      // Pull the models so the wrappers have observed the current live results.
+      table.getSortedRowModel()
+      const held = heldMembership
+      let filterMismatches = 0
+      for (const id of held) if (!liveFilteredIds.has(id)) filterMismatches++
+      const coreRows: any[] = table.getCoreRowModel().rows
+      for (const r of coreRows) if (!held.has(r.id) && liveFilteredIds.has(r.id)) filterMismatches++
+      const heldPos = new Map<string, number>()
+      heldOrder.forEach((id, i) => heldPos.set(id, i))
+      const livePos = new Map<string, number>()
+      liveSortedIds.forEach((id, i) => livePos.set(id, i))
+      let sortMismatches = 0
+      for (const i of written) {
+        const id = coreRows[i]?.id
+        if (id === undefined || !heldPos.has(id)) continue
+        if (heldPos.get(id) !== livePos.get(id)) sortMismatches++
+      }
+      return { held: true, filterMismatches, sortMismatches }
+    },
+  }
+}

package/src/index.ts

@@ -12,6 +12,6 @@ export { default as FilterSelect } from './FilterSelect';
 export { default as GroupBar } from './GroupBar';
 export { default as DetailPanel } from './DetailPanel';
 
-/** The `$expose` imperative handle received via `ref` — { sortColumn, clearSorting, toggleRowExpanded, expandAll, collapseAll, getExpandedRows, applyGrouping, clearGrouping, getFacetedUniqueValues, getFacetedMinMaxValues, getColumnDefs, toggleAllRows, clearSelection, getSelectedRows, setPage, setRowsPerPage, toggleColumnVisibility, applyColumnOrder, resetColumnSizing, pinColumn, focusCell, getActiveCell, clearActiveCell, scrollToRow, getScrollElement, getRowIndexRelativeToPage, editCell, commitEditing, editRow, getSelectedRange, cut, undo, redo, canUndo, canRedo, clearHistory }. */
+/** The `$expose` imperative handle received via `ref` — { sortColumn, clearSorting, toggleRowExpanded, expandAll, collapseAll, getExpandedRows, applyGrouping, clearGrouping, getFacetedUniqueValues, getFacetedMinMaxValues, getColumnDefs, toggleAllRows, clearSelection, getSelectedRows, setPage, setRowsPerPage, toggleColumnVisibility, applyColumnOrder, resetColumnSizing, pinColumn, focusCell, getActiveCell, clearActiveCell, scrollToRow, getScrollElement, getRowIndexRelativeToPage, editCell, commitEditing, editRow, getSelectedRange, cut, undo, redo, canUndo, canRedo, clearHistory, refreshView, getViewState }. */
 export type { DataTableHandle } from './DataTable';
 export type * from './DataTable';