@gridsuite/commons-ui 0.98.0 → 0.100.0

package/dist/components/parameters/common/computing-type.js

@@ -0,0 +1,46 @@
+var ComputingType = /* @__PURE__ */ ((ComputingType2) => {
+  ComputingType2["LOAD_FLOW"] = "LOAD_FLOW";
+  ComputingType2["SECURITY_ANALYSIS"] = "SECURITY_ANALYSIS";
+  ComputingType2["SENSITIVITY_ANALYSIS"] = "SENSITIVITY_ANALYSIS";
+  ComputingType2["NON_EVACUATED_ENERGY_ANALYSIS"] = "NON_EVACUATED_ENERGY_ANALYSIS";
+  ComputingType2["SHORT_CIRCUIT"] = "SHORT_CIRCUIT";
+  ComputingType2["SHORT_CIRCUIT_ONE_BUS"] = "SHORT_CIRCUIT_ONE_BUS";
+  ComputingType2["DYNAMIC_SIMULATION"] = "DYNAMIC_SIMULATION";
+  ComputingType2["DYNAMIC_SECURITY_ANALYSIS"] = "DYNAMIC_SECURITY_ANALYSIS";
+  ComputingType2["VOLTAGE_INITIALIZATION"] = "VOLTAGE_INITIALIZATION";
+  ComputingType2["STATE_ESTIMATION"] = "STATE_ESTIMATION";
+  return ComputingType2;
+})(ComputingType || {});
+const isValidComputingType = (value) => {
+  return Object.values(ComputingType).includes(value);
+};
+const formatComputingTypeLabel = (type) => {
+  switch (type) {
+    case "LOAD_FLOW":
+      return "LoadFlow";
+    case "SECURITY_ANALYSIS":
+      return "SecurityAnalysis";
+    case "SENSITIVITY_ANALYSIS":
+      return "SensitivityAnalysis";
+    case "NON_EVACUATED_ENERGY_ANALYSIS":
+      return "NonEvacuatedEnergy";
+    case "SHORT_CIRCUIT":
+      return "ShortCircuit";
+    case "VOLTAGE_INITIALIZATION":
+      return "VoltageInit";
+    case "DYNAMIC_SIMULATION":
+      return "DynamicSimulation";
+    case "DYNAMIC_SECURITY_ANALYSIS":
+      return "DynamicSecurityAnalysis";
+    case "STATE_ESTIMATION":
+      return "StateEstimation";
+    default:
+      console.warn(`Unrecognized computing type while formatting its label : ${type}`);
+      return void 0;
+  }
+};
+export {
+  ComputingType,
+  formatComputingTypeLabel,
+  isValidComputingType
+};

package/dist/components/parameters/common/constant.d.ts

@@ -0,0 +1,8 @@
+export declare const PROVIDER = "provider";
+export declare const VOLTAGE_LEVEL = "voltageLevel";
+export declare const PARAM_SA_PROVIDER = "provider";
+export declare const PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD = "flowProportionalThreshold";
+export declare const PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD = "lowVoltageProportionalThreshold";
+export declare const PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD = "lowVoltageAbsoluteThreshold";
+export declare const PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD = "highVoltageProportionalThreshold";
+export declare const PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD = "highVoltageAbsoluteThreshold";

package/dist/components/parameters/common/constant.js

@@ -0,0 +1,18 @@
+const PROVIDER = "provider";
+const VOLTAGE_LEVEL = "voltageLevel";
+const PARAM_SA_PROVIDER = "provider";
+const PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD = "flowProportionalThreshold";
+const PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD = "lowVoltageProportionalThreshold";
+const PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD = "lowVoltageAbsoluteThreshold";
+const PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD = "highVoltageProportionalThreshold";
+const PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD = "highVoltageAbsoluteThreshold";
+export {
+  PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD,
+  PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD,
+  PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD,
+  PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD,
+  PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD,
+  PARAM_SA_PROVIDER,
+  PROVIDER,
+  VOLTAGE_LEVEL
+};

package/dist/components/parameters/common/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 * from './computing-type';
+export * from './constant';
+export * from './line-separator';
+export * from './parameters';
+export * from './parameters-creation-dialog';
+export * from './ProviderParam';
+export * from './widget';
+export * from './voltage-level-table';
+export * from './limitreductions';

