@rozie-ui/data-table-solid 0.2.6 → 0.3.2

package/src/helpers/columnDefUtils.ts

@@ -0,0 +1,111 @@
+// columnDefUtils.ts — pure column-def helpers extracted from columnBuilders.rzts
+// (D-22, Phase 87 plan 87-01). Sigil-free, self-contained: no $props/$data/$emit/
+// $computed/$onMount/$refs/$el/$expose/$watch, and no cross-partial host-symbol
+// calls. Moved verbatim (bodies + explanatory comments intact) — behavior-neutral
+// extraction, proven by dist-parity zero drift + the data-table VR gate.
+
+// Prototype-safe id-keyed column resolution (T-48-PP): the `:columns` config array is
+// applied FIRST (lower precedence), then the <Column> registry OVERRIDES by id (LWW).
+// byId is a null-prototype object so a consumer column id of "__proto__"/"constructor"
+// cannot pollute Object.prototype. Returns the table-core ColumnDef[]. (No per-column
+// render callbacks — cells render via the single #cell/#header scoped slot on this
+// component, dispatched by columnId; <Column> carries metadata only.)
+const isSafeKey = (k: any) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype'
+
+// wrapAggregationFn (phase 50 req-5, D-05, threat T-50-04): resolve a per-column
+// aggregationFn straight onto the ColumnDef (no component-side switch — RESEARCH
+// anti-pattern). A built-in NAME string ('sum'/'min'/'max'/'extent'/'mean'/'median'/
+// 'unique'/'uniqueCount'/'count') passes through verbatim — table-core resolves it from its
+// built-in `aggregationFns` map. A CUSTOM function `(columnId, leafRows, childRows) => any`
+// is DEFENSIVELY WRAPPED (the runValidator precedent): a consumer fn runs per group, so a
+// throw is coerced to `undefined` and can never crash getGroupedRowModel (DoS guard).
+// Anything else → undefined (no aggregation; the cell renders as a placeholder).
+const wrapAggregationFn = (fn: any) => {
+  if (typeof fn === 'string') return fn
+  if (typeof fn !== 'function') return undefined
+  return (columnId: any, leafRows: any, childRows: any) => {
+    try {
+      return fn(columnId, leafRows, childRows)
+    } catch (err) {
+      return undefined
+    }
+  }
+}
+
+// ── B1 (quick 260906-afh) — nested group leaf def index ─────────────────────────────
+// LOOKUP-ONLY. This map is never fed to table-core (it does not replace/reshape the
+// columnDefs() array table-core consumes for createTable/setOptions — that stays
+// byte-identical); it exists purely so `defFor(colId)` (columnChrome.rzts) can resolve
+// a NESTED leaf's def (a `columns:` group child) in O(1), the same as a top-level leaf.
+//
+// collectNestedDefs: depth-first walk of a `columns` array (each entry may itself carry
+// a nested `columns` array — 3+ levels deep is supported). Writes `out[String(d.id)] = d`
+// ONLY when the id is ABSENT from `out` — first-write-wins so a caller can pre-seed `out`
+// with the higher-precedence top-level defs and this pass only ever fills GAPS.
+const collectNestedDefs = (list: any, out: any) => {
+  if (!Array.isArray(list)) return
+  for (const d of list) {
+    if (!d || d.id == null) continue
+    const id = String(d.id)
+    if (!(id in out)) out[id] = d
+    if (Array.isArray(d.columns)) collectNestedDefs(d.columns, out)
+  }
+}
+
+// indexDefsById: builds a null-prototype `{ id: def }` map from a `columnDefs()`-shaped
+// array in TWO passes. Pass 1 registers every TOP-LEVEL def unconditionally — so any id
+// that already resolves at HEAD (a top-level leaf OR a top-level group's OWN id) keeps
+// resolving to the EXACT SAME def, the byte-identical-lookup guarantee for every
+// pre-existing caller. Pass 2 walks each top-level entry's `columns` (if any) via
+// collectNestedDefs, so a nested leaf only fills a GAP — it can never shadow a
+// same-named top-level id (top-level wins regardless of array order). Object.create(null)
+// (T-AFH-01): a consumer column id of "__proto__"/"constructor" cannot pollute
+// Object.prototype through this map — mirrors the existing `byId` T-48-PP guard in
+// columnBuilders.rzts.
+const indexDefsById = (defs: any): any => {
+  const out = Object.create(null)
+  if (!Array.isArray(defs)) return out
+  for (const d of defs) {
+    if (!d || d.id == null) continue
+    out[String(d.id)] = d
+  }
+  for (const d of defs) {
+    if (d && Array.isArray(d.columns)) collectNestedDefs(d.columns, out)
+  }
+  return out
+}
+
+// ── C5+C6 (quick 260906-cvo) — groupable-leaf collection for the #groupBar ──────────────
+// C5: buildConfigDef's GROUP branch (columnBuilders.rzts) returns `{ id, header, columns }`
+// with NO `groupable` key and no accessor, so the OLD `groupableColumns()` loop's
+// `d.groupable === false` skip never fired for a group column — it was wrongly OFFERED to
+// the bar even though a group column can never produce a grouping value.
+// C6: that same loop walked TOP-LEVEL `columnDefs()` entries only, so a genuinely groupable
+// NESTED leaf (a `columns:` group child) was never offered at all.
+//
+// collectGroupableLeafDefs: a DEDICATED depth-first walk, NOT a reuse of `indexDefsById`.
+// `indexDefsById` is a LOOKUP index — it deliberately registers group columns too (a group
+// id must keep resolving for `defFor`), and its insertion order is all-top-level-first-then-
+// nested, which would both offer group columns AND hand the group bar an order that does not
+// match the rendered header order. This walk instead: recurses into a `columns:` array
+// WITHOUT ever pushing the group entry itself (closes C5 — a group column has no accessor
+// and cannot be a grouping target, so an explicit `groupable: true` on a group entry is
+// meaningless and is likewise never pushed); pushes every other (leaf) entry unless it opts
+// out via `groupable === false` (closes C6 — nested leaves are now reachable); walks in
+// DECLARATION order, depth-first, matching the rendered header order.
+const collectGroupableLeafDefs = (defs: any): any[] => {
+  const out: any[] = []
+  if (!Array.isArray(defs)) return out
+  for (const d of defs) {
+    if (!d) continue
+    if (Array.isArray(d.columns)) {
+      out.push(...collectGroupableLeafDefs(d.columns))
+      continue
+    }
+    if (d.groupable === false) continue
+    out.push(d)
+  }
+  return out
+}
+
+export { isSafeKey, wrapAggregationFn, collectNestedDefs, indexDefsById, collectGroupableLeafDefs }

