@nu-grid/nuxt 0.1.1

package/dist/runtime/composables/_internal/useNuGridGroupSelection.d.ts

@@ -0,0 +1,13 @@
+import type { TableData } from '@nuxt/ui';
+import type { Row, Table } from '@tanstack/vue-table';
+import type { ComputedRef } from 'vue';
+/**
+ * Composable for managing row selection within groups in a grouped table.
+ * Provides utilities to check and toggle selection state for rows within a specific group.
+ */
+export declare function useNuGridGroupSelection<T extends TableData>(tableApi: Table<T>, groupedRows: ComputedRef<Record<string, Row<T>[]>>): {
+    areAllGroupRowsSelected: (groupId: string) => boolean;
+    areSomeGroupRowsSelected: (groupId: string) => boolean;
+    toggleAllGroupRows: (groupId: string, selected: boolean) => void;
+    getGroupCheckboxState: (groupId: string) => boolean | "indeterminate";
+};

package/dist/runtime/composables/_internal/useNuGridGroupSelection.js

@@ -0,0 +1,38 @@
+export function useNuGridGroupSelection(tableApi, groupedRows) {
+  function areAllGroupRowsSelected(groupId) {
+    const rows = groupedRows.value[groupId] || [];
+    if (rows.length === 0) return false;
+    return rows.every((row) => row.getIsSelected());
+  }
+  function areSomeGroupRowsSelected(groupId) {
+    const rows = groupedRows.value[groupId] || [];
+    if (rows.length === 0) return false;
+    const selectedCount = rows.filter((row) => row.getIsSelected()).length;
+    return selectedCount > 0 && selectedCount < rows.length;
+  }
+  function toggleAllGroupRows(groupId, selected) {
+    const rows = groupedRows.value[groupId] || [];
+    const currentSelection = tableApi.getState().rowSelection;
+    const newSelection = { ...currentSelection };
+    rows.forEach((row) => {
+      if (selected) {
+        newSelection[row.id] = true;
+      } else {
+        delete newSelection[row.id];
+      }
+    });
+    tableApi.setRowSelection(newSelection);
+  }
+  function getGroupCheckboxState(groupId) {
+    if (areSomeGroupRowsSelected(groupId)) {
+      return "indeterminate";
+    }
+    return areAllGroupRowsSelected(groupId);
+  }
+  return {
+    areAllGroupRowsSelected,
+    areSomeGroupRowsSelected,
+    toggleAllGroupRows,
+    getGroupCheckboxState
+  };
+}

package/dist/runtime/composables/_internal/useNuGridGrouping.d.ts

@@ -0,0 +1,28 @@
+import type { TableData } from '@nuxt/ui';
+import type { Row, Table } from '@tanstack/vue-table';
+import type { Primitive } from 'reka-ui';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { NuGridProps } from '../../types/index.js';
+export declare function useNuGridGrouping<T extends TableData>(propsInput: MaybeRefOrGetter<NuGridProps<T>>, tableApi: Table<T>, rootRef: Ref<InstanceType<typeof Primitive> | null | undefined>, stickyEnabled?: Ref<boolean>, mode?: 'group' | 'splitgroup', addRowOptions?: {
+    addRowPosition: Ref<'top' | 'bottom' | 'none'>;
+    isAddRowRow: (row: Row<T>) => boolean;
+    getAddRowForGroup?: (groupId: string) => Row<T> | null;
+}): {
+    rows: import("vue").ComputedRef<Row<T>[]>;
+    groupRows: import("vue").ComputedRef<Row<T>[]>;
+    groupedRows: import("vue").ComputedRef<Record<string, Row<T>[]>>;
+    groupExpanded: import("vue").ComputedRef<Record<string, boolean>>;
+    toggleGroup: (groupId: string) => void;
+    isGroupExpanded: (groupId: string) => boolean;
+    virtualRowItems: import("vue").ComputedRef<import("./useNuGridVirtualization.js").GroupVirtualRowItem<T>[]>;
+    virtualizer: Ref<import("../../types/_internal/index.js").NuGridVirtualizer<Element, Element>, import("../../types/_internal/index.js").NuGridVirtualizer<Element, Element>> | null;
+    virtualizationEnabled: import("vue").ComputedRef<boolean>;
+    navigableRows: import("vue").ComputedRef<Row<T>[]>;
+    groupingRowHeights: import("vue").ComputedRef<Required<import("../../types/_internal/index.js").GroupingVirtualRowHeights>>;
+    headerGroupCount: import("vue").ComputedRef<number>;
+    activeStickyIndexes: Ref<number[], number[]>;
+    activeStickyHeight: import("vue").ComputedRef<number>;
+    measuredVirtualSizes: import("vue").ComputedRef<Map<number, number> | null>;
+    getVirtualItemHeight: (index: number) => number;
+    stickyOffsets: import("vue").ComputedRef<Map<number, number>>;
+};

