@gridsuite/commons-ui 0.270.0 → 0.272.0

package/dist/features/network-modifications/twoWindingsTransformer/creation/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 './twoWindingsTransformerCreation.types';
+export * from './twoWindingsTransformerCreation.utils';

package/dist/features/network-modifications/twoWindingsTransformer/creation/index.js

@@ -0,0 +1,12 @@
+import { PhaseTapChangerRegulationMode } from "./twoWindingsTransformerCreation.types.js";
+import { computeRatioTapChangerRegulationMode, getRegulationTypeForEdit, getTapSideForEdit, twoWindingsTransformerCreationDtoToForm, twoWindingsTransformerCreationEmptyFormData, twoWindingsTransformerCreationFormSchema, twoWindingsTransformerCreationFormToDto } from "./twoWindingsTransformerCreation.utils.js";
+export {
+  PhaseTapChangerRegulationMode,
+  computeRatioTapChangerRegulationMode,
+  getRegulationTypeForEdit,
+  getTapSideForEdit,
+  twoWindingsTransformerCreationDtoToForm,
+  twoWindingsTransformerCreationEmptyFormData,
+  twoWindingsTransformerCreationFormSchema,
+  twoWindingsTransformerCreationFormToDto
+};

package/dist/features/network-modifications/twoWindingsTransformer/creation/twoWindingsTransformerCreation.types.d.ts

@@ -0,0 +1,47 @@
+import { UUID } from 'node:crypto';
+import { BranchCreationDto } from '../../common/branch';
+export interface TapChangerStepCreationDto {
+    index: number;
+    rho: number;
+    r: number;
+    x: number;
+    g: number;
+    b: number;
+    alpha?: number;
+}
+export interface TapChangerCreationDto {
+    lowTapPosition: number;
+    tapPosition: number;
+    isRegulating: boolean;
+    targetDeadband: number | null;
+    terminalRefConnectableId: string | null;
+    terminalRefConnectableType: string | null;
+    terminalRefConnectableVlId: string | null;
+    steps: TapChangerStepCreationDto[];
+    hasLoadTapChangingCapabilities: boolean;
+}
+export interface RatioTapChangerCreationDto extends TapChangerCreationDto {
+    targetV: number | null;
+}
+export declare enum PhaseTapChangerRegulationMode {
+    CURRENT_LIMITER = "CURRENT_LIMITER",
+    ACTIVE_POWER_CONTROL = "ACTIVE_POWER_CONTROL"
+}
+export interface PhaseTapChangerCreationDto extends TapChangerCreationDto {
+    regulationMode: PhaseTapChangerRegulationMode | null;
+    regulationValue: number | null;
+}
+export interface TwoWindingsTransformerCreationDto extends BranchCreationDto {
+    r: number | null;
+    x: number;
+    g: number;
+    b: number;
+    ratedS: number | null;
+    ratedU1: number;
+    ratedU2: number;
+    ratioTapChanger: RatioTapChangerCreationDto | null;
+    phaseTapChanger: PhaseTapChangerCreationDto | null;
+}
+export type TwoWindingsTransformerCreationDtoWithId = TwoWindingsTransformerCreationDto & {
+    uuid?: UUID;
+};

package/dist/features/network-modifications/twoWindingsTransformer/creation/twoWindingsTransformerCreation.types.js

@@ -0,0 +1,8 @@
+var PhaseTapChangerRegulationMode = /* @__PURE__ */ ((PhaseTapChangerRegulationMode2) => {
+  PhaseTapChangerRegulationMode2["CURRENT_LIMITER"] = "CURRENT_LIMITER";
+  PhaseTapChangerRegulationMode2["ACTIVE_POWER_CONTROL"] = "ACTIVE_POWER_CONTROL";
+  return PhaseTapChangerRegulationMode2;
+})(PhaseTapChangerRegulationMode || {});
+export {
+  PhaseTapChangerRegulationMode
+};

