@gridsuite/commons-ui 0.292.0 → 0.293.0

package/dist/features/process-configs/common/index.js

@@ -1,11 +1,35 @@
+import { FormSection } from "./FormSection.js";
+import { FormSubSection } from "./FormSubSection.js";
+import { GeneralInformationSection } from "./GeneralInformationSection.js";
+import { ModificationsSubSection } from "./ModificationsSubSection.js";
+import { ProvidersParametersSubSection } from "./ProvidersParametersSubSection.js";
+import { SpecificInformationSection } from "./SpecificInformationSection.js";
 import { ProcessType } from "./process-config.type.js";
-import { emptyProcessConfigModificationsFormData, getProcessConfigModificationsBackendFromFormData, getProcessConfigModificationsFormData, processConfigModificationsShape } from "./process-config-modifications-edition.utils.js";
+import { PROCESS_CONFIG_PARAMETER_FIELDS, PROCESS_CONFIG_TYPE_DEFINITIONS, getProcessConfigTypeDefinition, getProcessTypesRequiringParameter } from "./process-config-type.definitions.js";
 import { ProcessConfigModificationsEdition } from "./process-config-modifications-edition.js";
+import { getProcessConfigModificationsBackendFromFormData, getProcessConfigModificationsFormData, processConfigModificationsShape } from "./process-config-modifications-edition.utils.js";
+import { PROCESS_CONFIG_TYPES, getProcessConfigFormDefaultValues } from "./process-config-form.constants.js";
+import { getProcessConfigFormSchema } from "./process-config-form.schema.js";
+import { getProcessConfigBackendFromFormData, getProcessConfigFormData } from "./process-config-mapping.js";
 export {
+  FormSection,
+  FormSubSection,
+  GeneralInformationSection,
+  ModificationsSubSection,
+  PROCESS_CONFIG_PARAMETER_FIELDS,
+  PROCESS_CONFIG_TYPES,
+  PROCESS_CONFIG_TYPE_DEFINITIONS,
   ProcessConfigModificationsEdition,
   ProcessType,
-  emptyProcessConfigModificationsFormData,
+  ProvidersParametersSubSection,
+  SpecificInformationSection,
+  getProcessConfigBackendFromFormData,
+  getProcessConfigFormData,
+  getProcessConfigFormDefaultValues,
+  getProcessConfigFormSchema,
   getProcessConfigModificationsBackendFromFormData,
   getProcessConfigModificationsFormData,
+  getProcessConfigTypeDefinition,
+  getProcessTypesRequiringParameter,
   processConfigModificationsShape
 };

package/dist/features/process-configs/common/process-config-backend.type.d.ts

@@ -0,0 +1,15 @@
+import { UUID } from 'node:crypto';
+import { ProcessConfigBaseBackend, ProcessType } from './process-config.type';
+import { PROCESS_CONFIG_TYPE_DEFINITIONS, ProcessConfigParameterUuidProperties } from './process-config-type.definitions';
+type ProcessConfigParameterUuidProperty<TProcessType extends ProcessType> = TProcessType extends keyof typeof PROCESS_CONFIG_TYPE_DEFINITIONS ? (typeof PROCESS_CONFIG_TYPE_DEFINITIONS)[TProcessType]['parameters'][number]['backendProperty'] : never;
+type ProcessConfigBackendByProcessType = {
+    [TProcessType in ProcessType]: ProcessConfigBaseBackend & {
+        processType: TProcessType;
+    } & Pick<ProcessConfigParameterUuidProperties, ProcessConfigParameterUuidProperty<TProcessType>>;
+};
+export type ProcessConfigBackend<TProcessType extends ProcessType = ProcessType> = ProcessConfigBackendByProcessType[TProcessType];
+export type PersistedProcessConfigBackend<TProcessType extends ProcessType = ProcessType> = {
+    id: UUID;
+    processConfig: ProcessConfigBackend<TProcessType>;
+};
+export {};

package/dist/features/process-configs/common/process-config-form.constants.d.ts

@@ -0,0 +1,7 @@
+import { ProcessType } from './process-config.type';
+import { ProcessConfigFormValues, ProcessConfigMode } from './process-config-form.types';
+export declare const PROCESS_CONFIG_TYPES: {
+    id: ProcessType;
+    label: "process_config/securityAnalysis" | "process_config/loadflow" | "process_config/shortcircuit";
+}[];
+export declare function getProcessConfigFormDefaultValues(mode: ProcessConfigMode): ProcessConfigFormValues;