package/dist/components/parameters/common/index.js

@@ -0,0 +1,61 @@
+import { ComputingType, formatComputingTypeLabel, isValidComputingType } from "./computing-type.js";
+import { PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_PROVIDER, PROVIDER, VOLTAGE_LEVEL } from "./constant.js";
+import { LineSeparator } from "./line-separator.js";
+import { LabelledButton, SwitchWithLabel, TabPanel } from "./parameters.js";
+import { CreateParameterDialog } from "./parameters-creation-dialog.js";
+import { ProviderParam } from "./ProviderParam.js";
+import { ParameterFloat } from "./widget/parameter-float.js";
+import { ParameterGroup } from "./widget/parameter-group.js";
+import { ParameterLineDirectoryItemsInput } from "./widget/parameter-line-directory-items-input.js";
+import { ParameterLineSlider, sanitizePercentageValue } from "./widget/parameter-line-slider.js";
+import { ParameterSwitch } from "./widget/parameter-switch.js";
+import { CustomVoltageLevelTable } from "./voltage-level-table/custom-voltage-level-table.js";
+import { CustomVoltageLevelTableCell } from "./voltage-level-table/custom-voltage-level-table-cell.js";
+import { CustomVoltageLevelTableRow } from "./voltage-level-table/custom-voltage-level-table-row.js";
+import { COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS, IST_FORM, LIMIT_DURATION_FORM, LIMIT_REDUCTIONS_FORM, TAB_INFO, TabValues, VOLTAGE_LEVELS_FORM, getLimitReductionsFormSchema, getSAParametersFromSchema } from "./limitreductions/columns-definitions.js";
+import { toFormValueSaParameters, toFormValuesLimitReductions } from "./limitreductions/limit-reductions-form-util.js";
+import { LimitReductionsTableForm } from "./limitreductions/limit-reductions-table-form.js";
+import { LimitReductionTableRow } from "./limitreductions/limit-reduction-table-row.js";
+import { LimitReductionTableCell } from "./limitreductions/limit-reduction-table-cell.js";
+export {
+  COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS,
+  ComputingType,
+  CreateParameterDialog,
+  CustomVoltageLevelTable,
+  CustomVoltageLevelTableCell,
+  CustomVoltageLevelTableRow,
+  IST_FORM,
+  LIMIT_DURATION_FORM,
+  LIMIT_REDUCTIONS_FORM,
+  LabelledButton,
+  LimitReductionTableCell,
+  LimitReductionTableRow,
+  LimitReductionsTableForm,
+  LineSeparator,
+  PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD,
+  PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD,
+  PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD,
+  PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD,
+  PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD,
+  PARAM_SA_PROVIDER,
+  PROVIDER,
+  ParameterFloat,
+  ParameterGroup,
+  ParameterLineDirectoryItemsInput,
+  ParameterLineSlider,
+  ParameterSwitch,
+  ProviderParam,
+  SwitchWithLabel,
+  TAB_INFO,
+  TabPanel,
+  TabValues,
+  VOLTAGE_LEVEL,
+  VOLTAGE_LEVELS_FORM,
+  formatComputingTypeLabel,
+  getLimitReductionsFormSchema,
+  getSAParametersFromSchema,
+  isValidComputingType,
+  sanitizePercentageValue,
+  toFormValueSaParameters,
+  toFormValuesLimitReductions
+};

package/dist/components/parameters/common/limitreductions/columns-definitions.d.ts

