@lostgradient/cinder 0.5.0 → 0.6.0

package/src/components/data-grid/_internal/selection-model.svelte.ts

@@ -1,168 +0,0 @@
-import {
-  clampCellCoordinate,
-  computeCellRange,
-  getCellCoordinateKey,
-  getCellsInRange,
-  type DataGridCellCoordinate,
-  type DataGridCellRange,
-} from './geometry.ts';
-
-export type DataGridSelectionModelOptions = {
-  rowIds: () => readonly string[];
-  columnKeys: () => readonly string[];
-};
-
-export class DataGridSelectionModel {
-  readonly rowIds: () => readonly string[];
-  readonly columnKeys: () => readonly string[];
-
-  activeCell = $state<DataGridCellCoordinate | undefined>();
-  anchorCell = $state<DataGridCellCoordinate | undefined>();
-  toggledCells = $state.raw<readonly DataGridCellCoordinate[]>([]);
-
-  constructor(options: DataGridSelectionModelOptions) {
-    this.rowIds = options.rowIds;
-    this.columnKeys = options.columnKeys;
-  }
-
-  readonly range: DataGridCellRange | undefined = $derived.by(() => {
-    if (!this.anchorCell || !this.activeCell) return undefined;
-    return computeCellRange(this.anchorCell, this.activeCell, this.rowIds(), this.columnKeys());
-  });
-
-  readonly selectedCellCoordinates = $derived.by(() => {
-    const cellsByKey = new Map<string, DataGridCellCoordinate>();
-    for (const cell of getCellsInRange(this.range))
-      cellsByKey.set(getCellCoordinateKey(cell), cell);
-    for (const cell of this.toggledCells) {
-      if (clampCellCoordinate(cell, this.rowIds(), this.columnKeys())) {
-        cellsByKey.set(getCellCoordinateKey(cell), cell);
-      }
-    }
-    return [...cellsByKey.values()];
-  });
-
-  readonly selectedCells = $derived.by(() => {
-    const keys = new Set<string>();
-    for (const cell of this.selectedCellCoordinates) keys.add(getCellCoordinateKey(cell));
-    return keys;
-  });
-
-  setActiveCell(
-    cell: DataGridCellCoordinate,
-    options: { extend?: boolean; toggle?: boolean } = {},
-  ): void {
-    if (options.toggle) {
-      this.materializeRangeSelection();
-      this.toggleCell(cell);
-      this.activeCell = cell;
-      this.anchorCell = undefined;
-      return;
-    }
-
-    if (options.extend) {
-      if (!this.anchorCell) this.anchorCell = this.activeCell ?? cell;
-      this.activeCell = cell;
-      return;
-    }
-
-    this.anchorCell = cell;
-    this.toggledCells = [];
-
-    this.activeCell = cell;
-  }
-
-  selectAll(): void {
-    const firstRowId = this.rowIds()[0];
-    const lastRowId = this.rowIds().at(-1);
-    const firstColumnKey = this.columnKeys()[0];
-    const lastColumnKey = this.columnKeys().at(-1);
-    if (
-      firstRowId === undefined ||
-      lastRowId === undefined ||
-      firstColumnKey === undefined ||
-      lastColumnKey === undefined
-    ) {
-      return;
-    }
-    this.anchorCell = { rowId: firstRowId, columnKey: firstColumnKey };
-    this.activeCell = { rowId: lastRowId, columnKey: lastColumnKey };
-    this.toggledCells = [];
-  }
-
-  collapseToActiveCell(): void {
-    if (!this.activeCell) return;
-    this.anchorCell = this.activeCell;
-    this.toggledCells = [];
-  }
-
-  isCellSelected(cell: DataGridCellCoordinate): boolean {
-    return this.selectedCells.has(getCellCoordinateKey(cell));
-  }
-
-  isAnchorCell(cell: DataGridCellCoordinate): boolean {
-    if (!this.anchorCell) return false;
-    return getCellCoordinateKey(this.anchorCell) === getCellCoordinateKey(cell);
-  }
-
-  reconcile(fallbackCell: DataGridCellCoordinate | undefined): void {
-    const rowIds = this.rowIds();
-    const columnKeys = this.columnKeys();
-
-    if (rowIds.length === 0 || columnKeys.length === 0) {
-      this.activeCell = undefined;
-      this.anchorCell = undefined;
-      this.toggledCells = [];
-      return;
-    }
-
-    const hadActiveCell = this.activeCell !== undefined;
-    const hadAnchorCell = this.anchorCell !== undefined;
-    const reconciledActiveCell =
-      this.activeCell && clampCellCoordinate(this.activeCell, rowIds, columnKeys);
-    const nextActiveCell = reconciledActiveCell ?? fallbackCell;
-    if (!areCellsEqual(this.activeCell, nextActiveCell)) this.activeCell = nextActiveCell;
-
-    const nextAnchorCell =
-      (this.anchorCell && clampCellCoordinate(this.anchorCell, rowIds, columnKeys)) ??
-      (hadAnchorCell || !hadActiveCell ? nextActiveCell : undefined);
-    if (!areCellsEqual(this.anchorCell, nextAnchorCell)) this.anchorCell = nextAnchorCell;
-
-    const nextToggledCells = this.toggledCells.filter((cell) =>
-      clampCellCoordinate(cell, rowIds, columnKeys),
-    );
-    if (nextToggledCells.length !== this.toggledCells.length) {
-      this.toggledCells = nextToggledCells;
-    }
-  }
-
-  private materializeRangeSelection(): void {
-    const rangeCells = getCellsInRange(this.range);
-    if (rangeCells.length <= 1) return;
-
-    const cellsByKey = new Map(
-      this.toggledCells.map((toggledCell) => [getCellCoordinateKey(toggledCell), toggledCell]),
-    );
-    for (const cell of rangeCells) cellsByKey.set(getCellCoordinateKey(cell), cell);
-    this.toggledCells = [...cellsByKey.values()];
-  }
-
-  private toggleCell(cell: DataGridCellCoordinate): void {
-    const key = getCellCoordinateKey(cell);
-    const cellsByKey = new Map(
-      this.toggledCells.map((toggledCell) => [getCellCoordinateKey(toggledCell), toggledCell]),
-    );
-    if (cellsByKey.has(key)) cellsByKey.delete(key);
-    else cellsByKey.set(key, cell);
-    this.toggledCells = [...cellsByKey.values()];
-  }
-}
-
-export function areCellsEqual(
-  left: DataGridCellCoordinate | undefined,
-  right: DataGridCellCoordinate | undefined,
-): boolean {
-  if (left === undefined && right === undefined) return true;
-  if (!left || !right) return false;
-  return left.rowId === right.rowId && left.columnKey === right.columnKey;
-}

