@gridsuite/commons-ui 0.241.1 → 0.243.0

package/dist/features/network-modifications/common/currentLimits/limitsEditor/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2026, 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 * from './limitsChart';
+export * from './LimitsPropertiesSideStack';
+export * from './LimitsEditor';
+export * from './TemporaryLimitsTable';

package/dist/features/network-modifications/common/currentLimits/limitsEditor/index.js

@@ -0,0 +1,10 @@
+import { LimitsChart } from "./limitsChart.js";
+import { LimitsPropertiesSideStack } from "./LimitsPropertiesSideStack.js";
+import { LimitsEditor } from "./LimitsEditor.js";
+import { TemporaryLimitsTable } from "./TemporaryLimitsTable.js";
+export {
+  LimitsChart,
+  LimitsEditor,
+  LimitsPropertiesSideStack,
+  TemporaryLimitsTable
+};

package/dist/features/network-modifications/common/currentLimits/limitsEditor/limitsChart.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 LimitsGraphProps {
+    limitsGroupFormName: string;
+    previousPermanentLimit?: number | null;
+}
+export declare function LimitsChart({ limitsGroupFormName, previousPermanentLimit }: Readonly<LimitsGraphProps>): import("react").JSX.Element;

package/dist/features/network-modifications/common/currentLimits/limitsEditor/limitsChart.js