package/dist/features/process-configs/common/process-config-form.constants.js

@@ -0,0 +1,39 @@
+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 { PROCESS_CONFIG_TYPE_DEFINITIONS, PROCESS_CONFIG_PARAMETER_FIELDS } from "./process-config-type.definitions.js";
+const PROCESS_CONFIG_TYPES = Object.entries(PROCESS_CONFIG_TYPE_DEFINITIONS).map(
+  ([processType, definition]) => ({
+    id: processType,
+    label: definition.label
+  })
+);
+function getEmptyParameterValues() {
+  const parameterValues = {};
+  PROCESS_CONFIG_PARAMETER_FIELDS.forEach((field) => {
+    parameterValues[field] = [];
+  });
+  return parameterValues;
+}
+function getProcessConfigFormDefaultValues(mode) {
+  const defaultValues = {
+    processType: "",
+    [FieldConstants.NAME]: "",
+    [FieldConstants.DESCRIPTION]: "",
+    [FieldConstants.MODIFICATIONS]: [],
+    ...getEmptyParameterValues()
+  };
+  if (mode === "create") {
+    return {
+      ...defaultValues,
+      [FieldConstants.DIRECTORY]: { directoryItemId: "", directoryItemFullPath: "" }
+    };
+  }
+  return defaultValues;
+}
+export {
+  PROCESS_CONFIG_TYPES,
+  getProcessConfigFormDefaultValues
+};

package/dist/features/process-configs/common/process-config-form.schema.d.ts

@@ -0,0 +1,29 @@
+import { ProcessType } from './process-config.type';
+import { ProcessConfigMode } from './process-config-form.types';
+/**
+ * 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/.
+ */
+import * as yup from 'yup';
+export declare function getProcessConfigFormSchema(mode: ProcessConfigMode): yup.ObjectSchema<{
+    directory?: unknown;
+    modifications: {
+        description?: string | null | undefined;
+        active: NonNullable<boolean | undefined>;
+        modification: {
+            name?: string | undefined;
+            id: string;
+        }[];
+    }[];
+    processType: NonNullable<ProcessType | undefined>;
+    name: string;
+    description: string | undefined;
+}, yup.AnyObject, {
+    directory?: undefined;
+    modifications: "";
+    processType: undefined;
+    name: undefined;
+    description: undefined;
+}, "">;

package/dist/features/process-configs/{loadflow/lf-process-config-edition.utils.js → common/process-config-form.schema.js}

@@ -1,18 +1,15 @@
 import * as yup from "yup";
+import "react/jsx-runtime";
+import "@mui/material";
+import "@mui/icons-material";
+import "react-intl";
+import "../../../components/ui/overflowableText/OverflowableText.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 { fetchElementNames } from "../../../services/directory.js";
-import { ProcessType } from "../common/process-config.type.js";
-import { emptyProcessConfigModificationsFormData, getProcessConfigModificationsBackendFromFormData, getProcessConfigModificationsFormData, processConfigModificationsShape } from "../common/process-config-modifications-edition.utils.js";
-import "react-hook-form";
 import "react";
-import "react-intl";
-import "@mui/material";
-import "../../../components/ui/overflowableText/OverflowableText.js";
+import "react-hook-form";
 import "localized-countries";
 import "notistack";
 import "../../../components/ui/reactHookForm/provider/CustomFormProvider.js";
@@ -20,10 +17,9 @@ import "../../../components/ui/treeViewFinder/TreeViewFinder.js";
 import "../../../components/ui/reactHookForm/numbers/RangeInput.js";
 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 { directoryItemSchema } from "../../../components/ui/reactHookForm/directory-item-input/directory-item-utils.js";
 import "@hello-pangea/dnd";
 import "../../../components/ui/dialogs/elementSaveDialog/ElementSaveDialog.js";
-import { getNameElementEditorEmptyFormData, getNameElementEditorSchema } from "../../../components/ui/dialogs/name-element-editor/name-element-editor-utils.js";
 import "../../../components/ui/snackbarProvider/SnackbarProvider.js";
 import "../../../chunks/module.pXeJjFiM.js";
 import "react-resizable-panels";
