@gridkitjs/core 0.7.0 → 0.9.0

package/dist/index.js

@@ -77,7 +77,10 @@ function buildKeyShortcuts(capabilities) {
     // handle to size the column to its content — same gate as the nudge
     // shortcuts, since both are resize actions.
     capabilities.resizable ? "Alt+ArrowLeft Alt+ArrowRight Alt+Enter" : "",
-    capabilities.sortable ? "Alt+ArrowUp" : ""
+    capabilities.sortable ? "Alt+ArrowUp" : "",
+    // Down rather than reusing Up: it reads as "drill into groups", and Up is
+    // already sort's own mnemonic on the same header.
+    capabilities.groupable ? "Alt+ArrowDown" : ""
   ].filter(Boolean).join(" ");
 }
 function accessDotted(obj, path) {
@@ -95,7 +98,21 @@ function clampFocus(focus, rowCount, columnCount) {
     )
   };
 }
-function nextFocusForKey(key, modifiers, focus, rowCount, columnCount, pageSize) {
+function noRowsSkippable() {
+  return false;
+}
+function skipSkippableRows(rowIndex, direction, rowCount, isSkippableRow, fallback) {
+  let next = rowIndex;
+  while (next >= 0 && next < rowCount && isSkippableRow(next)) {
+    const stepped = next + direction;
+    if (stepped < HEADER_ROW || stepped >= rowCount) {
+      return fallback;
+    }
+    next = stepped;
+  }
+  return next;
+}
+function nextFocusForKey(key, modifiers, focus, rowCount, columnCount, pageSize, isSkippableRow = noRowsSkippable) {
   if (modifiers.altKey) {
     return null;
   }
@@ -108,19 +125,64 @@ function nextFocusForKey(key, modifiers, focus, rowCount, columnCount, pageSize)
       if (modifiers.ctrlKey) return null;
       return { rowIndex, columnIndex: columnIndex + 1 };
     case "ArrowUp":
-      return { rowIndex: rowIndex - 1, columnIndex };
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex - 1,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
     case "ArrowDown":
-      return { rowIndex: rowIndex + 1, columnIndex };
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex + 1,
+          1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
     // Ctrl takes Home and End to the grid's ends rather than the row's, which
     // is the one place Ctrl is navigation rather than reorder.
     case "Home":
       return modifiers.ctrlKey ? { rowIndex: HEADER_ROW, columnIndex: 0 } : { rowIndex, columnIndex: 0 };
     case "End":
-      return modifiers.ctrlKey ? { rowIndex: rowCount - 1, columnIndex: columnCount - 1 } : { rowIndex, columnIndex: columnCount - 1 };
+      return modifiers.ctrlKey ? {
+        rowIndex: skipSkippableRows(
+          rowCount - 1,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex: columnCount - 1
+      } : { rowIndex, columnIndex: columnCount - 1 };
     case "PageUp":
-      return { rowIndex: rowIndex - pageSize, columnIndex };
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex - pageSize,
+          -1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
     case "PageDown":
-      return { rowIndex: rowIndex + pageSize, columnIndex };
+      return {
+        rowIndex: skipSkippableRows(
+          rowIndex + pageSize,
+          1,
+          rowCount,
+          isSkippableRow,
+          rowIndex
+        ),
+        columnIndex
+      };
     default:
       return null;
   }
@@ -302,6 +364,7 @@ function resolveColumnWidths(columns, sizing, options) {
       label: resolveColumnLabel(column),
       resizable: column.resizable ?? options?.resizable ?? false,
       reorderable: column.reorderable ?? options?.reorderable ?? false,
+      groupByDraggable: column.groupByDraggable ?? options?.groupByDraggable ?? false,
       alignment: column.alignment ?? alignmentForType(column.type ?? "string")
     };
   });
@@ -655,6 +718,137 @@ function filterRows(rows, filter, columns) {
   );
 }
 
