@gridsuite/commons-ui 0.202.0 → 0.203.0

package/dist/components/network-modifications/common/reactiveLimits/reactiveCapabilityCurve/reactiveCapability.utils.js

@@ -0,0 +1,152 @@
+import { array, object, number, ref, ValidationError } from "yup";
+import { FieldConstants } from "../../../../../utils/constants/fieldConstants.js";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { toNumber, validateValueIsANumber } from "../../../../../utils/validation-functions.js";
+import "../../../../../utils/yupConfig.js";
+const INSERT = "INSERT";
+const REMOVE = "REMOVE";
+const getCreationRowSchema = () => object().shape({
+  [FieldConstants.MAX_Q]: number().nullable().default(null),
+  [FieldConstants.MIN_Q]: number().nullable().default(null).max(ref(FieldConstants.MAX_Q), "ReactiveCapabilityCurveCreationErrorQminPQmaxPIncoherence"),
+  [FieldConstants.P]: number().nullable().default(null)
+});
+const getRowEmptyFormData = () => ({
+  [FieldConstants.P]: null,
+  [FieldConstants.MAX_Q]: null,
+  [FieldConstants.MIN_Q]: null
+});
+function getNotNullPFromArray(values) {
+  return values?.map((element) => {
+    const pValue = element[FieldConstants.P];
+    return validateValueIsANumber(pValue) ? toNumber(pValue) : null;
+  }).filter((p) => p !== null);
+}
+function checkAllPValuesAreUnique(values) {
+  const validActivePowerValues = getNotNullPFromArray(values);
+  const setOfPs = [...new Set(validActivePowerValues)];
+  return setOfPs.length === validActivePowerValues?.length;
+}
+function checkAllPValuesBetweenMinMax(values) {
+  const validActivePowerValues = getNotNullPFromArray(values);
+  if (validActivePowerValues) {
+    const minP = validActivePowerValues[0];
+    const maxP = validActivePowerValues[validActivePowerValues.length - 1];
+    return validActivePowerValues.every((p) => p >= minP && p <= maxP);
+  }
+  return void 0;
+}
+function hasAtLeastOneNegativeP(values) {
+  return values?.some((value) => value.p && value.p < 0);
+}
+function hasAtLeastOnePositiveP(values) {
+  return values?.some((value) => value.p && value.p >= 0);
+}
+function ifOneFieldThenAllFields(values, context) {
+  if (!values) {
+    return true;
+  }
+  const hasAnyValue = values.some((v) => v.p != null || v.maxQ != null || v.minQ != null);
+  if (!hasAnyValue) {
+    return true;
+  }
+  const errors = [];
+  values.forEach((value, index) => {
+    ["p", "maxQ", "minQ"].forEach((field) => {
+      if (value?.[field] == null) {
+        errors.push(
+          context.createError({
+            path: `${FieldConstants.REACTIVE_LIMITS}.${FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE}[${index}].${field}`,
+            message: "YupRequired"
+          })
+        );
+      }
+    });
+  });
+  return errors.length === 0 ? true : new ValidationError(errors);
+}
+const getReactiveCapabilityCurveValidationSchema = (id = FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE, positiveAndNegativePExist = false) => ({
+  [id]: array().nullable().when([FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE], {
+    is: "CURVE",
+    then: (schema) => {
+      let resultSchema = schema.of(getCreationRowSchema());
+      if (positiveAndNegativePExist) {
+        resultSchema = resultSchema.test(
+          "checkATLeastThereIsOneNegativeP",
+          "ReactiveCapabilityCurveCreationErrorMissingNegativeP",
+          hasAtLeastOneNegativeP
+        ).test(
+          "checkATLeastThereIsOnePositiveP",
+          "ReactiveCapabilityCurveCreationErrorMissingPositiveP",
+          hasAtLeastOnePositiveP
+        );
+      }
+      return resultSchema.min(2, "ReactiveCapabilityCurveCreationErrorMissingPoints").test("ifOneFieldThenAllFields", "", ifOneFieldThenAllFields).test(
+        "checkAllValuesAreUnique",
+        "ReactiveCapabilityCurveCreationErrorPInvalid",
+        checkAllPValuesAreUnique
+      ).test(
+        "checkAllValuesBetweenMinMax",
+        "ReactiveCapabilityCurveCreationErrorPOutOfRange",
+        checkAllPValuesBetweenMinMax
+      );
+    }
+  })
+});
+function setSelectedReactiveLimits(id, minMaxReactiveLimits, setValue) {
+  setValue(id, minMaxReactiveLimits ? "MINMAX" : "CURVE");
+}
+function setCurrentReactiveCapabilityCurveTable(previousReactiveCapabilityCurveTable, fieldKey, setValue) {
+  setValue(fieldKey, previousReactiveCapabilityCurveTable);
+}
+function handleReactiveCapabilityCurveChoice(currentChoice, previousChoice, currentReactiveLimits) {
+  if (currentChoice === "MINMAX") {
+    const hasAnyValue = currentReactiveLimits?.[FieldConstants.MAXIMUM_REACTIVE_POWER] || currentReactiveLimits?.[FieldConstants.MINIMUM_REACTIVE_POWER];
+    if (previousChoice === "CURVE" && !hasAnyValue) {
+      return "CURVE";
+    }
+    return "MINMAX";
+  }
+  if (currentChoice === "CURVE") {
+    const currentPoints = currentReactiveLimits?.[FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE];
+    const hasAnyValue = currentPoints?.some((v) => v.p != null || v.maxQ != null || v.minQ != null);
+    if (previousChoice === "MINMAX" && !hasAnyValue) {
+      return "MINMAX";
+    }
+    return "CURVE";
+  }
+  console.error(
+    "Reactive capability curve choice is not valid, it should be either MINMAX or CURVE. We return MINMAX by default."
+  );
+  return "MINMAX";
+}
+function toReactiveCapabilityCurveChoiceForGeneratorCreation(currentReactiveLimits, editData) {
+  const currentChoice = currentReactiveLimits?.[FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE];
+  let previousChoice;
+  if (editData) {
+    previousChoice = editData.reactiveCapabilityCurve ? "CURVE" : "MINMAX";
+  }
+  return handleReactiveCapabilityCurveChoice(currentChoice, previousChoice, currentReactiveLimits);
+}
+function toReactiveCapabilityCurveChoiceForGeneratorModification(currentReactiveLimits, editData, networkPoints) {
+  const currentChoice = currentReactiveLimits?.[FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE];
+  let editDataChoice;
+  if (editData) {
+    editDataChoice = editData.reactiveCapabilityCurve?.value === true ? "CURVE" : "MINMAX";
+  }
+  const networkChoice = networkPoints ? "CURVE" : "MINMAX";
+  const previousChoice = editDataChoice ?? networkChoice;
+  return handleReactiveCapabilityCurveChoice(currentChoice, previousChoice, currentReactiveLimits);
+}
+export {
+  INSERT,
+  REMOVE,
+  getReactiveCapabilityCurveValidationSchema,
+  getRowEmptyFormData,
+  setCurrentReactiveCapabilityCurveTable,
+  setSelectedReactiveLimits,
+  toReactiveCapabilityCurveChoiceForGeneratorCreation,
+  toReactiveCapabilityCurveChoiceForGeneratorModification
+};