package/src/helpers/indexMath.ts

@@ -0,0 +1,25 @@
+// indexMath.ts — pure index-math + DOM-query helpers extracted from gridFocusNav.rzts /
+// writeFunnels.rzts (D-22, Phase 87 plan 87-01). Sigil-free, self-contained: no
+// $props/$data/$emit/$computed/$onMount/$refs/$el/$expose/$watch, and no cross-partial
+// host-symbol calls. Moved verbatim (bodies + explanatory comments intact) —
+// behavior-neutral extraction, proven by dist-parity zero drift + the data-table VR gate.
+// `focusables(cellEl)` reads the DOM but receives its element as a parameter and touches
+// no sigil and no component ref, so it is framework-agnostic and belongs here alongside
+// `clamp` — its querySelectorAll selector string and its `!n.disabled` filter are kept
+// byte-identical to the pre-extraction body.
+
+const clamp = (v: any, lo: any, hi: any) => (v < lo ? lo : (v > hi ? hi : v))
+
+// The focusable descendants of a cell (non-disabled), in DOM order. Pure DOM — uniform ×6.
+const focusables = (cellEl: any) => {
+  if (!cellEl || !cellEl.querySelectorAll) return []
+  const list = Array.prototype.slice.call(
+    cellEl.querySelectorAll('button,[href],input,select,textarea,[tabindex]:not([tabindex="-1"])')
+  )
+  return list.filter((n) => !n.disabled)
+}
+
+const applyUpdater = (updater: any, current: any) =>
+  (typeof updater === 'function' ? updater(current) : updater)
+
+export { clamp, focusables, applyUpdater }

package/src/helpers/rowValueUtils.ts

