@gridsuite/commons-ui 0.241.0 → 0.242.0

package/dist/features/network-modifications/common/currentLimits/limitsPane.utils.js

@@ -0,0 +1,337 @@
+import { object, array, boolean, string, number } from "yup";
+import { OPERATIONAL_LIMITS_GROUPS_MODIFICATION_TYPE } from "./operationalLimitsGroups/operationalLimitsGroups.types.js";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import { toModificationOperation } from "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import { OperationType } from "../../../../utils/types/network-modification-types.js";
+import { areArrayElementsUnique } from "../../../../utils/functions.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { sanitizeString } from "../../../../utils/ts-utils.js";
+import { APPLICABILITY, TEMPORARY_LIMIT_MODIFICATION_TYPE } from "./limits.types.js";
+import "react";
+import "react-hook-form";
+import { creationPropertiesSchema } from "../properties/propertyUtils.js";
+import "@mui/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 "../../../../components/ui/treeViewFinder/TreeViewFinder.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 "../../../../components/ui/reactHookForm/directory-item-input/directory-item-utils.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 "react-papaparse";
+function hasDuplicateOperationalLimitsGroups(context) {
+  const limitsGroup = context.parent;
+  const operationalLimitsGroups = context.from?.[1]?.value?.[FieldConstants.OPERATIONAL_LIMITS_GROUPS] ?? [];
+  const operationalLimitsGroupsWithPath = operationalLimitsGroups.map(
+    (item, index) => {
+      return {
+        ...item,
+        rhfPath: `${FieldConstants.LIMITS}.${FieldConstants.OPERATIONAL_LIMITS_GROUPS}[${index}]`
+      };
+    }
+  );
+  const limitsGroupName = sanitizeString(limitsGroup[FieldConstants.NAME]);
+  const filtered = operationalLimitsGroupsWithPath.filter(
+    (item) => sanitizeString(item[FieldConstants.NAME]) === limitsGroupName
+  );
+  if (filtered.length <= 1) {
+    return true;
+  }
+  const applicabilityEquipment = filtered.filter(
+    (item) => item[FieldConstants.APPLICABILITY_FIELD] === APPLICABILITY.EQUIPMENT.id
+  ).length;
+  const applicabilitySide1 = filtered.filter(
+    (item) => item[FieldConstants.APPLICABILITY_FIELD] === APPLICABILITY.SIDE1.id
+  ).length;
+  const isDuplicate = filtered.length > 2 || applicabilityEquipment > 0 || applicabilitySide1 === 0 || applicabilitySide1 > 1;
+  return !isDuplicate;
+}
+function hasDuplicate(field, context) {
+  return hasDuplicateOperationalLimitsGroups(context);
+}
+const temporaryLimitsValidationSchema = () => {
+  return object().shape(
+    {
+      [FieldConstants.TEMPORARY_LIMIT_DURATION]: number().nullable().min(0, "mustBeGreaterOrEqualToZero").when([FieldConstants.TEMPORARY_LIMIT_VALUE, FieldConstants.TEMPORARY_LIMIT_NAME], {
+        is: (value, name) => value != null || !!name,
+        then: (schema) => schema.required()
+      }),
+      [FieldConstants.TEMPORARY_LIMIT_VALUE]: number().nullable().positive(),
+      [FieldConstants.TEMPORARY_LIMIT_NAME]: string().nullable().trim().when([FieldConstants.TEMPORARY_LIMIT_VALUE, FieldConstants.TEMPORARY_LIMIT_DURATION], {
+        is: (value, duration) => value != null || duration != null,
+        then: (schema) => schema.required()
+      })
+    },
+    [[FieldConstants.TEMPORARY_LIMIT_DURATION, FieldConstants.TEMPORARY_LIMIT_NAME]]
+  );
+};
+const currentLimitsValidationSchema = () => ({
+  [FieldConstants.PERMANENT_LIMIT]: number().positive("permanentCurrentLimitMustBeGreaterThanZero").required(),
+  [FieldConstants.TEMPORARY_LIMITS]: array().of(temporaryLimitsValidationSchema()).test("distinctNames", "TemporaryLimitNameUnicityError", (limitsArray) => {
+    const namesArray = !limitsArray ? [] : limitsArray.filter((l) => !!l[FieldConstants.TEMPORARY_LIMIT_NAME]).map((l) => sanitizeString(l[FieldConstants.TEMPORARY_LIMIT_NAME]));
+    return areArrayElementsUnique(namesArray);
+  }).test("distinctDurations", "TemporaryLimitDurationUnicityError", (limitsArray) => {
+    const durationsArray = !limitsArray ? [] : limitsArray.map((l) => l[FieldConstants.TEMPORARY_LIMIT_DURATION]).filter((d) => d);
+    return areArrayElementsUnique(durationsArray);
+  })
+});
+const limitsPropertyValidationSchema = () => {
+  return object().shape({
+    [FieldConstants.NAME]: string().required(),
+    [FieldConstants.VALUE]: string().required()
+  });
+};
+const limitsGroupValidationSchema = object().shape({
+  [FieldConstants.ID]: string().nonNullable().required(),
+  [FieldConstants.NAME]: string().nonNullable().required(),
+  [FieldConstants.APPLICABILITY_FIELD]: string().nonNullable().required(),
+  [FieldConstants.OLG_IS_DUPLICATE]: boolean().nullable().test("testDistinct", "LimitSetApplicabilityError", hasDuplicate),
+  [FieldConstants.CURRENT_LIMITS]: object().shape(currentLimitsValidationSchema()),
+  [FieldConstants.LIMITS_PROPERTIES]: array().of(limitsPropertyValidationSchema())
+}).concat(creationPropertiesSchema).required();
+const getLimitsValidationSchemaProps = (isEquipmentModification = false) => object().shape({
+  [FieldConstants.OPERATIONAL_LIMITS_GROUPS]: isEquipmentModification ? array(limitsGroupValidationSchema).when([FieldConstants.ENABLE_OLG_MODIFICATION], {
+    is: true,
+    then: (schema) => schema.required(),
+    otherwise: (schema) => schema.strip()
+  }) : array(limitsGroupValidationSchema).required(),
+  [FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID1]: string().nullable(),
+  [FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID2]: string().nullable(),
+  [FieldConstants.ENABLE_OLG_MODIFICATION]: boolean()
+});
+const limitsValidationSchemaCreation = (id, isModification) => {
+  return { [id]: getLimitsValidationSchemaProps(isModification) };
+};
+const getLimitsValidationSchema = (id = FieldConstants.LIMITS, isModification = false) => {
+  return limitsValidationSchemaCreation(id, isModification);
+};
+const getLimitsEmptyFormDataProps = (isModification = true) => {
+  return {
+    [FieldConstants.OPERATIONAL_LIMITS_GROUPS]: [],
+    [FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID1]: null,
+    [FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID2]: null,
+    [FieldConstants.ENABLE_OLG_MODIFICATION]: !isModification
+  };
+};
+const getLimitsEmptyFormData = (isModification = true, id = FieldConstants.LIMITS) => {
+  return { [id]: getLimitsEmptyFormDataProps(isModification) };
+};
+const formatTemporaryLimitsModificationToFormSchema = (temporaryLimits) => temporaryLimits?.map((limit) => {
+  return {
+    [FieldConstants.TEMPORARY_LIMIT_NAME]: limit?.[FieldConstants.TEMPORARY_LIMIT_NAME]?.value ?? "",
+    [FieldConstants.TEMPORARY_LIMIT_VALUE]: limit?.[FieldConstants.TEMPORARY_LIMIT_VALUE]?.value ?? null,
+    [FieldConstants.TEMPORARY_LIMIT_DURATION]: limit?.[FieldConstants.TEMPORARY_LIMIT_DURATION]?.value ?? null
+  };
+});
+const formatOpLimitGroupsToFormInfos = (limitGroups) => {
+  if (!limitGroups) {
+    return [];
+  }
+  return limitGroups.filter(
+    (opLimitGroup) => opLimitGroup.modificationType !== OPERATIONAL_LIMITS_GROUPS_MODIFICATION_TYPE.DELETE
+  ).map((opLimitGroup) => {
+    return {
+      id: opLimitGroup.id + opLimitGroup.applicability,
+      name: opLimitGroup.id,
+      applicability: opLimitGroup.applicability,
+      limitsProperties: opLimitGroup.limitsProperties,
+      currentLimits: {
+        permanentLimit: opLimitGroup?.currentLimits?.permanentLimit,
+        temporaryLimits: formatTemporaryLimitsModificationToFormSchema(
+          opLimitGroup?.currentLimits?.temporaryLimits
+        )
+      }
+    };
+  });
+};
+const getAllLimitsFormDataProperties = (operationalLimitsGroups = [], selectedOperationalLimitsGroupId1 = null, selectedOperationalLimitsGroupId2 = null, enableOLGModification = true) => {
+  return {
+    [FieldConstants.OPERATIONAL_LIMITS_GROUPS]: operationalLimitsGroups,
+    [FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID1]: selectedOperationalLimitsGroupId1,
+    [FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID2]: selectedOperationalLimitsGroupId2,
+    [FieldConstants.ENABLE_OLG_MODIFICATION]: !!enableOLGModification
+  };
+};
+const getAllLimitsFormData = (operationalLimitsGroups = [], selectedOperationalLimitsGroupId1 = null, selectedOperationalLimitsGroupId2 = null, enableOLGModification = true, id = FieldConstants.LIMITS) => {
+  return {
+    [id]: getAllLimitsFormDataProperties(
+      operationalLimitsGroups,
+      selectedOperationalLimitsGroupId1,
+      selectedOperationalLimitsGroupId2,
+      enableOLGModification
+    )
+  };
+};
+const sanitizeLimitsGroups = (limitsGroups = []) => (limitsGroups || []).map(({ currentLimits, [FieldConstants.OLG_IS_DUPLICATE]: isDuplicate, ...baseData }) => ({
+  ...baseData,
+  [FieldConstants.OLG_IS_DUPLICATE]: isDuplicate ?? void 0,
+  id: baseData.name,
+  currentLimits: !currentLimits ? {
+    id: "",
+    permanentLimit: 0,
+    temporaryLimits: []
+  } : {
+    permanentLimit: currentLimits.permanentLimit,
+    temporaryLimits: !currentLimits.temporaryLimits ? [] : currentLimits.temporaryLimits.filter((limit) => limit?.name?.trim()).map(({ name, ...temporaryLimit }) => ({
+      ...temporaryLimit,
+      name: sanitizeString(name) ?? ""
+    }))
+  }
+}));
+const sanitizeLimitNames = (temporaryLimitList) => temporaryLimitList?.filter((limit) => limit?.name?.trim()).map(({ name, ...temporaryLimit }) => ({
+  ...temporaryLimit,
+  name: sanitizeString(name) ?? ""
+})) || [];
+const formatMapInfosToTemporaryLimitsFormSchema = (temporaryLimits) => temporaryLimits?.map((limit) => {
+  return {
+    [FieldConstants.TEMPORARY_LIMIT_NAME]: limit?.[FieldConstants.TEMPORARY_LIMIT_NAME] ?? "",
+    [FieldConstants.TEMPORARY_LIMIT_VALUE]: limit?.[FieldConstants.TEMPORARY_LIMIT_VALUE] ?? null,
+    [FieldConstants.TEMPORARY_LIMIT_DURATION]: limit?.[FieldConstants.TEMPORARY_LIMIT_DURATION] ?? null
+  };
+});
+const mapServerLimitsGroupsToFormInfos = (currentLimits) => {
+  return currentLimits?.map((currentLimit) => {
+    return {
+      id: currentLimit.id + currentLimit.applicability,
+      name: currentLimit.id,
+      applicability: currentLimit.applicability,
+      limitsProperties: currentLimit.limitsProperties,
+      currentLimits: {
+        id: currentLimit.id,
+        permanentLimit: currentLimit.permanentLimit,
+        temporaryLimits: formatMapInfosToTemporaryLimitsFormSchema(currentLimit.temporaryLimits)
+      }
+    };
+  });
+};
+const convertToOperationalLimitsGroupFormSchema = (currentLimits) => {
+  const updatedOpLG = [];
+  currentLimits.forEach((currentLimit) => {
+    const equivalentFromNetMod = updatedOpLG.find(
+      (opLG) => currentLimit.id === opLG.name && currentLimit.applicability === opLG[FieldConstants.APPLICABILITY_FIELD]
+    );
+    if (equivalentFromNetMod === void 0) {
+      updatedOpLG.push({
+        id: currentLimit.id + currentLimit.applicability,
+        name: currentLimit.id,
+        applicability: currentLimit.applicability,
+        limitsProperties: currentLimit.limitsProperties,
+        currentLimits: {
+          permanentLimit: currentLimit.permanentLimit ?? 0,
+          temporaryLimits: formatMapInfosToTemporaryLimitsFormSchema(currentLimit.temporaryLimits)
+        }
+      });
+    }
+  });
+  return updatedOpLG;
+};
+const addModificationTypeToTemporaryLimits = (formTemporaryLimits) => {
+  return formTemporaryLimits.map((limit) => {
+    return {
+      name: toModificationOperation(limit?.name),
+      acceptableDuration: toModificationOperation(limit?.acceptableDuration),
+      value: toModificationOperation(limit?.value),
+      modificationType: TEMPORARY_LIMIT_MODIFICATION_TYPE.MODIFY_OR_ADD
+    };
+  });
+};
+function addOperationTypeToSelectedOpLG(selectedOpLG, noSelectionString) {
+  return selectedOpLG === noSelectionString ? {
+    value: selectedOpLG,
+    op: OperationType.UNSET
+  } : toModificationOperation(selectedOpLG);
+}
+const addModificationTypeToOpLimitsGroups = (limitsGroupsForm) => {
+  const modificationLimitsGroupsForm = sanitizeLimitsGroups(limitsGroupsForm);
+  return modificationLimitsGroupsForm.map((limitsGroupForm) => {
+    const temporaryLimits = addModificationTypeToTemporaryLimits(
+      sanitizeLimitNames(limitsGroupForm[FieldConstants.CURRENT_LIMITS]?.[FieldConstants.TEMPORARY_LIMITS])
+    );
+    const currentLimits = {
+      permanentLimit: limitsGroupForm[FieldConstants.CURRENT_LIMITS]?.[FieldConstants.PERMANENT_LIMIT] ?? null,
+      temporaryLimits: temporaryLimits ?? []
+    };
+    return {
+      id: limitsGroupForm.id,
+      name: limitsGroupForm.name,
+      applicability: limitsGroupForm.applicability,
+      limitsProperties: limitsGroupForm.limitsProperties,
+      currentLimits,
+      modificationType: OPERATIONAL_LIMITS_GROUPS_MODIFICATION_TYPE.MODIFY_OR_ADD,
+      temporaryLimitsModificationType: TEMPORARY_LIMIT_MODIFICATION_TYPE.REPLACE
+    };
+  });
+};
+function generateEmptyTemporaryLimitArray() {
+  return [
+    {
+      [FieldConstants.TEMPORARY_LIMIT_NAME]: "",
+      [FieldConstants.TEMPORARY_LIMIT_DURATION]: null,
+      [FieldConstants.TEMPORARY_LIMIT_VALUE]: null
+    }
+  ];
+}
+function generateEmptyOperationalLimitsGroup(name) {
+  return {
+    [FieldConstants.ID]: crypto.randomUUID(),
+    [FieldConstants.NAME]: name,
+    [FieldConstants.APPLICABILITY_FIELD]: APPLICABILITY.EQUIPMENT.id,
+    [FieldConstants.LIMITS_PROPERTIES]: [],
+    [FieldConstants.CURRENT_LIMITS]: {
+      [FieldConstants.TEMPORARY_LIMITS]: generateEmptyTemporaryLimitArray(),
+      [FieldConstants.PERMANENT_LIMIT]: null
+    }
+  };
+}
+function generateUniqueId(baseName, names) {
+  let finalId = baseName;
+  let found = false;
+  let increment = 1;
+  let suffix = "";
+  do {
+    found = names.includes(baseName + suffix, 0);
+    if (found) {
+      increment += 1;
+      suffix = `(${increment})`;
+      finalId = baseName + suffix;
+    }
+  } while (found);
+  return finalId;
+}
+export {
+  addModificationTypeToOpLimitsGroups,
+  addModificationTypeToTemporaryLimits,
+  addOperationTypeToSelectedOpLG,
+  convertToOperationalLimitsGroupFormSchema,
+  formatMapInfosToTemporaryLimitsFormSchema,
+  formatOpLimitGroupsToFormInfos,
+  formatTemporaryLimitsModificationToFormSchema,
+  generateEmptyOperationalLimitsGroup,
+  generateUniqueId,
+  getAllLimitsFormData,
+  getAllLimitsFormDataProperties,
+  getLimitsEmptyFormData,
+  getLimitsEmptyFormDataProps,
+  getLimitsValidationSchema,
+  getLimitsValidationSchemaProps,
+  mapServerLimitsGroupsToFormInfos,
+  sanitizeLimitNames,
+  sanitizeLimitsGroups
+};

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/LimitsGroupsContextualMenu.d.ts