package/dist/components/network-modifications/common/reactiveLimits/reactiveLimits.type.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2023, 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 ReactiveCapabilityCurvePoints {
+    p?: number | null;
+    maxQ?: number | null;
+    minQ?: number | null;
+}
+export interface MinMaxReactiveLimitsFormInfos {
+    minQ?: number | null;
+    maxQ?: number | null;
+}
+export type ReactiveCapabilityCurve = ReactiveCapabilityCurveRow[] | null | undefined;
+export type ReactiveCapabilityCurveRow = {
+    maxQ: number | null;
+    minQ: number | null;
+    p: number | null;
+};

package/dist/components/network-modifications/common/reactiveLimits/reactiveLimits.type.js

@@ -0,0 +1 @@
+

package/dist/components/network-modifications/common/reactiveLimits/reactiveLimits.utils.d.ts

@@ -0,0 +1,55 @@
+import { ReactiveCapabilityCurvePoints } from './reactiveLimits.type';
+import { FieldConstants } from '../../../../utils';
+export declare const REACTIVE_LIMIT_TYPES: readonly [{
+    readonly id: "MINMAX";
+    readonly label: "ReactiveLimitsKindMinMax";
+}, {
+    readonly id: "CURVE";
+    readonly label: "ReactiveLimitsKindCurve";
+}];
+export declare const getReactiveLimitsFormData: ({ id, reactiveCapabilityCurveChoice, minimumReactivePower, maximumReactivePower, reactiveCapabilityCurvePoints, }: {
+    id?: string;
+    reactiveCapabilityCurveChoice: string;
+    minimumReactivePower?: number | null;
+    maximumReactivePower?: number | null;
+    reactiveCapabilityCurvePoints?: ReactiveCapabilityCurvePoints[] | null;
+}) => {
+    [x: string]: {
+        reactiveCapabilityCurveChoice: string;
+        minimumReactivePower: number | null;
+        maximumReactivePower: number | null;
+        reactiveCapabilityCurveTable: ReactiveCapabilityCurvePoints[];
+    };
+};
+export declare const getReactiveLimitsEmptyFormData: (id?: FieldConstants) => {
+    [x: string]: {
+        reactiveCapabilityCurveChoice: string;
+        minimumReactivePower: null;
+        maximumReactivePower: null;
+        reactiveCapabilityCurveTable: {
+            p: null;
+            maxQ: null;
+            minQ: null;
+        }[];
+    };
+};
+export declare const getReactiveLimitsValidationSchema: (isEquipmentModification?: boolean, positiveAndNegativePExist?: boolean) => import('yup').ObjectSchema<{
+    reactiveCapabilityCurveChoice: string;
+    minimumReactivePower: number | null | undefined;
+    maximumReactivePower: number | null | undefined;
+}, import('yup').AnyObject, {
+    reactiveCapabilityCurveChoice: undefined;
+    minimumReactivePower: undefined;
+    maximumReactivePower: undefined;
+}, "">;
+export declare const getReactiveLimitsSchema: (isEquipmentModification?: boolean, positiveAndNegativePExist?: boolean, id?: FieldConstants) => {
+    [x: string]: import('yup').ObjectSchema<{
+        reactiveCapabilityCurveChoice: string;
+        minimumReactivePower: number | null | undefined;
+        maximumReactivePower: number | null | undefined;
+    }, import('yup').AnyObject, {
+        reactiveCapabilityCurveChoice: undefined;
+        minimumReactivePower: undefined;
+        maximumReactivePower: undefined;
+    }, "">;
+};