@@ -0,0 +1,177 @@
+import { jsx } from "react/jsx-runtime";
+import { BarChart } from "@mui/x-charts";
+import { useCallback, useMemo } from "react";
+import { useWatch } from "react-hook-form";
+import { useIntl } from "react-intl";
+const colorPermanentLimit = "#58d058";
+const colors = ["#ffc019", "#e47400", "#cc5500", "#ff5757", "#ff0000"];
+const colorForbidden = "#b10303";
+const formatTempo = (tempo) => {
+  if (!tempo) {
+    return "";
+  }
+  const min = Math.floor(tempo / 60);
+  const sec = tempo % 60;
+  if (min > 0 && sec === 0) {
+    return `${min}min`;
+  }
+  if (min === 0 && sec > 0) {
+    return `${sec}s`;
+  }
+  return `${min}min${sec}s`;
+};
+function LimitsChart({ limitsGroupFormName, previousPermanentLimit }) {
+  const currentLimits = useWatch({ name: `${limitsGroupFormName}` });
+  const intl = useIntl();
+  const permanentLimit = currentLimits?.permanentLimit ?? previousPermanentLimit ?? null;
+  const isIncoherent = useCallback(
+    (maxValuePermanentLimit, item, previousItem) => {
+      const isPermanentLimit = item.name === intl.formatMessage({ id: "permanentLimit" }) && permanentLimit || !permanentLimit && !item.acceptableDuration;
+      const permanentLimitValue = permanentLimit || maxValuePermanentLimit;
+      const itemTempoGreaterThanPrevious = item?.acceptableDuration && previousItem?.acceptableDuration && item.acceptableDuration > previousItem.acceptableDuration || false;
+      const atLeastTwoItemsWithNotempo = previousItem?.acceptableDuration && !item.acceptableDuration || false;
+      return !item.acceptableDuration && permanentLimit && !isPermanentLimit || !isPermanentLimit && item.value && item.value < permanentLimitValue || itemTempoGreaterThanPrevious || atLeastTwoItemsWithNotempo || false;
+    },
+    [intl, permanentLimit]
+  );
+  const { series, ticks, max } = useMemo(() => {
+    const thresholds = [];
+    let noValueThresholdFound = false;
+    let maxValuePermanentLimit = 0;
+    if (permanentLimit) {
+      thresholds.push({
+        name: intl.formatMessage({ id: "permanentLimit" }),
+        value: permanentLimit ? +permanentLimit : permanentLimit,
+        acceptableDuration: null
+      });
+      maxValuePermanentLimit = permanentLimit ?? 0;
+    }
+    if (currentLimits?.temporaryLimits) {
+      currentLimits.temporaryLimits.filter((field) => field.name && (field.acceptableDuration || field.value)).forEach((field) => {
+        if (!field.value) {
+          noValueThresholdFound = true;
+        }
+        if (!field.acceptableDuration && field.value) {
+          maxValuePermanentLimit = Math.max(maxValuePermanentLimit, field.value);
+        }
+        thresholds.push({
+          name: field.name,
+          value: field.value ? +field.value : field.value,
+          acceptableDuration: field.acceptableDuration
+        });
+      });
+    }
+    thresholds.sort((a, b) => {
+      if (a.value && !b.value) {
+        return -1;
+      }
+      if (!a.value && !b.value && a.acceptableDuration && b.acceptableDuration) {
+        return a.acceptableDuration - b.acceptableDuration;
+      }
+      if (!a.value && b.value) {
+        return 1;
+      }
+      if (a.value && b.value) {
+        return a.value - b.value;
+      }
+      return 0;
+    });
+    const maxValue = Math.max(...thresholds.map((item) => item.value ?? 0));
+    let colorIndex = 0;
+    let previousSum = 0;
+    return thresholds.reduce(
+      (acc, item, index) => {
+        const isPermanentLimit = item.name === intl.formatMessage({ id: "permanentLimit" }) && permanentLimit || !permanentLimit && !item.acceptableDuration && item.value === maxValuePermanentLimit;
+        const difference = item.value ? item.value - previousSum : void 0;
+        const color = isPermanentLimit || !item.acceptableDuration || item.acceptableDuration && item.value && maxValuePermanentLimit >= item.value ? colorPermanentLimit : colors?.[colorIndex] ?? colors[colors.length - 1];
+        const incoherent = isIncoherent(
+          maxValuePermanentLimit,
+          item,
+          index > 0 ? thresholds[index - 1] : void 0
+        );
+        if (item.value && item.value >= maxValuePermanentLimit) {
+          previousSum = item.value;
+        }
+        if (item.value && item.value > maxValuePermanentLimit) {
+          colorIndex += 1;
+        }
+        const updatedSeries = item.acceptableDuration && !item.value || item.value && item.value >= maxValuePermanentLimit ? [
+          ...acc.series,
+          {
+            type: "bar",
+            label: isPermanentLimit || item.value === maxValuePermanentLimit ? intl.formatMessage({ id: "unlimited" }) : formatTempo(item.acceptableDuration),
+            data: [difference ?? maxValue * 0.15],
+            color: item.value ? color : colorForbidden,
+            stack: "total"
+          }
+        ] : [...acc.series];
+        const updatedTicks = [...acc.ticks, { position: item.value, label: item.name, incoherent }];
+        if (index === thresholds.length - 1 && updatedTicks[updatedTicks.length - 1].position && !noValueThresholdFound) {
+          updatedSeries.push({
+            type: "bar",
+            label: intl.formatMessage({ id: "forbidden" }),
+            data: [(updatedTicks[updatedTicks.length - 1].position ?? 0) * 0.15],
+            color: colorForbidden,
+            stack: "total"
+          });
+        }
+        return {
+          series: updatedSeries,
+          ticks: updatedTicks,
+          max: updatedSeries.flatMap((serie) => serie.data).filter(Number.isFinite).reduce((a, b) => a + b, 0) ?? 100
+        };
+      },
+      { series: [], ticks: [], max: 0 }
+    );
+  }, [currentLimits.temporaryLimits, intl, isIncoherent, permanentLimit]);
+  const tickPositions = ticks.map((t) => t.position);
+  return /* @__PURE__ */ jsx(
+    BarChart,
+    {
+      margin: { left: 20, right: 20, top: 0, bottom: 0 },
+      height: 90,
+      slotProps: {
+        legend: {
+          position: {
+            vertical: "bottom"
+          }
+        }
+      },
+      series: series.length > 0 ? series : [{ label: intl.formatMessage({ id: "unlimited" }), data: [100], color: colorPermanentLimit }],
+      layout: "horizontal",
+      yAxis: [
+        // We can't totally disable the yAxis, so we have to give empty data
+        {
+          id: "leftAxis",
+          position: "none",
+          data: [""]
+        }
+      ],
+      xAxis: [
+        {
+          id: "bottomAxis",
+          position: "bottom",
+          tickInterval: tickPositions,
+          tickLabelStyle: { fontSize: 10 },
+          disableLine: true,
+          min: 0,
+          max
+        },
+        {
+          id: "topAxis",
+          position: "top",
+          tickInterval: tickPositions,
+          tickLabelStyle: { fontSize: 10 },
+          valueFormatter: (value, _context) => ticks.find((item) => item.position === value)?.label ?? "",
+          disableLine: true,
+          min: 0,
+          max
+        }
+      ],
+      sx: { pointerEvents: "none" }
+    }
+  );
+}
+export {
+  LimitsChart
+};

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

