@nu-grid/nuxt 0.1.1

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

@@ -0,0 +1,58 @@
+import baseCheckboxTheme from "#build/ui/checkbox";
+import { useAppConfig } from "#imports";
+import { tv } from "@nuxt/ui/runtime/utils/tv.js";
+import { twMerge } from "tailwind-merge";
+import { computed } from "vue";
+import { getTheme } from "../../themes/index.js";
+export function useNuGridUI(props) {
+  const appConfig = useAppConfig();
+  const ui = computed(() => {
+    const themeName = props.theme || "default";
+    const themeDefinition = getTheme(themeName);
+    if (!themeDefinition) {
+      if (import.meta.dev) {
+        console.warn(`[NuGrid] Theme "${themeName}" not found. Using "default" theme.`);
+      }
+      const defaultThemeDef = getTheme("default");
+      const virtualization2 = props.virtualization;
+      return tv({ extend: tv(defaultThemeDef.theme), ...appConfig.ui?.table || {} })({
+        sticky: virtualization2 ? false : props.sticky,
+        loading: props.loading,
+        loadingColor: props.loadingColor,
+        loadingAnimation: props.loadingAnimation,
+        virtualize: !!virtualization2
+      });
+    }
+    const selectedTheme = themeDefinition.theme;
+    const virtualization = props.virtualization;
+    return tv({ extend: tv(selectedTheme), ...appConfig.ui?.table || {} })({
+      sticky: virtualization ? false : props.sticky,
+      loading: props.loading,
+      loadingColor: props.loadingColor,
+      loadingAnimation: props.loadingAnimation,
+      virtualize: !!virtualization
+    });
+  });
+  const checkboxTheme = computed(() => {
+    const themeName = props.theme || "default";
+    const themeDefinition = getTheme(themeName) || getTheme("default");
+    const selectedTheme = themeDefinition.theme;
+    return {
+      ...baseCheckboxTheme,
+      slots: {
+        ...baseCheckboxTheme.slots,
+        base: twMerge(baseCheckboxTheme.slots.base, selectedTheme.slots.checkboxBase),
+        indicator: twMerge(
+          baseCheckboxTheme.slots.indicator,
+          selectedTheme.slots.checkboxIndicator
+        ),
+        container: twMerge(
+          baseCheckboxTheme.slots.container,
+          selectedTheme.slots.checkboxContainer
+        ),
+        icon: twMerge(baseCheckboxTheme.slots.icon, selectedTheme.slots.checkboxIcon)
+      }
+    };
+  });
+  return { ui, checkboxTheme };
+}

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