package/dist/components/network-modifications/common/reactiveLimits/reactiveLimits.utils.js

@@ -0,0 +1,66 @@
+import { object, number, string } from "yup";
+import { getRowEmptyFormData, getReactiveCapabilityCurveValidationSchema } from "./reactiveCapabilityCurve/reactiveCapability.utils.js";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import { YUP_REQUIRED } from "../../../../utils/constants/translationKeys.js";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import "../../../../utils/yupConfig.js";
+const REACTIVE_LIMIT_TYPES = [
+  { id: "MINMAX", label: "ReactiveLimitsKindMinMax" },
+  { id: "CURVE", label: "ReactiveLimitsKindCurve" }
+];
+const getReactiveLimitsFormData = ({
+  id = FieldConstants.REACTIVE_LIMITS,
+  reactiveCapabilityCurveChoice,
+  minimumReactivePower,
+  maximumReactivePower,
+  reactiveCapabilityCurvePoints
+}) => ({
+  [id]: {
+    [FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE]: reactiveCapabilityCurveChoice,
+    [FieldConstants.MINIMUM_REACTIVE_POWER]: minimumReactivePower ?? null,
+    [FieldConstants.MAXIMUM_REACTIVE_POWER]: maximumReactivePower ?? null,
+    [FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE]: reactiveCapabilityCurvePoints ?? [
+      getRowEmptyFormData(),
+      getRowEmptyFormData()
+    ]
+  }
+});
+const getReactiveLimitsEmptyFormData = (id = FieldConstants.REACTIVE_LIMITS) => ({
+  [id]: {
+    [FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE]: "MINMAX",
+    [FieldConstants.MINIMUM_REACTIVE_POWER]: null,
+    [FieldConstants.MAXIMUM_REACTIVE_POWER]: null,
+    [FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE]: [getRowEmptyFormData(), getRowEmptyFormData()]
+  }
+});
+const getReactiveLimitsValidationSchema = (isEquipmentModification = false, positiveAndNegativePExist = false) => object().shape(
+  {
+    [FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE]: string().nullable().required(YUP_REQUIRED),
+    [FieldConstants.MINIMUM_REACTIVE_POWER]: number().nullable().when([FieldConstants.MAXIMUM_REACTIVE_POWER], {
+      is: (maximumReactivePower) => !isEquipmentModification && maximumReactivePower != null,
+      then: (schema) => schema.required(YUP_REQUIRED)
+    }),
+    [FieldConstants.MAXIMUM_REACTIVE_POWER]: number().nullable().when([FieldConstants.MINIMUM_REACTIVE_POWER], {
+      is: (minimumReactivePower) => !isEquipmentModification && minimumReactivePower != null,
+      then: (schema) => schema.required(YUP_REQUIRED)
+    }),
+    ...getReactiveCapabilityCurveValidationSchema(
+      FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE,
+      positiveAndNegativePExist
+    )
+  },
+  [FieldConstants.MAXIMUM_REACTIVE_POWER, FieldConstants.MINIMUM_REACTIVE_POWER]
+);
+const getReactiveLimitsSchema = (isEquipmentModification = false, positiveAndNegativePExist = false, id = FieldConstants.REACTIVE_LIMITS) => ({
+  [id]: getReactiveLimitsValidationSchema(isEquipmentModification, positiveAndNegativePExist)
+});
+export {
+  REACTIVE_LIMIT_TYPES,
+  getReactiveLimitsEmptyFormData,
+  getReactiveLimitsFormData,
+  getReactiveLimitsSchema,
+  getReactiveLimitsValidationSchema
+};

