@gridsuite/commons-ui 0.214.0 → 0.216.0

package/dist/components/flatParameters/FlatParameters.js

@@ -1,366 +0,0 @@
-import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
-import { useState, useCallback, Fragment, createElement } from "react";
-import { List, ListItem, Typography, Divider, Select, MenuItem, TextField, IconButton, Autocomplete, Chip, Switch } from "@mui/material";
-import { Tune } from "@mui/icons-material";
-import { useIntl, FormattedMessage } from "react-intl";
-import { CustomTooltip } from "../ui/tooltip/CustomTooltip.js";
-import { MultipleSelectionDialog } from "../ui/dialogs/multipleSelectionDialog/MultipleSelectionDialog.js";
-const styles = {
-  paramList: {
-    width: "100%",
-    margin: 0
-  },
-  paramListItem: (theme) => ({
-    display: "flex",
-    justifyContent: "space-between",
-    gap: theme.spacing(2),
-    paddingLeft: 0,
-    paddingRight: 0
-  }),
-  paramName: {
-    fontWeight: "bold",
-    minWidth: "30%",
-    overflowWrap: "anywhere"
-  }
-};
-const FloatRE = /^-?\d*[.,]?\d*([eE]-?\d*)?$/;
-const IntegerRE = /^-?\d*$/;
-const ListRE = /^\[(.*)]$/;
-const sepRE = /[, ]/;
-function extractDefault(paramDescription) {
-  const d = paramDescription.defaultValue;
-  if (paramDescription.type === "BOOLEAN") {
-    return !!d;
-  }
-  if (paramDescription.type === "DOUBLE") {
-    return d - 0;
-  }
-  if (paramDescription.type === "INTEGER") {
-    return d - 0;
-  }
-  if (paramDescription.type === "STRING_LIST") {
-    if (Array.isArray(d)) {
-      return d;
-    }
-    const mo = ListRE.exec(d);
-    if (mo === null || mo.length <= 1) {
-      return [];
-    }
-    return mo[1].split(sepRE).map((s) => s.trim()).filter((s) => !!s);
-  }
-  return d ?? null;
-}
-function longestCommonPrefix(stringList) {
-  if (!stringList?.length) {
-    return "";
-  }
-  let prefix = stringList.reduce((acc, str) => str.length < acc.length ? str : acc);
-  stringList.forEach((str) => {
-    while (!str.startsWith(prefix)) {
-      prefix = prefix.slice(0, -1);
-    }
-  });
-  return prefix;
-}
-function FlatParameters({
-  paramsAsArray,
-  initValues,
-  onChange,
-  variant = "outlined",
-  showSeparator = false,
-  selectionWithDialog = () => false
-}) {
-  const intl = useIntl();
-  const longestPrefix = longestCommonPrefix(paramsAsArray.map((m) => m.name));
-  const lastDotIndex = longestPrefix.lastIndexOf(".");
-  const prefix = longestPrefix.slice(0, lastDotIndex + 1);
-  const [uncommitted, setUncommitted] = useState(null);
-  const [inEditionParam, setInEditionParam] = useState(null);
-  const [openSelector, setOpenSelector] = useState(false);
-  const getTranslatedValue = useCallback(
-    (prefixValue, value) => {
-      return intl.formatMessage({
-        id: `${prefixValue}.${value}`,
-        defaultMessage: value
-      });
-    },
-    [intl]
-  );
-  const getSelectionDialogName = useCallback(
-    (paramName) => {
-      const defaultMessage = intl.formatMessage({
-        id: paramName,
-        defaultMessage: paramName.slice(prefix.length)
-      });
-      return intl.formatMessage({
-        id: `${paramName}.selectionDialog.name`,
-        defaultMessage
-      });
-    },
-    [intl, prefix.length]
-  );
-  const sortPossibleValues = useCallback(
-    (prefixValue, values) => {
-      if (values == null) {
-        return [];
-      }
-      return values.map((value) => {
-        return {
-          id: value,
-          message: getTranslatedValue(prefixValue, value)
-        };
-      }).sort((a, b) => a.message.localeCompare(b.message));
-    },
-    [getTranslatedValue]
-  );
-  const onFieldChange = useCallback(
-    (value, param) => {
-      const paramName = param.name;
-      const isInEdition = inEditionParam === paramName;
-      if (isInEdition) {
-        setUncommitted(value);
-      }
-      if (onChange) {
-        if (param.type === "STRING_LIST") {
-          onChange(paramName, value ? value.toString() : null, isInEdition);
-        } else {
-          onChange(paramName, value, isInEdition);
-        }
-      }
-    },
-    [inEditionParam, onChange]
-  );
-  const onUncommitted = useCallback(
-    (param, inEdit) => {
-      if (inEdit) {
-        setInEditionParam(param.name);
-      } else {
-        if (onChange && uncommitted != null) {
-          if (!["INTEGER", "DOUBLE"].includes(param.type)) {
-            onChange(param.name, uncommitted, false);
-          } else if (uncommitted) {
-            onChange(param.name, uncommitted - 0, false);
-          } else {
-            onChange(param.name, extractDefault(param), false);
-          }
-        }
-        setInEditionParam(null);
-        setUncommitted(null);
-      }
-    },
-    [uncommitted, onChange]
-  );
-  function mixInitAndDefault(param) {
-    if (param.name === inEditionParam && uncommitted !== null) {
-      return uncommitted;
-    }
-    if (initValues && Object.hasOwn(initValues, param.name)) {
-      if (param.type === "BOOLEAN") {
-        return initValues[param.name] === "false" ? false : initValues[param.name];
-      }
-      if (param.type !== "STRING_LIST") {
-        return initValues[param.name];
-      }
-      const valueList = initValues[param.name];
-      if (Array.isArray(valueList)) {
-        return valueList;
-      }
-      return valueList ? valueList.split(",").map((s) => s.trim()).filter((s) => !!s) : [];
-    }
-    return extractDefault(param);
-  }
-  const outputTransformFloatString = (value) => {
-    return value?.replace(",", ".") || "";
-  };
-  const getStringListValue = (allValues, selectValues) => {
-    if (!selectValues || !selectValues.length) {
-      return intl.formatMessage({ id: "flat_parameters/none" });
-    }
-    if (selectValues.length === allValues.length) {
-      return intl.formatMessage({ id: "flat_parameters/all" });
-    }
-    return intl.formatMessage({ id: "flat_parameters/some" });
-  };
-  const renderField = (param) => {
-    const fieldValue = mixInitAndDefault(param);
-    switch (param.type) {
-      case "BOOLEAN":
-        return /* @__PURE__ */ jsx(Switch, { checked: !!fieldValue, onChange: (e) => onFieldChange(e.target.checked, param) });
-      case "DOUBLE": {
-        const err = Number.isNaN(fieldValue) || typeof fieldValue !== "number" && !!fieldValue && Number.isNaN(fieldValue - 0);
-        return /* @__PURE__ */ jsx(
-          TextField,
-          {
-            size: "small",
-            sx: { width: "50%" },
-            inputProps: { style: { textAlign: "right" } },
-            value: fieldValue,
-            onFocus: () => onUncommitted(param, true),
-            onBlur: () => onUncommitted(param, false),
-            onChange: (e) => {
-              const m = FloatRE.exec(e.target.value);
-              if (m) {
-                onFieldChange(outputTransformFloatString(e.target.value), param);
-              }
-            },
-            error: err,
-            variant
-          }
-        );
-      }
-      case "INTEGER":
-        return /* @__PURE__ */ jsx(
-          TextField,
-          {
-            size: "small",
-            sx: { width: "50%" },
-            inputProps: { style: { textAlign: "right" } },
-            value: fieldValue,
-            onFocus: () => onUncommitted(param, true),
-            onBlur: () => onUncommitted(param, false),
-            onChange: (e) => {
-              const m = IntegerRE.exec(e.target.value);
-              if (m) {
-                onFieldChange(e.target.value, param);
-              }
-            },
-            variant
-          }
-        );
-      case "STRING_LIST":
-        if (param.possibleValues) {
-          const allOptions = sortPossibleValues(param.name, param.possibleValues).map(({ id }) => id);
-          const withDialog = selectionWithDialog(param);
-          if (withDialog) {
-            return /* @__PURE__ */ jsxs(Fragment$1, { children: [
-              /* @__PURE__ */ jsx(
-                TextField,
-                {
-                  value: getStringListValue(allOptions, fieldValue),
-                  size: "small",
-                  variant,
-                  InputProps: {
-                    readOnly: true,
-                    endAdornment: /* @__PURE__ */ jsx(IconButton, { onClick: () => setOpenSelector(true), children: /* @__PURE__ */ jsx(Tune, {}) })
-                  }
-                }
-              ),
-              /* @__PURE__ */ jsx(
-                MultipleSelectionDialog,
-                {
-                  items: allOptions,
-                  titleId: getSelectionDialogName(param.name),
-                  open: openSelector,
-                  getItemLabel: (option) => getTranslatedValue(param.name, option),
-                  getItemId: (o) => o,
-                  selectedItems: fieldValue,
-                  addSelectAllCheckbox: true,
-                  handleClose: () => setOpenSelector(false),
-                  handleValidate: (selectedOptions) => {
-                    onFieldChange(selectedOptions, param);
-                    setOpenSelector(false);
-                  }
-                }
-              )
-            ] });
-          }
-          return /* @__PURE__ */ jsx(
-            Autocomplete,
-            {
-              fullWidth: true,
-              multiple: true,
-              size: "small",
-              options: sortPossibleValues(param.name, param.possibleValues).map((v) => v.id),
-              getOptionLabel: (option) => getTranslatedValue(param.name, option),
-              onChange: (e, value) => onFieldChange(value, param),
-              value: fieldValue,
-              renderTags: (values, getTagProps) => {
-                return values.map((value, index) => /* @__PURE__ */ createElement(
-                  Chip,
-                  {
-                    label: getTranslatedValue(param.name, value),
-                    ...getTagProps({ index }),
-                    key: `chip_${value}`
-                  }
-                ));
-              },
-              renderInput: (inputProps) => /* @__PURE__ */ jsx(TextField, { ...inputProps, variant })
-            }
-          );
-        }
-        return /* @__PURE__ */ jsx(
-          Autocomplete,
-          {
-            multiple: true,
-            freeSolo: true,
-            autoSelect: true,
-            sx: { width: "50%" },
-            options: [],
-            size: "small",
-            onChange: (e, value) => onFieldChange(value, param),
-            value: fieldValue,
-            renderTags: (values, getTagProps) => {
-              return values.map((value, index) => /* @__PURE__ */ createElement(
-                Chip,
-                {
-                  id: `chip_${value}`,
-                  size: "small",
-                  label: value,
-                  ...getTagProps({ index }),
-                  key: `chip_${value}`
-                }
-              ));
-            },
-            renderInput: (inputProps) => /* @__PURE__ */ jsx(TextField, { ...inputProps, variant })
-          }
-        );
-      case "STRING":
-        if (param.possibleValues) {
-          return /* @__PURE__ */ jsx(
-            Select,
-            {
-              labelId: param.name,
-              value: fieldValue ?? "",
-              onChange: (ev) => {
-                onFieldChange(ev.target.value, param);
-              },
-              size: "small",
-              sx: { minWidth: "4em" },
-              variant,
-              children: sortPossibleValues(param.name, param.possibleValues).map((value) => /* @__PURE__ */ jsx(MenuItem, { value: value.id, children: /* @__PURE__ */ jsx(Typography, { children: value.message }) }, value.id))
-            }
-          );
-        }
-    }
-    return /* @__PURE__ */ jsx(
-      TextField,
-      {
-        sx: { width: "50%" },
-        size: "small",
-        value: fieldValue || "",
-        onFocus: () => onUncommitted(param, true),
-        onBlur: () => onUncommitted(param, false),
-        onChange: (e) => onFieldChange(e.target.value, param),
-        variant
-      }
-    );
-  };
-  return /* @__PURE__ */ jsx(List, { sx: styles.paramList, children: paramsAsArray.map((param, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsxs(ListItem, { sx: styles.paramListItem, children: [
-      /* @__PURE__ */ jsx(
-        CustomTooltip,
-        {
-          title: /* @__PURE__ */ jsx(FormattedMessage, { id: `${param.name}.desc`, defaultMessage: param.description }),
-          children: /* @__PURE__ */ jsx(Typography, { sx: styles.paramName, children: /* @__PURE__ */ jsx(FormattedMessage, { id: param.name, defaultMessage: param.name.slice(prefix.length) }) })
-        },
-        param.name
-      ),
-      renderField(param)
-    ] }),
-    showSeparator && index !== paramsAsArray.length - 1 && /* @__PURE__ */ jsx(Divider, {})
-  ] }, param.name)) });
-}
-export {
-  FlatParameters,
-  extractDefault
-};

