@rozie-ui/data-table-solid 0.3.1 → 0.4.0

package/src/helpers/columnDefUtils.ts

@@ -32,4 +32,80 @@ const wrapAggregationFn = (fn: any) => {
   }
 }
 
-export { isSafeKey, wrapAggregationFn }
+// ── 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 }