@@ -0,0 +1,213 @@
+import { InferType } from 'yup';
+import { OperationalLimitsGroup, OperationalLimitsGroupFormSchema, OperationalLimitsGroupModificationInfos, TemporaryLimitFormSchema } from './operationalLimitsGroups/operationalLimitsGroups.types';
+import { AttributeModification, FieldConstants } from '../../../../utils';
+import { CurrentLimitsData, TemporaryLimit, TemporaryLimitsData } from './limits.types';
+declare const limitsGroupValidationSchema: import('yup').ObjectSchema<NonNullable<{
+    id: string;
+    name: string;
+    applicability: string;
+    operationalLimitsGroupsIsDuplicate: boolean | null | undefined;
+    currentLimits: {
+        temporaryLimits?: {
+            name?: string | null | undefined;
+            value?: number | null | undefined;
+            acceptableDuration?: number | null | undefined;
+        }[] | undefined;
+        permanentLimit: number;
+    };
+    limitsProperties: {
+        name: string;
+        value: string;
+    }[] | undefined;
+} & {
+    AdditionalProperties: {
+        previousValue?: string | null | undefined;
+        added: NonNullable<boolean | undefined>;
+        deletionMark: NonNullable<boolean | undefined>;
+        name: string;
+        value: string;
+    }[] | undefined;
+}>, import('yup').AnyObject, {
+    id: undefined;
+    name: undefined;
+    applicability: undefined;
+    operationalLimitsGroupsIsDuplicate: undefined;
+    currentLimits: {
+        permanentLimit: undefined;
+        temporaryLimits: "";
+    };
+    limitsProperties: "";
+    AdditionalProperties: "";
+}, "">;
+export type LimitsGroupFormData = InferType<typeof limitsGroupValidationSchema>;
+export declare const getLimitsValidationSchemaProps: (isEquipmentModification?: boolean) => import('yup').ObjectSchema<{
+    operationalLimitsGroups: {
+        AdditionalProperties?: {
+            previousValue?: string | null | undefined;
+            added: NonNullable<boolean | undefined>;
+            deletionMark: NonNullable<boolean | undefined>;
+            name: string;
+            value: string;
+        }[] | undefined;
+        limitsProperties?: {
+            name: string;
+            value: string;
+        }[] | undefined;
+        operationalLimitsGroupsIsDuplicate?: boolean | null | undefined;
+        applicability: string;
+        currentLimits: {
+            temporaryLimits?: {
+                name?: string | null | undefined;
+                value?: number | null | undefined;
+                acceptableDuration?: number | null | undefined;
+            }[] | undefined;
+            permanentLimit: number;
+        };
+        id: string;
+        name: string;
+    }[] | undefined;
+    selectedOperationalLimitsGroupId1: string | null | undefined;
+    selectedOperationalLimitsGroupId2: string | null | undefined;
+    enableOLGModification: boolean | undefined;
+}, import('yup').AnyObject, {
+    operationalLimitsGroups: undefined;
+    selectedOperationalLimitsGroupId1: undefined;
+    selectedOperationalLimitsGroupId2: undefined;
+    enableOLGModification: undefined;
+}, "">;
+export type LimitsSchemaType = InferType<ReturnType<typeof limitsValidationSchemaCreation>[typeof FieldConstants.LIMITS]>;
+declare const limitsValidationSchemaCreation: (id: string, isModification: boolean) => {
+    [x: string]: import('yup').ObjectSchema<{
+        operationalLimitsGroups: {
+            AdditionalProperties?: {
+                previousValue?: string | null | undefined;
+                added: NonNullable<boolean | undefined>;
+                deletionMark: NonNullable<boolean | undefined>;
+                name: string;
+                value: string;
+            }[] | undefined;
+            limitsProperties?: {
+                name: string;
+                value: string;
+            }[] | undefined;
+            operationalLimitsGroupsIsDuplicate?: boolean | null | undefined;
+            applicability: string;
+            currentLimits: {
+                temporaryLimits?: {
+                    name?: string | null | undefined;
+                    value?: number | null | undefined;
+                    acceptableDuration?: number | null | undefined;
+                }[] | undefined;
+                permanentLimit: number;
+            };
+            id: string;
+            name: string;
+        }[] | undefined;
+        selectedOperationalLimitsGroupId1: string | null | undefined;
+        selectedOperationalLimitsGroupId2: string | null | undefined;
+        enableOLGModification: boolean | undefined;
+    }, import('yup').AnyObject, {
+        operationalLimitsGroups: undefined;
+        selectedOperationalLimitsGroupId1: undefined;
+        selectedOperationalLimitsGroupId2: undefined;
+        enableOLGModification: undefined;
+    }, "">;
+};
+export declare const getLimitsValidationSchema: (id?: string, isModification?: boolean) => {
+    [x: string]: import('yup').ObjectSchema<{
+        operationalLimitsGroups: {
+            AdditionalProperties?: {
+                previousValue?: string | null | undefined;
+                added: NonNullable<boolean | undefined>;
+                deletionMark: NonNullable<boolean | undefined>;
+                name: string;
+                value: string;
+            }[] | undefined;
+            limitsProperties?: {
+                name: string;
+                value: string;
+            }[] | undefined;
+            operationalLimitsGroupsIsDuplicate?: boolean | null | undefined;
+            applicability: string;
+            currentLimits: {
+                temporaryLimits?: {
+                    name?: string | null | undefined;
+                    value?: number | null | undefined;
+                    acceptableDuration?: number | null | undefined;
+                }[] | undefined;
+                permanentLimit: number;
+            };
+            id: string;
+            name: string;
+        }[] | undefined;
+        selectedOperationalLimitsGroupId1: string | null | undefined;
+        selectedOperationalLimitsGroupId2: string | null | undefined;
+        enableOLGModification: boolean | undefined;
+    }, import('yup').AnyObject, {
+        operationalLimitsGroups: undefined;
+        selectedOperationalLimitsGroupId1: undefined;
+        selectedOperationalLimitsGroupId2: undefined;
+        enableOLGModification: undefined;
+    }, "">;
+};
+export declare const getLimitsEmptyFormDataProps: (isModification?: boolean) => {
+    operationalLimitsGroups: never[];
+    selectedOperationalLimitsGroupId1: null;
+    selectedOperationalLimitsGroupId2: null;
+    enableOLGModification: boolean;
+};
+export declare const getLimitsEmptyFormData: (isModification?: boolean, id?: FieldConstants) => {
+    [x: string]: {
+        operationalLimitsGroups: never[];
+        selectedOperationalLimitsGroupId1: null;
+        selectedOperationalLimitsGroupId2: null;
+        enableOLGModification: boolean;
+    };
+};
+export declare const formatTemporaryLimitsModificationToFormSchema: (temporaryLimits: TemporaryLimit[]) => TemporaryLimitFormSchema[];
+export declare const formatOpLimitGroupsToFormInfos: (limitGroups?: OperationalLimitsGroup[] | OperationalLimitsGroupModificationInfos[] | null) => OperationalLimitsGroupFormSchema[];
+export declare const getAllLimitsFormDataProperties: (operationalLimitsGroups?: OperationalLimitsGroupFormSchema[], selectedOperationalLimitsGroupId1?: string | null, selectedOperationalLimitsGroupId2?: string | null, enableOLGModification?: boolean | null) => {
+    operationalLimitsGroups: OperationalLimitsGroupFormSchema[];
+    selectedOperationalLimitsGroupId1: string | null;
+    selectedOperationalLimitsGroupId2: string | null;
+    enableOLGModification: boolean;
+};
+export declare const getAllLimitsFormData: (operationalLimitsGroups?: OperationalLimitsGroupFormSchema[], selectedOperationalLimitsGroupId1?: string | null, selectedOperationalLimitsGroupId2?: string | null, enableOLGModification?: boolean | null, id?: FieldConstants) => {
+    [x: string]: {
+        operationalLimitsGroups: OperationalLimitsGroupFormSchema[];
+        selectedOperationalLimitsGroupId1: string | null;
+        selectedOperationalLimitsGroupId2: string | null;
+        enableOLGModification: boolean;
+    };
+};
+/**
+ * sanitizes limit names and filters out the empty temporary limits lines
+ */
+export declare const sanitizeLimitsGroups: (limitsGroups?: LimitsGroupFormData[]) => OperationalLimitsGroupFormSchema[];
+export declare const sanitizeLimitNames: (temporaryLimitList: TemporaryLimitFormSchema[]) => TemporaryLimitFormSchema[];
+export declare const formatMapInfosToTemporaryLimitsFormSchema: (temporaryLimits: TemporaryLimitsData[]) => TemporaryLimitFormSchema[];
+export declare const mapServerLimitsGroupsToFormInfos: (currentLimits: CurrentLimitsData[]) => {
+    id: string;
+    name: string;
+    applicability: string;
+    limitsProperties: import('./limits.types').LimitsProperty[] | undefined;
+    currentLimits: {
+        id: string;
+        permanentLimit: number;
+        temporaryLimits: TemporaryLimitFormSchema[];
+    };
+}[];
+export declare const convertToOperationalLimitsGroupFormSchema: (currentLimits: CurrentLimitsData[]) => OperationalLimitsGroupFormSchema[];
+export declare const addModificationTypeToTemporaryLimits: (formTemporaryLimits: TemporaryLimitFormSchema[]) => TemporaryLimit[];
+export declare function addOperationTypeToSelectedOpLG(selectedOpLG: string | null | undefined, noSelectionString: string): AttributeModification<string> | null;
+/**
+ * converts the limits groups into a modification limits group
+ * ie mostly add the ADD, MODIFY, MODIFY_OR_ADD, DELETE and REPLACE tags to the data using a delta between the form and the network values
+ * note : for now only MODIFY_OR_ADD is handled, the others have been disabled for various reasons
+ *
+ * @param limitsGroupsForm current data from the form
+ */
+export declare const addModificationTypeToOpLimitsGroups: (limitsGroupsForm: OperationalLimitsGroupFormSchema[]) => OperationalLimitsGroup[];
+export declare function generateEmptyOperationalLimitsGroup(name: string): OperationalLimitsGroupFormSchema;
+export declare function generateUniqueId(baseName: string, names: string[]): string;
+export {};