package/dist/components/grid/grid-item.js

@@ -1,9 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { Grid } from "@mui/material";
-import { CustomTooltip } from "../ui/tooltip/CustomTooltip.js";
-function GridItem({ children, size = 6, alignItem = "flex-start", tooltip }) {
-  return /* @__PURE__ */ jsx(Grid, { item: true, xs: size, alignItems: alignItem, children: children && (tooltip ? /* @__PURE__ */ jsx(CustomTooltip, { title: tooltip, children: /* @__PURE__ */ jsx("div", { children }) }) : children) });
-}
-export {
-  GridItem as default
-};

package/dist/components/grid/grid-section.d.ts

@@ -1,8 +0,0 @@
-import { SxStyle } from '../../utils/styles';
-export interface GridSectionProps {
-    title: string;
-    heading?: 1 | 2 | 3 | 4 | 5 | 6;
-    size?: number;
-    customStyle?: SxStyle;
-}
-export default function GridSection({ title, heading, size, customStyle }: Readonly<GridSectionProps>): import("react/jsx-runtime").JSX.Element;

package/dist/components/muiTable/OverflowableTableCell.d.ts

@@ -1,3 +0,0 @@
-import { OverflowableTextProps } from '../ui/overflowableText';
-export declare function OverflowableTableCell(overflowableTextProps: Readonly<OverflowableTextProps>): import("react/jsx-runtime").JSX.Element;
-export default OverflowableTableCell;