package/dist/features/network-modifications/twoWindingsTransformer/creation/twoWindingsTransformerCreation.utils.d.ts

@@ -0,0 +1,248 @@
+import { InferType } from 'yup';
+import { DeepNullable } from '../../../../utils';
+import { RatioTapChangerCreationDto, TapChangerCreationDto, TwoWindingsTransformerCreationDto } from './twoWindingsTransformerCreation.types';
+import { TapChangerMapInfos } from '../common/twoWindingsTransformer.types';
+export declare const getRegulationTypeForEdit: (twt: TwoWindingsTransformerCreationDto, tap: TapChangerCreationDto | null) => "LOCAL" | "DISTANT" | null;
+export declare const computeRatioTapChangerRegulationMode: (ratioTapChangerFormValues?: RatioTapChangerCreationDto | TapChangerMapInfos | null) => "FIXED_RATIO" | "VOLTAGE_REGULATION";
+export declare const getTapSideForEdit: (twt: TwoWindingsTransformerCreationDto, tap: TapChangerCreationDto | null | undefined) => "SIDE1" | "SIDE2" | null;
+export declare const twoWindingsTransformerCreationFormSchema: import('yup').ObjectSchema<NonNullable<{
+    equipmentID: string;
+    equipmentName: string | null | undefined;
+    connectivity: {
+        connectivity1: {
+            terminalConnected?: boolean | null | undefined;
+            connectionDirection?: string | null | undefined;
+            connectionName?: string | undefined;
+            connectionPosition?: number | null | undefined;
+            busOrBusbarSection: {
+                id?: string | undefined;
+            } | null;
+            voltageLevel: {
+                id?: string | undefined;
+            } | null;
+        };
+        connectivity2: {
+            terminalConnected?: boolean | null | undefined;
+            connectionDirection?: string | null | undefined;
+            connectionName?: string | undefined;
+            connectionPosition?: number | null | undefined;
+            busOrBusbarSection: {
+                id?: string | undefined;
+            } | null;
+            voltageLevel: {
+                id?: string | undefined;
+            } | null;
+        };
+    };
+    characteristics: {
+        b?: number | null | undefined;
+        g?: number | null | undefined;
+        ratedS?: number | null | undefined;
+        ratedU1?: number | null | undefined;
+        ratedU2?: number | null | undefined;
+        r?: number | null | undefined;
+        x?: number | null | undefined;
+    };
+    limits: {
+        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: NonNullable<boolean | undefined>;
+    };
+    ratioTapChanger: {
+        highTapPosition?: number | null | undefined;
+        hasLoadTapChangingCapabilities?: boolean | null | undefined;
+        lowTapPosition?: number | null | undefined;
+        regulationMode?: string | null | undefined;
+        regulationSide?: string | null | undefined;
+        regulationType?: string | null | undefined;
+        steps?: {
+            b?: number | undefined;
+            g?: number | undefined;
+            r?: number | undefined;
+            x?: number | undefined;
+            rho?: number | undefined;
+            index: number;
+        }[] | undefined;
+        targetDeadband?: {} | null | undefined;
+        targetV?: {} | null | undefined;
+        tapPosition?: number | null | undefined;
+        enabled: NonNullable<boolean | undefined>;
+        equipment: {
+            id?: string | undefined;
+            name?: string | null | undefined;
+            type?: string | undefined;
+        } | null;
+        voltageLevel: {
+            id?: string | undefined;
+            name?: string | undefined;
+            nominalVoltage?: string | undefined;
+            substationId?: string | undefined;
+            topologyKind?: string | null | undefined;
+        } | null;
+    };
+    phaseTapChanger: {
+        currentLimiterRegulatingValue?: number | null | undefined;
+        flowSetPointRegulatingValue?: number | null | undefined;
+        highTapPosition?: number | null | undefined;
+        lowTapPosition?: number | null | undefined;
+        regulationMode?: string | null | undefined;
+        regulationSide?: string | null | undefined;
+        regulationType?: string | null | undefined;
+        steps?: {
+            b?: number | undefined;
+            g?: number | undefined;
+            r?: number | undefined;
+            x?: number | undefined;
+            rho?: number | undefined;
+            alpha?: number | undefined;
+            index: number;
+        }[] | undefined;
+        targetDeadband?: number | null | undefined;
+        tapPosition?: number | null | undefined;
+        enabled: NonNullable<boolean | undefined>;
+        equipment: {
+            id?: string | undefined;
+            name?: string | null | undefined;
+            type?: string | undefined;
+        } | null;
+        voltageLevel: {
+            id?: string | undefined;
+            name?: string | undefined;
+            nominalVoltage?: string | undefined;
+            substationId?: string | undefined;
+            topologyKind?: string | null | undefined;
+        } | null;
+    };
+} & {
+    AdditionalProperties: {
+        previousValue?: string | null | undefined;
+        added: NonNullable<boolean | undefined>;
+        deletionMark: NonNullable<boolean | undefined>;
+        name: string;
+        value: string;
+    }[] | undefined;
+}>, import('yup').AnyObject, {
+    equipmentID: undefined;
+    equipmentName: undefined;
+    connectivity: {
+        connectivity1: {
+            voltageLevel: {
+                id: undefined;
+            };
+            busOrBusbarSection: {
+                id: undefined;
+            };
+            connectionDirection: undefined;
+            connectionName: undefined;
+            connectionPosition: undefined;
+            terminalConnected: undefined;
+        };
+        connectivity2: {
+            voltageLevel: {
+                id: undefined;
+            };
+            busOrBusbarSection: {
+                id: undefined;
+            };
+            connectionDirection: undefined;
+            connectionName: undefined;
+            connectionPosition: undefined;
+            terminalConnected: undefined;
+        };
+    };
+    characteristics: {
+        r: undefined;
+        x: undefined;
+        g: undefined;
+        b: undefined;
+        ratedS: undefined;
+        ratedU1: undefined;
+        ratedU2: undefined;
+    };
+    limits: {
+        operationalLimitsGroups: undefined;
+        selectedOperationalLimitsGroupId1: undefined;
+        selectedOperationalLimitsGroupId2: undefined;
+        enableOLGModification: undefined;
+    };
+    ratioTapChanger: {
+        voltageLevel: {
+            id: undefined;
+            name: undefined;
+            substationId: undefined;
+            nominalVoltage: undefined;
+            topologyKind: undefined;
+        };
+        equipment: {
+            id: undefined;
+            name: undefined;
+            type: undefined;
+        };
+        enabled: undefined;
+        hasLoadTapChangingCapabilities: undefined;
+        regulationMode: undefined;
+        regulationType: undefined;
+        regulationSide: undefined;
+        targetV: undefined;
+        targetDeadband: undefined;
+        lowTapPosition: undefined;
+        highTapPosition: undefined;
+        tapPosition: undefined;
+        steps: "";
+    };
+    phaseTapChanger: {
+        voltageLevel: {
+            id: undefined;
+            name: undefined;
+            substationId: undefined;
+            nominalVoltage: undefined;
+            topologyKind: undefined;
+        };
+        equipment: {
+            id: undefined;
+            name: undefined;
+            type: undefined;
+        };
+        enabled: undefined;
+        regulationMode: undefined;
+        regulationType: undefined;
+        regulationSide: undefined;
+        currentLimiterRegulatingValue: undefined;
+        flowSetPointRegulatingValue: undefined;
+        targetDeadband: undefined;
+        lowTapPosition: undefined;
+        highTapPosition: undefined;
+        tapPosition: undefined;
+        steps: "";
+    };
+    AdditionalProperties: "";
+}, "">;
+export type TwoWindingsTransformerCreationFormData = InferType<typeof twoWindingsTransformerCreationFormSchema>;
+export declare const twoWindingsTransformerCreationEmptyFormData: DeepNullable<TwoWindingsTransformerCreationFormData>;
+export declare const twoWindingsTransformerCreationDtoToForm: (twtDto: TwoWindingsTransformerCreationDto) => TwoWindingsTransformerCreationFormData;
+export declare const twoWindingsTransformerCreationFormToDto: (twtForm: TwoWindingsTransformerCreationFormData) => TwoWindingsTransformerCreationDto;