package/dist/components/network-modifications/common/setpoints/setPoints.utils.js

@@ -1,6 +1,6 @@
 import { number } from "yup";
 import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
-import { YUP_NOT_TYPE_NUMBER } from "../../../../utils/constants/translationKeys.js";
+import { YUP_NOT_TYPE_NUMBER, YUP_REQUIRED } from "../../../../utils/constants/translationKeys.js";
 import "../../../../utils/conversionUtils.js";
 import "../../../../utils/types/equipmentType.js";
 import "react/jsx-runtime";
@@ -36,7 +36,7 @@ const getActivePowerSetPointSchema = (isEquipmentModification = false) => ({
   }).when([], {
     is: () => !isEquipmentModification,
     then: (schema) => {
-      return schema.required().nonNullable("FieldIsRequired").test(
+      return schema.required(YUP_REQUIRED).nonNullable("FieldIsRequired").test(
         "activePowerSetPoint",
         "ActivePowerMustBeZeroOrBetweenMinAndMaxActivePower",
         testValueWithinPowerIntervalOrEqualToZero
@@ -47,7 +47,7 @@ const getActivePowerSetPointSchema = (isEquipmentModification = false) => ({
 const getReactivePowerSetPointSchema = (isEquipmentModification = false) => ({
   [FieldConstants.REACTIVE_POWER_SET_POINT]: number().typeError(YUP_NOT_TYPE_NUMBER).nullable().when([FieldConstants.VOLTAGE_REGULATION], {
     is: (value) => !isEquipmentModification && !value,
-    then: (schema) => schema.required()
+    then: (schema) => schema.required(YUP_REQUIRED)
   })
 });
 const getSetPointsSchema = (isEquipmentModification = false) => ({

package/dist/components/network-modifications/common/shortCircuit/ShortCircuitForm.d.ts

@@ -0,0 +1,5 @@
+import { ShortCircuitInfos } from './shortCircuitForm.type';
+export interface ShortCircuitFormProps {
+    previousValues?: ShortCircuitInfos;
+}
+export declare function ShortCircuitForm({ previousValues }: Readonly<ShortCircuitFormProps>): import("react/jsx-runtime").JSX.Element;

package/dist/components/network-modifications/common/shortCircuit/ShortCircuitForm.js

@@ -0,0 +1,68 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import "react-intl";
+import "../../../overflowableText/OverflowableText.js";
+import { OhmAdornment } 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 "../../../../utils/yupConfig.js";
+import "react";
+import "react-hook-form";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "../../../treeViewFinder/TreeViewFinder.js";
+import "../../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import { FloatInput } from "../../../inputs/reactHookForm/numbers/FloatInput.js";
+import "../../../inputs/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/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes.svg?react";
+import "../../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../../inputs/reactHookForm/expandableInput/ExpandableInput.js";
+import "@react-querybuilder/material";
+import "../../../filter/expert/expertFilterConstants.js";
+import "../../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import GridItem from "../../../grid/grid-item.js";
+function ShortCircuitForm({ previousValues }) {
+  const transientReactanceField = /* @__PURE__ */ jsx(
+    FloatInput,
+    {
+      name: FieldConstants.TRANSIENT_REACTANCE,
+      label: "TransientReactanceForm",
+      adornment: OhmAdornment,
+      previousValue: previousValues?.directTransX ?? void 0,
+      clearable: true
+    }
+  );
+  const transformerReactanceField = /* @__PURE__ */ jsx(
+    FloatInput,
+    {
+      name: FieldConstants.TRANSFORMER_REACTANCE,
+      label: "TransformerReactanceForm",
+      adornment: OhmAdornment,
+      previousValue: Number.isNaN(Number(previousValues?.stepUpTransformerX)) ? void 0 : previousValues?.stepUpTransformerX ?? void 0,
+      clearable: true
+    }
+  );
+  return /* @__PURE__ */ jsxs(Grid, { container: true, spacing: 2, children: [
+    /* @__PURE__ */ jsx(GridItem, { size: 4, children: transientReactanceField }),
+    /* @__PURE__ */ jsx(GridItem, { size: 4, children: transformerReactanceField })
+  ] });
+}
+export {
+  ShortCircuitForm
+};

package/dist/components/network-modifications/common/shortCircuit/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 './shortCircuitForm.type';
+export * from './shortCircuitForm.utils';
+export * from './ShortCircuitForm';

package/dist/components/network-modifications/common/shortCircuit/index.js

@@ -0,0 +1,8 @@
+import { getShortCircuitEmptyFormData, getShortCircuitFormData, getShortCircuitFormSchema } from "./shortCircuitForm.utils.js";
+import { ShortCircuitForm } from "./ShortCircuitForm.js";
+export {
+  ShortCircuitForm,
+  getShortCircuitEmptyFormData,
+  getShortCircuitFormData,
+  getShortCircuitFormSchema
+};

package/dist/components/network-modifications/common/shortCircuit/shortCircuitForm.type.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 ShortCircuitInfos {
+    directTransX?: number | null;
+    stepUpTransformerX?: number | null;
+}

package/dist/components/network-modifications/common/shortCircuit/shortCircuitForm.type.js

@@ -0,0 +1 @@
+

package/dist/components/network-modifications/common/shortCircuit/shortCircuitForm.utils.d.ts

@@ -0,0 +1,15 @@
+export declare const getShortCircuitEmptyFormData: () => {
+    directTransX: null;
+    transformerReactance: null;
+};
+export declare const getShortCircuitFormSchema: (isEquipmentModification?: boolean) => {
+    transformerReactance: import('yup').NumberSchema<number | null | undefined, import('yup').AnyObject, undefined, "">;
+    directTransX: import('yup').NumberSchema<number | null | undefined, import('yup').AnyObject, undefined, "">;
+};
+export declare const getShortCircuitFormData: ({ directTransX, stepUpTransformerX, }: {
+    directTransX?: number | null;
+    stepUpTransformerX?: number | null;
+}) => {
+    directTransX: number | null | undefined;
+    transformerReactance: number | null | undefined;
+};

package/dist/components/network-modifications/common/shortCircuit/shortCircuitForm.utils.js

@@ -0,0 +1,37 @@
+import { number } from "yup";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import { YUP_REQUIRED } from "../../../../utils/constants/translationKeys.js";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import "../../../../utils/yupConfig.js";
+const getShortCircuitEmptyFormData = () => {
+  return {
+    [FieldConstants.TRANSIENT_REACTANCE]: null,
+    [FieldConstants.TRANSFORMER_REACTANCE]: null
+  };
+};
+const getShortCircuitFormSchema = (isEquipmentModification = false) => {
+  return {
+    [FieldConstants.TRANSFORMER_REACTANCE]: number().nullable(),
+    [FieldConstants.TRANSIENT_REACTANCE]: number().nullable().when([FieldConstants.TRANSFORMER_REACTANCE], {
+      is: (transformerReactance) => isEquipmentModification && transformerReactance != null,
+      then: (schema) => schema.required(YUP_REQUIRED)
+    })
+  };
+};
+const getShortCircuitFormData = ({
+  directTransX,
+  stepUpTransformerX
+}) => {
+  return {
+    [FieldConstants.TRANSIENT_REACTANCE]: directTransX,
+    [FieldConstants.TRANSFORMER_REACTANCE]: stepUpTransformerX
+  };
+};
+export {
+  getShortCircuitEmptyFormData,
+  getShortCircuitFormData,
+  getShortCircuitFormSchema
+};

package/dist/components/network-modifications/generator/creation/generatorCreation.types.d.ts

@@ -0,0 +1,40 @@
+import { Property } from '../../common/properties';
+import { ReactiveCapabilityCurvePoints } from '../../common/reactiveLimits/reactiveLimits.type';
+import { ModificationType } from '../../../../utils';
+export interface GeneratorCreationDto {
+    type: ModificationType;
+    uuid?: string;
+    equipmentId: string;
+    equipmentName: string | null;
+    energySource: string | null;
+    minP: number | null;
+    maxP: number | null;
+    ratedS: number | null;
+    targetP: number | null;
+    targetQ: number | null;
+    voltageRegulationOn: boolean | null;
+    targetV: number | null;
+    qPercent: number | null;
+    voltageLevelId: string | null;
+    busOrBusbarSectionId: string | null;
+    plannedActivePowerSetPoint: number | null;
+    marginalCost: number | null;
+    plannedOutageRate: number | null;
+    forcedOutageRate: number | null;
+    directTransX: number | null;
+    stepUpTransformerX: number | null;
+    regulatingTerminalId: string | null;
+    regulatingTerminalType: string | null;
+    regulatingTerminalVlId: string | null;
+    reactiveCapabilityCurve: boolean;
+    participate: boolean | null;
+    droop: number | null;
+    maxQ: number | null;
+    minQ: number | null;
+    reactiveCapabilityCurvePoints: ReactiveCapabilityCurvePoints[] | null;
+    connectionDirection: string | null;
+    connectionName: string | null;
+    connectionPosition: number | null;
+    terminalConnected: boolean | null;
+    properties: Property[] | null;
+}

package/dist/components/network-modifications/generator/creation/generatorCreation.types.js

@@ -0,0 +1 @@
+

package/dist/components/network-modifications/generator/creation/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 './generatorCreation.types';

package/dist/components/network-modifications/generator/creation/index.js

@@ -0,0 +1 @@
+

package/dist/components/network-modifications/generator/generatorDialog.type.d.ts

@@ -0,0 +1,102 @@
+import { FieldConstants } from '../../../utils';
+import { ActivePowerControlInfos } from '../common/activePowerControl';
+import { MinMaxReactiveLimitsFormInfos, ReactiveCapabilityCurvePoints } from '../common/reactiveLimits/reactiveLimits.type';
+import { ShortCircuitInfos } from '../common/shortCircuit/shortCircuitForm.type';
+import { Property } from '../common/properties/properties.type';
+import { ConnectablePositionFormInfos } from '../common/connectivity/connectivity.type';
+export type GeneratorDialogSchemaBaseForm = {
+    [FieldConstants.EQUIPMENT_NAME]?: string;
+    [FieldConstants.ENERGY_SOURCE]: string | null;
+    [FieldConstants.MAXIMUM_ACTIVE_POWER]: number | null;
+    [FieldConstants.MINIMUM_ACTIVE_POWER]: number | null;
+    [FieldConstants.RATED_NOMINAL_POWER]?: number | null;
+    [FieldConstants.TRANSFORMER_REACTANCE]?: number | null;
+    [FieldConstants.TRANSIENT_REACTANCE]?: number | null;
+    [FieldConstants.PLANNED_ACTIVE_POWER_SET_POINT]?: number | null;
+    [FieldConstants.MARGINAL_COST]?: number | null;
+    [FieldConstants.PLANNED_OUTAGE_RATE]?: number | null;
+    [FieldConstants.FORCED_OUTAGE_RATE]?: number | null;
+    [FieldConstants.CONNECTIVITY]: {
+        [FieldConstants.VOLTAGE_LEVEL]: {
+            [FieldConstants.ID]?: string;
+        };
+        [FieldConstants.BUS_OR_BUSBAR_SECTION]: {
+            [FieldConstants.ID]?: string;
+        };
+        [FieldConstants.CONNECTION_DIRECTION]?: string;
+        [FieldConstants.CONNECTION_NAME]?: string;
+        [FieldConstants.CONNECTION_POSITION]?: number;
+        [FieldConstants.CONNECTED]?: boolean;
+    };
+    [FieldConstants.VOLTAGE_REGULATION]?: boolean | null;
+    [FieldConstants.ACTIVE_POWER_SET_POINT]?: number;
+    [FieldConstants.REACTIVE_POWER_SET_POINT]?: number | null;
+    [FieldConstants.VOLTAGE_REGULATION_TYPE]?: string | null;
+    [FieldConstants.VOLTAGE_SET_POINT]?: number | null;
+    [FieldConstants.Q_PERCENT]?: number | null;
+    [FieldConstants.VOLTAGE_LEVEL]?: {
+        [FieldConstants.ID]?: string;
+        [FieldConstants.NAME]?: string;
+        [FieldConstants.SUBSTATION_ID]?: string;
+        [FieldConstants.NOMINAL_VOLTAGE]?: string;
+        [FieldConstants.TOPOLOGY_KIND]?: string | null;
+    };
+    [FieldConstants.EQUIPMENT]?: {
+        [FieldConstants.ID]?: string;
+        [FieldConstants.NAME]?: string | null;
+        [FieldConstants.TYPE]?: string;
+    };
+    [FieldConstants.FREQUENCY_REGULATION]?: boolean | null;
+    [FieldConstants.DROOP]?: number | null;
+    [FieldConstants.REACTIVE_LIMITS]: {
+        [FieldConstants.MINIMUM_REACTIVE_POWER]?: number | null;
+        [FieldConstants.MAXIMUM_REACTIVE_POWER]?: number | null;
+        [FieldConstants.REACTIVE_CAPABILITY_CURVE_CHOICE]: string | null;
+        [FieldConstants.REACTIVE_CAPABILITY_CURVE_TABLE]?: ReactiveCapabilityCurvePoints[];
+    };
+    [FieldConstants.ADDITIONAL_PROPERTIES]?: Property[];
+};
+export type GeneratorCreationDialogSchemaForm = {
+    equipmentId: string;
+} & GeneratorDialogSchemaBaseForm;
+export type GeneratorModificationDialogSchemaForm = Partial<GeneratorDialogSchemaBaseForm>;
+export interface GeneratorFormInfos {
+    id: string;
+    name: string;
+    energySource?: string;
+    maxP: number;
+    minP: number;
+    ratedS: number;
+    targetP: number;
+    voltageRegulatorOn: boolean;
+    targetV: number;
+    targetQ: number;
+    generatorStartup: GeneratorStartUpFormInfos;
+    connectablePosition: ConnectablePositionFormInfos;
+    activePowerControl: ActivePowerControlInfos;
+    generatorShortCircuit: ShortCircuitInfos;
+    regulatingTerminalId: string;
+    regulatingTerminalVlId: string;
+    regulatingTerminalConnectableId: string;
+    regulatingTerminalConnectableType: string;
+    coordinatedReactiveControl: CoordinatedReactiveControlInfos;
+    minMaxReactiveLimits: MinMaxReactiveLimitsFormInfos;
+    reactiveCapabilityCurvePoints: ReactiveCapabilityCurvePoints[];
+    voltageLevelId: string;
+    busOrBusbarSectionId: string;
+    connectionDirection: string | null;
+    connectionName?: string | null;
+    connectionPosition?: number | null;
+    terminalConnected?: boolean | null;
+    properties: Record<string, string> | undefined;
+}
+interface CoordinatedReactiveControlInfos {
+    qPercent?: number | null;
+}
+interface GeneratorStartUpFormInfos {
+    plannedActivePowerSetPoint: number | null;
+    marginalCost?: number | null;
+    plannedOutageRate?: number | null;
+    forcedOutageRate?: number | null;
+}
+export {};

package/dist/components/network-modifications/generator/generatorDialog.type.js

@@ -0,0 +1 @@
+

package/dist/components/network-modifications/generator/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 './generatorDialog.type';
+export * from './creation';
+export * from './modification';