package/dist/components/muiTable/OverflowableTableCell.js

@@ -1,10 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { TableCell } from "@mui/material";
-import { OverflowableText } from "../ui/overflowableText/OverflowableText.js";
-function OverflowableTableCell(overflowableTextProps) {
-  return /* @__PURE__ */ jsx(TableCell, { sx: { display: "flex", alignItems: "center" }, children: /* @__PURE__ */ jsx(OverflowableText, { sx: { flex: "1 1 0", width: 0, display: "block" }, ...overflowableTextProps }) });
-}
-export {
-  OverflowableTableCell,
-  OverflowableTableCell as default
-};

package/dist/components/muiTable/OverflowableTableCellWithCheckbox.d.ts

@@ -1,6 +0,0 @@
-import { OverflowableTextProps } from '../ui/overflowableText';
-export interface OverflowableTableCellProps extends OverflowableTextProps {
-    checked: boolean;
-}
-export declare function OverflowableTableCellWithCheckbox({ checked, ...overflowableTextProps }: Readonly<OverflowableTableCellProps>): import("react/jsx-runtime").JSX.Element;
-export default OverflowableTableCellWithCheckbox;

package/dist/components/muiTable/OverflowableTableCellWithCheckbox.js

@@ -1,16 +0,0 @@
-import { jsxs, jsx } from "react/jsx-runtime";
-import { TableCell, Checkbox } from "@mui/material";
-import { OverflowableText } from "../ui/overflowableText/OverflowableText.js";
-function OverflowableTableCellWithCheckbox({
-  checked,
-  ...overflowableTextProps
-}) {
-  return /* @__PURE__ */ jsxs(TableCell, { padding: "checkbox", sx: { display: "flex", alignItems: "center", width: "100%" }, children: [
-    /* @__PURE__ */ jsx(Checkbox, { checked }),
-    /* @__PURE__ */ jsx(OverflowableText, { sx: { flex: "1 1 0", width: 0, display: "block" }, ...overflowableTextProps })
-  ] });
-}
-export {
-  OverflowableTableCellWithCheckbox,
-  OverflowableTableCellWithCheckbox as default
-};