package/dist/features/network-modifications/twoWindingsTransformer/creation/twoWindingsTransformerCreation.utils.js

@@ -0,0 +1,325 @@
+import { object, string } from "yup";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import { convertInputValue, convertOutputValue } from "../../../../utils/conversionUtils.js";
+import { RATIO_REGULATION_MODES, REGULATION_SIDES, PHASE_REGULATION_MODES, UNDEFINED_CONNECTION_DIRECTION, EquipmentType } from "../../../../utils/types/equipmentType.js";
+import { ModificationType } from "../../../../utils/types/modificationType.js";
+import { FieldType } from "../../../../utils/types/fieldType.js";
+import { addSelectedFieldToRows } from "../../../../utils/functions.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { sanitizeString } from "../../../../utils/ts-utils.js";
+import { getBranchConnectivityWithPositionSchema, getBranchConnectivityWithPositionEmptyFormDataProps, getConnectivityFormDataProps } from "../../common/connectivity/connectivityForm.utils.js";
+import "@mui/material";
+import "react";
+import "react-intl";
+import "../../../../components/ui/overflowableText/OverflowableText.js";
+import "react-hook-form";
+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-fill.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";
+import { creationPropertiesSchema, getFilledPropertiesFromModification, toModificationProperties } from "../../common/properties/propertyUtils.js";
+import { getLimitsValidationSchemaProps, getLimitsEmptyFormDataProps, getAllLimitsFormData, sanitizeLimitsGroups } from "../../common/currentLimits/limitsPane.utils.js";
+import { getTwtCharacteristicsValidationSchemaProps, getTwtCharacteristicsEmptyFormData } from "../characteristics/twoWindingsTransformerCharacteristicsPane.utils.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 "@react-querybuilder/material";
+import "../../../../components/composite/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "../../../../components/composite/reactQueryBuilder/PropertyValueEditor.js";
+import "../../../../components/composite/agGridTable/BottomTableButtons.js";
+import "../../../../components/composite/agGridTable/CustomAgGridTable.js";
+import "ag-grid-community";
+import "../../../../components/composite/customAGGrid/customAggrid.js";
+import "../../../../components/composite/customAGGrid/context/custom-aggrid-context.js";
+import "mathjs";
+import "../../../../components/composite/report/report-viewer/log-table/log-table.js";
+import "react-window";
+import "../../../../components/composite/report/report-treeview/treeview-item.js";
+import "../../../../components/composite/report/report-viewer/context/report-viewer-context.js";
+import "../../common/regulatingTerminal/RegulatingTerminalForm.js";
+import { REGULATION_TYPES } from "../../common/voltageRegulation/voltageRegulation.utils.js";
+import "@mui/material/colors";
+import "@mui/x-charts";
+import { computeHighTapPosition } from "../tapChanger/tapChanger.utils.js";
+import "../tapChanger/regulationRule/CreateRuleForm.js";
+import "../tapChanger/regulationRule/CreateRuleDialog.js";
+import { getPhaseTapChangerValidationSchemaProps, getPhaseTapChangerEmptyFormData, getPhaseTapChangerFormData } from "../tapChanger/phaseTapChanger/phaseTapChanger.utils.js";
+import { getRatioTapChangerValidationSchemaProps, getRatioTapChangerEmptyFormData, getRatioTapChangerFormData } from "../tapChanger/ratioTapChanger/ratioTapChanger.utils.js";
+const getRegulationTypeForEdit = (twt, tap) => {
+  if (tap?.terminalRefConnectableId == null) {
+    return null;
+  }
+  return tap.terminalRefConnectableId === twt.equipmentId ? REGULATION_TYPES.LOCAL.id : REGULATION_TYPES.DISTANT.id;
+};
+const computeRatioTapChangerRegulationMode = (ratioTapChangerFormValues) => {
+  if (ratioTapChangerFormValues?.isRegulating) {
+    return RATIO_REGULATION_MODES.VOLTAGE_REGULATION.id;
+  }
+  return RATIO_REGULATION_MODES.FIXED_RATIO.id;
+};
+const getTapSideForEdit = (twt, tap) => {
+  if (tap?.terminalRefConnectableId !== twt.equipmentId) {
+    return null;
+  }
+  return tap?.terminalRefConnectableVlId === twt?.voltageLevelId1 ? REGULATION_SIDES.SIDE1.id : REGULATION_SIDES.SIDE2.id;
+};
+const computeRatioTapChangerRegulating = (ratioTapChangerFormValues) => {
+  return ratioTapChangerFormValues?.regulationMode === RATIO_REGULATION_MODES.VOLTAGE_REGULATION.id;
+};
+const computeRegulatingTerminalId = (tapChangerValue, currentTwtId) => {
+  if (tapChangerValue?.regulationType === REGULATION_TYPES.LOCAL.id) {
+    return currentTwtId;
+  }
+  return tapChangerValue?.equipment?.id ?? null;
+};
+const computeRegulatingTerminalType = (tapChangerValue) => {
+  if (tapChangerValue?.equipment?.type) {
+    return tapChangerValue?.equipment?.type;
+  }
+  if (tapChangerValue?.regulationType === REGULATION_TYPES.LOCAL.id) {
+    return EquipmentType.TWO_WINDINGS_TRANSFORMER;
+  }
+  return null;
+};
+const computeTapTerminalVlId = (tapChangerValue, connectivity) => {
+  if (tapChangerValue?.regulationType === REGULATION_TYPES.LOCAL.id) {
+    if (tapChangerValue?.regulationSide === REGULATION_SIDES.SIDE1.id) {
+      return connectivity.connectivity1.voltageLevel?.id ?? null;
+    }
+    return connectivity.connectivity2.voltageLevel?.id ?? null;
+  }
+  return tapChangerValue?.voltageLevel?.id ?? null;
+};
+const computePhaseTapChangerRegulating = (phaseTapChangerFormValues) => {
+  return phaseTapChangerFormValues?.regulationMode === PHASE_REGULATION_MODES.CURRENT_LIMITER.id || phaseTapChangerFormValues?.regulationMode === PHASE_REGULATION_MODES.ACTIVE_POWER_CONTROL.id;
+};
+const computePhaseTapChangerRegulationValue = (phaseTapChangerFormValues) => {
+  switch (phaseTapChangerFormValues?.regulationMode) {
+    case PHASE_REGULATION_MODES.ACTIVE_POWER_CONTROL.id:
+      return phaseTapChangerFormValues?.flowSetPointRegulatingValue ?? void 0;
+    case PHASE_REGULATION_MODES.CURRENT_LIMITER.id:
+      return phaseTapChangerFormValues?.currentLimiterRegulatingValue ?? void 0;
+    default:
+      return void 0;
+  }
+};
+const computeRegulationModeValue = (phaseTapChangerFormValues) => {
+  if (phaseTapChangerFormValues?.regulationMode === PHASE_REGULATION_MODES.OFF.id) {
+    return null;
+  }
+  return phaseTapChangerFormValues?.regulationMode;
+};
+const transformOperationalLimitsGroupsForForm = (operationalLimitsGroups) => {
+  return operationalLimitsGroups?.filter(
+    (group) => group.id != null && group.applicability != null
+  ).map(({ id, currentLimits, applicability, limitsProperties }) => ({
+    id: id + applicability,
+    name: id,
+    applicability,
+    limitsProperties: limitsProperties ?? void 0,
+    currentLimits: {
+      permanentLimit: currentLimits?.permanentLimit ?? "",
+      temporaryLimits: currentLimits?.temporaryLimits?.map((tl) => ({
+        name: tl.name ?? "",
+        value: tl.value ?? "",
+        acceptableDuration: tl.acceptableDuration ?? ""
+      })) ?? []
+    }
+  }));
+};
+const twoWindingsTransformerCreationFormSchema = object().shape({
+  [FieldConstants.EQUIPMENT_ID]: string().required(),
+  [FieldConstants.EQUIPMENT_NAME]: string().nullable(),
+  [FieldConstants.CONNECTIVITY]: getBranchConnectivityWithPositionSchema(false, true),
+  [FieldConstants.CHARACTERISTICS]: getTwtCharacteristicsValidationSchemaProps(false),
+  [FieldConstants.LIMITS]: getLimitsValidationSchemaProps(false),
+  [FieldConstants.RATIO_TAP_CHANGER]: getRatioTapChangerValidationSchemaProps(false),
+  [FieldConstants.PHASE_TAP_CHANGER]: getPhaseTapChangerValidationSchemaProps(false)
+}).concat(creationPropertiesSchema).required();
+const twoWindingsTransformerCreationEmptyFormData = {
+  [FieldConstants.EQUIPMENT_ID]: "",
+  [FieldConstants.EQUIPMENT_NAME]: "",
+  [FieldConstants.CONNECTIVITY]: getBranchConnectivityWithPositionEmptyFormDataProps(),
+  [FieldConstants.CHARACTERISTICS]: getTwtCharacteristicsEmptyFormData(),
+  [FieldConstants.LIMITS]: getLimitsEmptyFormDataProps(false),
+  [FieldConstants.RATIO_TAP_CHANGER]: getRatioTapChangerEmptyFormData(false),
+  [FieldConstants.PHASE_TAP_CHANGER]: getPhaseTapChangerEmptyFormData(false),
+  AdditionalProperties: []
+};
+const twoWindingsTransformerCreationDtoToForm = (twtDto) => {
+  const ratioTap = twtDto.ratioTapChanger;
+  const phaseTap = twtDto.phaseTapChanger;
+  return {
+    equipmentID: twtDto.equipmentId,
+    equipmentName: twtDto.equipmentName ?? "",
+    connectivity: {
+      connectivity1: getConnectivityFormDataProps({
+        voltageLevelId: twtDto.voltageLevelId1,
+        busbarSectionId: twtDto.busOrBusbarSectionId1,
+        connectionDirection: twtDto.connectionDirection1,
+        connectionName: twtDto.connectionName1,
+        connectionPosition: twtDto.connectionPosition1,
+        terminalConnected: twtDto.connected1
+      }),
+      connectivity2: getConnectivityFormDataProps({
+        voltageLevelId: twtDto.voltageLevelId2,
+        busbarSectionId: twtDto.busOrBusbarSectionId2,
+        connectionDirection: twtDto.connectionDirection2,
+        connectionName: twtDto.connectionName2,
+        connectionPosition: twtDto.connectionPosition2,
+        terminalConnected: twtDto.connected2
+      })
+    },
+    characteristics: {
+      r: twtDto.r,
+      x: twtDto.x,
+      g: convertInputValue(FieldType.G, twtDto.g),
+      b: convertInputValue(FieldType.B, twtDto.b),
+      ratedU1: twtDto.ratedU1,
+      ratedU2: twtDto.ratedU2,
+      ratedS: twtDto.ratedS
+    },
+    AdditionalProperties: getFilledPropertiesFromModification(twtDto.properties),
+    ...getAllLimitsFormData(
+      transformOperationalLimitsGroupsForForm(twtDto?.operationalLimitsGroups),
+      twtDto?.selectedOperationalLimitsGroupId1 ?? null,
+      twtDto?.selectedOperationalLimitsGroupId2 ?? null
+    ),
+    ...getPhaseTapChangerFormData({
+      enabled: phaseTap?.tapPosition !== void 0,
+      regulationMode: phaseTap?.isRegulating ? phaseTap?.regulationMode : PHASE_REGULATION_MODES.OFF.id,
+      regulationType: getRegulationTypeForEdit(twtDto, phaseTap),
+      regulationSide: getTapSideForEdit(twtDto, phaseTap),
+      currentLimiterRegulatingValue: phaseTap?.regulationMode === PHASE_REGULATION_MODES.CURRENT_LIMITER.id ? phaseTap?.regulationValue : null,
+      flowSetpointRegulatingValue: phaseTap?.regulationMode === PHASE_REGULATION_MODES.ACTIVE_POWER_CONTROL.id ? phaseTap?.regulationValue : null,
+      targetDeadband: phaseTap?.targetDeadband,
+      lowTapPosition: phaseTap?.lowTapPosition,
+      highTapPosition: computeHighTapPosition(phaseTap?.steps ?? []),
+      tapPosition: phaseTap?.tapPosition,
+      steps: addSelectedFieldToRows(phaseTap?.steps ?? []),
+      equipmentID: phaseTap?.terminalRefConnectableId ?? void 0,
+      equipmentType: phaseTap?.terminalRefConnectableType ?? void 0,
+      voltageLevelId: phaseTap?.terminalRefConnectableVlId ?? void 0
+    }),
+    ...getRatioTapChangerFormData({
+      enabled: ratioTap?.tapPosition !== void 0,
+      hasLoadTapChangingCapabilities: ratioTap?.hasLoadTapChangingCapabilities,
+      regulationMode: computeRatioTapChangerRegulationMode(ratioTap),
+      regulationType: getRegulationTypeForEdit(twtDto, ratioTap),
+      regulationSide: getTapSideForEdit(twtDto, ratioTap),
+      targetV: ratioTap?.targetV,
+      targetDeadband: ratioTap?.targetDeadband,
+      lowTapPosition: ratioTap?.lowTapPosition,
+      highTapPosition: computeHighTapPosition(ratioTap?.steps ?? []),
+      tapPosition: ratioTap?.tapPosition,
+      steps: addSelectedFieldToRows(ratioTap?.steps ?? []),
+      equipmentId: ratioTap?.terminalRefConnectableId ?? void 0,
+      equipmentType: ratioTap?.terminalRefConnectableType ?? void 0,
+      voltageLevelId: ratioTap?.terminalRefConnectableVlId ?? void 0
+    })
+  };
+};
+const twoWindingsTransformerCreationFormToDto = (twtForm) => {
+  const enablePhaseTapChanger = twtForm?.phaseTapChanger?.enabled;
+  const enableRatioTapChanger = twtForm?.ratioTapChanger?.enabled;
+  let ratioTap;
+  let phaseTap;
+  if (enableRatioTapChanger) {
+    const ratioForm = twtForm.ratioTapChanger;
+    const hasLoadTapCapabilities = ratioForm.hasLoadTapChangingCapabilities;
+    ratioTap = {
+      ...ratioForm,
+      isRegulating: computeRatioTapChangerRegulating(ratioForm),
+      terminalRefConnectableId: hasLoadTapCapabilities ? computeRegulatingTerminalId(ratioForm, twtForm.equipmentID) : null,
+      terminalRefConnectableType: hasLoadTapCapabilities ? computeRegulatingTerminalType(ratioForm) : null,
+      terminalRefConnectableVlId: hasLoadTapCapabilities ? computeTapTerminalVlId(ratioForm, twtForm.connectivity) : null,
+      targetV: hasLoadTapCapabilities && ratioForm.targetV != null ? Number(ratioForm.targetV) : null,
+      targetDeadband: hasLoadTapCapabilities && ratioForm.targetDeadband != null ? Number(ratioForm.targetDeadband) : null
+    };
+  }
+  if (enablePhaseTapChanger) {
+    const phaseForm = twtForm.phaseTapChanger;
+    phaseTap = {
+      hasLoadTapChangingCapabilities: true,
+      isRegulating: computePhaseTapChangerRegulating(phaseForm),
+      regulationValue: computePhaseTapChangerRegulationValue(phaseForm),
+      terminalRefConnectableId: computeRegulatingTerminalId(phaseForm, twtForm.equipmentID),
+      terminalRefConnectableType: computeRegulatingTerminalType(phaseForm),
+      terminalRefConnectableVlId: computeTapTerminalVlId(phaseForm, twtForm.connectivity),
+      ...phaseForm,
+      regulationMode: computeRegulationModeValue(phaseForm)
+    };
+  }
+  return {
+    type: ModificationType.TWO_WINDINGS_TRANSFORMER_CREATION,
+    equipmentId: twtForm.equipmentID,
+    equipmentName: sanitizeString(twtForm.equipmentName),
+    // connectivity
+    voltageLevelId1: twtForm.connectivity.connectivity1.voltageLevel?.id ?? "",
+    busOrBusbarSectionId1: twtForm.connectivity.connectivity1.busOrBusbarSection?.id ?? "",
+    connectionDirection1: twtForm.connectivity.connectivity1.connectionDirection ?? UNDEFINED_CONNECTION_DIRECTION,
+    connectionName1: sanitizeString(twtForm.connectivity.connectivity1.connectionName),
+    connectionPosition1: twtForm.connectivity.connectivity1.connectionPosition,
+    connected1: twtForm.connectivity.connectivity1.terminalConnected ?? null,
+    voltageLevelId2: twtForm.connectivity.connectivity2.voltageLevel?.id ?? "",
+    busOrBusbarSectionId2: twtForm.connectivity.connectivity2.busOrBusbarSection?.id ?? "",
+    connectionDirection2: twtForm.connectivity.connectivity2.connectionDirection ?? UNDEFINED_CONNECTION_DIRECTION,
+    connectionName2: sanitizeString(twtForm.connectivity.connectivity2.connectionName),
+    connectionPosition2: twtForm.connectivity.connectivity2.connectionPosition,
+    connected2: twtForm.connectivity.connectivity2.terminalConnected ?? null,
+    // characteristics
+    r: twtForm.characteristics.r ?? null,
+    x: Number(twtForm.characteristics.x),
+    g: Number(convertOutputValue(FieldType.G, twtForm.characteristics.g)),
+    b: Number(convertOutputValue(FieldType.B, twtForm.characteristics.b)),
+    ratedS: twtForm.characteristics.ratedS ?? null,
+    ratedU1: Number(twtForm.characteristics.ratedU1),
+    ratedU2: Number(twtForm.characteristics.ratedU2),
+    properties: toModificationProperties(twtForm),
+    // limits
+    operationalLimitsGroups: sanitizeLimitsGroups(twtForm.limits.operationalLimitsGroups ?? []),
+    selectedOperationalLimitsGroupId1: twtForm.limits.selectedOperationalLimitsGroupId1 ?? null,
+    selectedOperationalLimitsGroupId2: twtForm.limits.selectedOperationalLimitsGroupId2 ?? null,
+    // tap changers
+    ratioTapChanger: ratioTap ?? null,
+    phaseTapChanger: phaseTap ?? null
+  };
+};
+export {
+  computeRatioTapChangerRegulationMode,
+  getRegulationTypeForEdit,
+  getTapSideForEdit,
+  twoWindingsTransformerCreationDtoToForm,
+  twoWindingsTransformerCreationEmptyFormData,
+  twoWindingsTransformerCreationFormSchema,
+  twoWindingsTransformerCreationFormToDto
+};

package/dist/features/network-modifications/twoWindingsTransformer/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 './common';
+export * from './characteristics';
+export * from './tapChanger';
+export * from './creation';
+export * from './modification';