@@ -0,0 +1,25 @@
+import { FieldValues, UseFieldArrayAppend, UseFieldArrayRemove } from 'react-hook-form';
+import { Dispatch, SetStateAction } from 'react';
+import { OperationalLimitsGroupFormSchema } from './operationalLimitsGroups.types';
+import { CurrentLimitsData } from '../limits.types';
+export interface ContextMenuCoordinates {
+    x: null | number;
+    y: null | number;
+    tabIndex: null | number;
+}
+export interface LimitsGroupsContextualMenuProps {
+    parentFormName: string;
+    indexSelectedLimitSet: number | null;
+    setIndexSelectedLimitSet: Dispatch<SetStateAction<number | null>>;
+    handleCloseMenu: () => void;
+    contextMenuCoordinates: ContextMenuCoordinates;
+    selectedLimitsGroups1: string;
+    selectedLimitsGroups2: string;
+    currentLimitsToModify: CurrentLimitsData[];
+    operationalLimitsGroups: FieldValues;
+    appendToLimitsGroups: UseFieldArrayAppend<{
+        [p: string]: OperationalLimitsGroupFormSchema[];
+    }, string>;
+    removeLimitsGroups: UseFieldArrayRemove;
+}
+export declare function LimitsGroupsContextualMenu({ parentFormName, indexSelectedLimitSet, setIndexSelectedLimitSet, handleCloseMenu, contextMenuCoordinates, selectedLimitsGroups1, selectedLimitsGroups2, operationalLimitsGroups, appendToLimitsGroups, removeLimitsGroups, }: Readonly<LimitsGroupsContextualMenuProps>): import("react").JSX.Element;

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/LimitsGroupsContextualMenu.js