@@ -0,0 +1,77 @@
+import { UUID } from 'crypto';
+import { default as yup } from '../../../../utils/yupConfig';
+import { PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_PROVIDER } from '../constant';
+export declare const LIMIT_REDUCTIONS_FORM = "limitReductionsForm";
+export declare const VOLTAGE_LEVELS_FORM = "voltageLevelsForm";
+export declare const IST_FORM = "istForm";
+export declare const LIMIT_DURATION_FORM = "limitReductionForm";
+export interface IVoltageLevel {
+    nominalV: number;
+    lowBound: number;
+    highBound: number;
+}
+export interface ILimitDuration {
+    lowBound: number;
+    lowClosed: boolean;
+    highBound: number;
+    highClosed: boolean;
+}
+export interface ITemporaryLimitReduction {
+    reduction: number;
+    limitDuration: ILimitDuration;
+}
+export interface ILimitReductionsByVoltageLevel {
+    voltageLevel: IVoltageLevel;
+    permanentLimitReduction: number;
+    temporaryLimitReductions: ITemporaryLimitReduction[];
+}
+export interface ISAParameters {
+    uuid?: UUID;
+    [PARAM_SA_PROVIDER]: string;
+    limitReductions: ILimitReductionsByVoltageLevel[];
+    [PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD]: number;
+    [PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD]: number;
+    [PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD]: number;
+    [PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD]: number;
+    [PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD]: number;
+}
+export declare enum TabValues {
+    'General' = 0,
+    'LimitReductions' = 1
+}
+export declare const TAB_INFO: {
+    label: string;
+    developerModeOnly: boolean;
+}[];
+export interface IColumnsDef {
+    label: string;
+    dataKey: string;
+    tooltip: string;
+    width?: string;
+}
+export declare const COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS: IColumnsDef[];
+export declare const getLimitReductionsFormSchema: (nbTemporaryLimits: number) => yup.ObjectSchema<{
+    limitReductionsForm: {
+        voltageLevelsForm?: string | undefined;
+        istForm: number;
+    }[] | undefined;
+}, yup.AnyObject, {
+    limitReductionsForm: "";
+}, "">;
+export declare const getSAParametersFromSchema: (limitReductions?: ILimitReductionsByVoltageLevel[]) => yup.ObjectSchema<{
+    flowProportionalThreshold: unknown;
+    lowVoltageProportionalThreshold: unknown;
+    lowVoltageAbsoluteThreshold: unknown;
+    highVoltageProportionalThreshold: unknown;
+    highVoltageAbsoluteThreshold: unknown;
+    limitReductionsForm: unknown;
+    provider: unknown;
+}, yup.AnyObject, {
+    flowProportionalThreshold: undefined;
+    lowVoltageProportionalThreshold: undefined;
+    lowVoltageAbsoluteThreshold: undefined;
+    highVoltageProportionalThreshold: undefined;
+    highVoltageAbsoluteThreshold: undefined;
+    limitReductionsForm: undefined;
+    provider: undefined;
+}, "">;

package/dist/components/parameters/common/limitreductions/columns-definitions.js

@@ -0,0 +1,83 @@
+import "../../../../utils/yupConfig.js";
+import { PARAM_SA_PROVIDER, PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD } from "../constant.js";
+import * as yup from "yup";
+const LIMIT_REDUCTIONS_FORM = "limitReductionsForm";
+const VOLTAGE_LEVELS_FORM = "voltageLevelsForm";
+const IST_FORM = "istForm";
+const LIMIT_DURATION_FORM = "limitReductionForm";
+var TabValues = /* @__PURE__ */ ((TabValues2) => {
+  TabValues2[TabValues2["General"] = 0] = "General";
+  TabValues2[TabValues2["LimitReductions"] = 1] = "LimitReductions";
+  return TabValues2;
+})(TabValues || {});
+const TAB_INFO = [
+  { label: TabValues[
+    0
+    /* General */
+  ], developerModeOnly: false },
+  { label: TabValues[
+    1
+    /* LimitReductions */
+  ], developerModeOnly: false }
+];
+const COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS = [
+  {
+    label: "voltageRange",
+    dataKey: VOLTAGE_LEVELS_FORM,
+    tooltip: "voltageRange"
+  },
+  {
+    label: "IST",
+    dataKey: IST_FORM,
+    tooltip: "IST"
+  }
+];
+const getLimitDurationsFormSchema = (nbLimits) => {
+  const limitDurationsFormSchema = {};
+  for (let i = 0; i < nbLimits; i++) {
+    limitDurationsFormSchema[LIMIT_DURATION_FORM + i] = yup.number().min(0, "RealPercentage").max(1, "RealPercentage").nullable().required();
+  }
+  return limitDurationsFormSchema;
+};
+const getLimitReductionsFormSchema = (nbTemporaryLimits) => {
+  return yup.object().shape({
+    [LIMIT_REDUCTIONS_FORM]: yup.array().of(
+      yup.object().shape({
+        [VOLTAGE_LEVELS_FORM]: yup.string(),
+        [IST_FORM]: yup.number().min(0, "RealPercentage").max(1, "RealPercentage").nullable().required(),
+        ...getLimitDurationsFormSchema(nbTemporaryLimits)
+      })
+    )
+  }).required();
+};
+const getSAParametersFromSchema = (limitReductions) => {
+  const providerSchema = yup.object().shape({
+    [PARAM_SA_PROVIDER]: yup.string().required()
+  });
+  const limitReductionsSchema = getLimitReductionsFormSchema(
+    (limitReductions == null ? void 0 : limitReductions.length) ? limitReductions[0].temporaryLimitReductions.length : 0
+  );
+  const thresholdsSchema = yup.object().shape({
+    [PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD]: yup.number().min(0, "NormalizedPercentage").max(100, "NormalizedPercentage").required(),
+    [PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD]: yup.number().min(0, "NormalizedPercentage").max(100, "NormalizedPercentage").required(),
+    [PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD]: yup.number().required(),
+    [PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD]: yup.number().min(0, "NormalizedPercentage").max(100, "NormalizedPercentage").required(),
+    [PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD]: yup.number().required()
+  });
+  return yup.object().shape({
+    ...providerSchema.fields,
+    ...limitReductionsSchema.fields,
+    ...thresholdsSchema.fields
+  });
+};
+export {
+  COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS,
+  IST_FORM,
+  LIMIT_DURATION_FORM,
+  LIMIT_REDUCTIONS_FORM,
+  TAB_INFO,
+  TabValues,
+  VOLTAGE_LEVELS_FORM,
+  getLimitReductionsFormSchema,
+  getSAParametersFromSchema
+};