@@ -0,0 +1,62 @@
+// rowValueUtils.ts — pure row-value helpers extracted from editCellLifecycle.rzts /
+// editRowLifecycle.rzts (D-22, Phase 87 plan 87-01). Sigil-free, self-contained: no
+// $props/$data/$emit/$computed/$onMount/$refs/$el/$expose/$watch, and no cross-partial
+// host-symbol calls. Moved verbatim (bodies + explanatory comments intact) —
+// behavior-neutral extraction, proven by dist-parity zero drift + the data-table VR gate.
+
+// replaceRowValue: build a FRESH array with ONE row object replaced (the column's field
+// set to the new value); the rest share by reference (the family immutable whole-array
+// replace — in-place mutation is silently dropped on React/Solid/Angular/Lit). rowIndex
+// is over currentData() (== the visible model order for the non-virtual, unsorted/
+// unfiltered single-cell case; the row id is carried for the commit payload).
+const replaceRowValue = (rows: any, rowIndex: any, field: any, value: any) => {
+  const src = rows || []
+  const out = []
+  for (let i = 0; i < src.length; i++) {
+    if (i === rowIndex) {
+      // WR-03: own-property spread, NOT `for (const k in orig)` which walks the prototype chain
+      // and would copy inherited enumerable props of typed/class-instance row objects.
+      out.push({ ...(src[i] || {}), [field]: value })
+    } else {
+      out.push(src[i])
+    }
+  }
+  return out
+}
+
+// replaceRowValues: like replaceRowValue but applies a MAP of field→value to ONE row object
+// in a single fresh-array replace (req-6 — the whole-row commit is ONE write, not per cell).
+const replaceRowValues = (rows: any, rowIndex: any, fieldValues: any) => {
+  const src = rows || []
+  const fv = fieldValues || {}
+  const out = []
+  for (let i = 0; i < src.length; i++) {
+    if (i === rowIndex) {
+      // WR-03: own-property spread (orig then the field→value map), NOT a `for..in`
+      // prototype-walking copy. Spread copies own enumerable props only.
+      out.push({ ...(src[i] || {}), ...fv })
+    } else {
+      out.push(src[i])
+    }
+  }
+  return out
+}
+
+// B23: the index of a committed row WITHIN a given (fresh) visible-model array, resolved by
+// row IDENTITY. table-core's default getRowId is source-index-based, so a row's id is stable
+// across a re-sort (only its VISIBLE position moves); a committed edit replaces the row object
+// via a fresh spread (the `original` reference changes), so match by `id` FIRST, `original`
+// only as a fallback. Returns -1 when the row filtered out of the view. PURE (the caller passes
+// the FRESH row list — refreshRowModel's just-pulled `nextRows`, never the React-stale state).
+const indexOfRowIn = (rows: any, rowOriginal: any, rowId: any) => {
+  const list = rows || []
+  for (let i = 0; i < list.length; i++) {
+    const r = list[i]
+    if (!r) continue
+    if (rowId != null && r.id === rowId) return i
+    if (rowOriginal != null && r.original === rowOriginal) return i
+  }
+  return -1
+}
+
+export { replaceRowValue, replaceRowValues, indexOfRowIn }

package/src/helpers/tsvGrid.ts

