@mui/x-data-grid-generator 8.0.0-beta.3 → 8.1.0

package/modern/constants/prompts.js

@@ -1,49 +0,0 @@
-export const mockPrompts = new Map([['sort by name', {
-  select: -1,
-  filters: [],
-  aggregation: {},
-  sorting: [{
-    column: 'name',
-    direction: 'asc'
-  }],
-  grouping: [],
-  error: null
-}], ['sort by company name and employee name', {
-  select: -1,
-  filters: [],
-  aggregation: {},
-  sorting: [{
-    column: 'company',
-    direction: 'asc'
-  }, {
-    column: 'name',
-    direction: 'asc'
-  }],
-  grouping: [],
-  error: null
-}], ['show people from the eu', {
-  select: -1,
-  filters: [{
-    column: 'country',
-    operator: 'isAnyOf',
-    value: ['AT', 'BE', 'BG', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GR', 'HR', 'HU', 'IE', 'IT', 'LT', 'LU', 'LV', 'MT', 'NL', 'PL', 'PT', 'RO', 'SE', 'SI', 'SK']
-  }],
-  aggregation: {},
-  sorting: [],
-  grouping: [],
-  error: null
-}], ['order companies by amount of people', {
-  select: -1,
-  filters: [],
-  aggregation: {
-    id: 'size'
-  },
-  sorting: [{
-    column: 'id',
-    direction: 'desc'
-  }],
-  grouping: [{
-    column: 'company'
-  }],
-  error: null
-}]]);

package/modern/hooks/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./useDemoData.js";
-export * from "./useBasicDemoData.js";
-export { useMovieData } from "./useMovieData.js";
-export type { Movie } from './useMovieData';
-export * from "./useQuery.js";
-export * from "./useMockServer.js";
-export { loadServerRows } from "./serverUtils.js";
-export type { QueryOptions } from './serverUtils';

package/modern/hooks/index.js

@@ -1,6 +0,0 @@
-export * from "./useDemoData.js";
-export * from "./useBasicDemoData.js";
-export { useMovieData } from "./useMovieData.js";
-export * from "./useQuery.js";
-export * from "./useMockServer.js";
-export { loadServerRows } from "./serverUtils.js";

package/modern/hooks/serverUtils.d.ts

@@ -1,61 +0,0 @@
-import { GridRowModel, GridFilterModel, GridSortModel, GridColDef, GridRowId, GridPaginationModel, GridValidRowModel, GridAggregationModel } from '@mui/x-data-grid-premium';
-export interface FakeServerResponse {
-  returnedRows: GridRowModel[];
-  aggregateRow?: GridValidRowModel;
-  nextCursor?: string;
-  hasNextPage?: boolean;
-  totalRowCount: number;
-}
-export interface PageInfo {
-  totalRowCount?: number;
-  nextCursor?: string;
-  hasNextPage?: boolean;
-  pageSize?: number;
-}
-export interface DefaultServerOptions {
-  minDelay: number;
-  maxDelay: number;
-  useCursorPagination?: boolean;
-}
-export type ServerOptions = Partial<DefaultServerOptions>;
-export interface QueryOptions {
-  cursor?: GridRowId;
-  page?: number;
-  pageSize?: number;
-  filterModel?: GridFilterModel;
-  aggregationModel?: GridAggregationModel;
-  sortModel?: GridSortModel;
-  start?: number;
-  end?: number;
-}
-export interface ServerSideQueryOptions {
-  cursor?: GridRowId;
-  paginationModel?: GridPaginationModel;
-  groupKeys?: string[];
-  filterModel?: GridFilterModel;
-  sortModel?: GridSortModel;
-  aggregationModel?: GridAggregationModel;
-  start?: number;
-  end?: number;
-  groupFields?: string[];
-}
-export declare const disableDelay: any;
-export declare const DEFAULT_SERVER_OPTIONS: DefaultServerOptions;
-/**
- * Simulates server data loading
- */
-export declare const loadServerRows: (rows: GridRowModel[], queryOptions: QueryOptions, serverOptions: ServerOptions, columnsWithDefaultColDef: GridColDef[]) => Promise<FakeServerResponse>;
-interface NestedDataRowsResponse {
-  rows: GridRowModel[];
-  rootRowCount: number;
-  aggregateRow?: GridRowModel;
-}
-/**
- * Simulates server data for tree-data feature
- */
-export declare const processTreeDataRows: (rows: GridRowModel[], queryOptions: ServerSideQueryOptions, serverOptions: ServerOptions, columnsWithDefaultColDef: GridColDef[]) => Promise<NestedDataRowsResponse>;
-/**
- * Simulates server data for row grouping feature
- */
-export declare const processRowGroupingRows: (rows: GridValidRowModel[], queryOptions: ServerSideQueryOptions, serverOptions: ServerOptions, columnsWithDefaultColDef: GridColDef[]) => Promise<NestedDataRowsResponse>;
-export {};

package/modern/hooks/serverUtils.js

@@ -1,527 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { GridLogicOperator, GRID_AGGREGATION_FUNCTIONS } from '@mui/x-data-grid-premium';
-import { randomInt } from "../services/random-generator.js";
-const getAvailableAggregationFunctions = columnType => {
-  const availableAggregationFunctions = new Map();
-  Object.keys(GRID_AGGREGATION_FUNCTIONS).forEach(functionName => {
-    const columnTypes = GRID_AGGREGATION_FUNCTIONS[functionName].columnTypes;
-    if (!columnTypes || columnTypes.includes(columnType ?? 'string')) {
-      availableAggregationFunctions.set(functionName, GRID_AGGREGATION_FUNCTIONS[functionName]);
-    }
-  });
-  return availableAggregationFunctions;
-};
-export const disableDelay = typeof DISABLE_CHANCE_RANDOM !== 'undefined' && DISABLE_CHANCE_RANDOM;
-export const DEFAULT_SERVER_OPTIONS = {
-  minDelay: disableDelay ? 0 : 100,
-  maxDelay: disableDelay ? 0 : 300,
-  useCursorPagination: true
-};
-const apiRef = {};
-const simplifiedValueGetter = (field, colDef) => row => {
-  return colDef.valueGetter?.(row[row.id], row, colDef, apiRef) || row[field];
-};
-const getRowComparator = (sortModel, columnsWithDefaultColDef) => {
-  if (!sortModel) {
-    const comparator = () => 0;
-    return comparator;
-  }
-  const sortOperators = sortModel.map(sortItem => {
-    const columnField = sortItem.field;
-    const colDef = columnsWithDefaultColDef.find(({
-      field
-    }) => field === columnField);
-    return _extends({}, sortItem, {
-      valueGetter: simplifiedValueGetter(columnField, colDef),
-      sortComparator: colDef.sortComparator
-    });
-  });
-  const comparator = (row1, row2) => sortOperators.reduce((acc, {
-    valueGetter,
-    sort,
-    sortComparator
-  }) => {
-    if (acc !== 0) {
-      return acc;
-    }
-    const v1 = valueGetter(row1);
-    const v2 = valueGetter(row2);
-    return sort === 'desc' ? -1 * sortComparator(v1, v2) : sortComparator(v1, v2);
-  }, 0);
-  return comparator;
-};
-const buildQuickFilterApplier = (filterModel, columns) => {
-  const quickFilterValues = filterModel.quickFilterValues?.filter(Boolean) ?? [];
-  if (quickFilterValues.length === 0) {
-    return null;
-  }
-  const appliersPerField = [];
-  const stubApiRef = {
-    current: {
-      getRowFormattedValue: (row, c) => {
-        const field = c.field;
-        return row[field];
-      }
-    }
-  };
-  columns.forEach(column => {
-    const getApplyQuickFilterFn = column?.getApplyQuickFilterFn;
-    if (getApplyQuickFilterFn) {
-      appliersPerField.push({
-        column,
-        appliers: quickFilterValues.map(quickFilterValue => {
-          return {
-            fn: getApplyQuickFilterFn(quickFilterValue, column, stubApiRef)
-          };
-        })
-      });
-    }
-  });
-  return function isRowMatchingQuickFilter(row, shouldApplyFilter) {
-    const result = {};
-
-    /* eslint-disable no-labels */
-    outer: for (let v = 0; v < quickFilterValues.length; v += 1) {
-      const filterValue = quickFilterValues[v];
-      for (let i = 0; i < appliersPerField.length; i += 1) {
-        const {
-          column,
-          appliers
-        } = appliersPerField[i];
-        const {
-          field
-        } = column;
-        if (shouldApplyFilter && !shouldApplyFilter(field)) {
-          continue;
-        }
-        const applier = appliers[v];
-        const value = row[field];
-        if (applier.fn === null) {
-          continue;
-        }
-        const isMatching = applier.fn(value, row, column, stubApiRef);
-        if (isMatching) {
-          result[filterValue] = true;
-          continue outer;
-        }
-      }
-      result[filterValue] = false;
-    }
-    /* eslint-enable no-labels */
-
-    return result;
-  };
-};
-const getQuicklyFilteredRows = (rows, filterModel, columnsWithDefaultColDef) => {
-  if (filterModel === undefined || filterModel.quickFilterValues?.length === 0) {
-    return rows;
-  }
-  const isRowMatchingQuickFilter = buildQuickFilterApplier(filterModel, columnsWithDefaultColDef);
-  if (isRowMatchingQuickFilter) {
-    return rows.filter(row => {
-      const result = isRowMatchingQuickFilter(row);
-      return filterModel.quickFilterLogicOperator === GridLogicOperator.And ? Object.values(result).every(Boolean) : Object.values(result).some(Boolean);
-    });
-  }
-  return rows;
-};
-const getFilteredRows = (rows, filterModel, columnsWithDefaultColDef) => {
-  if (filterModel === undefined || filterModel.items.length === 0) {
-    return rows;
-  }
-  const valueGetters = filterModel.items.map(({
-    field
-  }) => simplifiedValueGetter(field, columnsWithDefaultColDef.find(column => column.field === field)));
-  const filterFunctions = filterModel.items.map(filterItem => {
-    const {
-      field,
-      operator
-    } = filterItem;
-    const colDef = columnsWithDefaultColDef.find(column => column.field === field);
-    if (!colDef.filterOperators) {
-      throw new Error(`MUI: No filter operator found for column '${field}'.`);
-    }
-    const filterOperator = colDef.filterOperators.find(({
-      value
-    }) => operator === value);
-    let parsedValue = filterItem.value;
-    if (colDef.valueParser) {
-      const parser = colDef.valueParser;
-      parsedValue = Array.isArray(filterItem.value) ? filterItem.value?.map(x => parser(x, {}, colDef, apiRef)) : parser(filterItem.value, {}, colDef, apiRef);
-    }
-    return filterOperator.getApplyFilterFn({
-      filterItem,
-      value: parsedValue
-    }, colDef);
-  });
-  if (filterModel.logicOperator === GridLogicOperator.Or) {
-    return rows.filter(row => filterModel.items.some((_, index) => {
-      const value = valueGetters[index](row);
-      return filterFunctions[index] === null ? true : filterFunctions[index](value);
-    }));
-  }
-  return rows.filter(row => filterModel.items.every((_, index) => {
-    const value = valueGetters[index](row);
-    return filterFunctions[index] === null ? true : filterFunctions[index](value);
-  }));
-};
-const applyAggregation = (aggregationModel, colDefs, rows, groupId = 'root') => {
-  const columnsToAggregate = Object.keys(aggregationModel);
-  if (columnsToAggregate.length === 0) {
-    return {};
-  }
-  const aggregateValues = {};
-  columnsToAggregate.forEach(field => {
-    const type = colDefs.find(({
-      field: f
-    }) => f === field)?.type;
-    if (!type) {
-      return;
-    }
-    const availableAggregationFunctions = getAvailableAggregationFunctions(type);
-    if (!availableAggregationFunctions.has(aggregationModel[field])) {
-      return;
-    }
-    const aggregationFunction = availableAggregationFunctions.get(aggregationModel[field]);
-    if (!aggregationFunction) {
-      return;
-    }
-    const values = rows.map(row => row[field]);
-    aggregateValues[`${field}Aggregate`] = aggregationFunction.apply({
-      values,
-      field,
-      groupId
-    });
-  });
-  return aggregateValues;
-};
-
-/**
- * Simulates server data loading
- */
-export const loadServerRows = (rows, queryOptions, serverOptions, columnsWithDefaultColDef) => {
-  const {
-    minDelay = 100,
-    maxDelay = 300,
-    useCursorPagination
-  } = serverOptions;
-  if (maxDelay < minDelay) {
-    throw new Error('serverOptions.minDelay is larger than serverOptions.maxDelay ');
-  }
-  const delay = randomInt(minDelay, maxDelay);
-  const {
-    cursor,
-    page = 0,
-    pageSize,
-    start,
-    end
-  } = queryOptions;
-  let nextCursor;
-  let firstRowIndex;
-  let lastRowIndex;
-  let filteredRows = getFilteredRows(rows, queryOptions.filterModel, columnsWithDefaultColDef);
-  const rowComparator = getRowComparator(queryOptions.sortModel, columnsWithDefaultColDef);
-  filteredRows = [...filteredRows].sort(rowComparator);
-  let aggregateRow = {};
-  if (queryOptions.aggregationModel) {
-    aggregateRow = applyAggregation(queryOptions.aggregationModel, columnsWithDefaultColDef, filteredRows);
-  }
-  const totalRowCount = filteredRows.length;
-  if (start !== undefined && end !== undefined) {
-    firstRowIndex = start;
-    lastRowIndex = end;
-  } else if (!pageSize) {
-    firstRowIndex = 0;
-    lastRowIndex = filteredRows.length - 1;
-  } else if (useCursorPagination) {
-    firstRowIndex = cursor ? filteredRows.findIndex(({
-      id
-    }) => id === cursor) : 0;
-    firstRowIndex = Math.max(firstRowIndex, 0); // if cursor not found return 0
-    lastRowIndex = firstRowIndex + pageSize - 1;
-    nextCursor = filteredRows[lastRowIndex + 1]?.id;
-  } else {
-    firstRowIndex = page * pageSize;
-    lastRowIndex = (page + 1) * pageSize - 1;
-  }
-  const hasNextPage = lastRowIndex < filteredRows.length - 1;
-  const response = _extends({
-    returnedRows: filteredRows.slice(firstRowIndex, lastRowIndex + 1),
-    hasNextPage,
-    nextCursor,
-    totalRowCount
-  }, queryOptions.aggregationModel ? {
-    aggregateRow
-  } : {});
-  return new Promise(resolve => {
-    setTimeout(() => {
-      resolve(response);
-    }, delay); // simulate network latency
-  });
-};
-const findTreeDataRowChildren = (allRows, parentPath, pathKey = 'path', depth = 1, rowQualifier) => {
-  const parentDepth = parentPath.length;
-  const children = [];
-  for (let i = 0; i < allRows.length; i += 1) {
-    const row = allRows[i];
-    const rowPath = row[pathKey];
-    if (!rowPath) {
-      continue;
-    }
-    if ((depth < 0 && rowPath.length > parentDepth || rowPath.length === parentDepth + depth) && parentPath.every((value, index) => value === rowPath[index])) {
-      if (!rowQualifier || rowQualifier(row)) {
-        children.push(row);
-      }
-    }
-  }
-  return children;
-};
-const getTreeDataFilteredRows = (rows, filterModel, columnsWithDefaultColDef) => {
-  let filteredRows = [...rows];
-  if (filterModel && filterModel.quickFilterValues?.length > 0) {
-    filteredRows = getQuicklyFilteredRows(rows, filterModel, columnsWithDefaultColDef);
-  }
-  if ((filterModel?.items.length ?? 0) > 0) {
-    filteredRows = getFilteredRows(filteredRows, filterModel, columnsWithDefaultColDef);
-  }
-  if (filteredRows.length === rows.length || filteredRows.length === 0) {
-    return filteredRows;
-  }
-  const pathsToIndexesMap = new Map();
-  rows.forEach((row, index) => {
-    pathsToIndexesMap.set(row.path.join(','), index);
-  });
-  const includedPaths = new Set();
-  filteredRows.forEach(row => {
-    includedPaths.add(row.path.join(','));
-  });
-  const missingChildren = [];
-
-  // include missing children of filtered rows
-  filteredRows.forEach(row => {
-    const path = row.path;
-    if (path) {
-      const children = findTreeDataRowChildren(rows, path, 'path', -1);
-      children.forEach(child => {
-        const subPath = child.path.join(',');
-        if (!includedPaths.has(subPath)) {
-          missingChildren.push(child);
-        }
-      });
-    }
-  });
-  filteredRows = missingChildren.concat(filteredRows);
-  const missingParents = [];
-
-  // include missing parents of filtered rows
-  filteredRows.forEach(row => {
-    const path = row.path;
-    if (path) {
-      includedPaths.add(path.join(','));
-      for (let i = 0; i < path.length - 1; i += 1) {
-        const subPath = path.slice(0, i + 1).join(',');
-        if (!includedPaths.has(subPath)) {
-          const index = pathsToIndexesMap.get(subPath);
-          if (index !== undefined) {
-            missingParents.push(rows[index]);
-            includedPaths.add(subPath);
-          }
-        }
-      }
-    }
-  });
-  return missingParents.concat(filteredRows);
-};
-
-/**
- * Simulates server data for tree-data feature
- */
-export const processTreeDataRows = (rows, queryOptions, serverOptions, columnsWithDefaultColDef) => {
-  const {
-    minDelay = 100,
-    maxDelay = 300
-  } = serverOptions;
-  const pathKey = 'path';
-  // TODO: Support filtering and cursor based pagination
-  if (maxDelay < minDelay) {
-    throw new Error('serverOptions.minDelay is larger than serverOptions.maxDelay ');
-  }
-  if (queryOptions.groupKeys == null) {
-    throw new Error('serverOptions.groupKeys must be defined to compute tree data ');
-  }
-  const delay = randomInt(minDelay, maxDelay);
-
-  // apply plain filtering
-  const filteredRows = getTreeDataFilteredRows(rows, queryOptions.filterModel, columnsWithDefaultColDef);
-
-  // get root row count
-  const rootRowCount = findTreeDataRowChildren(filteredRows, []).length;
-
-  // find direct children referring to the `parentPath`
-  const childRows = findTreeDataRowChildren(filteredRows, queryOptions.groupKeys);
-  let childRowsWithDescendantCounts = childRows.map(row => {
-    const descendants = findTreeDataRowChildren(filteredRows, row[pathKey], pathKey, -1);
-    const descendantCount = descendants.length;
-    if (descendantCount > 0 && queryOptions.aggregationModel) {
-      // Parent row, compute aggregation
-      return _extends({}, row, {
-        descendantCount
-      }, applyAggregation(queryOptions.aggregationModel, columnsWithDefaultColDef, descendants, row.id));
-    }
-    return _extends({}, row, {
-      descendantCount
-    });
-  });
-  if (queryOptions.sortModel) {
-    // apply sorting
-    const rowComparator = getRowComparator(queryOptions.sortModel, columnsWithDefaultColDef);
-    childRowsWithDescendantCounts = [...childRowsWithDescendantCounts].sort(rowComparator);
-  }
-  let aggregateRow;
-  if (queryOptions.aggregationModel) {
-    aggregateRow = applyAggregation(queryOptions.aggregationModel, columnsWithDefaultColDef, filteredRows);
-  }
-  if (queryOptions.paginationModel && queryOptions.groupKeys.length === 0) {
-    // Only paginate root rows, grid should refetch root rows when `paginationModel` updates
-    const {
-      pageSize,
-      page
-    } = queryOptions.paginationModel;
-    if (pageSize < childRowsWithDescendantCounts.length) {
-      childRowsWithDescendantCounts = childRowsWithDescendantCounts.slice(page * pageSize, (page + 1) * pageSize);
-    }
-  }
-  return new Promise(resolve => {
-    setTimeout(() => {
-      resolve({
-        rows: childRowsWithDescendantCounts,
-        rootRowCount,
-        aggregateRow
-      });
-    }, delay); // simulate network latency
-  });
-};
-
-/**
- * Simulates server data for row grouping feature
- */
-export const processRowGroupingRows = (rows, queryOptions, serverOptions, columnsWithDefaultColDef) => {
-  const {
-    minDelay = 100,
-    maxDelay = 300
-  } = serverOptions;
-  const pathKey = 'path';
-  if (maxDelay < minDelay) {
-    throw new Error('serverOptions.minDelay is larger than serverOptions.maxDelay ');
-  }
-  if (queryOptions.groupKeys == null) {
-    throw new Error('serverOptions.groupKeys must be defined to compute row grouping data');
-  }
-  if (queryOptions.groupFields == null) {
-    throw new Error('serverOptions.groupFields must be defined to compute row grouping data');
-  }
-  const delay = randomInt(minDelay, maxDelay);
-  const pathsToAutogenerate = new Set();
-  let rowsWithPaths = rows;
-  const rowsWithMissingGroups = [];
-
-  // add paths and generate parent rows based on `groupFields`
-  const groupFields = queryOptions.groupFields;
-  if (groupFields.length > 0) {
-    rowsWithPaths = rows.reduce((acc, row) => {
-      const partialPath = groupFields.map(field => String(row[field]));
-      for (let index = 0; index < partialPath.length; index += 1) {
-        const value = partialPath[index];
-        if (value === undefined) {
-          if (index === 0) {
-            rowsWithMissingGroups.push(_extends({}, row, {
-              group: false
-            }));
-          }
-          return acc;
-        }
-        const parentPath = partialPath.slice(0, index + 1);
-        const strigifiedPath = parentPath.join(',');
-        if (!pathsToAutogenerate.has(strigifiedPath)) {
-          pathsToAutogenerate.add(strigifiedPath);
-        }
-      }
-      acc.push(_extends({}, row, {
-        path: [...partialPath, '']
-      }));
-      return acc;
-    }, []);
-  } else {
-    rowsWithPaths = rows.map(row => _extends({}, row, {
-      path: ['']
-    }));
-  }
-  const autogeneratedRows = Array.from(pathsToAutogenerate).map(path => {
-    const pathArray = path.split(',');
-    return {
-      id: `auto-generated-parent-${pathArray.join('-')}`,
-      path: pathArray.slice(0, pathArray.length),
-      group: pathArray.slice(-1)[0]
-    };
-  });
-
-  // apply plain filtering
-  const filteredRows = getTreeDataFilteredRows([...autogeneratedRows, ...rowsWithPaths, ...rowsWithMissingGroups], queryOptions.filterModel, columnsWithDefaultColDef);
-
-  // get root row count
-  const rootRows = findTreeDataRowChildren(filteredRows, []);
-  const rootRowCount = rootRows.length;
-  let filteredRowsWithMissingGroups = [];
-  let childRows = rootRows;
-  if (queryOptions.groupKeys.length === 0) {
-    filteredRowsWithMissingGroups = filteredRows.filter(({
-      group
-    }) => group === false);
-  } else {
-    childRows = findTreeDataRowChildren(filteredRows, queryOptions.groupKeys);
-  }
-  let childRowsWithDescendantCounts = childRows.map(row => {
-    const descendants = findTreeDataRowChildren(filteredRows, row[pathKey], pathKey, -1, ({
-      id
-    }) => typeof id !== 'string' || !id.startsWith('auto-generated-parent-'));
-    const descendantCount = descendants.length;
-    if (descendantCount > 0 && queryOptions.aggregationModel) {
-      // Parent row, compute aggregation
-      return _extends({}, row, {
-        descendantCount
-      }, applyAggregation(queryOptions.aggregationModel, columnsWithDefaultColDef, descendants, row.id));
-    }
-    return _extends({}, row, {
-      descendantCount
-    });
-  });
-  if (queryOptions.sortModel) {
-    const rowComparator = getRowComparator(queryOptions.sortModel, columnsWithDefaultColDef);
-    const sortedMissingGroups = [...filteredRowsWithMissingGroups].sort(rowComparator);
-    const sortedChildRows = [...childRowsWithDescendantCounts].sort(rowComparator);
-    childRowsWithDescendantCounts = [...sortedMissingGroups, ...sortedChildRows];
-  }
-  let aggregateRow;
-  if (queryOptions.aggregationModel) {
-    aggregateRow = applyAggregation(queryOptions.aggregationModel, columnsWithDefaultColDef, filteredRows);
-  }
-  if (queryOptions.paginationModel && queryOptions.groupKeys.length === 0) {
-    // Only paginate root rows, grid should refetch root rows when `paginationModel` updates
-    const {
-      pageSize,
-      page
-    } = queryOptions.paginationModel;
-    if (pageSize < childRowsWithDescendantCounts.length) {
-      childRowsWithDescendantCounts = childRowsWithDescendantCounts.slice(page * pageSize, (page + 1) * pageSize);
-    }
-  }
-  return new Promise(resolve => {
-    setTimeout(() => {
-      resolve({
-        rows: childRowsWithDescendantCounts,
-        rootRowCount,
-        aggregateRow
-      });
-    }, delay); // simulate network latency
-  });
-};

package/modern/hooks/useBasicDemoData.d.ts

@@ -1,2 +0,0 @@
-import { GridBasicData } from "../services/index.js";
-export declare const useBasicDemoData: (nbRows: number, nbCols: number) => GridBasicData;

package/modern/hooks/useBasicDemoData.js

@@ -1,5 +0,0 @@
-import * as React from 'react';
-import { getBasicGridData } from "../services/index.js";
-export const useBasicDemoData = (nbRows, nbCols) => {
-  return React.useMemo(() => getBasicGridData(nbRows, nbCols), [nbRows, nbCols]);
-};

package/modern/hooks/useDemoData.d.ts

@@ -1,30 +0,0 @@
-import { GridColumnVisibilityModel } from '@mui/x-data-grid-premium';
-import { GridDemoData } from "../services/real-data-service.js";
-import { GridColDefGenerator } from "../services/gridColDefGenerator.js";
-import { AddPathToDemoDataOptions, DemoTreeDataValue } from "../services/tree-data-generator.js";
-export type DemoDataReturnType = {
-  data: DemoTreeDataValue;
-  loading: boolean;
-  setRowLength: (count: number) => void;
-  loadNewData: () => void;
-};
-type DataSet = 'Commodity' | 'Employee';
-export interface UseDemoDataOptions {
-  dataSet: DataSet;
-  rowLength: number;
-  maxColumns?: number;
-  visibleFields?: string[];
-  editable?: boolean;
-  treeData?: AddPathToDemoDataOptions;
-}
-export declare function extrapolateSeed(rowLength: number, data: GridDemoData): Promise<GridDemoData>;
-export declare const deepFreeze: <T>(object: T) => T;
-export interface ColumnsOptions extends Pick<UseDemoDataOptions, 'dataSet' | 'editable' | 'maxColumns' | 'visibleFields'> {}
-export declare const getColumnsFromOptions: (options: ColumnsOptions) => GridColDefGenerator[];
-export declare const getInitialState: (options: UseDemoDataOptions, columns: GridColDefGenerator[]) => {
-  columns: {
-    columnVisibilityModel: GridColumnVisibilityModel;
-  };
-};
-export declare const useDemoData: (options: UseDemoDataOptions) => DemoDataReturnType;
-export {};