package/dist/components/parameters/common/limitreductions/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2025, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export * from './columns-definitions';
+export * from './limit-reductions-form-util';
+export * from './limit-reductions-table-form';
+export * from './limit-reduction-table-row';
+export * from './limit-reduction-table-cell';

package/dist/components/parameters/common/limitreductions/index.js

@@ -0,0 +1,21 @@
+import { COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS, IST_FORM, LIMIT_DURATION_FORM, LIMIT_REDUCTIONS_FORM, TAB_INFO, TabValues, VOLTAGE_LEVELS_FORM, getLimitReductionsFormSchema, getSAParametersFromSchema } from "./columns-definitions.js";
+import { toFormValueSaParameters, toFormValuesLimitReductions } from "./limit-reductions-form-util.js";
+import { LimitReductionsTableForm } from "./limit-reductions-table-form.js";
+import { LimitReductionTableRow } from "./limit-reduction-table-row.js";
+import { LimitReductionTableCell } from "./limit-reduction-table-cell.js";
+export {
+  COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS,
+  IST_FORM,
+  LIMIT_DURATION_FORM,
+  LIMIT_REDUCTIONS_FORM,
+  LimitReductionTableCell,
+  LimitReductionTableRow,
+  LimitReductionsTableForm,
+  TAB_INFO,
+  TabValues,
+  VOLTAGE_LEVELS_FORM,
+  getLimitReductionsFormSchema,
+  getSAParametersFromSchema,
+  toFormValueSaParameters,
+  toFormValuesLimitReductions
+};

package/dist/components/parameters/common/limitreductions/limit-reduction-table-cell.d.ts