+// src/util/grouping.ts
+function groupRowId(path) {
+  return JSON.stringify(path);
+}
+function bucketKey(value) {
+  if (value === null || value === void 0) {
+    return "\0empty";
+  }
+  if (value instanceof Date) {
+    return `\0date:${String(value.getTime())}`;
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return `\0${typeof value}:${String(value)}`;
+    case "function":
+      return "\0function";
+    default:
+      return `\0object:${JSON.stringify(value)}`;
+  }
+}
+function partitionByValue(rows, column, direction) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const value = accessDotted(row.row, column.field);
+    const key = bucketKey(value);
+    const bucket = buckets.get(key);
+    if (bucket === void 0) {
+      buckets.set(key, { value, rows: [row] });
+    } else {
+      bucket.rows.push(row);
+    }
+  }
+  const groups = [...buckets.values()];
+  groups.sort((a, b) => {
+    const result = compareValues(a.value, b.value, column.type);
+    return direction === "asc" ? result : -result;
+  });
+  return groups;
+}
+function buildLevel(rows, levels, parentPath, expansion, byId, out) {
+  const level = levels[0];
+  if (level === void 0) {
+    out.push(...rows);
+    return;
+  }
+  const column = byId.get(level.columnId);
+  if (column === void 0) {
+    out.push(...rows);
+    return;
+  }
+  const rest = levels.slice(1);
+  const groups = partitionByValue(rows, column, level.direction ?? "asc");
+  for (const group of groups) {
+    const path = [...parentPath, group.value];
+    const groupId = groupRowId(path);
+    const expanded = !expansion.includes(groupId);
+    const header = {
+      kind: "group",
+      groupId,
+      level: parentPath.length,
+      columnId: level.columnId,
+      value: group.value,
+      path,
+      expanded,
+      count: group.rows.length,
+      // Renumbered globally once `groupRows` has the whole flattened array —
+      // a header has no row of its own to carry a dataset position, so
+      // `datasetIndex` takes the same renumbered value `rowIndex` does.
+      rowIndex: -1,
+      datasetIndex: -1,
+      // Set by `withGroupAggregates`, downstream of grouping — empty here
+      // since `groupRows` itself never knows about `AggregateState`.
+      aggregates: /* @__PURE__ */ new Map()
+    };
+    out.push(header);
+    if (expanded) {
+      buildLevel(group.rows, rest, path, expansion, byId, out);
+    }
+  }
+}
+function groupRows(rows, groupBy, expansion, columns) {
+  if (groupBy.length === 0) {
+    return rows;
+  }
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const active = groupBy.filter((entry) => byId.has(entry.columnId));
+  if (active.length === 0) {
+    return rows;
+  }
+  const out = [];
+  buildLevel(rows, active, [], expansion, byId, out);
+  return out.map((entry, index) => {
+    if ("kind" in entry) {
+      return entry.rowIndex === index && entry.datasetIndex === index ? entry : { ...entry, rowIndex: index, datasetIndex: index };
+    }
+    return entry.rowIndex === index ? entry : { ...entry, rowIndex: index };
+  });
+}
+function toggleGroupExpansion(expansion, groupId) {
+  return expansion.includes(groupId) ? expansion.filter((id) => id !== groupId) : [...expansion, groupId];
+}
+function expandAllGroups(expansion) {
+  return expansion.length === 0 ? expansion : [];
+}
+function collapseAllGroups(rows) {
+  return rows.filter((entry) => "kind" in entry).map((entry) => entry.groupId);
+}
+function moveGroupByBefore(groupBy, columnId, beforeColumnId) {
+  if (columnId === beforeColumnId) {
+    return groupBy;
+  }
+  const without = groupBy.filter((entry) => entry.columnId !== columnId);
+  const moved = groupBy.find((entry) => entry.columnId === columnId) ?? {
+    columnId
+  };
+  const target = beforeColumnId === null ? without.length : without.findIndex((entry) => entry.columnId === beforeColumnId);
+  if (target === -1) {
+    return groupBy;
+  }
+  const next = [...without];
+  next.splice(target, 0, moved);
+  return next.length === groupBy.length && next.every((entry, index) => entry === groupBy[index]) ? groupBy : next;
+}
+function movesGroupBy(groupBy, columnId, beforeColumnId) {
+  return moveGroupByBefore(groupBy, columnId, beforeColumnId) !== groupBy;
+}
+
 // src/util/rows.ts
 function resolveShownRows(rows, filter, sort, columns) {
   return sortRows(filterRows(rows, filter, columns), sort, columns);
@@ -691,6 +885,262 @@ function resolveCell(rowsById, columns, cell) {
     value: accessDotted(entry.row, column.column.field)
   };
 }
