@gridsuite/commons-ui 0.214.0 → 0.216.0

package/dist/features/network-modification-table/row/drag-row-clone.js

@@ -0,0 +1,34 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Box } from "@mui/material";
+import { DragIndicator } from "@mui/icons-material";
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+import { networkModificationTableStyles } from "../network-modification-table-styles.js";
+import { useModificationLabelComputer } from "../../../hooks/useModificationLabelComputer.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import { mergeSx } from "../../../utils/styles.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+function DragCloneRow({ row }) {
+  const intl = useIntl();
+  const { computeLabel } = useModificationLabelComputer();
+  const getModificationLabel = useCallback(
+    (modification, formatBold = true) => {
+      return intl.formatMessage(
+        { id: `network_modifications.${modification.messageType}` },
+        { ...modification, ...computeLabel(modification, formatBold) }
+      );
+    },
+    [computeLabel, intl]
+  );
+  return /* @__PURE__ */ jsxs(Box, { sx: networkModificationTableStyles.dragRowClone, children: [
+    /* @__PURE__ */ jsx(Box, { sx: networkModificationTableStyles.tableCell, children: /* @__PURE__ */ jsx(Box, { sx: mergeSx(networkModificationTableStyles.dragHandle, { opacity: 1 }), children: /* @__PURE__ */ jsx(DragIndicator, { sx: networkModificationTableStyles.dragIndicatorIcon }) }) }),
+    /* @__PURE__ */ jsx(Box, { sx: networkModificationTableStyles.tableCell, children: /* @__PURE__ */ jsx(Box, { sx: networkModificationTableStyles.modificationLabel, children: getModificationLabel(row.original) }) })
+  ] });
+}
+export {
+  DragCloneRow
+};

package/dist/features/network-modification-table/row/modification-row.js