@@ -0,0 +1,75 @@
+import type { TableData } from '@nuxt/ui';
+import type { Row, Table } from '@tanstack/vue-table';
+import type { Primitive } from 'reka-ui';
+import type { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+import type { NuGridProps } from '../../types/index.js';
+import type { GroupingVirtualRowHeights, GroupVirtualRowItem, GroupVirtualRowType, NuGridVirtualizer, NuGridVirtualizerOptions, ResolvedNuGridVirtualizeOptions } from '../../types/_internal/index.js';
+export type { GroupVirtualRowItem, GroupVirtualRowType };
+/**
+ * Resolve virtualization options using centralized defaults.
+ * Handles boolean toggles, explicit enable/disable, breakpoint-aware overscan, and dynamic row height heuristics.
+ */
+export declare function resolveVirtualizationOptions(virtualization: boolean | NuGridVirtualizerOptions | undefined, defaultEstimateSize?: number, currentBreakpoint?: string): ResolvedNuGridVirtualizeOptions;
+interface SharedVirtualizerResult<T extends TableData = TableData> {
+    virtualizer: Ref<NuGridVirtualizer> | null;
+    virtualizationEnabled: ComputedRef<boolean>;
+    activeStickyIndexes: Ref<number[]>;
+    activeStickyHeight: ComputedRef<number>;
+    virtualRowItems: ComputedRef<GroupVirtualRowItem<T>[]>;
+    measuredVirtualSizes: ComputedRef<Map<number, number> | null>;
+    getVirtualItemHeight: (index: number) => number;
+    stickyOffsets: ComputedRef<Map<number, number>>;
+}
+export interface UseNuGridGroupVirtualizationOptions<T extends TableData> {
+    props: MaybeRefOrGetter<NuGridProps<T>>;
+    tableApi: Table<T>;
+    rootRef: Ref<InstanceType<typeof Primitive> | null | undefined>;
+    stickyEnabled?: Ref<boolean>;
+    groupRows: ComputedRef<Row<T>[]>;
+    groupedRows: ComputedRef<Record<string, Row<T>[]>>;
+    isGroupExpanded: (groupId: string) => boolean;
+    topLevelRows: ComputedRef<Row<T>[]>;
+    addRowOptions?: {
+        addRowPosition: Ref<'top' | 'bottom' | 'none'>;
+        getAddRowForGroup?: (groupId: string) => Row<T> | null;
+    };
+}
+export declare function useNuGridGroupVirtualization<T extends TableData>(options: UseNuGridGroupVirtualizationOptions<T>): {
+    groupingRowHeights: ComputedRef<Required<GroupingVirtualRowHeights>>;
+    headerGroupCount: ComputedRef<number>;
+    virtualRowItems: ComputedRef<GroupVirtualRowItem<T>[]>;
+    virtualizer: Ref<NuGridVirtualizer<Element, Element>, NuGridVirtualizer<Element, Element>> | null;
+    virtualizationEnabled: ComputedRef<boolean>;
+    activeStickyIndexes: Ref<number[], number[]>;
+    activeStickyHeight: ComputedRef<number>;
+    measuredVirtualSizes: ComputedRef<Map<number, number> | null>;
+    getVirtualItemHeight: (index: number) => number;
+    stickyOffsets: ComputedRef<Map<number, number>>;
+};
+/**
+ * Virtualization for large datasets (non-grouped grids)
+ */
+export interface UseNuGridVirtualizationOptions<T extends TableData> {
+    props: MaybeRefOrGetter<NuGridProps<T>>;
+    rows: ComputedRef<Row<T>[]>;
+    tableApi: Table<T>;
+    rootRef: Ref<InstanceType<typeof Primitive> | null | undefined>;
+    stickyEnabled?: Ref<boolean>;
+    hasFooter?: MaybeRefOrGetter<boolean>;
+}
+export declare function useNuGridVirtualization<T extends TableData>(options: UseNuGridVirtualizationOptions<T>): SharedVirtualizerResult<T>;
+/**
+ * Virtualization for standard group mode (column headers once at top, group subheaders between rows)
+ */
+export declare function useNuGridStandardGroupVirtualization<T extends TableData>(options: UseNuGridGroupVirtualizationOptions<T>): {
+    groupingRowHeights: ComputedRef<Required<GroupingVirtualRowHeights>>;
+    headerGroupCount: ComputedRef<number>;
+    virtualRowItems: ComputedRef<GroupVirtualRowItem<T>[]>;
+    virtualizer: Ref<NuGridVirtualizer<Element, Element>, NuGridVirtualizer<Element, Element>> | null;
+    virtualizationEnabled: ComputedRef<boolean>;
+    activeStickyIndexes: Ref<number[], number[]>;
+    activeStickyHeight: ComputedRef<number>;
+    measuredVirtualSizes: ComputedRef<Map<number, number> | null>;
+    getVirtualItemHeight: (index: number) => number;
+    stickyOffsets: ComputedRef<Map<number, number>>;
+};

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

@@ -0,0 +1,534 @@
+import { defaultRangeExtractor, useVirtualizer } from "@tanstack/vue-virtual";
+import { breakpointsTailwind, useBreakpoints } from "@vueuse/core";
+import { computed, ref, toValue, watch } from "vue";
+import { nuGridDefaults } from "../../config/_internal/index.js";
+function resolveOverscanForBreakpoint(overscan, currentBreakpoint, fallback) {
+  if (overscan === void 0) {
+    return fallback;
+  }
+  if (typeof overscan === "number") {
+    return overscan;
+  }
+  if (currentBreakpoint && overscan[currentBreakpoint] !== void 0) {
+    return overscan[currentBreakpoint];
+  }
+  if (overscan.default !== void 0) {
+    return overscan.default;
+  }
+  const firstValue = Object.values(overscan).find((value) => typeof value === "number");
+  return typeof firstValue === "number" ? firstValue : fallback;
+}
+function useNuGridBreakpointKey() {
+  const breakpoints = useBreakpoints(breakpointsTailwind);
+  const current = breakpoints.current();
+  return computed(() => {
+    const value = current.value;
+    if (Array.isArray(value)) {
+      return value[0];
+    }
+    return value ?? void 0;
+  });
+}
+export function resolveVirtualizationOptions(virtualization, defaultEstimateSize = nuGridDefaults.virtualization.estimateSize, currentBreakpoint) {
+  const defaults = nuGridDefaults.virtualization;
+  const options = typeof virtualization === "object" && virtualization !== null ? virtualization : void 0;
+  const enabled = virtualization === true || (typeof virtualization === "object" && virtualization !== null ? options?.enabled !== false : false);
+  const rowHeights = resolveRowHeights(
+    options?.rowHeights,
+    defaults.rowHeights ?? {}
+  );
+  const estimateSize = options?.estimateSize ?? defaultEstimateSize ?? defaults.estimateSize;
+  const overscanSetting = options?.overscanByBreakpoint ?? options?.overscan ?? defaults.overscanByBreakpoint ?? defaults.overscan;
+  const overscan = resolveOverscanForBreakpoint(
+    overscanSetting,
+    currentBreakpoint,
+    defaults.overscan ?? defaultEstimateSize ?? 12
+  );
+  const overscanByBreakpoint = options?.overscanByBreakpoint ?? (typeof options?.overscan === "object" && options.overscan !== null ? options.overscan : defaults.overscanByBreakpoint);
+  const dynamicRowHeights = typeof options?.dynamicRowHeights === "boolean" ? options.dynamicRowHeights : options?.rowHeights ? false : defaults.dynamicRowHeights;
+  return {
+    ...options,
+    enabled,
+    estimateSize,
+    overscan,
+    overscanByBreakpoint,
+    dynamicRowHeights,
+    rowHeights
+  };
+}
+function resolveRowHeights(rowHeights, defaults) {
+  return {
+    groupHeader: rowHeights?.groupHeader ?? defaults.groupHeader,
+    columnHeader: rowHeights?.columnHeader ?? defaults.columnHeader,
+    dataRow: rowHeights?.dataRow ?? defaults.dataRow,
+    footer: rowHeights?.footer ?? defaults.footer
+  };
+}
+export function useNuGridGroupVirtualization(options) {
+  const props = computed(() => toValue(options.props));
+  const currentBreakpoint = useNuGridBreakpointKey();
+  const virtualization = computed(
+    () => resolveVirtualizationOptions(props.value.virtualization, 80, currentBreakpoint.value)
+  );
+  const groupingRowHeights = computed(() => virtualization.value.rowHeights);
+  const headerGroupCount = computed(() => options.tableApi.getHeaderGroups().length);
+  const getColumnHeadersHeight = (expanded) => {
+    const columnHeaderHeight = groupingRowHeights.value.columnHeader;
+    if (!expanded) {
+      return columnHeaderHeight;
+    }
+    return headerGroupCount.value * columnHeaderHeight;
+  };
+  function processGroupRecursively(groupRow, items, indexRef, heights, parentExpanded = true, depth = 0) {
+    const groupId = groupRow.id;
+    const expanded = options.isGroupExpanded(groupId);
+    if (!parentExpanded) {
+      return;
+    }
+    items.push({
+      type: "group-header",
+      height: heights.groupHeader,
+      groupId,
+      groupRow,
+      index: indexRef.value++,
+      depth
+    });
+    if (!expanded) {
+      items.push({
+        type: "column-headers",
+        height: getColumnHeadersHeight(false),
+        groupId,
+        index: indexRef.value++
+      });
+      items.push({
+        type: "footer",
+        height: heights.footer,
+        groupId,
+        index: indexRef.value++
+      });
+    } else {
+      items.push({
+        type: "column-headers",
+        height: getColumnHeadersHeight(true),
+        groupId,
+        index: indexRef.value++
+      });
+      const addRowPosition = options.addRowOptions?.addRowPosition.value ?? "none";
+      const addRowRow = options.addRowOptions?.getAddRowForGroup?.(groupId) || null;
+      if (addRowRow && addRowPosition === "top") {
+        items.push({
+          type: "data",
+          height: heights.dataRow,
+          groupId,
+          dataRow: addRowRow,
+          index: indexRef.value++,
+          depth
+        });
+      }
+      if (groupRow.subRows && groupRow.subRows.length > 0) {
+        groupRow.subRows.forEach((subRow) => {
+          if (subRow.getIsGrouped()) {
+            processGroupRecursively(subRow, items, indexRef, heights, expanded, depth + 1);
+          } else {
+            items.push({
+              type: "data",
+              height: heights.dataRow,
+              groupId,
+              dataRow: subRow,
+              index: indexRef.value++,
+              depth
+            });
+          }
+        });
+      }
+      if (addRowRow && addRowPosition === "bottom") {
+        items.push({
+          type: "data",
+          height: heights.dataRow,
+          groupId,
+          dataRow: addRowRow,
+          index: indexRef.value++,
+          depth
+        });
+      }
+      items.push({
+        type: "footer",
+        height: heights.footer,
+        groupId,
+        index: indexRef.value++
+      });
+    }
+  }
+  const virtualRowItems = computed(() => {
+    const items = [];
+    const index = 0;
+    const heights = groupingRowHeights.value;
+    const indexRef = { value: index };
+    options.topLevelRows.value.forEach((row) => {
+      if (row.getIsGrouped()) {
+        processGroupRecursively(row, items, indexRef, heights, true, 0);
+      }
+    });
+    return items;
+  });
+  const {
+    virtualizer,
+    virtualizationEnabled,
+    activeStickyIndexes,
+    activeStickyHeight,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  } = useSharedVirtualizer({
+    virtualization,
+    rootRef: options.rootRef,
+    stickyEnabled: options.stickyEnabled,
+    virtualRowItems,
+    resolveStickyIndexes: ({ range, items }) => resolveGroupStickyIndexes(range, items)
+  });
+  return {
+    groupingRowHeights,
+    headerGroupCount,
+    virtualRowItems,
+    virtualizer,
+    virtualizationEnabled,
+    activeStickyIndexes,
+    activeStickyHeight,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  };
+}
+export function useNuGridVirtualization(options) {
+  const props = computed(() => toValue(options.props));
+  const rows = computed(() => options.rows.value);
+  const headerGroupCount = computed(() => options.tableApi.getHeaderGroups().length);
+  const hasFooter = computed(() => toValue(options.hasFooter ?? false));
+  const currentBreakpoint = useNuGridBreakpointKey();
+  const virtualization = computed(
+    () => resolveVirtualizationOptions(props.value.virtualization, 65, currentBreakpoint.value)
+  );
+  const rowHeights = computed(() => virtualization.value.rowHeights);
+  const virtualRowItems = computed(() => {
+    const items = [];
+    let index = 0;
+    items.push({
+      type: "column-headers",
+      height: rowHeights.value.columnHeader * Math.max(headerGroupCount.value, 1),
+      index: index++
+    });
+    rows.value.forEach((row) => {
+      items.push({
+        type: "data",
+        height: rowHeights.value.dataRow,
+        dataRow: row,
+        index: index++
+      });
+    });
+    if (hasFooter.value) {
+      items.push({
+        type: "footer",
+        height: rowHeights.value.footer,
+        index: index++
+      });
+    }
+    return items;
+  });
+  const shared = useSharedVirtualizer({
+    virtualization,
+    rootRef: options.rootRef,
+    stickyEnabled: options.stickyEnabled,
+    virtualRowItems,
+    resolveStickyIndexes: () => {
+      if (!options.stickyEnabled?.value) {
+        return [];
+      }
+      return [0];
+    }
+  });
+  return shared;
+}
+function useSharedVirtualizer(options) {
+  const virtualizerProps = computed(() => {
+    const {
+      enabled: _enabled,
+      rowHeights: _rowHeights,
+      dynamicRowHeights: _dyn,
+      overscanByBreakpoint: _overscanMap,
+      ...rest
+    } = options.virtualization.value;
+    return rest;
+  });
+  const virtualizationEnabled = computed(() => options.virtualization.value.enabled);
+  const activeStickyIndexes = ref([]);
+  if (!virtualizationEnabled.value) {
+    const measuredVirtualSizes2 = computed(() => null);
+    const getVirtualItemHeight2 = (index) => options.virtualRowItems.value[index]?.height ?? 0;
+    const stickyOffsets2 = computed(() => /* @__PURE__ */ new Map());
+    const activeStickyHeight2 = computed(() => {
+      let total = 0;
+      for (const index of activeStickyIndexes.value) {
+        total += getVirtualItemHeight2(index);
+      }
+      return total;
+    });
+    return {
+      virtualizer: null,
+      virtualizationEnabled,
+      activeStickyIndexes,
+      activeStickyHeight: activeStickyHeight2,
+      virtualRowItems: options.virtualRowItems,
+      measuredVirtualSizes: measuredVirtualSizes2,
+      getVirtualItemHeight: getVirtualItemHeight2,
+      stickyOffsets: stickyOffsets2
+    };
+  }
+  const baseVirtualizer = useVirtualizer({
+    ...virtualizerProps.value,
+    get count() {
+      return options.virtualRowItems.value.length;
+    },
+    getScrollElement: () => options.rootRef.value?.$el,
+    estimateSize: (index) => {
+      const item = options.virtualRowItems.value[index];
+      return item?.height ?? virtualizerProps.value.estimateSize;
+    },
+    rangeExtractor: (range) => {
+      if (!options.stickyEnabled?.value || !options.resolveStickyIndexes) {
+        activeStickyIndexes.value = [];
+        return defaultRangeExtractor(range);
+      }
+      const sticky = options.resolveStickyIndexes({ range, items: options.virtualRowItems.value });
+      activeStickyIndexes.value = sticky;
+      if (!sticky.length) {
+        return defaultRangeExtractor(range);
+      }
+      const merged = /* @__PURE__ */ new Set([...sticky, ...defaultRangeExtractor(range)]);
+      return [...merged];
+    }
+  });
+  const virtualizer = baseVirtualizer;
+  const dynamicRowHeightsEnabled = computed(() => options.virtualization.value.dynamicRowHeights);
+  virtualizer.value.props = options.virtualization;
+  virtualizer.value.dynamicRowHeightsEnabled = dynamicRowHeightsEnabled;
+  if (options.stickyEnabled) {
+    watch(options.stickyEnabled, () => {
+      virtualizer.value?.measure();
+    });
+  }
+  const measuredVirtualSizes = computed(() => {
+    if (!dynamicRowHeightsEnabled.value) {
+      return null;
+    }
+    const map = /* @__PURE__ */ new Map();
+    virtualizer.value.getVirtualItems().forEach((virtualItem) => {
+      map.set(virtualItem.index, virtualItem.size);
+    });
+    return map;
+  });
+  const getVirtualItemHeight = (index) => {
+    const fallbackHeight = options.virtualRowItems.value[index]?.height ?? 0;
+    if (!dynamicRowHeightsEnabled.value) {
+      return fallbackHeight;
+    }
+    return measuredVirtualSizes.value?.get(index) ?? fallbackHeight;
+  };
+  const stickyOffsets = computed(() => {
+    if (!options.stickyEnabled?.value || !activeStickyIndexes.value.length) {
+      return /* @__PURE__ */ new Map();
+    }
+    const offsets = /* @__PURE__ */ new Map();
+    let topOffset = 0;
+    activeStickyIndexes.value.forEach((stickyIndex) => {
+      offsets.set(stickyIndex, topOffset);
+      topOffset += getVirtualItemHeight(stickyIndex);
+    });
+    return offsets;
+  });
+  const activeStickyHeight = computed(() => {
+    let total = 0;
+    for (const index of activeStickyIndexes.value) {
+      total += getVirtualItemHeight(index);
+    }
+    return total;
+  });
+  return {
+    virtualizer,
+    virtualizationEnabled,
+    activeStickyIndexes,
+    activeStickyHeight,
+    virtualRowItems: options.virtualRowItems,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  };
+}
+function resolveGroupStickyIndexes(range, items) {
+  const activeStickySet = /* @__PURE__ */ new Set();
+  const groupHeaderIndexes = items.map((item, index) => item.type === "group-header" ? index : -1).filter((index) => index !== -1);
+  let activeGroupHeaderIndex;
+  for (let i = groupHeaderIndexes.length - 1; i >= 0; i--) {
+    const headerIndex = groupHeaderIndexes[i];
+    if (headerIndex !== void 0 && headerIndex <= range.startIndex) {
+      activeGroupHeaderIndex = headerIndex;
+      break;
+    }
+  }
+  if (activeGroupHeaderIndex === void 0 && groupHeaderIndexes.length > 0) {
+    activeGroupHeaderIndex = groupHeaderIndexes[0];
+  }
+  if (activeGroupHeaderIndex !== void 0) {
+    activeStickySet.add(activeGroupHeaderIndex);
+    let nextIndex = activeGroupHeaderIndex + 1;
+    while (nextIndex < items.length) {
+      const item = items[nextIndex];
+      if (item?.type === "column-headers") {
+        activeStickySet.add(nextIndex);
+        break;
+      } else if (item?.type === "group-header") {
+        break;
+      }
+      nextIndex++;
+    }
+  }
+  return Array.from(activeStickySet);
+}
+export function useNuGridStandardGroupVirtualization(options) {
+  const props = computed(() => toValue(options.props));
+  const currentBreakpoint = useNuGridBreakpointKey();
+  const virtualization = computed(
+    () => resolveVirtualizationOptions(props.value.virtualization, 80, currentBreakpoint.value)
+  );
+  const groupingRowHeights = computed(() => virtualization.value.rowHeights);
+  const headerGroupCount = computed(() => options.tableApi.getHeaderGroups().length);
+  const getColumnHeadersHeight = () => {
+    const columnHeaderHeight = groupingRowHeights.value.columnHeader;
+    return headerGroupCount.value * columnHeaderHeight;
+  };
+  function processGroupRecursively(groupRow, items, indexRef, heights, parentExpanded = true, depth = 0) {
+    const groupId = groupRow.id;
+    const expanded = options.isGroupExpanded(groupId);
+    if (!parentExpanded) {
+      return;
+    }
+    items.push({
+      type: "group-header",
+      height: heights.groupHeader,
+      groupId,
+      groupRow,
+      index: indexRef.value++,
+      depth
+    });
+    if (expanded) {
+      const addRowPosition = options.addRowOptions?.addRowPosition.value ?? "none";
+      const addRowRow = options.addRowOptions?.getAddRowForGroup?.(groupId) || null;
+      if (addRowRow && addRowPosition === "top") {
+        items.push({
+          type: "data",
+          height: heights.dataRow,
+          groupId,
+          dataRow: addRowRow,
+          index: indexRef.value++,
+          depth
+        });
+      }
+      if (groupRow.subRows && groupRow.subRows.length > 0) {
+        groupRow.subRows.forEach((subRow) => {
+          if (subRow.getIsGrouped()) {
+            processGroupRecursively(subRow, items, indexRef, heights, expanded, depth + 1);
+          } else {
+            items.push({
+              type: "data",
+              height: heights.dataRow,
+              groupId,
+              dataRow: subRow,
+              index: indexRef.value++,
+              depth
+            });
+          }
+        });
+      }
+      if (addRowRow && addRowPosition === "bottom") {
+        items.push({
+          type: "data",
+          height: heights.dataRow,
+          groupId,
+          dataRow: addRowRow,
+          index: indexRef.value++,
+          depth
+        });
+      }
+    }
+  }
+  const virtualRowItems = computed(() => {
+    const items = [];
+    const index = 0;
+    const heights = groupingRowHeights.value;
+    const indexRef = { value: index };
+    items.push({
+      type: "column-headers",
+      height: getColumnHeadersHeight(),
+      index: indexRef.value++
+    });
+    options.topLevelRows.value.forEach((row) => {
+      if (row.getIsGrouped()) {
+        processGroupRecursively(row, items, indexRef, heights, true, 0);
+      }
+    });
+    items.push({
+      type: "footer",
+      height: heights.footer,
+      index: indexRef.value++
+    });
+    return items;
+  });
+  const {
+    virtualizer,
+    virtualizationEnabled,
+    activeStickyIndexes,
+    activeStickyHeight,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  } = useSharedVirtualizer({
+    virtualization,
+    rootRef: options.rootRef,
+    stickyEnabled: options.stickyEnabled,
+    virtualRowItems,
+    resolveStickyIndexes: ({ range, items }) => resolveStandardGroupStickyIndexes(range, items)
+  });
+  return {
+    groupingRowHeights,
+    headerGroupCount,
+    virtualRowItems,
+    virtualizer,
+    virtualizationEnabled,
+    activeStickyIndexes,
+    activeStickyHeight,
+    measuredVirtualSizes,
+    getVirtualItemHeight,
+    stickyOffsets
+  };
+}
+function resolveStandardGroupStickyIndexes(range, items) {
+  const activeStickySet = /* @__PURE__ */ new Set();
+  if (items[0]?.type === "column-headers") {
+    activeStickySet.add(0);
+  }
+  const groupHeaderIndexes = items.map((item, index) => item.type === "group-header" ? index : -1).filter((index) => index !== -1);
+  let activeGroupHeaderIndex;
+  for (let i = groupHeaderIndexes.length - 1; i >= 0; i--) {
+    const headerIndex = groupHeaderIndexes[i];
+    if (headerIndex !== void 0 && headerIndex <= range.startIndex) {
+      activeGroupHeaderIndex = headerIndex;
+      break;
+    }
+  }
+  if (activeGroupHeaderIndex === void 0 && groupHeaderIndexes.length > 0) {
+    activeGroupHeaderIndex = groupHeaderIndexes[0];
+  }
+  if (activeGroupHeaderIndex !== void 0) {
+    activeStickySet.add(activeGroupHeaderIndex);
+  }
+  return Array.from(activeStickySet).sort((a, b) => a - b);
+}

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

@@ -0,0 +1,25 @@
+export interface UseNuGridWheelSmoothingOptions {
+    threshold?: number;
+    /** Maximum scroll speed in px/sec for intercepted wheel input */
+    maxVelocityPxPerSec?: number;
+    /** Maximum scroll speed in px/sec for touchpad input (small deltas) */
+    maxVelocityPxPerSecTouchpad?: number;
+    /** Delta threshold to distinguish touchpad (below) from mouse wheel (above) */
+    touchpadDeltaThreshold?: number;
+    /** How long (ms) after the last wheel event before we cancel any remaining momentum */
+    stopOnInactivityMs?: number;
+    /** Fraction of pending delta applied each frame (lower = smoother) */
+    smoothingFactor?: number;
+    /** Minimum px to apply per frame when pending exists (avoids stutter) */
+    minStepPx?: number;
+    /** Enable adaptive smoothing based on recent velocity */
+    adaptive?: boolean;
+}
+/**
+ * Smooths bursty mouse-wheel events by batching them into rAF-driven scrolls and
+ * optionally caps their speed so mouse wheels cannot spike scroll velocity.
+ * Only intercepts large pixel-mode deltas to avoid affecting trackpads.
+ */
+export declare function useNuGridWheelSmoothing(containerRef: {
+    value: HTMLElement | null;
+}, options?: UseNuGridWheelSmoothingOptions): void;