+
+// src/util/paging.ts
+function unitsOf(rows) {
+  const units = [];
+  let start = 0;
+  let openedByGroup = false;
+  for (let index = 0; index < rows.length; index++) {
+    const entry = rows[index];
+    if (entry === void 0) {
+      continue;
+    }
+    const isTopLevelHeader = "kind" in entry && entry.kind === "group" && entry.level === 0;
+    const isBoundary = index !== start && (isTopLevelHeader || !openedByGroup);
+    if (isBoundary) {
+      units.push({ start, end: index });
+      start = index;
+      openedByGroup = isTopLevelHeader;
+    } else if (index === start) {
+      openedByGroup = isTopLevelHeader;
+    }
+  }
+  if (start < rows.length) {
+    units.push({ start, end: rows.length });
+  }
+  return units;
+}
+function paginateRows(rows, pagination) {
+  const pageSize = Math.max(1, pagination.pageSize);
+  const units = unitsOf(rows);
+  const pageCount = Math.ceil(units.length / pageSize);
+  if (pageCount === 0) {
+    return { rows: [], pageCount: 0, pageIndex: 0 };
+  }
+  const pageIndex = Math.min(Math.max(pagination.pageIndex, 0), pageCount - 1);
+  const firstUnit = units[pageIndex * pageSize];
+  const lastUnit = units[Math.min(pageIndex * pageSize + pageSize, units.length) - 1];
+  if (firstUnit === void 0 || lastUnit === void 0) {
+    return { rows: [], pageCount, pageIndex };
+  }
+  const page = rows.slice(firstUnit.start, lastUnit.end);
+  const renumbered = page.map(
+    (entry, index) => entry.rowIndex === index ? entry : { ...entry, rowIndex: index }
+  );
+  return { rows: renumbered, pageCount, pageIndex };
+}
+
+// src/util/paginationWindow.ts
+function paginationWindow(currentPage, pageCount, options) {
+  if (pageCount <= 0) {
+    return [];
+  }
+  const boundaryCount = Math.max(0, options?.boundaryCount ?? 1);
+  const siblingCount = Math.max(0, options?.siblingCount ?? 1);
+  const current = Math.min(Math.max(currentPage, 1), pageCount);
+  const pages = /* @__PURE__ */ new Set();
+  for (let page = 1; page <= Math.min(boundaryCount, pageCount); page++) {
+    pages.add(page);
+  }
+  for (let page = Math.max(pageCount - boundaryCount + 1, 1); page <= pageCount; page++) {
+    pages.add(page);
+  }
+  for (let page = Math.max(current - siblingCount, 1); page <= Math.min(current + siblingCount, pageCount); page++) {
+    pages.add(page);
+  }
+  const sorted = Array.from(pages).sort((a, b) => a - b);
+  const entries = [];
+  let previous;
+  for (const page of sorted) {
+    if (previous !== void 0) {
+      if (page - previous === 2) {
+        entries.push(previous + 1);
+      } else if (page - previous > 2) {
+        entries.push("ellipsis");
+      }
+    }
+    entries.push(page);
+    previous = page;
+  }
+  return entries;
+}
+
+// src/util/aggregation.ts
+function isEmpty2(value) {
+  return value === null || value === void 0;
+}
+function toNumber(value) {
+  return Number(value);
+}
+function distinctKey(value) {
+  if (isEmpty2(value)) {
+    return "\0empty";
+  }
+  if (value instanceof Date) {
+    return `\0date:${String(value.getTime())}`;
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return `\0${typeof value}:${String(value)}`;
+    case "function":
+      return "\0function";
+    default:
+      return `\0object:${JSON.stringify(value)}`;
+  }
+}
+function reduceBuiltIn(rows, fn, column) {
+  if (fn === "count") {
+    return rows.length;
+  }
+  const field = column?.column.field;
+  const values = field === void 0 ? [] : rows.map((row) => accessDotted(row, field));
+  switch (fn) {
+    case "sum": {
+      let total = 0;
+      for (const value of values) {
+        if (isEmpty2(value)) continue;
+        total += toNumber(value);
+      }
+      return total;
+    }
+    case "avg": {
+      const present = values.filter((value) => !isEmpty2(value));
+      if (present.length === 0) return void 0;
+      const total = present.reduce(
+        (acc, value) => acc + toNumber(value),
+        0
+      );
+      return total / present.length;
+    }
+    case "min":
+    case "max": {
+      const type = column?.column.type;
+      let result;
+      for (const value of values) {
+        if (isEmpty2(value)) continue;
+        if (result === void 0) {
+          result = value;
+          continue;
+        }
+        const comparison = compareValues(value, result, type);
+        if (fn === "min" ? comparison < 0 : comparison > 0) {
+          result = value;
+        }
+      }
+      return result;
+    }
+    case "countDistinct": {
+      const seen = /* @__PURE__ */ new Set();
+      for (const value of values) {
+        if (isEmpty2(value)) continue;
+        seen.add(distinctKey(value));
+      }
+      return seen.size;
+    }
+  }
+}
+function keyOf(spec) {
+  return spec.id ?? spec.columnId;
+}
+function computeAggregates(rows, specs, columns) {
+  const results = /* @__PURE__ */ new Map();
+  if (specs.length === 0) {
+    return results;
+  }
+  const byId = new Map(columns.map((entry) => [entry.id, entry]));
+  for (const spec of specs) {
+    const value = typeof spec.fn === "function" ? spec.fn(rows) : reduceBuiltIn(rows, spec.fn, byId.get(spec.columnId));
+    results.set(keyOf(spec), value);
+  }
+  return results;
+}
+function leafDescendantsOf(flatRows, path, groupBy, byId) {
+  const keys = path.map((value) => bucketKey(value));
+  return flatRows.filter(
+    (row) => keys.every((key, level) => {
+      const columnId = groupBy[level]?.columnId;
+      const column = columnId === void 0 ? void 0 : byId.get(columnId);
+      if (column === void 0) return false;
+      return bucketKey(accessDotted(row.row, column.field)) === key;
+    })
+  ).map((row) => row.row);
+}
+function appendAggregatedSpan(displayRows, start, levelFloor, flatRows, groupBy, byId, specs, columns, display, out) {
+  let index = start;
+  while (index < displayRows.length) {
+    const entry = displayRows[index];
+    if (entry === void 0) {
+      index++;
+      continue;
+    }
+    if (levelFloor !== null && "kind" in entry && entry.kind === "group" && entry.level <= levelFloor) {
+      break;
+    }
+    index++;
+    if (!("kind" in entry) || entry.kind !== "group") {
+      out.push(entry);
+      continue;
+    }
+    const leaves = leafDescendantsOf(flatRows, entry.path, groupBy, byId);
+    const aggregates = computeAggregates(leaves, specs, columns);
+    const withAggregates = { ...entry, aggregates };
+    out.push(withAggregates);
+    index = appendAggregatedSpan(
+      displayRows,
+      index,
+      entry.level,
+      flatRows,
+      groupBy,
+      byId,
+      specs,
+      columns,
+      display,
+      out
+    );
+    if (display === "row") {
+      const summary = {
+        kind: "group-summary",
+        groupId: entry.groupId,
+        level: entry.level,
+        rowIndex: -1,
+        datasetIndex: -1,
+        aggregates
+      };
+      out.push(summary);
+    }
+  }
+  return index;
+}
+function withGroupAggregates(displayRows, flatRows, groupBy, specs, columns, display = "inline") {
+  if (specs.length === 0) {
+    return displayRows;
+  }
+  const byId = new Map(columns.map((entry) => [entry.id, entry.column]));
+  const out = [];
+  appendAggregatedSpan(
+    displayRows,
+    0,
+    null,
+    flatRows,
+    groupBy,
+    byId,
+    specs,
+    columns,
+    display,
+    out
+  );
+  return out.map((entry, position) => {
+    if ("kind" in entry) {
+      return entry.rowIndex === position && entry.datasetIndex === position ? entry : { ...entry, rowIndex: position, datasetIndex: position };
+    }
+    return entry.rowIndex === position ? entry : { ...entry, rowIndex: position };
+  });
+}
 export {
   DEFAULT_COLUMN_SIZES,
   HEADER_ROW,
@@ -706,19 +1156,28 @@ export {
   clampFocus,
   clearAllFilters,
   clearSelection,
+  collapseAllGroups,
   compareValues,
+  computeAggregates,
   defineColumnsFromRows,
   diffSelection,
+  expandAllGroups,
   filterQueryFor,
   filterRows,
   fitColumnsToWidth,
   getColumnId,
+  groupRowId,
+  groupRows,
   intentOf,
   isSameCell,
   matchesQuery,
   moveColumnBefore,
+  moveGroupByBefore,
   movesColumn,
+  movesGroupBy,
   nextFocusForKey,
+  paginateRows,
+  paginationWindow,
   resolveCell,
   resolveColumnConstraints,
   resolveColumnLabel,
@@ -741,7 +1200,9 @@ export {
   sortRows,
   toggleCellSelection,
   toggleColumnSort,
+  toggleGroupExpansion,
   toggleSelection,
-  totalColumnWidth
+  totalColumnWidth,
+  withGroupAggregates
 };
 //# sourceMappingURL=index.js.map