@teselagen/ui 0.8.6-beta.23 → 0.8.6-beta.24

package/DataTable/EditabelCell.d.ts

@@ -0,0 +1,7 @@
+export function EditableCell({ cancelEdit, dataTest, finishEdit, isNumeric, initialValue }: {
+    cancelEdit: any;
+    dataTest: any;
+    finishEdit: any;
+    isNumeric: any;
+    initialValue: any;
+}): import("react/jsx-runtime").JSX.Element;

package/DataTable/defaultProps.d.ts

@@ -0,0 +1,43 @@
+import { noop } from 'lodash-es';
+declare namespace _default {
+    export { noop as addFilters };
+    export let className: string;
+    export { noop as clearFilters };
+    export { noop as contextMenu };
+    export let disabled: boolean;
+    export let entities: never[];
+    export let extraClasses: string;
+    export let filters: never[];
+    export let isCopyable: boolean;
+    export { noop as isEntityDisabled };
+    export let isLoading: boolean;
+    export let isSimple: boolean;
+    export let isSingleSelect: boolean;
+    export let maxHeight: number;
+    export let noHeader: boolean;
+    export let noSelect: boolean;
+    export let noUserSelect: boolean;
+    export { noop as onDeselect };
+    export { noop as onMultiRowSelect };
+    export { noop as onRowClick };
+    export { noop as onRowSelect };
+    export { noop as onSingleRowSelect };
+    export let page: number;
+    export let pageSize: number;
+    export let reduxFormExpandedEntityIdMap: {};
+    export let reduxFormSearchInput: string;
+    export let reduxFormSelectedEntityIdMap: {};
+    export { noop as removeSingleFilter };
+    export let resized: never[];
+    export { noop as resizePersist };
+    export { noop as setFilter };
+    export { noop as setOrder };
+    export { noop as setPage };
+    export { noop as setPageSize };
+    export { noop as setSearchTerm };
+    export let showCount: boolean;
+    export let style: {};
+    export let withCheckboxes: boolean;
+    export let withSort: boolean;
+}
+export default _default;

package/DataTable/utils/computePresets.d.ts

@@ -0,0 +1 @@
+export default function computePresets(props?: {}): import('lodash').Dictionary<any>;

package/DataTable/utils/convertSchema.d.ts

@@ -1,3 +1,23 @@
-export function mergeSchemas(_originalSchema: any, _overrideSchema: any): any;
+type Field = {
+    type?: string;
+    displayName?: string;
+    path?: string;
+    filterDisabled?: boolean;
+    sortDisabled?: boolean;
+};
+type Schema = {
+    fields: (Field | string)[];
+};
+type CompleteField = Field & {
+    type: string;
+    displayName: string;
+    path: string;
+};
+type CompleteSchema = {
+    fields: CompleteField[];
+};
+declare const convertSchema: (schema: Schema) => CompleteSchema;
+export declare function mergeSchemas(_originalSchema: Schema, _overrideSchema: Schema): {
+    fields: CompleteField[];
+};
 export default convertSchema;
-declare function convertSchema(schema: any): any;

package/DataTable/utils/getAllRows.d.ts

@@ -1 +1 @@
-export function getAllRows(e: any): any;
+export function getAllRows(tableRef: any): any;

package/DataTable/utils/handleCopyColumn.d.ts

@@ -1 +1 @@
-export function handleCopyColumn(e: any, cellWrapper: any, selectedRecords: any): void;
+export function handleCopyColumn(tableRef: any, cellWrapper: any, selectedRecords: any): void;

package/DataTable/utils/handleCopyTable.d.ts

@@ -1 +1 @@
-export function handleCopyTable(e: any, opts: any): void;
+export function handleCopyTable(tableRef: any, opts: any): void;

package/DataTable/utils/isBottomRightCornerOfRectangle.d.ts

@@ -1,8 +1,10 @@
-export function isBottomRightCornerOfRectangle({ cellId, selectionGrid, lastRowIndex, lastCellIndex, entityMap, pathToIndex }: {
-    cellId: any;
-    selectionGrid: any;
-    lastRowIndex: any;
-    lastCellIndex: any;
-    entityMap: any;
-    pathToIndex: any;
-}): boolean | undefined;
+export declare const isBottomRightCornerOfRectangle: ({ cellId, selectionGrid, lastRowIndex, lastCellIndex, entityMap, pathToIndex }: {
+    cellId: string;
+    selectionGrid: (string | undefined)[][];
+    lastRowIndex: number;
+    lastCellIndex: number;
+    entityMap: Record<string, {
+        i: number;
+    }>;
+    pathToIndex: Record<string, number>;
+}) => boolean | undefined;