package/src/components/data-grid/_internal/sort-model.ts

@@ -1,134 +0,0 @@
-import type { DataGridSortDirection, DataGridSortModel } from '../data-grid.types.ts';
-import { getDataGridColumnValue, type DataGridValueColumn } from './column-model.svelte.ts';
-
-const sortCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
-
-export function getNextDataGridSortModel(
-  currentSortModel: DataGridSortModel,
-  columnKey: string,
-  multiSort: boolean,
-): DataGridSortModel {
-  const currentIndex = currentSortModel.findIndex((item) => item.key === columnKey);
-  const currentItem = currentIndex >= 0 ? currentSortModel[currentIndex] : undefined;
-  const nextDirection = getNextSortDirection(currentItem?.direction);
-
-  if (!multiSort) {
-    return nextDirection === undefined ? [] : [{ key: columnKey, direction: nextDirection }];
-  }
-
-  if (currentIndex < 0) return [...currentSortModel, { key: columnKey, direction: 'ascending' }];
-  if (nextDirection === undefined) return currentSortModel.filter((item) => item.key !== columnKey);
-  return currentSortModel.map((item, index) =>
-    index === currentIndex ? { key: columnKey, direction: nextDirection } : item,
-  );
-}
-
-export function getActiveDataGridSortModel<TRow>(
-  columns: readonly DataGridValueColumn<TRow>[],
-  sortModel: DataGridSortModel,
-): DataGridSortModel {
-  return sortModel.filter((item) =>
-    columns.some((column) => column.sortable && column.key === item.key),
-  );
-}
-
-export function getSortedDataGridRowIndices<TRow>(
-  rows: readonly TRow[],
-  columns: readonly DataGridValueColumn<TRow>[],
-  sortModel: DataGridSortModel,
-): number[] {
-  const rowIndices = rows.map((_, index) => index);
-  const activeSortItems = getActiveDataGridSortModel(columns, sortModel).flatMap((item) => {
-    const column = columns.find((candidate) => candidate.key === item.key);
-    return column === undefined ? [] : [{ column, direction: item.direction }];
-  });
-
-  if (activeSortItems.length === 0) return rowIndices;
-
-  const sortedRowIndices = rowIndices.slice();
-  sortedRowIndices.sort((leftIndex, rightIndex) => {
-    const leftRow = rows[leftIndex];
-    const rightRow = rows[rightIndex];
-    if (leftRow === undefined || rightRow === undefined) return leftIndex - rightIndex;
-
-    for (const { column, direction } of activeSortItems) {
-      const leftValue = getDataGridColumnValue(leftRow, column);
-      const rightValue = getDataGridColumnValue(rightRow, column);
-      if (isNullishSortValue(leftValue) || isNullishSortValue(rightValue)) {
-        const comparison = compareDataGridValues(leftValue, rightValue, direction);
-        if (comparison !== 0) return comparison;
-        continue;
-      }
-      const comparison = column.sortComparator
-        ? column.sortComparator(leftValue, rightValue, leftRow, rightRow)
-        : compareDataGridValues(leftValue, rightValue, direction);
-
-      if (comparison !== 0) {
-        return column.sortComparator && direction === 'descending' ? -comparison : comparison;
-      }
-    }
-
-    return leftIndex - rightIndex;
-  });
-  return sortedRowIndices;
-}
-
-export function compareDataGridValues(
-  leftValue: unknown,
-  rightValue: unknown,
-  direction: DataGridSortDirection = 'ascending',
-): number {
-  if (Object.is(leftValue, rightValue)) return 0;
-  const leftValueIsNullish = isNullishSortValue(leftValue);
-  const rightValueIsNullish = isNullishSortValue(rightValue);
-  if (leftValueIsNullish && rightValueIsNullish) return 0;
-  if (leftValueIsNullish) return 1;
-  if (rightValueIsNullish) return -1;
-
-  const leftNumber = getComparableNumber(leftValue);
-  const rightNumber = getComparableNumber(rightValue);
-  if (leftNumber !== undefined && rightNumber !== undefined) {
-    return direction === 'ascending' ? leftNumber - rightNumber : rightNumber - leftNumber;
-  }
-
-  const comparison = sortCollator.compare(
-    getComparableLabel(leftValue),
-    getComparableLabel(rightValue),
-  );
-  return direction === 'ascending' ? comparison : -comparison;
-}
-
-function getNextSortDirection(
-  currentDirection: DataGridSortDirection | undefined,
-): DataGridSortDirection | undefined {
-  if (currentDirection === undefined) return 'ascending';
-  if (currentDirection === 'ascending') return 'descending';
-  return undefined;
-}
-
-function getComparableNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (value instanceof Date) {
-    const time = value.getTime();
-    return Number.isFinite(time) ? time : undefined;
-  }
-  return undefined;
-}
-
-function getComparableLabel(value: unknown): string {
-  if (typeof value === 'string') return value;
-  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
-    return value.toString();
-  }
-  if (typeof value === 'symbol') return value.description ?? '';
-  if (value instanceof Date) return value.toISOString();
-  return Object.prototype.toString.call(value);
-}
-
-function isNullishSortValue(value: unknown): boolean {
-  return (
-    value === null ||
-    value === undefined ||
-    (value instanceof Date && !Number.isFinite(value.getTime()))
-  );
-}