@@ -0,0 +1,115 @@
+// tsvGrid.ts — pure TSV/clipboard-grid helpers extracted from clipboardFill.rzts
+// (D-22, Phase 87 plan 87-01). Sigil-free, self-contained: no $props/$data/$emit/
+// $computed/$onMount/$refs/$el/$expose/$watch, and no cross-partial host-symbol
+// calls. Moved verbatim (bodies + explanatory comments intact) — behavior-neutral
+// extraction, proven by dist-parity zero drift + the data-table VR gate.
+
+// B10: escape a TSV field per the spreadsheet convention — a field containing a tab, a CR/LF,
+// or a double-quote is wrapped in double-quotes with internal quotes DOUBLED; an ordinary
+// field is emitted verbatim. parseTsv() unescapes symmetrically, so a cell carrying a tab /
+// newline / quote round-trips without smearing into adjacent cells (T-63-03-02).
+const escapeTsvField = (s: any) => {
+  if (s.indexOf('\t') >= 0 || s.indexOf('\n') >= 0 || s.indexOf('\r') >= 0 || s.indexOf('"') >= 0) {
+    return '"' + s.replace(/"/g, '""') + '"'
+  }
+  return s
+}
+
+// parseTsv(text): a TSV string → string[][] (rows of cells). Tolerates \r\n; a trailing
+// newline does not add a phantom empty row. Pure — produces plain string DATA only (T-51-01:
+// the cells are NEVER eval'd / interpolated into a selector / rendered as markup).
+const parseTsv = (text: any) => {
+  const str = text != null ? String(text) : ''
+  // CR-03: length guard BEFORE the parse — an empty string is a no-op, and a pathologically
+  // large clipboard payload (>2M chars) is rejected outright (DoS-shaped input) before the
+  // single-pass scan allocates a cell-per-character grid.
+  if (str === '' || str.length > 2000000) return []
+  // B10: a quote-aware single-pass state machine (replaces the naive split, which corrupted a
+  // cell containing a tab/newline). A field that OPENS with a double-quote is "quoted": tabs,
+  // newlines, and doubled quotes ("") inside it are literal content until the closing quote;
+  // an unquoted field ends at the next tab/newline. CR/LF and CRLF all delimit a row.
+  const rows = []
+  let row = []
+  let field = ''
+  let inQuotes = false
+  let i = 0
+  const n = str.length
+  while (i < n) {
+    const ch = str[i]
+    if (inQuotes) {
+      if (ch === '"') {
+        if (i + 1 < n && str[i + 1] === '"') { field = field + '"'; i = i + 2; continue }
+        inQuotes = false; i = i + 1; continue
+      }
+      field = field + ch; i = i + 1; continue
+    }
+    if (ch === '"' && field === '') { inQuotes = true; i = i + 1; continue }
+    if (ch === '\t') { row.push(field); field = ''; i = i + 1; continue }
+    if (ch === '\r') {
+      if (i + 1 < n && str[i + 1] === '\n') i = i + 1
+      row.push(field); field = ''; rows.push(row); row = []; i = i + 1; continue
+    }
+    if (ch === '\n') { row.push(field); field = ''; rows.push(row); row = []; i = i + 1; continue }
+    field = field + ch; i = i + 1
+  }
+  // Flush the trailing field + row.
+  row.push(field)
+  rows.push(row)
+  // Drop a single trailing empty row (a TSV that ends with a newline → a phantom [''] row).
+  if (rows.length > 1) {
+    const last = rows[rows.length - 1]
+    if (last.length === 1 && last[0] === '') rows.pop()
+  }
+  return rows
+}
+
+// C3: tile a parsed clipboard `grid` (string[][]) to fill a destination `box` — the spreadsheet
+// paste-into-range semantics. The target rectangle is the MAX of the box dims and the source
+// dims per axis, so a SMALLER clipboard TILES across a LARGER selection (a single 1×1 cell fills
+// the whole range; a 2×2 block repeats — tiled[dr][dc] = src[dr % srcRows][dc % srcCols]), while a
+// clipboard LARGER than the selection pastes its full block from the top-left (preserving the
+// no-range "clipboard-sized block at the active cell" behavior — a 1×1 destBox + a 1×N clipboard
+// yields the full 1×N block, byte-for-byte the prior path). Pure — returns a fresh grid; applies
+// nothing. A ragged/short source row defaults the missing cell to '' (coerced per column on write).
+const tileGridToBox = (grid: any, box: any) => {
+  const srcRows = grid.length
+  // srcCols is the MAX row width across ALL rows (not grid[0].length): a RAGGED clipboard
+  // (a later row WIDER than the first, e.g. TSV "a\tb\nc\td\te") would otherwise never read
+  // the extra column and silently drop those cells. A row SHORTER than srcCols tiles its
+  // missing cells as '' (the `v != null ? v : ''` coercion below), never undefined.
+  let srcCols = 0
+  for (let i = 0; i < srcRows; i++) {
+    const w = grid[i] && grid[i].length ? grid[i].length : 0
+    if (w > srcCols) srcCols = w
+  }
+  if (srcRows <= 0 || srcCols <= 0) return grid
+  const boxRows = (box.r1 - box.r0) + 1
+  const boxCols = (box.c1 - box.c0) + 1
+  const rows = boxRows > srcRows ? boxRows : srcRows
+  const cols = boxCols > srcCols ? boxCols : srcCols
+  const out = []
+  for (let r = 0; r < rows; r++) {
+    const srcLine = grid[r % srcRows] || []
+    const line = []
+    for (let c = 0; c < cols; c++) {
+      const v = srcLine[c % srcCols]
+      line.push(v != null ? v : '')
+    }
+    out.push(line)
+  }
+  return out
+}
+
+// tileIndex(i, lo, hi): map an index into the inclusive [lo,hi] source span by TILING (repeat
+// the source block), handling indices below lo (negative offset) correctly. A 1-wide source
+// (lo===hi) always returns lo. Used by fillRange to resolve, per target cell, WHICH source
+// cell it copies — so each column copies its OWN source value down its OWN column.
+const tileIndex = (i: any, lo: any, hi: any) => {
+  const span = (hi - lo) + 1
+  if (span <= 1) return lo
+  let k = (i - lo) % span
+  if (k < 0) k = k + span
+  return lo + k
+}
+
+export { escapeTsvField, parseTsv, tileGridToBox, tileIndex }