package/dist/components/network-modification-table/network-modifications-table.js

@@ -1,217 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { useRef, useState, useEffect, useCallback, useMemo } from "react";
-import { useTheme, Box, Table, TableHead, TableRow, TableCell, TableBody } from "@mui/material";
-import { useReactTable, getExpandedRowModel, getCoreRowModel, flexRender } from "@tanstack/react-table";
-import { DragDropContext, Droppable } from "@hello-pangea/dnd";
-import { useVirtualizer } from "@tanstack/react-virtual";
-import { MODIFICATION_ROW_HEIGHT, networkModificationTableStyles, createHeaderCellStyle } from "./network-modification-table-styles.js";
-import { AUTO_EXTENSIBLE_COLUMNS } from "./columns-definition.js";
-import { useModificationsDragAndDrop } from "./use-modifications-drag-and-drop.js";
-import { useModificationsSelection } from "./use-modifications-selection.js";
-import { formatToComposedModification, mergeSubModificationsIntoTree, findAllLoadedCompositeModifications, fetchSubModificationsForExpandedRows, isCompositeModification } from "./utils.js";
-import "@mui/icons-material";
-import "react-intl";
-import "../../utils/conversionUtils.js";
-import "../../utils/types/equipmentType.js";
-import "../../utils/yupConfig.js";
-import "localized-countries";
-import "localized-countries/data/fr";
-import "localized-countries/data/en";
-import "notistack";
-import { ModificationRow } from "./row/modification-row.js";
-function NetworkModificationsTable({
-  modifications,
-  handleCellClick,
-  isRowDragDisabled = false,
-  onRowDragStart,
-  onRowDragEnd,
-  onRowSelected,
-  columns,
-  highlightedModificationUuid,
-  studyUuid = null,
-  currentNodeId = void 0,
-  currentRootNetworkUuid,
-  rootNetworks,
-  modificationsToExclude,
-  setModificationsToExclude,
-  isDisabled = false,
-  isImpactedByNotification,
-  notificationMessageId,
-  isFetchingModifications,
-  pendingState
-}) {
-  const theme = useTheme();
-  const containerRef = useRef(null);
-  const [expanded, setExpanded] = useState({});
-  const [composedModifications, setComposedModifications] = useState(
-    formatToComposedModification(modifications)
-  );
-  const { rowSelection, onRowSelectionChange, lastClickedRowId, emitSelection } = useModificationsSelection({
-    modifications: composedModifications,
-    onRowSelected
-  });
-  useEffect(() => {
-    setComposedModifications((prevMods) => {
-      const nextMods = mergeSubModificationsIntoTree(formatToComposedModification(modifications), prevMods);
-      const loadedComposite = [];
-      findAllLoadedCompositeModifications(nextMods, loadedComposite);
-      fetchSubModificationsForExpandedRows(
-        loadedComposite.map((mod) => mod.uuid),
-        nextMods,
-        setComposedModifications,
-        true
-      );
-      return nextMods;
-    });
-  }, [modifications]);
-  const handleExpandRow = useCallback((updater) => {
-    setExpanded((prevExpanded) => {
-      const nextExpanded = typeof updater === "function" ? updater(prevExpanded) : updater;
-      const prevRecord = prevExpanded === true ? {} : prevExpanded;
-      const nextRecord = nextExpanded === true ? {} : nextExpanded;
-      const newlyExpandedIds = Object.keys(nextRecord).filter((id) => nextRecord[id] && !prevRecord[id]);
-      setComposedModifications((prevMods) => {
-        fetchSubModificationsForExpandedRows(newlyExpandedIds, prevMods, setComposedModifications);
-        return [...prevMods];
-      });
-      return nextExpanded;
-    });
-  }, []);
-  const tableMeta = useMemo(
-    () => ({
-      context: {
-        studyUuid,
-        currentNodeId,
-        currentRootNetworkUuid,
-        rootNetworks
-      },
-      modifications: {
-        count: modifications.length,
-        toExclude: modificationsToExclude,
-        setToExclude: setModificationsToExclude
-      },
-      interaction: {
-        lastClickedRowId,
-        onRowSelected,
-        isRowDragDisabled
-      },
-      status: {
-        isImpactedByNotification,
-        notificationMessageId,
-        isFetchingModifications,
-        pendingState,
-        isDisabled
-      }
-    }),
-    [
-      studyUuid,
-      currentNodeId,
-      currentRootNetworkUuid,
-      rootNetworks,
-      modifications.length,
-      modificationsToExclude,
-      setModificationsToExclude,
-      lastClickedRowId,
-      onRowSelected,
-      isRowDragDisabled,
-      isImpactedByNotification,
-      notificationMessageId,
-      isFetchingModifications,
-      pendingState,
-      isDisabled
-    ]
-  );
-  const table = useReactTable({
-    data: composedModifications,
-    columns,
-    state: { expanded, rowSelection },
-    getCoreRowModel: getCoreRowModel(),
-    getExpandedRowModel: getExpandedRowModel(),
-    getSubRows: (row) => row.subModifications,
-    getRowId: (row) => row.uuid,
-    getRowCanExpand: (row) => isCompositeModification(row.original),
-    enableRowSelection: true,
-    enableSubRowSelection: true,
-    enableExpanding: true,
-    onExpandedChange: handleExpandRow,
-    onRowSelectionChange,
-    meta: tableMeta
-  });
-  const { rows, flatRows } = table.getRowModel();
-  useEffect(() => {
-    emitSelection(flatRows);
-  }, [rowSelection, flatRows, emitSelection]);
-  const virtualizer = useVirtualizer({
-    count: rows.length,
-    getScrollElement: () => containerRef.current,
-    overscan: 5,
-    estimateSize: () => MODIFICATION_ROW_HEIGHT
-  });
-  const virtualItems = virtualizer.getVirtualItems();
-  const { handleDragUpdate, handleDragEnd, renderClone } = useModificationsDragAndDrop({
-    table,
-    containerRef,
-    composedModifications,
-    setComposedModifications,
-    onDragEnd: onRowDragEnd,
-    studyUuid,
-    currentNodeUuid: currentNodeId
-  });
-  useEffect(() => {
-    table.resetRowSelection();
-    table.resetExpanded();
-    lastClickedRowId.current = null;
-  }, [lastClickedRowId, table, currentNodeId]);
-  useEffect(() => {
-    if (highlightedModificationUuid && containerRef.current) {
-      const rowIndex = rows.findIndex((row) => row.original.uuid === highlightedModificationUuid);
-      if (rowIndex !== -1) {
-        virtualizer.scrollToIndex(rowIndex, { align: "start", behavior: "auto" });
-      }
-    }
-  }, [highlightedModificationUuid, rows, virtualizer]);
-  return /* @__PURE__ */ jsx(DragDropContext, { onDragEnd: handleDragEnd, onDragStart: onRowDragStart, onDragUpdate: handleDragUpdate, children: /* @__PURE__ */ jsx(Box, { sx: networkModificationTableStyles.tableWrapper, children: /* @__PURE__ */ jsx(Droppable, { droppableId: "modifications-table", mode: "virtual", renderClone, children: (provided) => /* @__PURE__ */ jsx(Box, { ref: containerRef, sx: networkModificationTableStyles.container, children: /* @__PURE__ */ jsxs(Table, { sx: networkModificationTableStyles.table, children: [
-    /* @__PURE__ */ jsx(TableHead, { sx: networkModificationTableStyles.thead, children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx(TableRow, { sx: networkModificationTableStyles.tableRow, children: headerGroup.headers.map((header) => /* @__PURE__ */ jsx(
-      TableCell,
-      {
-        sx: createHeaderCellStyle(
-          header,
-          theme,
-          header.index === 0,
-          header.index === headerGroup.headers.length - 1,
-          AUTO_EXTENSIBLE_COLUMNS.includes(header.column.id)
-        ),
-        children: flexRender(header.column.columnDef.header, header.getContext())
-      },
-      header.id
-    )) }, headerGroup.id)) }),
-    /* @__PURE__ */ jsx(
-      TableBody,
-      {
-        ref: provided.innerRef,
-        ...provided.droppableProps,
-        sx: {
-          ...networkModificationTableStyles.tableBody,
-          height: `${virtualizer.getTotalSize()}px`
-        },
-        children: virtualItems.map((virtualRow) => {
-          const row = rows[virtualRow.index];
-          return /* @__PURE__ */ jsx(
-            ModificationRow,
-            {
-              virtualRow,
-              row,
-              handleCellClick,
-              isRowDragDisabled,
-              highlightedModificationUuid
-            },
-            row.id
-          );
-        })
-      }
-    )
-  ] }) }) }) }) });
-}
-export {
-  NetworkModificationsTable
-};