@@ -0,0 +1,106 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { flexRender } from "@tanstack/react-table";
+import { useTheme, TableRow, TableCell, Box } from "@mui/material";
+import { Draggable } from "@hello-pangea/dnd";
+import { useIntl } from "react-intl";
+import { BASE_MODIFICATION_TABLE_COLUMNS, AUTO_EXTENSIBLE_COLUMNS } from "../columns-definition.js";
+import { COLUMNS_WITHOUT_BORDER, createCellStyle, createCellContentWrapperSx, createRowSx, networkModificationTableStyles } from "../network-modification-table-styles.js";
+import { isCompositeModification } from "../utils.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import { mergeSx } from "../../../utils/styles.js";
+function ModificationRow({
+  virtualRow,
+  row,
+  handleCellClick,
+  isRowDragDisabled,
+  highlightedModificationUuid
+}) {
+  const isHighlighted = row.original.uuid === highlightedModificationUuid;
+  const theme = useTheme();
+  const intl = useIntl();
+  const isExpanded = row.getIsExpanded() && row.subRows.length > 0;
+  const handleCellClickCallback = useCallback(
+    (columnId) => {
+      if (columnId === BASE_MODIFICATION_TABLE_COLUMNS.NAME.id) {
+        handleCellClick?.(row.original);
+      }
+    },
+    [handleCellClick, row.original]
+  );
+  return /* @__PURE__ */ jsx(Draggable, { draggableId: row.id, index: virtualRow.index, isDragDisabled: isRowDragDisabled, children: (provided, snapshot) => {
+    const { style, ...draggablePropsWithoutStyle } = provided.draggableProps;
+    return /* @__PURE__ */ jsx(
+      TableRow,
+      {
+        ref: provided.innerRef,
+        ...draggablePropsWithoutStyle,
+        "data-row-id": row.original.uuid,
+        sx: mergeSx(
+          networkModificationTableStyles.tableRow,
+          createRowSx(
+            theme,
+            isHighlighted,
+            snapshot.isDragging,
+            virtualRow,
+            row.depth,
+            isCompositeModification(row.original)
+          )
+        ),
+        children: row.getVisibleCells().map((cell) => {
+          const isNameColumn = cell.column.id === BASE_MODIFICATION_TABLE_COLUMNS.NAME.id;
+          const isDragHandle = cell.column.id === BASE_MODIFICATION_TABLE_COLUMNS.DRAG_HANDLE.id;
+          const isCheckboxColumn = cell.column.id === BASE_MODIFICATION_TABLE_COLUMNS.SELECT.id;
+          const cellContent = flexRender(cell.column.columnDef.cell, cell.getContext());
+          const cellWithoutBorders = (isExpanded || row.depth > 0) && COLUMNS_WITHOUT_BORDER.has(cell.column.columnDef.id ?? "");
+          if (isDragHandle) {
+            return /* @__PURE__ */ jsx(
+              TableCell,
+              {
+                sx: createCellStyle(cell, AUTO_EXTENSIBLE_COLUMNS.includes(cell.column.id)),
+                children: /* @__PURE__ */ jsx(
+                  Box,
+                  {
+                    sx: createCellContentWrapperSx(theme, cellWithoutBorders),
+                    ...provided.dragHandleProps,
+                    "aria-label": intl.formatMessage({ id: "moveModification" }),
+                    children: cellContent
+                  }
+                )
+              },
+              cell.id
+            );
+          }
+          if (isCheckboxColumn) {
+            return /* @__PURE__ */ jsx(
+              TableCell,
+              {
+                sx: createCellStyle(cell, AUTO_EXTENSIBLE_COLUMNS.includes(cell.column.id)),
+                onClick: () => handleCellClickCallback(cell.column.id),
+                children: /* @__PURE__ */ jsx(Box, { sx: createCellContentWrapperSx(theme, cellWithoutBorders), children: cellContent })
+              },
+              cell.id
+            );
+          }
+          return /* @__PURE__ */ jsx(
+            TableCell,
+            {
+              sx: createCellStyle(cell, AUTO_EXTENSIBLE_COLUMNS.includes(cell.column.id)),
+              onClick: () => handleCellClickCallback(cell.column.id),
+              children: isNameColumn ? (
+                // NameCell owns its own borders entirely
+                flexRender(cell.column.columnDef.cell, cell.getContext())
+              ) : /* @__PURE__ */ jsx(Box, { sx: createCellContentWrapperSx(theme, cellWithoutBorders), children: cellContent })
+            },
+            cell.id
+          );
+        })
+      }
+    );
+  } });
+}
+export {
+  ModificationRow
+};

package/dist/features/network-modification-table/use-modifications-drag-and-drop.js