package/dist/runtime/composables/_internal/useNuGridGrouping.js

@@ -0,0 +1,211 @@
+import { computed, toValue, watch } from "vue";
+import {
+  useNuGridGroupVirtualization,
+  useNuGridStandardGroupVirtualization
+} from "./useNuGridVirtualization.js";
+export function useNuGridGrouping(propsInput, tableApi, rootRef, stickyEnabled, mode = "splitgroup", addRowOptions) {
+  const props = computed(() => toValue(propsInput));
+  const rows = computed(() => {
+    return tableApi.getRowModel().rows;
+  });
+  function collectAllGroupRows(rowsToProcess) {
+    const allGroups = [];
+    rowsToProcess.forEach((row) => {
+      if (row.getIsGrouped()) {
+        allGroups.push(row);
+        if (row.subRows && row.subRows.length > 0) {
+          allGroups.push(...collectAllGroupRows(row.subRows));
+        }
+      }
+    });
+    return allGroups;
+  }
+  const groupRows = computed(() => {
+    return collectAllGroupRows(rows.value);
+  });
+  const isRowExpanded = (groupId) => {
+    const expanded = tableApi.getState().expanded;
+    if (expanded === true) return true;
+    if (typeof expanded === "object" && expanded !== null) {
+      return expanded[groupId] !== false;
+    }
+    return true;
+  };
+  const setRowExpanded = (groupId, expanded) => {
+    const currentState = tableApi.getState().expanded;
+    if (currentState === true) {
+      const newState = {};
+      groupRows.value.forEach((gr) => {
+        newState[gr.id] = gr.id === groupId ? expanded : true;
+      });
+      tableApi.setExpanded(newState);
+    } else if (typeof currentState === "object" && currentState !== null) {
+      tableApi.setExpanded({
+        ...currentState,
+        [groupId]: expanded
+      });
+    } else {
+      tableApi.setExpanded({ [groupId]: expanded });
+    }
+  };
+  const groupExpanded = computed(() => {
+    const expanded = tableApi.getState().expanded;
+    if (expanded === true) {
+      const result = {};
+      groupRows.value.forEach((gr) => {
+        result[gr.id] = true;
+      });
+      return result;
+    }
+    return expanded || {};
+  });
+  const reorderGroup = (groupId, rowsForGroup) => {
+    if (!addRowOptions || addRowOptions.addRowPosition.value === "none") {
+      return rowsForGroup;
+    }
+    const placeholder = addRowOptions.getAddRowForGroup?.(groupId) || null;
+    const regularRows = rowsForGroup;
+    if (placeholder && addRowOptions.addRowPosition.value === "top") {
+      return [placeholder, ...regularRows];
+    }
+    if (placeholder && addRowOptions.addRowPosition.value === "bottom") {
+      return [...regularRows, placeholder];
+    }
+    return regularRows;
+  };
+  function extractDataRows(groupRow) {
+    const dataRows = [];
+    if (!groupRow.subRows || groupRow.subRows.length === 0) {
+      return dataRows;
+    }
+    groupRow.subRows.forEach((subRow) => {
+      if (subRow.getIsGrouped()) {
+        dataRows.push(...extractDataRows(subRow));
+      } else {
+        dataRows.push(subRow);
+      }
+    });
+    return dataRows;
+  }
+  function processGroupsRecursively(rowsToProcess, groups) {
+    rowsToProcess.forEach((row) => {
+      if (row.getIsGrouped()) {
+        const groupId = row.id;
+        const dataRows = extractDataRows(row);
+        groups[groupId] = reorderGroup(groupId, dataRows);
+        if (row.subRows && row.subRows.length > 0) {
+          processGroupsRecursively(row.subRows, groups);
+        }
+      }
+    });
+  }
+  const groupedRows = computed(() => {
+    const groups = {};
+    processGroupsRecursively(rows.value, groups);
+    return groups;
+  });
+  watch(
+    groupRows,
+    (newGroupRows) => {
+      if (newGroupRows.length === 0) return;
+      const currentState = tableApi.getState().expanded;
+      if (!currentState || typeof currentState === "object" && Object.keys(currentState).length === 0) {
+        tableApi.setExpanded(true);
+      }
+    },
+    { immediate: true }
+  );
+  function toggleGroup(groupId) {
+    setRowExpanded(groupId, !isRowExpanded(groupId));
+  }
+  function isGroupExpanded(groupId) {
+    return isRowExpanded(groupId);
+  }
+  const virtualizationFn = mode === "group" ? useNuGridStandardGroupVirtualization : useNuGridGroupVirtualization;
+  const {
+    groupingRowHeights,
+    headerGroupCount,
+    virtualRowItems,
+    virtualizer,
+    virtualizationEnabled,
+    activeStickyIndexes,
+    activeStickyHeight,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  } = virtualizationFn({
+    props,
+    tableApi,
+    rootRef,
+    stickyEnabled,
+    groupRows,
+    groupedRows,
+    isGroupExpanded,
+    topLevelRows: rows,
+    addRowOptions
+  });
+  function findParentGroupId(groupRow, allRows) {
+    for (const row of allRows) {
+      if (row.getIsGrouped() && row.subRows) {
+        if (row.subRows.some((subRow) => subRow.id === groupRow.id)) {
+          return row.id;
+        }
+        const parentId = findParentGroupId(groupRow, row.subRows);
+        if (parentId) {
+          return parentId;
+        }
+      }
+    }
+    return null;
+  }
+  function isGroupVisible(groupId, allRows) {
+    const groupRow = groupRows.value.find((gr) => gr.id === groupId);
+    if (!groupRow) {
+      return false;
+    }
+    const parentId = findParentGroupId(groupRow, allRows);
+    if (parentId === null) {
+      return true;
+    }
+    if (!isGroupExpanded(parentId)) {
+      return false;
+    }
+    return isGroupVisible(parentId, allRows);
+  }
+  const navigableRows = computed(() => {
+    if (groupRows.value.length === 0) {
+      return rows.value;
+    }
+    const navRows = [];
+    groupRows.value.forEach((groupRow) => {
+      const groupId = groupRow.id;
+      const visible = isGroupVisible(groupId, rows.value);
+      const expanded = isGroupExpanded(groupId);
+      const hasSubgroups = groupRow.subRows?.some((subRow) => subRow.getIsGrouped());
+      if (visible && expanded && !hasSubgroups) {
+        const dataRows = groupedRows.value[groupId] || [];
+        navRows.push(...dataRows);
+      }
+    });
+    return navRows;
+  });
+  return {
+    rows,
+    groupRows,
+    groupedRows,
+    groupExpanded,
+    toggleGroup,
+    isGroupExpanded,
+    virtualRowItems,
+    virtualizer,
+    virtualizationEnabled,
+    navigableRows,
+    groupingRowHeights,
+    headerGroupCount,
+    activeStickyIndexes,
+    activeStickyHeight,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  };
+}

package/dist/runtime/composables/_internal/useNuGridInteractionRouter.d.ts

@@ -0,0 +1,9 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridEventEmitter } from '../../types/index.js';
+import type { NuGridInteractionRouter } from '../../types/_internal/index.js';
+interface RouterOptions<T extends TableData = TableData> {
+    debug?: boolean;
+    eventEmitter?: NuGridEventEmitter<T>;
+}
+export declare function useNuGridInteractionRouter<T extends TableData>(options?: RouterOptions<T>): NuGridInteractionRouter<T>;
+export {};