@@ -0,0 +1,92 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useFormContext } from "react-hook-form";
+import { Menu, MenuItem, ListItemIcon, ListItemText } from "@mui/material";
+import { Delete, ContentCopy } from "@mui/icons-material";
+import { useIntl } from "react-intl";
+import { useCallback } from "react";
+import { APPLICABILITY } from "../limits.types.js";
+import { FieldConstants } from "../../../../../utils/constants/fieldConstants.js";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+function LimitsGroupsContextualMenu({
+  parentFormName,
+  indexSelectedLimitSet,
+  setIndexSelectedLimitSet,
+  handleCloseMenu,
+  contextMenuCoordinates,
+  selectedLimitsGroups1,
+  selectedLimitsGroups2,
+  operationalLimitsGroups,
+  appendToLimitsGroups,
+  removeLimitsGroups
+}) {
+  const intl = useIntl();
+  const { setValue } = useFormContext();
+  const handleDeleteTab = useCallback(() => {
+    if (indexSelectedLimitSet !== null) {
+      const tabName = operationalLimitsGroups[indexSelectedLimitSet]?.name;
+      const applicability = operationalLimitsGroups[indexSelectedLimitSet]?.applicability ?? "";
+      if (selectedLimitsGroups1 === tabName && (applicability === APPLICABILITY.SIDE1.id || applicability === APPLICABILITY.EQUIPMENT.id)) {
+        setValue(`${parentFormName}.${FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID1}`, null);
+      }
+      if (selectedLimitsGroups2 === tabName && (applicability === APPLICABILITY.SIDE2.id || applicability === APPLICABILITY.EQUIPMENT.id)) {
+        setValue(`${parentFormName}.${FieldConstants.SELECTED_OPERATIONAL_LIMITS_GROUP_ID2}`, null);
+      }
+      removeLimitsGroups(indexSelectedLimitSet);
+      setIndexSelectedLimitSet(null);
+    }
+    handleCloseMenu();
+  }, [
+    handleCloseMenu,
+    indexSelectedLimitSet,
+    operationalLimitsGroups,
+    parentFormName,
+    removeLimitsGroups,
+    selectedLimitsGroups1,
+    selectedLimitsGroups2,
+    setIndexSelectedLimitSet,
+    setValue
+  ]);
+  const handleDuplicateTab = useCallback(() => {
+    let newName = "";
+    if (indexSelectedLimitSet !== null) {
+      const duplicatedLimits1 = operationalLimitsGroups[indexSelectedLimitSet];
+      newName = `${duplicatedLimits1.name}_COPY`;
+      const newLimitsGroup1 = {
+        ...duplicatedLimits1,
+        [FieldConstants.ID]: newName
+      };
+      appendToLimitsGroups(newLimitsGroup1);
+      handleCloseMenu();
+      setIndexSelectedLimitSet(operationalLimitsGroups.length);
+    }
+  }, [
+    indexSelectedLimitSet,
+    operationalLimitsGroups,
+    appendToLimitsGroups,
+    setIndexSelectedLimitSet,
+    handleCloseMenu
+  ]);
+  return /* @__PURE__ */ jsxs(
+    Menu,
+    {
+      open: contextMenuCoordinates.tabIndex != null,
+      onClose: handleCloseMenu,
+      anchorReference: "anchorPosition",
+      anchorPosition: contextMenuCoordinates.y !== null && contextMenuCoordinates.x !== null ? { top: contextMenuCoordinates.y, left: contextMenuCoordinates.x } : void 0,
+      children: [
+        /* @__PURE__ */ jsxs(MenuItem, { onClick: handleDeleteTab, children: [
+          /* @__PURE__ */ jsx(ListItemIcon, { children: /* @__PURE__ */ jsx(Delete, { fontSize: "small" }) }),
+          /* @__PURE__ */ jsx(ListItemText, { children: intl.formatMessage({ id: "DeleteFromMenu" }) })
+        ] }),
+        /* @__PURE__ */ jsxs(MenuItem, { onClick: handleDuplicateTab, children: [
+          /* @__PURE__ */ jsx(ListItemIcon, { children: /* @__PURE__ */ jsx(ContentCopy, { fontSize: "small" }) }),
+          /* @__PURE__ */ jsx(ListItemText, { children: intl.formatMessage({ id: "Duplicate" }) })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  LimitsGroupsContextualMenu
+};

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/LimitsPropertiesStack.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2025, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export interface LimitsPropertiesStackProps {
+    name: string;
+}
+export declare function LimitsPropertiesStack({ name }: Readonly<LimitsPropertiesStackProps>): import("react").JSX.Element;

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/LimitsPropertiesStack.js

@@ -0,0 +1,25 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Stack, Avatar } from "@mui/material";
+import { useWatch } from "react-hook-form";
+import { LimitsTagChip } from "../LimitsTagChip.js";
+const MAX_PROPERTIES_TO_RENDER = 2;
+function getLimitsPropertiesToRender(limitsProperties) {
+  return limitsProperties.length < MAX_PROPERTIES_TO_RENDER ? limitsProperties : limitsProperties?.slice(0, 2);
+}
+function LimitsPropertiesStack({ name }) {
+  const limitsProperties = useWatch({ name });
+  const propertiesToRender = getLimitsPropertiesToRender(limitsProperties ?? []);
+  return /* @__PURE__ */ jsxs(Stack, { direction: "row", sx: { alignItems: "center" }, children: [
+    propertiesToRender.map((property) => /* @__PURE__ */ jsx(LimitsTagChip, { limitsProperty: property }, `${property.name}`)),
+    limitsProperties && propertiesToRender.length !== limitsProperties.length ? /* @__PURE__ */ jsx(
+      Avatar,
+      {
+        sx: { width: 30, height: 30 },
+        children: `+${limitsProperties.length - propertiesToRender.length}`
+      }
+    ) : ""
+  ] });
+}
+export {
+  LimitsPropertiesStack
+};

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/OperationalLimitsGroupTabLabel.d.ts

@@ -0,0 +1,10 @@
+import { OperationalLimitsGroupFormSchema } from './operationalLimitsGroups.types';
+interface OperationalLimitsGroupTabLabelProps {
+    operationalLimitsGroup: OperationalLimitsGroupFormSchema;
+    showIconButton: boolean;
+    limitsPropertiesName: string;
+    handleOpenMenu: (event: React.MouseEvent<HTMLElement>, index: number) => void;
+    index: number;
+}
+export declare function OperationalLimitsGroupTabLabel({ operationalLimitsGroup, showIconButton, limitsPropertiesName, handleOpenMenu, index, }: Readonly<OperationalLimitsGroupTabLabelProps>): import("react").JSX.Element;
+export {};

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/OperationalLimitsGroupTabLabel.js

@@ -0,0 +1,73 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Box, Stack, Tooltip, Typography, FormHelperText, IconButton } from "@mui/material";
+import { FormattedMessage } from "react-intl";
+import { red, grey } from "@mui/material/colors";
+import { useFormState } from "react-hook-form";
+import { ErrorOutlineOutlined, MoreVert } from "@mui/icons-material";
+import { LimitsPropertiesStack } from "./LimitsPropertiesStack.js";
+import { APPLICABILITY } from "../limits.types.js";
+import { FieldConstants } from "../../../../../utils/constants/fieldConstants.js";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+function OperationalLimitsGroupTabLabel({
+  operationalLimitsGroup,
+  showIconButton,
+  limitsPropertiesName,
+  handleOpenMenu,
+  index
+}) {
+  const { errors } = useFormState({
+    name: `${FieldConstants.LIMITS}.${FieldConstants.OPERATIONAL_LIMITS_GROUPS}`
+  });
+  const temporaryLimitsErrors = errors?.limits?.operationalLimitsGroups?.[index]?.currentLimits?.temporaryLimits;
+  const hasTemporaryLimitError = Array.isArray(temporaryLimitsErrors) && temporaryLimitsErrors.some((tl) => tl?.name?.message || tl?.acceptableDuration?.message);
+  const hasError = errors?.limits?.operationalLimitsGroups?.[index]?.name?.message || errors?.limits?.operationalLimitsGroups?.[index]?.currentLimits?.permanentLimit?.message || errors?.limits?.operationalLimitsGroups?.[index]?.[FieldConstants.OLG_IS_DUPLICATE]?.message || hasTemporaryLimitError;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      sx: {
+        display: "inline-flex",
+        alignItems: "center",
+        boxSizing: "inherit",
+        justifyContent: "space-between",
+        paddingRight: 1,
+        paddingLeft: 1
+      },
+      children: [
+        /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, sx: { alignItems: "center" }, children: [
+          /* @__PURE__ */ jsxs(Stack, { spacing: 0, children: [
+            /* @__PURE__ */ jsx(Tooltip, { title: operationalLimitsGroup.name, children: /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, sx: { alignItems: "stretch" }, children: [
+              /* @__PURE__ */ jsx(
+                Typography,
+                {
+                  variant: "body1",
+                  color: hasError ? red[500] : void 0,
+                  sx: {
+                    maxWidth: "10ch",
+                    textOverflow: "ellipsis"
+                  },
+                  noWrap: true,
+                  children: operationalLimitsGroup.name
+                }
+              ),
+              hasError && /* @__PURE__ */ jsx(FormHelperText, { error: true, children: /* @__PURE__ */ jsx(ErrorOutlineOutlined, {}) })
+            ] }) }),
+            operationalLimitsGroup?.applicability ? /* @__PURE__ */ jsx(Typography, { noWrap: true, align: "left", color: grey[500], children: /* @__PURE__ */ jsx(
+              FormattedMessage,
+              {
+                id: Object.values(APPLICABILITY).find(
+                  (item) => item.id === operationalLimitsGroup.applicability
+                )?.label
+              }
+            ) }) : ""
+          ] }),
+          /* @__PURE__ */ jsx(LimitsPropertiesStack, { name: limitsPropertiesName })
+        ] }),
+        showIconButton && /* @__PURE__ */ jsx(IconButton, { component: "span", size: "small", onClick: (e) => handleOpenMenu(e, index), children: /* @__PURE__ */ jsx(MoreVert, { fontSize: "small" }) })
+      ]
+    }
+  );
+}
+export {
+  OperationalLimitsGroupTabLabel
+};

package/dist/features/network-modifications/common/currentLimits/operationalLimitsGroups/OperationalLimitsGroups.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { UseFieldArrayAppend } from 'react-hook-form';
+import { OperationalLimitsGroupFormSchema } from './operationalLimitsGroups.types';
+import { CurrentLimitsData } from '../limits.types';
+export interface OperationalLimitsGroupsProps {
+    parentFormName: string;
+    indexSelectedLimitSet: number | null;
+    setIndexSelectedLimitSet: React.Dispatch<React.SetStateAction<number | null>>;
+    currentLimitsToModify: CurrentLimitsData[];
+    editable: boolean;
+    appendToLimitsGroups: UseFieldArrayAppend<{
+        [p: string]: OperationalLimitsGroupFormSchema[];
+    }, string>;
+    removeLimitsGroups: () => void;
+}
+export declare function OperationalLimitsGroups({ parentFormName, setIndexSelectedLimitSet, indexSelectedLimitSet, editable, appendToLimitsGroups, removeLimitsGroups, currentLimitsToModify, }: Readonly<OperationalLimitsGroupsProps>): React.JSX.Element;