@@ -0,0 +1,5 @@
+import { IColumnsDef } from './columns-definitions';
+export declare function LimitReductionTableCell({ rowIndex, column }: Readonly<{
+    rowIndex: number;
+    column: IColumnsDef;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/common/limitreductions/limit-reduction-table-cell.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { TableCell } from "@mui/material";
+import { VOLTAGE_LEVELS_FORM, LIMIT_REDUCTIONS_FORM } from "./columns-definitions.js";
+import "react-intl";
+import "@mui/icons-material";
+import "react";
+import "react-hook-form";
+import { RawReadOnlyInput } from "../../../inputs/reactHookForm/RawReadOnlyInput.js";
+import "../../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "notistack";
+import "../../../overflowableText/OverflowableText.js";
+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 "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "../../../../utils/yupConfig.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";
+function LimitReductionTableCell({ rowIndex, column }) {
+  return /* @__PURE__ */ jsx(TableCell, { sx: { fontWeight: "bold" }, children: column.dataKey === VOLTAGE_LEVELS_FORM ? /* @__PURE__ */ jsx(RawReadOnlyInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) : /* @__PURE__ */ jsx(FloatInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) });
+}
+export {
+  LimitReductionTableCell
+};

package/dist/components/parameters/common/limitreductions/limit-reduction-table-row.d.ts

@@ -0,0 +1,7 @@
+import { IColumnsDef } from './columns-definitions';
+interface TableRowComponentProps {
+    columnsDefinition: IColumnsDef[];
+    index: number;
+}
+export declare function LimitReductionTableRow({ columnsDefinition, index }: Readonly<TableRowComponentProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/common/limitreductions/limit-reduction-table-row.js

@@ -0,0 +1,9 @@
+import { jsx } from "react/jsx-runtime";
+import { TableRow } from "@mui/material";
+import { LimitReductionTableCell } from "./limit-reduction-table-cell.js";
+function LimitReductionTableRow({ columnsDefinition, index }) {
+  return /* @__PURE__ */ jsx(TableRow, { children: columnsDefinition.map((column) => /* @__PURE__ */ jsx(LimitReductionTableCell, { rowIndex: index, column }, `${column.dataKey}`)) });
+}
+export {
+  LimitReductionTableRow
+};

package/dist/components/parameters/common/limitreductions/limit-reductions-form-util.d.ts

@@ -0,0 +1,29 @@
+import { ILimitReductionsByVoltageLevel, ISAParameters } from './columns-definitions';
+export declare const toFormValuesLimitReductions: (limits: ILimitReductionsByVoltageLevel[]) => {
+    limitReductionsForm?: undefined;
+} | {
+    limitReductionsForm: {
+        voltageLevelsForm: string;
+        istForm: number;
+    }[];
+};
+export declare const toFormValueSaParameters: (params: ISAParameters) => {
+    flowProportionalThreshold: number;
+    lowVoltageProportionalThreshold: number;
+    lowVoltageAbsoluteThreshold: number;
+    highVoltageProportionalThreshold: number;
+    highVoltageAbsoluteThreshold: number;
+    limitReductionsForm?: undefined;
+    provider: string;
+} | {
+    flowProportionalThreshold: number;
+    lowVoltageProportionalThreshold: number;
+    lowVoltageAbsoluteThreshold: number;
+    highVoltageProportionalThreshold: number;
+    highVoltageAbsoluteThreshold: number;
+    limitReductionsForm: {
+        voltageLevelsForm: string;
+        istForm: number;
+    }[];
+    provider: string;
+};

package/dist/components/parameters/common/limitreductions/limit-reductions-form-util.js

@@ -0,0 +1,27 @@
+import { LIMIT_REDUCTIONS_FORM, IST_FORM, VOLTAGE_LEVELS_FORM, LIMIT_DURATION_FORM } from "./columns-definitions.js";
+import { PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD, PARAM_SA_PROVIDER } from "../constant.js";
+const toFormValuesFromTemporaryLimits = (limits) => limits.reduce((acc, limit, index) => {
+  acc[LIMIT_DURATION_FORM + index] = limit.reduction;
+  return acc;
+}, {});
+const toFormValuesLimitReductions = (limits) => !limits ? {} : {
+  [LIMIT_REDUCTIONS_FORM]: limits.map((vlLimits) => ({
+    [VOLTAGE_LEVELS_FORM]: `${vlLimits.voltageLevel.nominalV} kV`,
+    [IST_FORM]: vlLimits.permanentLimitReduction,
+    ...toFormValuesFromTemporaryLimits(vlLimits.temporaryLimitReductions)
+  }))
+};
+const toFormValueSaParameters = (params) => ({
+  [PARAM_SA_PROVIDER]: params[PARAM_SA_PROVIDER],
+  ...toFormValuesLimitReductions(params == null ? void 0 : params.limitReductions),
+  // SA specific form values
+  [PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD]: params[PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD] * 100,
+  [PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD]: params[PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD] * 100,
+  [PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD]: params[PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD],
+  [PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD]: params[PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD] * 100,
+  [PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD]: params[PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD]
+});
+export {
+  toFormValueSaParameters,
+  toFormValuesLimitReductions
+};

package/dist/components/parameters/common/limitreductions/limit-reductions-table-form.d.ts

@@ -0,0 +1,4 @@
+import { ILimitReductionsByVoltageLevel } from './columns-definitions';
+export declare function LimitReductionsTableForm({ limits }: Readonly<{
+    limits: ILimitReductionsByVoltageLevel[];
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/common/limitreductions/limit-reductions-table-form.js

@@ -0,0 +1,87 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import { useIntl } from "react-intl";
+import { COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS, LIMIT_DURATION_FORM, LIMIT_REDUCTIONS_FORM } from "./columns-definitions.js";
+import { CustomVoltageLevelTable } from "../voltage-level-table/custom-voltage-level-table.js";
+import "@mui/material";
+import "@mui/icons-material";
+import "react-hook-form";
+import "../../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "notistack";
+import "../../../overflowableText/OverflowableText.js";
+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 "../../../inputs/reactHookForm/numbers/RangeInput.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "../../../../utils/yupConfig.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";
+const getLabelColumn = (limit) => {
+  const lowBound = `${Math.trunc(limit.limitDuration.lowBound / 60)} min`;
+  const highBoundValue = Math.trunc(limit.limitDuration.highBound / 60);
+  const highBound = highBoundValue === 0 ? "∞" : `${Math.trunc(limit.limitDuration.highBound / 60)} min`;
+  const lowerBoundClosed = limit.limitDuration.lowClosed ? "[" : "]";
+  const highBoundClosed = limit.limitDuration.highClosed || null ? "]" : "[";
+  return `${lowerBoundClosed}${lowBound}, ${highBound}${highBoundClosed}`;
+};
+function LimitReductionsTableForm({ limits }) {
+  const intl = useIntl();
+  const getToolTipColumn = useCallback(
+    (limit) => {
+      const lowBound = Math.trunc(limit.limitDuration.lowBound / 60);
+      const highBound = Math.trunc(limit.limitDuration.highBound / 60);
+      if (lowBound === 0) {
+        return intl.formatMessage({ id: "LimitDurationAfterIST" }, { value: highBound });
+      }
+      return intl.formatMessage(
+        { id: "LimitDurationInterval" },
+        {
+          lowBound: `IT${lowBound}`,
+          highBound: highBound === 0 ? "IST" : `IT${highBound}`
+        }
+      );
+    },
+    [intl]
+  );
+  const columnsDefinition = useMemo(() => {
+    const columnsDef = COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS.map((column) => ({
+      ...column,
+      label: intl.formatMessage({ id: column.label }),
+      tooltip: intl.formatMessage({ id: column.tooltip })
+    }));
+    if (limits !== null && limits.length > 0) {
+      limits[0].temporaryLimitReductions.forEach((tlimit, index) => {
+        columnsDef.push({
+          label: getLabelColumn(tlimit),
+          dataKey: LIMIT_DURATION_FORM + index,
+          tooltip: getToolTipColumn(tlimit)
+        });
+      });
+    }
+    return columnsDef;
+  }, [intl, limits, getToolTipColumn]);
+  return /* @__PURE__ */ jsx(
+    CustomVoltageLevelTable,
+    {
+      formName: LIMIT_REDUCTIONS_FORM,
+      columnsDefinition,
+      tableHeight: 450
+    }
+  );
+}
+export {
+  LimitReductionsTableForm
+};

package/dist/components/parameters/common/line-separator.d.ts

@@ -0,0 +1 @@
+export declare function LineSeparator(): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/common/line-separator.js

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+import { Grid, Divider } from "@mui/material";
+function LineSeparator() {
+  return /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(Divider, {}) });
+}
+export {
+  LineSeparator
+};

package/dist/components/parameters/common/parameters-creation-dialog.d.ts

@@ -0,0 +1,13 @@
+import { FieldValues, UseFormGetValues } from 'react-hook-form';
+import { UUID } from 'crypto';
+import { ElementType } from '../../../utils';
+interface CreateParameterProps<T extends FieldValues> {
+    studyUuid: UUID | null;
+    open: boolean;
+    onClose: () => void;
+    parameterValues: UseFormGetValues<T> | any;
+    parameterType: ElementType;
+    parameterFormatter: (newParams: any) => any;
+}
+export declare function CreateParameterDialog<T extends FieldValues>({ studyUuid, open, onClose, parameterValues, parameterType, parameterFormatter, }: Readonly<CreateParameterProps<T>>): import("react/jsx-runtime").JSX.Element | null;
+export {};