package/DataTable/utils/isEntityClean.d.ts

@@ -1 +1,3 @@
-export function isEntityClean(e: any): boolean;
+export declare function isEntityClean(e: {
+    [key: string]: unknown;
+} | null): boolean;

package/DataTable/utils/primarySelectedValue.d.ts

@@ -1 +1 @@
-export const PRIMARY_SELECTED_VAL: "main_cell";
+export declare const PRIMARY_SELECTED_VAL = "main_cell";

package/DataTable/utils/removeCleanRows.d.ts

@@ -1,4 +1,12 @@
-export function removeCleanRows(entities: any, cellValidation: any): {
-    entsToUse: any;
-    validationToUse: {};
+export declare const removeCleanRows: (entities: ({
+    [key: string]: unknown;
+} & {
+    _isClean?: boolean;
+})[], cellValidation: Record<string, unknown>) => {
+    entsToUse: ({
+        [key: string]: unknown;
+    } & {
+        _isClean?: boolean;
+    })[];
+    validationToUse: Record<string, unknown>;
 };

package/DataTable/utils/selection.d.ts

@@ -1 +1,3 @@
-export function getSelectedRowsFromEntities(entities: any, idMap: any): any;
+export declare const getSelectedRowsFromEntities: (entities: {
+    [key: string]: unknown;
+}[], idMap: Record<string, boolean>) => number[];

package/DataTable/utils/useDeepEqualMemo.d.ts

@@ -0,0 +1 @@
+export function useDeepEqualMemo(value: any): undefined;

package/DataTable/utils/useTableEntities.d.ts

@@ -1,5 +1,18 @@
-export function useTableEntities(tableFormName: any): {
-    selectTableEntities: (entities?: any[]) => void;
-    allOrderedEntities: any;
-    selectedEntities: any;
+type _Entity = {
+    [key: string]: unknown;
+} & {
+    id: string;
 };
+type SelectedEntityIdMap<Entity extends _Entity> = Record<string, {
+    entity: Entity;
+    time: number;
+    index?: number;
+}>;
+export declare const useTableEntities: <Entity extends _Entity>(tableFormName: string) => {
+    selectTableEntities: (entities?: {
+        id: string;
+    }[]) => void;
+    allOrderedEntities: Entity[] | undefined;
+    selectedEntities: SelectedEntityIdMap<Entity> | undefined;
+};
+export {};

package/DataTable/utils/useTableParams.d.ts

@@ -0,0 +1,49 @@
+/**
+ *  Note all these options can be passed at Design Time or at Runtime (like reduxForm())
+ *
+ * @export
+ *
+ * @param {compOrOpts} compOrOpts
+ * @typedef {object} compOrOpts
+ * @property {*string} formName - required unique identifier for the table
+ * @property {Object | Function} schema - The data table schema or a function returning it. The function wll be called with props as the argument.
+ * @property {boolean} urlConnected - whether the table should connect to/update the URL
+ * @property {boolean} withSelectedEntities - whether or not to pass the selected entities
+ * @property {boolean} isCodeModel - whether the model is keyed by code instead of id in the db
+ * @property {object} defaults - tableParam defaults such as pageSize, filter, etc
+ * @property {boolean} noOrderError - won't console an error if an order is not found on schema
+ */
+export default function useTableParams(props: any): any;
+/**
+ * Note all these options can be passed at Design Time or at Runtime (like reduxForm())
+ */
+export type compOrOpts = {
+    /**
+     * } formName - required unique identifier for the table
+     */
+    string: any;
+    /**
+     * - The data table schema or a function returning it. The function wll be called with props as the argument.
+     */
+    schema: Object | Function;
+    /**
+     * - whether the table should connect to/update the URL
+     */
+    urlConnected: boolean;
+    /**
+     * - whether or not to pass the selected entities
+     */
+    withSelectedEntities: boolean;
+    /**
+     * - whether the model is keyed by code instead of id in the db
+     */
+    isCodeModel: boolean;
+    /**
+     * - tableParam defaults such as pageSize, filter, etc
+     */
+    defaults: object;
+    /**
+     * - won't console an error if an order is not found on schema
+     */
+    noOrderError: boolean;
+};

package/index.cjs.js

@@ -15867,6 +15867,7 @@ var itemSizeEstimator = /* @__PURE__ */ __name(function itemSizeEstimator2() {
   return 41.36;
 }, "itemSizeEstimator");
 var ReactTableDefaults = defaultProps;
+var VIRTUALIZE_CUTOFF_LENGTH = 200;
 var ReactTable = function(_Methods) {
   _inherits$8(ReactTable2, _Methods);
   function ReactTable2(props) {
@@ -16452,7 +16453,7 @@ var ReactTable = function(_Methods) {
                   minWidth: rowMinWidth + "px"
                 })
               }, tBodyProps.rest),
-              pageRows.length < 200 ? pageRows.map(function(d2, i2) {
+              _this2.props.noVirtual || pageRows.length < VIRTUALIZE_CUTOFF_LENGTH ? pageRows.map(function(d2, i2) {
                 return makePageRow(d2, i2);
               }) : React.createElement(ReactList, {
                 type: "variable",
@@ -16556,7 +16557,7 @@ const getIdOrCodeOrIndex = /* @__PURE__ */ __name((record, rowIndex) => {
 const getSelectedRowsFromEntities = /* @__PURE__ */ __name((entities, idMap) => {
   if (!idMap) return [];
   return entities.reduce((acc, entity, i2) => {
-    return idMap[getIdOrCodeOrIndex(entity, i2)] ? acc.concat(i2) : acc;
+    return idMap[getIdOrCodeOrIndex(entity, i2)] ? acc.concat([i2]) : acc;
   }, []);
 }, "getSelectedRowsFromEntities");
 const removeCleanRows = /* @__PURE__ */ __name((entities, cellValidation) => {
@@ -16680,9 +16681,9 @@ const stripNumberAtEnd = /* @__PURE__ */ __name((str) => {
   var _a;
   return (_a = str == null ? void 0 : str.replace) == null ? void 0 : _a.call(str, getNumberStrAtEnd(str), "");
 }, "stripNumberAtEnd");
-const getAllRows = /* @__PURE__ */ __name((e) => {
-  const el = e.target.querySelector(".data-table-container") ? e.target.querySelector(".data-table-container") : e.target.closest(".data-table-container");
-  const allRowEls = el.querySelectorAll(".rt-tr");
+const getAllRows = /* @__PURE__ */ __name((tableRef) => {
+  var _a, _b;
+  const allRowEls = (_b = (_a = tableRef.current) == null ? void 0 : _a.tableRef) == null ? void 0 : _b.querySelectorAll(".rt-tr");
   if (!allRowEls || !allRowEls.length) {
     return;
   }
@@ -16949,14 +16950,14 @@ const handleCopyRows = /* @__PURE__ */ __name((rowElsToCopy, { specificColumn, o
     handleCopyHelper(textToCopy, jsonToCopy, onFinishMsg || "Row Copied");
   }
 }, "handleCopyRows");
-const handleCopyColumn = /* @__PURE__ */ __name((e, cellWrapper, selectedRecords) => {
+const handleCopyColumn = /* @__PURE__ */ __name((tableRef, cellWrapper, selectedRecords) => {
   const specificColumn = cellWrapper.getAttribute("data-test");
-  let rowElsToCopy = getAllRows(e);
+  let rowElsToCopy = getAllRows(tableRef);
   if (!rowElsToCopy) return;
   if (selectedRecords) {
-    const ids2 = selectedRecords.map((e2) => {
+    const ids2 = selectedRecords.map((e) => {
       var _a;
-      return (_a = getIdOrCodeOrIndex(e2)) == null ? void 0 : _a.toString();
+      return (_a = getIdOrCodeOrIndex(e)) == null ? void 0 : _a.toString();
     });
     rowElsToCopy = Array.from(rowElsToCopy).filter((rowEl) => {
       var _a;
@@ -16989,9 +16990,9 @@ const isBottomRightCornerOfRectangle = /* @__PURE__ */ __name(({
   const isBottomRight = i2 === lastRowIndex && cellIndex === lastCellIndex;
   return isBottomRight;
 }, "isBottomRightCornerOfRectangle");
-const handleCopyTable = /* @__PURE__ */ __name((e, opts) => {
+const handleCopyTable = /* @__PURE__ */ __name((tableRef, opts) => {
   try {
-    const allRowEls = getAllRows(e);
+    const allRowEls = getAllRows(tableRef);
     if (!allRowEls) return;
     handleCopyRows(allRowEls, __spreadProps(__spreadValues({}, opts), {
       onFinishMsg: "Table Copied"
@@ -17028,13 +17029,15 @@ const useTableEntities = /* @__PURE__ */ __name((tableFormName) => {
     },
     [dispatch, tableFormName]
   );
-  const { allOrderedEntities, selectedEntities } = reactRedux.useSelector((state) => {
-    var _a, _b, _c, _d, _e, _f;
-    return {
-      allOrderedEntities: (_c = (_b = (_a = state.form) == null ? void 0 : _a[tableFormName]) == null ? void 0 : _b.values) == null ? void 0 : _c.allOrderedEntities,
-      selectedEntities: (_f = (_e = (_d = state.form) == null ? void 0 : _d[tableFormName]) == null ? void 0 : _e.values) == null ? void 0 : _f.reduxFormSelectedEntityIdMap
-    };
-  });
+  const { allOrderedEntities, selectedEntities } = reactRedux.useSelector(
+    (state) => {
+      var _a, _b, _c, _d, _e, _f;
+      return {
+        allOrderedEntities: (_c = (_b = (_a = state.form) == null ? void 0 : _a[tableFormName]) == null ? void 0 : _b.values) == null ? void 0 : _c.allOrderedEntities,
+        selectedEntities: (_f = (_e = (_d = state.form) == null ? void 0 : _d[tableFormName]) == null ? void 0 : _e.values) == null ? void 0 : _f.reduxFormSelectedEntityIdMap
+      };
+    }
+  );
   return { selectTableEntities, allOrderedEntities, selectedEntities };
 }, "useTableEntities");
 const useDeepEqualMemo = /* @__PURE__ */ __name((value) => {
@@ -37232,7 +37235,7 @@ const multiViewColumn = __spreadProps(__spreadValues({}, viewColumn), {
     ));
   }, "render")
 });
-function convertSchema(schema) {
+const convertSchema = /* @__PURE__ */ __name((schema) => {
   let schemaToUse = schema;
   if (!schemaToUse.fields && Array.isArray(schema)) {
     schemaToUse = {
@@ -37241,35 +37244,26 @@ function convertSchema(schema) {
   }
   schemaToUse = __spreadValues({}, schemaToUse);
   schemaToUse.fields = schemaToUse.fields.map((field, i2) => {
-    let fieldToUse = field;
     if (typeof field === "string") {
-      fieldToUse = {
+      return {
         displayName: startCase(camelCase(field)),
         path: field,
         type: "string"
       };
-    } else if (!field.type) {
-      fieldToUse = __spreadProps(__spreadValues({}, field), {
-        type: "string"
-      });
-    }
-    if (!fieldToUse.displayName) {
-      fieldToUse = __spreadProps(__spreadValues({}, fieldToUse), {
-        displayName: startCase(camelCase(fieldToUse.path))
-      });
-    }
-    if (!fieldToUse.path) {
-      fieldToUse = __spreadProps(__spreadValues({}, fieldToUse), {
-        filterDisabled: true,
-        sortDisabled: true,
-        path: "fake-path" + i2
-      });
+    } else {
+      const fieldToUse = __spreadValues({}, field);
+      fieldToUse.type = fieldToUse.type || "string";
+      fieldToUse.displayName = fieldToUse.displayName || startCase(camelCase(fieldToUse.path || ""));
+      if (!fieldToUse.path) {
+        fieldToUse.filterDisabled = true;
+        fieldToUse.sortDisabled = true;
+        fieldToUse.path = "fake-path" + i2;
+      }
+      return fieldToUse;
     }
-    return fieldToUse;
   });
   return schemaToUse;
-}
-__name(convertSchema, "convertSchema");
+}, "convertSchema");
 function mergeSchemas(_originalSchema, _overrideSchema) {
   const originalSchema = convertSchema(_originalSchema);
   const overrideSchema = convertSchema(_overrideSchema);
@@ -56320,6 +56314,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
   );
   const tableRef = React.useRef();
   const alreadySelected = React.useRef(false);
+  const [noVirtual, setNoVirtual] = React.useState(false);
   const [onlyShowRowsWErrors, setOnlyShowRowsWErrors] = React.useState(false);
   const [entitiesUndoRedoStack, setEntitiesUndoRedoStack] = React.useState({
     currentVersion: 0
@@ -57161,76 +57156,94 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
     updateEntitiesHelper,
     updateValidation
   ]);
-  const handleCopySelectedCells = React.useCallback(
-    (e) => {
-      if (isEmpty$1(selectedCells)) return;
-      const pathToIndex = getFieldPathToIndex(schema);
-      const entityIdToEntity = getEntityIdToEntity(entities);
-      const selectionGrid = [];
-      let firstRowIndex;
-      let firstCellIndex;
-      Object.keys(selectedCells).forEach((key) => {
-        const [rowId, path2] = key.split(":");
-        const eInfo = entityIdToEntity[rowId];
-        if (eInfo) {
-          if (firstRowIndex === void 0 || eInfo.i < firstRowIndex) {
-            firstRowIndex = eInfo.i;
-          }
-          if (!selectionGrid[eInfo.i]) {
-            selectionGrid[eInfo.i] = [];
-          }
-          const cellIndex = pathToIndex[path2];
-          if (firstCellIndex === void 0 || cellIndex < firstCellIndex) {
-            firstCellIndex = cellIndex;
-          }
-          selectionGrid[eInfo.i][cellIndex] = true;
-        }
-      });
-      if (firstRowIndex === void 0) return;
-      const allRows = getAllRows(e);
-      let fullCellText = "";
-      const fullJson = [];
-      times(selectionGrid.length, (i2) => {
-        const row = selectionGrid[i2];
-        if (fullCellText) {
-          fullCellText += "\n";
-        }
-        if (!row) {
-          return;
-        } else {
-          const jsonRow = [];
-          let [rowCopyText, json] = getRowCopyText(allRows[i2 + 1]);
-          rowCopyText = rowCopyText.split("	");
-          times(row.length, (i22) => {
-            const cell = row[i22];
-            if (cell) {
-              fullCellText += rowCopyText[i22];
-              jsonRow.push(json[i22]);
-            }
-            if (i22 !== row.length - 1 && i22 >= firstCellIndex)
-              fullCellText += "	";
-          });
-          fullJson.push(jsonRow);
+  const waitUntilAllRowsAreRendered = React.useCallback(() => {
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        var _a2, _b;
+        const allRowEls = (_b = (_a2 = tableRef.current) == null ? void 0 : _a2.tableRef) == null ? void 0 : _b.querySelectorAll(".rt-tr-group");
+        if ((allRowEls == null ? void 0 : allRowEls.length) === entities.length) {
+          clearInterval(interval);
+          resolve();
+        }
+      }, 50);
+    });
+  }, []);
+  const handleCopySelectedCells = React.useCallback(() => __async(exports, null, function* () {
+    if (isEmpty$1(selectedCells)) return;
+    if (entities.length > VIRTUALIZE_CUTOFF_LENGTH) {
+      setNoVirtual(true);
+      yield waitUntilAllRowsAreRendered();
+    }
+    const pathToIndex = getFieldPathToIndex(schema);
+    const entityIdToEntity = getEntityIdToEntity(entities);
+    const selectionGrid = [];
+    let firstRowIndex;
+    let firstCellIndex;
+    Object.keys(selectedCells).forEach((key) => {
+      const [rowId, path2] = key.split(":");
+      const eInfo = entityIdToEntity[rowId];
+      if (eInfo) {
+        if (firstRowIndex === void 0 || eInfo.i < firstRowIndex) {
+          firstRowIndex = eInfo.i;
+        }
+        if (!selectionGrid[eInfo.i]) {
+          selectionGrid[eInfo.i] = [];
+        }
+        const cellIndex = pathToIndex[path2];
+        if (firstCellIndex === void 0 || cellIndex < firstCellIndex) {
+          firstCellIndex = cellIndex;
         }
-      });
-      if (!fullCellText) return window.toastr.warning("No text to copy");
-      handleCopyHelper(fullCellText, fullJson, "Selected cells copied");
-    },
-    [entities, selectedCells, schema]
-  );
+        selectionGrid[eInfo.i][cellIndex] = true;
+      }
+    });
+    if (firstRowIndex === void 0) return;
+    const allRows = getAllRows(tableRef);
+    let fullCellText = "";
+    const fullJson = [];
+    times(selectionGrid.length, (i2) => {
+      const row = selectionGrid[i2];
+      if (fullCellText) {
+        fullCellText += "\n";
+      }
+      if (!row) {
+        return;
+      } else {
+        const jsonRow = [];
+        let [rowCopyText, json] = getRowCopyText(allRows[i2 + 1]);
+        rowCopyText = rowCopyText.split("	");
+        times(row.length, (i22) => {
+          const cell = row[i22];
+          if (cell) {
+            fullCellText += rowCopyText[i22];
+            jsonRow.push(json[i22]);
+          }
+          if (i22 !== row.length - 1 && i22 >= firstCellIndex) fullCellText += "	";
+        });
+        fullJson.push(jsonRow);
+      }
+    });
+    if (!fullCellText) return window.toastr.warning("No text to copy");
+    handleCopyHelper(fullCellText, fullJson, "Selected cells copied");
+    setNoVirtual(false);
+  }), [entities, selectedCells, schema, waitUntilAllRowsAreRendered]);
   const handleCopySelectedRows = React.useCallback(
-    (selectedRecords, e) => {
-      const idToIndex = entities.reduce((acc, e2, i2) => {
-        acc[e2.id || e2.code] = i2;
+    (selectedRecords) => __async(exports, null, function* () {
+      if (entities.length > VIRTUALIZE_CUTOFF_LENGTH) {
+        setNoVirtual(true);
+        yield waitUntilAllRowsAreRendered();
+      }
+      const idToIndex = entities.reduce((acc, e, i2) => {
+        acc[e.id || e.code] = i2;
         return acc;
       }, {});
       const rowNumbersToCopy = selectedRecords.map((rec) => idToIndex[rec.id || rec.code] + 1).sort();
       if (!rowNumbersToCopy.length) return;
       rowNumbersToCopy.unshift(0);
       try {
-        const allRowEls = getAllRows(e);
+        const allRowEls = getAllRows(tableRef);
         if (!allRowEls) return;
         const rowEls = rowNumbersToCopy.map((i2) => allRowEls[i2]);
+        if (window.Cypress) window.Cypress.__copiedRowsLength = rowEls.length;
         handleCopyRows(rowEls, {
           onFinishMsg: "Selected rows copied"
         });
@@ -57238,8 +57251,9 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
         console.error(`error:`, error);
         window.toastr.error("Error copying rows.");
       }
-    },
-    [entities]
+      setNoVirtual(false);
+    }),
+    [entities, waitUntilAllRowsAreRendered]
   );
   const handleCopyHotkey = React.useCallback(
     (e) => {
@@ -58006,7 +58020,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
               {
                 key: "copyColumn",
                 onClick: /* @__PURE__ */ __name(() => {
-                  handleCopyColumn(e, cellWrapper);
+                  handleCopyColumn(tableRef, cellWrapper);
                 }, "onClick"),
                 text: "Column"
               }
@@ -58019,7 +58033,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
                 {
                   key: "copyColumnSelected",
                   onClick: /* @__PURE__ */ __name(() => {
-                    handleCopyColumn(e, cellWrapper, selectedRecords);
+                    handleCopyColumn(tableRef, cellWrapper, selectedRecords);
                   }, "onClick"),
                   text: "Column (Selected)"
                 }
@@ -58062,7 +58076,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             {
               key: "copyFullTableRows",
               onClick: /* @__PURE__ */ __name(() => {
-                handleCopyTable(e);
+                handleCopyTable(tableRef);
               }, "onClick"),
               text: "Table"
             }
@@ -58599,6 +58613,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
       __spreadValues({
         data: filteredEnts,
         ref: tableRef,
+        noVirtual,
         className: classNames({
           isCellEditable,
           "tg-table-loading": isLoading,
@@ -58666,7 +58681,8 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
       resizePersist,
       resized,
       rowsToShow,
-      style
+      style,
+      noVirtual
     ]
   );
   return /* @__PURE__ */ React.createElement("div", { tabIndex: "1", onKeyDown: handleKeyDown, onKeyUp: handleKeyUp }, /* @__PURE__ */ React.createElement(
@@ -58949,8 +58965,8 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
       ), /* @__PURE__ */ React.createElement(
         core.Button,
         {
-          onClick: /* @__PURE__ */ __name((e) => {
-            handleCopyTable(e, { isDownload: true });
+          onClick: /* @__PURE__ */ __name(() => {
+            handleCopyTable(tableRef, { isDownload: true });
           }, "onClick"),
           "data-tip": "Download Table as CSV",
           minimal: true,