@@ -0,0 +1,192 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { DragCloneRow } from "./row/drag-row-clone.js";
+import "@tanstack/react-table";
+import "@mui/material";
+import "@hello-pangea/dnd";
+import "react-intl";
+import "./columns-definition.js";
+import { DROP_FORBIDDEN_INDICATOR_BOTTOM, DROP_FORBIDDEN_INDICATOR_TOP, DROP_INDICATOR_BOTTOM, DROP_INDICATOR_TOP } from "./network-modification-table-styles.js";
+import { isCompositeModification, MAX_COMPOSITE_NESTING_DEPTH, findModificationInTree, moveSubModificationInTree } from "./utils.js";
+import "../../utils/conversionUtils.js";
+import { snackWithFallback } from "../../utils/error.js";
+import "../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import { injectForbiddenChips, CHIP_ATTR } from "./drag-forbidden-chip.js";
+import { changeCompositeSubModificationOrder, changeNetworkModificationOrder } from "../../services/networkModification.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../hooks/useSnackMessage.js";
+const clearRowDragIndicators = (container) => {
+  const rowElements = container?.querySelectorAll("[data-row-id]");
+  rowElements?.forEach((rowElement) => {
+    rowElement.style.boxShadow = "";
+  });
+  container?.querySelectorAll(`[${CHIP_ATTR}]`).forEach((chip) => chip.remove());
+};
+function getTargetCompositeUuid(droppingIntoExpandedComposite, targetRow) {
+  if (droppingIntoExpandedComposite) {
+    return targetRow.original.uuid;
+  }
+  return targetRow.depth > 0 ? targetRow.getParentRow()?.original.uuid ?? null : null;
+}
+function getTargetSiblings(targetCompositeUuid, rows) {
+  return targetCompositeUuid ? rows.filter((r) => r.depth > 0 && r.getParentRow()?.original.uuid === targetCompositeUuid) : rows.filter((r) => r.depth === 0);
+}
+function getContainerShadow(forbidden, isMovingDown) {
+  if (forbidden) {
+    return isMovingDown ? DROP_FORBIDDEN_INDICATOR_BOTTOM : DROP_FORBIDDEN_INDICATOR_TOP;
+  }
+  return isMovingDown ? DROP_INDICATOR_BOTTOM : DROP_INDICATOR_TOP;
+}
+const useModificationsDragAndDrop = ({
+  table,
+  containerRef,
+  composedModifications,
+  setComposedModifications,
+  onDragEnd,
+  studyUuid = null,
+  currentNodeUuid = void 0
+}) => {
+  const { snackError } = useSnackMessage();
+  const { rows } = table.getRowModel();
+  const computeTargetDepth = useCallback(
+    (sourceRow, targetRow) => {
+      const sourceRowIndex = table.getRowModel().flatRows.findIndex((row) => {
+        return row.id === sourceRow.id;
+      });
+      const targetRowIndex = table.getRowModel().flatRows.findIndex((row) => {
+        return row.id === targetRow.id;
+      });
+      const isDraggingDown = sourceRowIndex < targetRowIndex;
+      return isCompositeModification(targetRow.original) && targetRow.getIsExpanded() && isDraggingDown ? targetRow.depth + 1 : targetRow.depth;
+    },
+    [table]
+  );
+  const isDropForbidden = useCallback(
+    (sourceRow, targetRow) => {
+      if (isCompositeModification(sourceRow.original)) {
+        const targetDepth = computeTargetDepth(sourceRow, targetRow);
+        return (sourceRow.original.maxDepth ?? 0) + targetDepth > MAX_COMPOSITE_NESTING_DEPTH || !!(isCompositeModification(sourceRow.original) && findModificationInTree(targetRow.original.uuid, [sourceRow.original]));
+      }
+      return false;
+    },
+    [computeTargetDepth]
+  );
+  const handleDragUpdate = useCallback(
+    (update) => {
+      clearRowDragIndicators(containerRef.current);
+      const { source, destination } = update;
+      if (!destination || source.index === destination.index) {
+        return;
+      }
+      const sourceRow = rows[source.index];
+      const targetRow = rows[destination.index];
+      const el = containerRef.current?.querySelector(`[data-row-id="${targetRow?.original.uuid}"]`);
+      if (!el) {
+        return;
+      }
+      const forbidden = isDropForbidden(sourceRow, targetRow);
+      const isMovingDown = destination.index > source.index;
+      el.style.boxShadow = getContainerShadow(forbidden, isMovingDown);
+      if (forbidden && containerRef.current) {
+        injectForbiddenChips(containerRef.current, el, isMovingDown);
+      }
+    },
+    [containerRef, isDropForbidden, rows]
+  );
+  const handleDragEndComposite = useCallback(
+    (sourceRow, targetRow, droppingIntoExpandedComposite, isDraggingDown) => {
+      const movingUuid = sourceRow.original.uuid;
+      const sourceCompositeUuid = sourceRow.depth > 0 ? sourceRow.getParentRow()?.original.uuid ?? null : null;
+      const targetCompositeUuid = getTargetCompositeUuid(droppingIntoExpandedComposite, targetRow);
+      const targetSiblings = getTargetSiblings(targetCompositeUuid, rows);
+      let beforeUuid;
+      if (droppingIntoExpandedComposite) {
+        beforeUuid = targetSiblings[0]?.original.uuid ?? null;
+      } else {
+        const landingIndexInSiblings = targetSiblings.findIndex(
+          (r) => r.original.uuid === targetRow.original.uuid
+        );
+        const beforeSiblingIndex = isDraggingDown ? landingIndexInSiblings + 1 : landingIndexInSiblings;
+        beforeUuid = targetSiblings[beforeSiblingIndex]?.original.uuid ?? null;
+      }
+      const previousComposed = composedModifications;
+      setComposedModifications(
+        (prev) => moveSubModificationInTree(movingUuid, sourceCompositeUuid, targetCompositeUuid, beforeUuid, prev)
+      );
+      changeCompositeSubModificationOrder(
+        studyUuid,
+        currentNodeUuid,
+        movingUuid,
+        sourceCompositeUuid,
+        targetCompositeUuid,
+        beforeUuid
+      ).catch((error) => {
+        snackWithFallback(snackError, error, { headerId: "errReorderModificationMsg" });
+        setComposedModifications(previousComposed);
+      });
+    },
+    [rows, studyUuid, currentNodeUuid, snackError, composedModifications, setComposedModifications]
+  );
+  const handleDragEnd = useCallback(
+    (result) => {
+      clearRowDragIndicators(containerRef.current);
+      onDragEnd();
+      const { source, destination } = result;
+      if (!destination || source.index === destination.index) {
+        return;
+      }
+      const sourceRow = rows[source.index];
+      const targetRow = rows[destination.index];
+      if (isDropForbidden(sourceRow, targetRow)) {
+        return;
+      }
+      const isSubRowInvolved = sourceRow.depth > 0 || targetRow.depth > 0;
+      const isDraggingDown = destination.index > source.index;
+      const droppingIntoExpandedComposite = isDraggingDown && targetRow.getIsExpanded();
+      if (isSubRowInvolved || droppingIntoExpandedComposite) {
+        handleDragEndComposite(sourceRow, targetRow, droppingIntoExpandedComposite, isDraggingDown);
+      } else {
+        const sourceDepth0Uuid = sourceRow.original.uuid;
+        const targetDepth0Uuid = targetRow.original.uuid;
+        const oldPosition = composedModifications.findIndex((m) => m.uuid === sourceDepth0Uuid);
+        const newPosition = composedModifications.findIndex((m) => m.uuid === targetDepth0Uuid);
+        if (oldPosition === -1 || newPosition === -1 || oldPosition === newPosition || !currentNodeUuid) {
+          return;
+        }
+        const previousModifications = [...composedModifications];
+        const updatedModifications = [...composedModifications];
+        const [movedItem] = updatedModifications.splice(oldPosition, 1);
+        updatedModifications.splice(newPosition, 0, movedItem);
+        setComposedModifications(updatedModifications);
+        const before = updatedModifications[newPosition + 1]?.uuid ?? null;
+        changeNetworkModificationOrder(studyUuid, currentNodeUuid, movedItem.uuid, before).catch((error) => {
+          snackWithFallback(snackError, error, { headerId: "errReorderModificationMsg" });
+          setComposedModifications(previousModifications);
+        });
+      }
+    },
+    [
+      containerRef,
+      onDragEnd,
+      rows,
+      isDropForbidden,
+      handleDragEndComposite,
+      composedModifications,
+      currentNodeUuid,
+      setComposedModifications,
+      studyUuid,
+      snackError
+    ]
+  );
+  const renderClone = useCallback(
+    (provided, _snapshot, rubric) => /* @__PURE__ */ jsx("div", { ref: provided.innerRef, ...provided.draggableProps, ...provided.dragHandleProps, children: /* @__PURE__ */ jsx(DragCloneRow, { row: rows[rubric.source.index] }) }),
+    [rows]
+  );
+  return { handleDragUpdate, handleDragEnd, renderClone };
+};
+export {
+  useModificationsDragAndDrop
+};