@@ -54,48 +50,34 @@ import "../../../components/composite/report/report-viewer/log-table/log-table.j
 import "react-window";
 import "../../../components/composite/report/report-treeview/treeview-item.js";
 import "../../../components/composite/report/report-viewer/context/report-viewer-context.js";
-function getNamedLFProcessConfigFormSchema(initialName) {
-  const formSchema = yup.object().shape({
+import { ProcessType } from "./process-config.type.js";
+import { processConfigModificationsShape } from "./process-config-modifications-edition.utils.js";
+import { PROCESS_CONFIG_PARAMETER_FIELDS, getProcessTypesRequiringParameter } from "./process-config-type.definitions.js";
+const parameterSelectionSchema = yup.object({
+  id: yup.string().required(),
+  name: yup.string()
+});
+const parameterField = (field) => yup.array().of(parameterSelectionSchema).when("processType", {
+  is: (value) => getProcessTypesRequiringParameter(field).includes(value),
+  then: (schema) => schema.required().length(1, YUP_REQUIRED),
+  otherwise: (schema) => schema
+});
+function getProcessConfigFormSchema(mode) {
+  const parameterFields = {};
+  PROCESS_CONFIG_PARAMETER_FIELDS.forEach((field) => {
+    parameterFields[field] = parameterField(field);
+  });
+  return yup.object().shape({
+    processType: yup.string().oneOf(Object.values(ProcessType)).required(),
+    [FieldConstants.NAME]: yup.string().trim().required(),
+    [FieldConstants.DESCRIPTION]: yup.string().optional(),
     ...processConfigModificationsShape,
-    [FieldConstants.LOADFLOW_PARAMETERS]: yup.array().required().of(yup.object().shape({ id: yup.string().required(), name: yup.string() })).length(1, YUP_REQUIRED)
+    ...parameterFields,
+    ...mode === "create" ? {
+      [FieldConstants.DIRECTORY]: directoryItemSchema.nullable().required()
+    } : {}
   });
-  return formSchema.concat(getNameElementEditorSchema(initialName));
-}
-function getEmptyLFProcessConfigFormData(initialName, initialDescription) {
-  return {
-    ...getNameElementEditorEmptyFormData(initialName, initialDescription),
-    ...emptyProcessConfigModificationsFormData,
-    [FieldConstants.LOADFLOW_PARAMETERS]: []
-  };
-}
-async function getNamedLFProcessConfigFormData(processConfig, name, description) {
-  const allUuids = /* @__PURE__ */ new Set([
-    ...processConfig.modifications.map((modification) => modification.modificationUuid),
-    processConfig.loadflowParametersUuid
-  ]);
-  const elementNamesByUuid = await fetchElementNames(allUuids);
-  return {
-    name,
-    description: description ?? void 0,
-    ...getProcessConfigModificationsFormData(processConfig.modifications, elementNamesByUuid),
-    [FieldConstants.LOADFLOW_PARAMETERS]: [
-      {
-        id: processConfig.loadflowParametersUuid,
-        name: elementNamesByUuid[processConfig.loadflowParametersUuid]
-      }
-    ]
-  };
-}
-function getLFProcessConfigBackendFromFormData(formData) {
-  return {
-    processType: ProcessType.LOADFLOW,
-    ...getProcessConfigModificationsBackendFromFormData(formData[FieldConstants.MODIFICATIONS]),
-    loadflowParametersUuid: formData[FieldConstants.LOADFLOW_PARAMETERS][0].id
-  };
 }
 export {
-  getEmptyLFProcessConfigFormData,
-  getLFProcessConfigBackendFromFormData,
-  getNamedLFProcessConfigFormData,
-  getNamedLFProcessConfigFormSchema
+  getProcessConfigFormSchema
 };

package/dist/features/process-configs/common/process-config-form.types.d.ts

@@ -0,0 +1,45 @@
+import { UUID } from 'node:crypto';
+import { UseFormReturn } from 'react-hook-form';
+import { DirectoryItemSchema } from '../../../components';
+import { FieldConstants } from '../../../utils';
+import { ProcessType } from './process-config.type';
+import { ProcessConfigModification } from './process-config-modifications-edition.utils';
+import { PersistedProcessConfigBackend, ProcessConfigBackend } from './process-config-backend.type';
+import { ProcessConfigParameterField } from './process-config-type.definitions';
+export type ProcessConfigMode = 'create' | 'edit';
+export type ProcessConfigParameterRef = {
+    id: string;
+    name?: string;
+};
+type ProcessConfigParameterValues = Partial<Record<ProcessConfigParameterField, ProcessConfigParameterRef[]>>;
+export type ProcessConfigFormValues = {
+    processType: ProcessType | '';
+    [FieldConstants.NAME]: string;
+    [FieldConstants.DESCRIPTION]?: string;
+    [FieldConstants.DIRECTORY]?: DirectoryItemSchema | null;
+    [FieldConstants.MODIFICATIONS]: ProcessConfigModification[];
+} & ProcessConfigParameterValues;
+export type ProcessConfigPrefillValues = Partial<Omit<ProcessConfigFormValues, 'processType'>>;
+export type FetchProcessConfigHandler = (processConfigUuid: string, elementName?: string, elementDescription?: string) => Promise<ProcessConfigPrefillValues | undefined>;
+export type FetchPersistedProcessConfigHandler = (processConfigUuid: UUID) => Promise<PersistedProcessConfigBackend<ProcessType>>;
+export type UpdateProcessConfigHandler = (processConfigUuid: UUID, name: string, description: string, processConfig: ProcessConfigBackend<ProcessType>) => Promise<Response>;
+export type ProcessConfigFormProps = {
+    form: UseFormReturn<ProcessConfigFormValues>;
+    mode: ProcessConfigMode;
+    initialElementName?: string;
+    activeDirectory?: UUID;
+    onFetchProcessConfig?: FetchProcessConfigHandler;
+};
+export type ProcessConfigDialogCommonProps = {
+    open: boolean;
+    onClose: () => void;
+};
+export type ProcessConfigEditionDialogProps = ProcessConfigDialogCommonProps & {
+    processConfigUuid: UUID;
+    processConfigName: string;
+    description: string | null;
+    directory: UUID;
+    fetchProcessConfig: FetchPersistedProcessConfigHandler;
+    updateProcessConfig: UpdateProcessConfigHandler;
+};
+export {};

package/dist/features/process-configs/common/process-config-mapping.d.ts

@@ -0,0 +1,4 @@
+import { ProcessConfigBackend, PersistedProcessConfigBackend } from './process-config-backend.type';
+import { ProcessConfigFormValues } from './process-config-form.types';
+export declare function getProcessConfigFormData(persistedProcessConfig: PersistedProcessConfigBackend, name: string, description: string | null): Promise<ProcessConfigFormValues>;
+export declare function getProcessConfigBackendFromFormData(formData: ProcessConfigFormValues): ProcessConfigBackend;

package/dist/features/process-configs/common/process-config-mapping.js

@@ -0,0 +1,57 @@
+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 { fetchElementNames } from "../../../services/directory.js";
+import { getProcessConfigModificationsBackendFromFormData, getProcessConfigModificationsFormData } from "./process-config-modifications-edition.utils.js";
+import { getProcessConfigTypeDefinition } from "./process-config-type.definitions.js";
+async function getProcessConfigFormData(persistedProcessConfig, name, description) {
+  const { processConfig } = persistedProcessConfig;
+  const definition = getProcessConfigTypeDefinition(processConfig.processType);
+  if (!definition) {
+    throw new Error(`Unsupported process type: ${processConfig.processType}`);
+  }
+  const backendParameters = processConfig;
+  const parameterUuids = definition.parameters.map(({ backendProperty }) => backendParameters[backendProperty]);
+  const allUuids = /* @__PURE__ */ new Set([
+    ...processConfig.modifications.map((modification) => modification.modificationUuid),
+    ...parameterUuids
+  ]);
+  const elementNamesByUuid = await fetchElementNames(allUuids);
+  const parameterValues = {};
+  definition.parameters.forEach(({ field, backendProperty }) => {
+    const uuid = backendParameters[backendProperty];
+    parameterValues[field] = [{ id: uuid, name: elementNamesByUuid[uuid] }];
+  });
+  return {
+    processType: processConfig.processType,
+    [FieldConstants.NAME]: name,
+    [FieldConstants.DESCRIPTION]: description ?? void 0,
+    ...getProcessConfigModificationsFormData(processConfig.modifications, elementNamesByUuid),
+    ...parameterValues
+  };
+}
+function getProcessConfigBackendFromFormData(formData) {
+  const processType = formData.processType;
+  const definition = getProcessConfigTypeDefinition(processType);
+  if (!definition) {
+    throw new Error(`Unsupported process type: ${formData.processType}`);
+  }
+  const backendParameters = {};
+  definition.parameters.forEach(({ field, backendProperty }) => {
+    const [parameter] = formData[field] ?? [];
+    if (parameter?.id) {
+      backendParameters[backendProperty] = parameter.id;
+    }
+  });
+  return {
+    processType,
+    ...getProcessConfigModificationsBackendFromFormData(formData[FieldConstants.MODIFICATIONS] ?? []),
+    ...backendParameters
+  };
+}
+export {
+  getProcessConfigBackendFromFormData,
+  getProcessConfigFormData
+};

package/dist/features/process-configs/common/process-config-modifications-edition.utils.d.ts

@@ -30,9 +30,6 @@ export declare const processConfigModificationsShape: {
         }[];
     }[], yup.AnyObject, "", "">;
 };
-export declare const emptyProcessConfigModificationsFormData: {
-    modifications: never[];
-};
 export declare function getProcessConfigModificationsFormData(processConfigModifications: ModificationInfo[], elementNamesByUuid: Record<string, string>): {
     modifications: {
         modification: {

package/dist/features/process-configs/common/process-config-modifications-edition.utils.js

@@ -18,7 +18,6 @@ const processConfigModificationSchema = yup.object().shape({
 const processConfigModificationsShape = {
   [FieldConstants.MODIFICATIONS]: yup.array().required().of(processConfigModificationSchema)
 };
-const emptyProcessConfigModificationsFormData = { [FieldConstants.MODIFICATIONS]: [] };
 function getProcessConfigModificationsFormData(processConfigModifications, elementNamesByUuid) {
   return {
     [FieldConstants.MODIFICATIONS]: processConfigModifications.map((modification) => ({
@@ -43,7 +42,6 @@ function getProcessConfigModificationsBackendFromFormData(formProcessConfigModif
   };
 }
 export {
-  emptyProcessConfigModificationsFormData,
   getProcessConfigModificationsBackendFromFormData,
   getProcessConfigModificationsFormData,
   processConfigModificationsShape

package/dist/features/process-configs/common/process-config-type.definitions.d.ts

@@ -0,0 +1,56 @@
+import { UUID } from 'node:crypto';
+import { ElementType, FieldConstants } from '../../../utils';
+import { ProcessType } from './process-config.type';
+export type ProcessConfigParameterField = FieldConstants.LOADFLOW_PARAMETERS | FieldConstants.SECURITY_ANALYSIS_PARAMETERS | FieldConstants.SHORTCIRCUIT_PARAMETERS;
+export type ProcessConfigParameterUuidProperties = {
+    loadflowParametersUuid: UUID;
+    securityAnalysisParametersUuid: UUID;
+    shortCircuitParametersUuid: UUID;
+};
+export type ProcessConfigParameterDefinition = {
+    field: ProcessConfigParameterField;
+    elementType: ElementType;
+    label: string;
+    backendProperty: keyof ProcessConfigParameterUuidProperties;
+};
+export type ProcessConfigTypeDefinition = {
+    label: string;
+    parameters: readonly ProcessConfigParameterDefinition[];
+};
+export declare const PROCESS_CONFIG_TYPE_DEFINITIONS: {
+    readonly SECURITY_ANALYSIS: {
+        readonly label: "process_config/securityAnalysis";
+        readonly parameters: readonly [{
+            readonly field: FieldConstants.LOADFLOW_PARAMETERS;
+            readonly elementType: ElementType.LOADFLOW_PARAMETERS;
+            readonly label: "process_config/loadflow";
+            readonly backendProperty: "loadflowParametersUuid";
+        }, {
+            readonly field: FieldConstants.SECURITY_ANALYSIS_PARAMETERS;
+            readonly elementType: ElementType.SECURITY_ANALYSIS_PARAMETERS;
+            readonly label: "process_config/securityAnalysis";
+            readonly backendProperty: "securityAnalysisParametersUuid";
+        }];
+    };
+    readonly LOADFLOW: {
+        readonly label: "process_config/loadflow";
+        readonly parameters: readonly [{
+            readonly field: FieldConstants.LOADFLOW_PARAMETERS;
+            readonly elementType: ElementType.LOADFLOW_PARAMETERS;
+            readonly label: "process_config/loadflow";
+            readonly backendProperty: "loadflowParametersUuid";
+        }];
+    };
+    readonly SHORT_CIRCUIT: {
+        readonly label: "process_config/shortcircuit";
+        readonly parameters: readonly [{
+            readonly field: FieldConstants.SHORTCIRCUIT_PARAMETERS;
+            readonly elementType: ElementType.SHORT_CIRCUIT_PARAMETERS;
+            readonly label: "process_config/shortcircuit";
+            readonly backendProperty: "shortCircuitParametersUuid";
+        }];
+    };
+};
+export declare const PROCESS_CONFIG_PARAMETER_FIELDS: ProcessConfigParameterField[];
+export declare function getProcessConfigTypeDefinition(processType: ProcessType | ''): ProcessConfigTypeDefinition | undefined;
+export declare function getProcessTypesRequiringParameter(field: ProcessConfigParameterField): ProcessType[];

package/dist/features/process-configs/common/process-config-type.definitions.js

@@ -0,0 +1,70 @@
+import { FieldConstants } from "../../../utils/constants/fieldConstants.js";
+import "../../../utils/conversionUtils.js";
+import { ElementType } from "../../../utils/types/elementType.js";
+import "../../../utils/types/equipmentType.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { ProcessType } from "./process-config.type.js";
+const PROCESS_CONFIG_TYPE_DEFINITIONS = {
+  [ProcessType.SECURITY_ANALYSIS]: {
+    label: "process_config/securityAnalysis",
+    parameters: [
+      {
+        field: FieldConstants.LOADFLOW_PARAMETERS,
+        elementType: ElementType.LOADFLOW_PARAMETERS,
+        label: "process_config/loadflow",
+        backendProperty: "loadflowParametersUuid"
+      },
+      {
+        field: FieldConstants.SECURITY_ANALYSIS_PARAMETERS,
+        elementType: ElementType.SECURITY_ANALYSIS_PARAMETERS,
+        label: "process_config/securityAnalysis",
+        backendProperty: "securityAnalysisParametersUuid"
+      }
+    ]
+  },
+  [ProcessType.LOADFLOW]: {
+    label: "process_config/loadflow",
+    parameters: [
+      {
+        field: FieldConstants.LOADFLOW_PARAMETERS,
+        elementType: ElementType.LOADFLOW_PARAMETERS,
+        label: "process_config/loadflow",
+        backendProperty: "loadflowParametersUuid"
+      }
+    ]
+  },
+  [ProcessType.SHORT_CIRCUIT]: {
+    label: "process_config/shortcircuit",
+    parameters: [
+      {
+        field: FieldConstants.SHORTCIRCUIT_PARAMETERS,
+        elementType: ElementType.SHORT_CIRCUIT_PARAMETERS,
+        label: "process_config/shortcircuit",
+        backendProperty: "shortCircuitParametersUuid"
+      }
+    ]
+  }
+};
+const definitionsByProcessType = PROCESS_CONFIG_TYPE_DEFINITIONS;
+const PROCESS_CONFIG_PARAMETER_FIELDS = [
+  ...new Set(
+    Object.values(PROCESS_CONFIG_TYPE_DEFINITIONS).flatMap(
+      (definition) => definition.parameters.map((parameter) => parameter.field)
+    )
+  )
+];
+function getProcessConfigTypeDefinition(processType) {
+  return definitionsByProcessType[processType];
+}
+function getProcessTypesRequiringParameter(field) {
+  return Object.values(ProcessType).filter(
+    (processType) => getProcessConfigTypeDefinition(processType)?.parameters.some((parameter) => parameter.field === field)
+  );
+}
+export {
+  PROCESS_CONFIG_PARAMETER_FIELDS,
+  PROCESS_CONFIG_TYPE_DEFINITIONS,
+  getProcessConfigTypeDefinition,
+  getProcessTypesRequiringParameter
+};

package/dist/features/process-configs/form/components/ProcessTypeChangeDialog.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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/.
+ */
+type ProcessTypeChangeDialogProps = {
+    open: boolean;
+    onCancel: () => void;
+    onConfirm: () => void;
+};
+export declare function ProcessTypeChangeDialog({ open, onCancel, onConfirm }: Readonly<ProcessTypeChangeDialogProps>): import("react").JSX.Element;
+export {};

package/dist/features/process-configs/form/components/ProcessTypeChangeDialog.js

@@ -0,0 +1,27 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Dialog, DialogTitle, DialogContent, Typography, DialogActions, Button } from "@mui/material";
+import { FormattedMessage } from "react-intl";
+function ProcessTypeChangeDialog({ open, onCancel, onConfirm }) {
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      open,
+      onClose: onCancel,
+      disableEscapeKeyDown: true,
+      maxWidth: "xs",
+      slotProps: { paper: { sx: { minWidth: 320 } } },
+      "aria-labelledby": "process-type-change-warning-title",
+      children: [
+        /* @__PURE__ */ jsx(DialogTitle, { id: "process-type-change-warning-title", children: /* @__PURE__ */ jsx(FormattedMessage, { id: "processConfigProcessTypeChangeTitle" }) }),
+        /* @__PURE__ */ jsx(DialogContent, { children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "processConfigProcessTypeChangeWarning" }) }) }),
+        /* @__PURE__ */ jsxs(DialogActions, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "text", sx: { textTransform: "none" }, onClick: onCancel, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "cancel" }) }),
+          /* @__PURE__ */ jsx(Button, { variant: "contained", sx: { textTransform: "none" }, onClick: onConfirm, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "modifier" }) })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  ProcessTypeChangeDialog
+};

package/dist/features/process-configs/form/components/ProcessTypeSelect.d.ts

@@ -0,0 +1,6 @@
+import { Option } from '../../../../utils';
+type ProcessTypeSelectProps = {
+    onCheckNewValue: (value: Option | null) => boolean;
+};
+export declare function ProcessTypeSelect({ onCheckNewValue }: Readonly<ProcessTypeSelectProps>): import("react").JSX.Element;
+export {};

package/dist/features/process-configs/form/components/ProcessTypeSelect.js

@@ -0,0 +1,69 @@
+import { jsx } from "react/jsx-runtime";
+import "@mui/material";
+import "@mui/icons-material";
+import "react-intl";
+import "../../../../components/ui/overflowableText/OverflowableText.js";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "react";
+import "react-hook-form";
+import "localized-countries";
+import "notistack";
+import "../../../../components/ui/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "../../../../components/ui/treeViewFinder/TreeViewFinder.js";
+import "../../../../components/ui/reactHookForm/numbers/RangeInput.js";
+import { SelectInput } from "../../../../components/ui/reactHookForm/selectInputs/SelectInput.js";
+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 "../../../../chunks/module.pXeJjFiM.js";
+import "react-resizable-panels";
+import "react-papaparse";
+import "react-dom";
+import "../../../../chunks/index.BJsVzTMz.js";
+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 { PROCESS_CONFIG_TYPES } from "../../common/process-config-form.constants.js";
+function ProcessTypeSelect({ onCheckNewValue }) {
+  return /* @__PURE__ */ jsx(
+    SelectInput,
+    {
+      name: "processType",
+      label: "processType",
+      options: PROCESS_CONFIG_TYPES,
+      onCheckNewValue,
+      fullWidth: true,
+      disableClearable: true,
+      size: "small"
+    }
+  );
+}
+export {
+  ProcessTypeSelect
+};

package/dist/features/process-configs/form/hooks/usePrefillSelection.d.ts

@@ -0,0 +1,19 @@
+import { UseFormReturn } from 'react-hook-form';
+import { ElementAttributes } from '../../../../utils';
+import { FetchProcessConfigHandler, ProcessConfigFormValues } from '../../common/process-config-form.types';
+type UsePrefillSelectionParams = {
+    form: UseFormReturn<ProcessConfigFormValues>;
+    onFetchProcessConfig?: FetchProcessConfigHandler;
+    selectedProcessType: string;
+};
+export declare function usePrefillSelection({ form, onFetchProcessConfig, selectedProcessType }: UsePrefillSelectionParams): {
+    isSelectorOpen: boolean;
+    openSelector: () => void;
+    itemFilter: (item: ElementAttributes) => boolean;
+    handleSelect: (nodes: ReadonlyArray<{
+        id: string;
+        name?: string;
+        description?: string;
+    }>) => Promise<void>;
+};
+export {};