package/dist/features/network-modification-table/utils.js

@@ -0,0 +1,165 @@
+import "../../utils/conversionUtils.js";
+import "../../utils/types/equipmentType.js";
+import { MODIFICATION_TYPES } from "../../utils/types/modificationType.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { getNetworkModificationsFromComposite } from "../../services/networkModification.js";
+const MAX_COMPOSITE_NESTING_DEPTH = 5;
+const formatToComposedModification = (modifications) => {
+  return modifications.map((modification) => ({ ...modification, subModifications: [] }));
+};
+function isCompositeModification(modification) {
+  return modification?.messageType === MODIFICATION_TYPES.COMPOSITE_MODIFICATION.type;
+}
+function findAllLoadedCompositeModifications(modifications, composites) {
+  modifications.forEach((modification) => {
+    if (isCompositeModification(modification) && modification.subModifications.length > 0) {
+      composites.push(modification);
+      findAllLoadedCompositeModifications(modification.subModifications, composites);
+    }
+  });
+}
+function findModificationInTree(uuid, mods) {
+  for (const mod of mods) {
+    if (mod.uuid === uuid) {
+      return mod;
+    }
+    const found = findModificationInTree(uuid, mod.subModifications);
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+function updateSubModificationsOfACompositeInTree(parentModUuid, subModifications, tree) {
+  return tree.map((m) => {
+    if (m.uuid === parentModUuid) {
+      return { ...m, subModifications };
+    }
+    if (m.subModifications.length > 0) {
+      return {
+        ...m,
+        subModifications: updateSubModificationsOfACompositeInTree(
+          parentModUuid,
+          subModifications,
+          m.subModifications
+        )
+      };
+    }
+    return m;
+  });
+}
+function mergeSubModificationsIntoTree(nextMods, prevMods) {
+  return nextMods.map((nextMod) => {
+    const prevMod = prevMods.find((m) => m.uuid === nextMod.uuid);
+    if (!prevMod || prevMod.subModifications.length === 0) {
+      return nextMod;
+    }
+    return {
+      ...nextMod,
+      subModifications: mergeSubModificationsIntoTree(
+        nextMod.subModifications.length > 0 ? nextMod.subModifications : prevMod.subModifications,
+        prevMod.subModifications
+      )
+    };
+  });
+}
+function updateModificationFieldInTree(uuid, fields, mods) {
+  return mods.map((m) => {
+    if (m.uuid === uuid) {
+      return { ...m, ...fields };
+    }
+    if (m.subModifications.length > 0) {
+      return { ...m, subModifications: updateModificationFieldInTree(uuid, fields, m.subModifications) };
+    }
+    return m;
+  });
+}
+function getModificationInTree(modUuid, sourceParentUuid, mods) {
+  if (sourceParentUuid) {
+    const sourceMod = findModificationInTree(sourceParentUuid, mods);
+    if (!sourceMod) {
+      return void 0;
+    }
+    return sourceMod.subModifications.find((m) => m.uuid === modUuid);
+  }
+  return mods.find((m) => m.uuid === modUuid);
+}
+function moveSubModificationInTree(movingUuid, sourceParentUuid, targetParentUuid, beforeUuid, mods) {
+  const movedMod = getModificationInTree(
+    movingUuid,
+    sourceParentUuid,
+    mods
+  );
+  if (!movedMod) {
+    console.error(`Can't find the ${movingUuid} modification that should be moved`);
+    return mods;
+  }
+  let modsWithoutTheMovedModification;
+  if (sourceParentUuid) {
+    const sourceMod = findModificationInTree(sourceParentUuid, mods);
+    if (!sourceMod) {
+      return mods;
+    }
+    const newSourceSubs = sourceMod.subModifications.filter((m) => m.uuid !== movingUuid);
+    modsWithoutTheMovedModification = updateSubModificationsOfACompositeInTree(
+      sourceParentUuid,
+      newSourceSubs,
+      mods
+    );
+  } else {
+    modsWithoutTheMovedModification = mods.filter((m) => m.uuid !== movingUuid);
+  }
+  if (targetParentUuid) {
+    const targetMod = findModificationInTree(targetParentUuid, modsWithoutTheMovedModification);
+    if (!targetMod) {
+      return mods;
+    }
+    const newTargetSubs = [...targetMod.subModifications];
+    const insertIdx2 = beforeUuid ? newTargetSubs.findIndex((m) => m.uuid === beforeUuid) : -1;
+    newTargetSubs.splice(insertIdx2 === -1 ? newTargetSubs.length : insertIdx2, 0, movedMod);
+    return updateSubModificationsOfACompositeInTree(
+      targetParentUuid,
+      newTargetSubs,
+      modsWithoutTheMovedModification
+    );
+  }
+  const insertIdx = beforeUuid ? modsWithoutTheMovedModification.findIndex((m) => m.uuid === beforeUuid) : -1;
+  const result = [...modsWithoutTheMovedModification];
+  result.splice(insertIdx === -1 ? result.length : insertIdx, 0, movedMod);
+  return result;
+}
+function fetchSubModificationsForExpandedRows(expandedIds, mods, setMods, force = false) {
+  const uuidsToFetch = expandedIds.filter((id) => {
+    const mod = findModificationInTree(id, mods);
+    return isCompositeModification(mod) && (force || mod?.subModifications.length === 0);
+  });
+  if (uuidsToFetch.length === 0) {
+    return;
+  }
+  getNetworkModificationsFromComposite(uuidsToFetch).then((subModsByUuid) => {
+    setMods(
+      (prev) => Object.entries(subModsByUuid).reduce((tree, [uuid, subMods]) => {
+        const liveModifications = formatToComposedModification(subMods.filter((m) => !m.stashed));
+        const existingMod = findModificationInTree(uuid, tree);
+        const mergedSubs = mergeSubModificationsIntoTree(
+          liveModifications,
+          existingMod?.subModifications ?? []
+        );
+        return updateSubModificationsOfACompositeInTree(uuid, mergedSubs, tree);
+      }, prev)
+    );
+  });
+}
+export {
+  MAX_COMPOSITE_NESTING_DEPTH,
+  fetchSubModificationsForExpandedRows,
+  findAllLoadedCompositeModifications,
+  findModificationInTree,
+  formatToComposedModification,
+  isCompositeModification,
+  mergeSubModificationsIntoTree,
+  moveSubModificationInTree,
+  updateModificationFieldInTree,
+  updateSubModificationsOfACompositeInTree
+};

package/dist/features/network-modifications/battery/creation/BatteryCreationForm.js

@@ -0,0 +1,121 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import { filledTextField } from "../../common/form.utils.js";
+import { PropertiesForm } from "../../common/properties/PropertiesForm.js";
+import "react";
+import "react-hook-form";
+import { ActivePowerAdornment } from "../../../../utils/constants/adornments.js";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import "react-intl";
+import "../../../../components/ui/overflowableText/OverflowableText.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../../../components/ui/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "../../../../components/ui/treeViewFinder/TreeViewFinder.js";
+import { FloatInput } from "../../../../components/ui/reactHookForm/numbers/FloatInput.js";
+import { TextInput } from "../../../../components/ui/reactHookForm/text/TextInput.js";
+import "../../../../components/ui/reactHookForm/numbers/RangeInput.js";
+import "@material-symbols/svg-400/outlined/left_panel_open.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_output.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_input.svg?react";
+import "@material-symbols/svg-400/outlined/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes.svg?react";
+import "../../../../components/ui/dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../../../components/ui/reactHookForm/expandableInput/ExpandableInput.js";
+import "@hello-pangea/dnd";
+import "../../../../components/ui/dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../../../../components/ui/snackbarProvider/SnackbarProvider.js";
+import "mui-nested-menu";
+import "react-resizable-panels";
+import "../../common/properties/propertyUtils.js";
+import GridSection from "../../../../components/composite/grid/grid-section.js";
+import "react-dom";
+import "autosuggest-highlight/match";
+import "autosuggest-highlight/parse";
+import "clsx";
+import "../../../../components/composite/filter/FilterCreationDialog.js";
+import "../../../../components/composite/filter/HeaderFilterForm.js";
+import "../../../../components/composite/filter/explicitNaming/ExplicitNamingFilterForm.js";
+import "../../../../components/composite/filter/expert/ExpertFilterForm.js";
+import "../../../../components/composite/filter/expert/ExpertFilterEditionDialog.js";
+import "../../../../components/composite/filter/expert/expertFilterConstants.js";
+import "react-querybuilder";
+import "uuid";
+import "../../../../components/composite/filter/explicitNaming/ExplicitNamingFilterEditionDialog.js";
+import "../../../../components/composite/filter/utils/filterFormUtils.js";
+import GridItem from "../../../../components/composite/grid/grid-item.js";
+import "@react-querybuilder/material";
+import "../../../../components/composite/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "../../../../components/composite/reactQueryBuilder/PropertyValueEditor.js";
+import "../../../../components/composite/agGridTable/BottomRightButtons.js";
+import "../../../../components/composite/customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import { SetPointsForm } from "../../common/setpoints/SetPointsForm.js";
+import { ConnectivityForm } from "../../common/connectivity/ConnectivityForm.js";
+import { ActivePowerControlForm } from "../../common/activePowerControl/ActivePowerControlForm.js";
+import { ShortCircuitForm } from "../../common/shortCircuit/ShortCircuitForm.js";
+import { ReactiveLimitsForm } from "../../common/reactiveLimits/ReactiveLimitsForm.js";
+import "../../common/regulatingTerminal/RegulatingTerminalForm.js";
+function BatteryCreationForm({
+  voltageLevelOptions,
+  fetchBusesOrBusbarSections,
+  PositionDiagramPane
+}) {
+  const batteryIdField = /* @__PURE__ */ jsx(TextInput, { name: FieldConstants.EQUIPMENT_ID, label: "ID", formProps: { autoFocus: true, ...filledTextField } });
+  const batteryNameField = /* @__PURE__ */ jsx(TextInput, { name: FieldConstants.EQUIPMENT_NAME, label: "Name", formProps: filledTextField });
+  const connectivityForm = /* @__PURE__ */ jsx(
+    ConnectivityForm,
+    {
+      voltageLevelOptions,
+      PositionDiagramPane,
+      fetchBusesOrBusbarSections
+    }
+  );
+  const maximumActivePowerField = /* @__PURE__ */ jsx(
+    FloatInput,
+    {
+      name: FieldConstants.MAXIMUM_ACTIVE_POWER,
+      label: "MaximumActivePowerText",
+      adornment: ActivePowerAdornment
+    }
+  );
+  const minimumActivePowerField = /* @__PURE__ */ jsx(
+    FloatInput,
+    {
+      name: FieldConstants.MINIMUM_ACTIVE_POWER,
+      label: "MinimumActivePowerText",
+      adornment: ActivePowerAdornment
+    }
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(Grid, { container: true, spacing: 2, children: [
+      /* @__PURE__ */ jsx(GridItem, { size: 4, children: batteryIdField }),
+      /* @__PURE__ */ jsx(GridItem, { size: 4, children: batteryNameField })
+    ] }),
+    /* @__PURE__ */ jsx(GridSection, { title: "Connectivity" }),
+    /* @__PURE__ */ jsx(Grid, { container: true, spacing: 2, children: /* @__PURE__ */ jsx(GridItem, { size: 12, children: connectivityForm }) }),
+    /* @__PURE__ */ jsx(GridSection, { title: "ActiveLimits" }),
+    /* @__PURE__ */ jsxs(Grid, { container: true, spacing: 2, children: [
+      /* @__PURE__ */ jsx(GridItem, { size: 4, children: minimumActivePowerField }),
+      /* @__PURE__ */ jsx(GridItem, { size: 4, children: maximumActivePowerField })
+    ] }),
+    /* @__PURE__ */ jsx(GridSection, { title: "ReactiveLimits" }),
+    /* @__PURE__ */ jsx(ReactiveLimitsForm, {}),
+    /* @__PURE__ */ jsx(SetPointsForm, {}),
+    /* @__PURE__ */ jsx(Grid, { container: true, spacing: 2, paddingTop: 2, children: /* @__PURE__ */ jsx(ActivePowerControlForm, {}) }),
+    /* @__PURE__ */ jsx(GridSection, { title: "ShortCircuit" }),
+    /* @__PURE__ */ jsx(ShortCircuitForm, {}),
+    /* @__PURE__ */ jsx(PropertiesForm, { networkElementType: "battery" })
+  ] });
+}
+export {
+  BatteryCreationForm
+};