@gridsuite/commons-ui 0.192.0 → 0.194.0

package/dist/components/parameters/dynamic-simulation/index.js

@@ -0,0 +1,4 @@
+import { DynamicSimulationInline } from "./dynamic-simulation-inline.js";
+export {
+  DynamicSimulationInline
+};

package/dist/components/parameters/dynamic-simulation/mapping/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 './mapping-parameters-constants';
+export * from './mapping-parameters-utils';
+export * from './mapping-parameters';

package/dist/components/parameters/dynamic-simulation/mapping/index.js

@@ -0,0 +1,9 @@
+import { MAPPING } from "./mapping-parameters-constants.js";
+import { mappingEmptyFormData, mappingFormSchema } from "./mapping-parameters-utils.js";
+import { MappingParameters } from "./mapping-parameters.js";
+export {
+  MAPPING,
+  MappingParameters,
+  mappingEmptyFormData,
+  mappingFormSchema
+};

package/dist/components/parameters/dynamic-simulation/mapping/mapping-parameters-constants.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 declare const MAPPING = "mapping";

package/dist/components/parameters/dynamic-simulation/mapping/mapping-parameters-constants.js

@@ -0,0 +1,4 @@
+const MAPPING = "mapping";
+export {
+  MAPPING
+};

package/dist/components/parameters/dynamic-simulation/mapping/mapping-parameters-utils.d.ts

@@ -0,0 +1,9 @@
+import { default as yup } from '../../../../utils/yupConfig';
+export declare const mappingFormSchema: yup.ObjectSchema<{
+    mapping: string;
+}, yup.AnyObject, {
+    mapping: undefined;
+}, "">;
+export declare const mappingEmptyFormData: {
+    mapping: string;
+};

package/dist/components/parameters/dynamic-simulation/mapping/mapping-parameters-utils.js

@@ -0,0 +1,13 @@
+import "../../../../utils/yupConfig.js";
+import { MAPPING } from "./mapping-parameters-constants.js";
+import * as yup from "yup";
+const mappingFormSchema = yup.object().shape({
+  [MAPPING]: yup.string().required()
+});
+const mappingEmptyFormData = {
+  [MAPPING]: ""
+};
+export {
+  mappingEmptyFormData,
+  mappingFormSchema
+};

package/dist/components/parameters/dynamic-simulation/mapping/mapping-parameters.d.ts

@@ -0,0 +1,5 @@
+interface MappingParametersProps {
+    path: string;
+}
+export declare function MappingParameters({ path }: Readonly<MappingParametersProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/dynamic-simulation/mapping/mapping-parameters.js

@@ -0,0 +1,52 @@
+import { jsx } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import { useState, useEffect, useMemo } from "react";
+import { ParameterType } from "../../../../utils/types/parameters.type.js";
+import ParameterField from "../../common/parameter-field.js";
+import { MAPPING } from "./mapping-parameters-constants.js";
+import "../../../../utils/conversionUtils.js";
+import { snackWithFallback } from "../../../../utils/error.js";
+import "../../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import "../../../../utils/yupConfig.js";
+import { getDynamicMappings } from "../../../../services/dynamic-mapping.js";
+import "react-intl";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../../../hooks/useSnackMessage.js";
+function MappingParameters({ path }) {
+  const { snackError } = useSnackMessage();
+  const [mappings, setMappings] = useState([]);
+  useEffect(() => {
+    getDynamicMappings().then((_mappings) => {
+      setMappings(_mappings);
+    }).catch((error) => {
+      snackWithFallback(snackError, error, {
+        headerId: `DynamicSimulationMappingsError`
+      });
+    });
+  }, [setMappings, snackError]);
+  const mappingOptions = useMemo(() => {
+    return mappings?.map((elem) => elem.name) ?? [];
+  }, [mappings]);
+  const params = useMemo(
+    () => [
+      {
+        name: MAPPING,
+        type: ParameterType.STRING,
+        label: "DynamicSimulationMapping",
+        possibleValues: mappingOptions,
+        sx: { width: "100%" }
+      }
+    ],
+    [mappingOptions]
+  );
+  return /* @__PURE__ */ jsx(Grid, { container: true, children: params.map((param) => {
+    const { name, type, ...otherParams } = param;
+    return /* @__PURE__ */ jsx(ParameterField, { id: path, name: param.name, type: param.type, ...otherParams }, param.name);
+  }) });
+}
+export {
+  MappingParameters
+};

package/dist/components/parameters/dynamic-simulation/network/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 './network-parameters-constants';
+export * from './network-parameters-utils';
+export * from './network-parameters';

package/dist/components/parameters/dynamic-simulation/network/index.js

@@ -0,0 +1,10 @@
+import { NETWORK, Network } from "./network-parameters-constants.js";
+import { networkEmptyFormData, networkFormSchema } from "./network-parameters-utils.js";
+import { NetworkParameters } from "./network-parameters.js";
+export {
+  NETWORK,
+  Network,
+  NetworkParameters,
+  networkEmptyFormData,
+  networkFormSchema
+};

package/dist/components/parameters/dynamic-simulation/network/network-parameters-constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 declare const NETWORK = "network";
+export declare enum Network {
+    CAPACITOR_NO_RECLOSING_DELAY = "capacitorNoReclosingDelay",
+    DANGLING_LINE_CURRENT_LIMIT_MAX_TIME_OPERATION = "danglingLineCurrentLimitMaxTimeOperation",
+    LINE_CURRENT_LIMIT_MAX_TIME_OPERATION = "lineCurrentLimitMaxTimeOperation",
+    LOAD_TP = "loadTp",
+    LOAD_TQ = "loadTq",
+    LOAD_ALPHA = "loadAlpha",
+    LOAD_ALPHA_LONG = "loadAlphaLong",
+    LOAD_BETA = "loadBeta",
+    LOAD_BETA_LONG = "loadBetaLong",
+    LOAD_IS_CONTROLLABLE = "loadIsControllable",
+    LOAD_IS_RESTORATIVE = "loadIsRestorative",
+    LOAD_Z_PMAX = "loadZPMax",
+    LOAD_Z_QMAX = "loadZQMax",
+    REACTANCE_NO_RECLOSING_DELAY = "reactanceNoReclosingDelay",
+    TRANSFORMER_CURRENT_LIMIT_MAX_TIME_OPERATION = "transformerCurrentLimitMaxTimeOperation",
+    TRANSFORMER_T1_ST_HT = "transformerT1StHT",
+    TRANSFORMER_T1_ST_THT = "transformerT1StTHT",
+    TRANSFORMER_T_NEXT_HT = "transformerTNextHT",
+    TRANSFORMER_T_NEXT_THT = "transformerTNextTHT",
+    TRANSFORMER_TO_LV = "transformerTolV"
+}

package/dist/components/parameters/dynamic-simulation/network/network-parameters-constants.js

@@ -0,0 +1,28 @@
+const NETWORK = "network";
+var Network = /* @__PURE__ */ ((Network2) => {
+  Network2["CAPACITOR_NO_RECLOSING_DELAY"] = "capacitorNoReclosingDelay";
+  Network2["DANGLING_LINE_CURRENT_LIMIT_MAX_TIME_OPERATION"] = "danglingLineCurrentLimitMaxTimeOperation";
+  Network2["LINE_CURRENT_LIMIT_MAX_TIME_OPERATION"] = "lineCurrentLimitMaxTimeOperation";
+  Network2["LOAD_TP"] = "loadTp";
+  Network2["LOAD_TQ"] = "loadTq";
+  Network2["LOAD_ALPHA"] = "loadAlpha";
+  Network2["LOAD_ALPHA_LONG"] = "loadAlphaLong";
+  Network2["LOAD_BETA"] = "loadBeta";
+  Network2["LOAD_BETA_LONG"] = "loadBetaLong";
+  Network2["LOAD_IS_CONTROLLABLE"] = "loadIsControllable";
+  Network2["LOAD_IS_RESTORATIVE"] = "loadIsRestorative";
+  Network2["LOAD_Z_PMAX"] = "loadZPMax";
+  Network2["LOAD_Z_QMAX"] = "loadZQMax";
+  Network2["REACTANCE_NO_RECLOSING_DELAY"] = "reactanceNoReclosingDelay";
+  Network2["TRANSFORMER_CURRENT_LIMIT_MAX_TIME_OPERATION"] = "transformerCurrentLimitMaxTimeOperation";
+  Network2["TRANSFORMER_T1_ST_HT"] = "transformerT1StHT";
+  Network2["TRANSFORMER_T1_ST_THT"] = "transformerT1StTHT";
+  Network2["TRANSFORMER_T_NEXT_HT"] = "transformerTNextHT";
+  Network2["TRANSFORMER_T_NEXT_THT"] = "transformerTNextTHT";
+  Network2["TRANSFORMER_TO_LV"] = "transformerTolV";
+  return Network2;
+})(Network || {});
+export {
+  NETWORK,
+  Network
+};

package/dist/components/parameters/dynamic-simulation/network/network-parameters-utils.d.ts

@@ -0,0 +1,66 @@
+import { default as yup } from '../../../../utils/yupConfig';
+export declare const networkFormSchema: yup.ObjectSchema<{
+    capacitorNoReclosingDelay: number;
+    danglingLineCurrentLimitMaxTimeOperation: number;
+    lineCurrentLimitMaxTimeOperation: number;
+    loadTp: number;
+    loadTq: number;
+    loadAlpha: number;
+    loadAlphaLong: number;
+    loadBeta: number;
+    loadBetaLong: number;
+    loadIsControllable: boolean | undefined;
+    loadIsRestorative: boolean | undefined;
+    loadZPMax: number;
+    loadZQMax: number;
+    reactanceNoReclosingDelay: number;
+    transformerCurrentLimitMaxTimeOperation: number;
+    transformerT1StHT: number;
+    transformerT1StTHT: number;
+    transformerTNextHT: number;
+    transformerTNextTHT: number;
+    transformerTolV: number;
+}, yup.AnyObject, {
+    capacitorNoReclosingDelay: undefined;
+    danglingLineCurrentLimitMaxTimeOperation: undefined;
+    lineCurrentLimitMaxTimeOperation: undefined;
+    loadTp: undefined;
+    loadTq: undefined;
+    loadAlpha: undefined;
+    loadAlphaLong: undefined;
+    loadBeta: undefined;
+    loadBetaLong: undefined;
+    loadIsControllable: undefined;
+    loadIsRestorative: undefined;
+    loadZPMax: undefined;
+    loadZQMax: undefined;
+    reactanceNoReclosingDelay: undefined;
+    transformerCurrentLimitMaxTimeOperation: undefined;
+    transformerT1StHT: undefined;
+    transformerT1StTHT: undefined;
+    transformerTNextHT: undefined;
+    transformerTNextTHT: undefined;
+    transformerTolV: undefined;
+}, "">;
+export declare const networkEmptyFormData: {
+    capacitorNoReclosingDelay: number;
+    danglingLineCurrentLimitMaxTimeOperation: number;
+    lineCurrentLimitMaxTimeOperation: number;
+    loadTp: number;
+    loadTq: number;
+    loadAlpha: number;
+    loadAlphaLong: number;
+    loadBeta: number;
+    loadBetaLong: number;
+    loadIsControllable: boolean;
+    loadIsRestorative: boolean;
+    loadZPMax: number;
+    loadZQMax: number;
+    reactanceNoReclosingDelay: number;
+    transformerCurrentLimitMaxTimeOperation: number;
+    transformerT1StHT: number;
+    transformerT1StTHT: number;
+    transformerTNextHT: number;
+    transformerTNextTHT: number;
+    transformerTolV: number;
+};

package/dist/components/parameters/dynamic-simulation/network/network-parameters-utils.js

@@ -0,0 +1,51 @@
+import { Network } from "./network-parameters-constants.js";
+import "../../../../utils/yupConfig.js";
+import * as yup from "yup";
+const networkFormSchema = yup.object().shape({
+  [Network.CAPACITOR_NO_RECLOSING_DELAY]: yup.number().required(),
+  [Network.DANGLING_LINE_CURRENT_LIMIT_MAX_TIME_OPERATION]: yup.number().required(),
+  [Network.LINE_CURRENT_LIMIT_MAX_TIME_OPERATION]: yup.number().required(),
+  [Network.LOAD_TP]: yup.number().required(),
+  [Network.LOAD_TQ]: yup.number().required(),
+  [Network.LOAD_ALPHA]: yup.number().required(),
+  [Network.LOAD_ALPHA_LONG]: yup.number().required(),
+  [Network.LOAD_BETA]: yup.number().required(),
+  [Network.LOAD_BETA_LONG]: yup.number().required(),
+  [Network.LOAD_IS_CONTROLLABLE]: yup.boolean(),
+  [Network.LOAD_IS_RESTORATIVE]: yup.boolean(),
+  [Network.LOAD_Z_PMAX]: yup.number().required(),
+  [Network.LOAD_Z_QMAX]: yup.number().required(),
+  [Network.REACTANCE_NO_RECLOSING_DELAY]: yup.number().required(),
+  [Network.TRANSFORMER_CURRENT_LIMIT_MAX_TIME_OPERATION]: yup.number().required(),
+  [Network.TRANSFORMER_T1_ST_HT]: yup.number().required(),
+  [Network.TRANSFORMER_T1_ST_THT]: yup.number().required(),
+  [Network.TRANSFORMER_T_NEXT_HT]: yup.number().required(),
+  [Network.TRANSFORMER_T_NEXT_THT]: yup.number().required(),
+  [Network.TRANSFORMER_TO_LV]: yup.number().required()
+});
+const networkEmptyFormData = {
+  [Network.CAPACITOR_NO_RECLOSING_DELAY]: 0,
+  [Network.DANGLING_LINE_CURRENT_LIMIT_MAX_TIME_OPERATION]: 0,
+  [Network.LINE_CURRENT_LIMIT_MAX_TIME_OPERATION]: 0,
+  [Network.LOAD_TP]: 0,
+  [Network.LOAD_TQ]: 0,
+  [Network.LOAD_ALPHA]: 0,
+  [Network.LOAD_ALPHA_LONG]: 0,
+  [Network.LOAD_BETA]: 0,
+  [Network.LOAD_BETA_LONG]: 0,
+  [Network.LOAD_IS_CONTROLLABLE]: false,
+  [Network.LOAD_IS_RESTORATIVE]: false,
+  [Network.LOAD_Z_PMAX]: 0,
+  [Network.LOAD_Z_QMAX]: 0,
+  [Network.REACTANCE_NO_RECLOSING_DELAY]: 0,
+  [Network.TRANSFORMER_CURRENT_LIMIT_MAX_TIME_OPERATION]: 0,
+  [Network.TRANSFORMER_T1_ST_HT]: 0,
+  [Network.TRANSFORMER_T1_ST_THT]: 0,
+  [Network.TRANSFORMER_T_NEXT_HT]: 0,
+  [Network.TRANSFORMER_T_NEXT_THT]: 0,
+  [Network.TRANSFORMER_TO_LV]: 0
+};
+export {
+  networkEmptyFormData,
+  networkFormSchema
+};

package/dist/components/parameters/dynamic-simulation/network/network-parameters.d.ts

@@ -0,0 +1,3 @@
+export declare function NetworkParameters({ path }: Readonly<{
+    path: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/dynamic-simulation/network/network-parameters.js

@@ -0,0 +1,120 @@
+import { jsx } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import { Network } from "./network-parameters-constants.js";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import { ParameterType } from "../../../../utils/types/parameters.type.js";
+import "@mui/icons-material";
+import "../../../../utils/yupConfig.js";
+import ParameterField from "../../common/parameter-field.js";
+const params = [
+  {
+    name: Network.CAPACITOR_NO_RECLOSING_DELAY,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkCapacitorNoReclosingDelay"
+  },
+  {
+    name: Network.DANGLING_LINE_CURRENT_LIMIT_MAX_TIME_OPERATION,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkDanglingLineCurrentLimitMaxTimeOperation"
+  },
+  {
+    name: Network.LINE_CURRENT_LIMIT_MAX_TIME_OPERATION,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLineCurrentLimitMaxTimeOperation"
+  },
+  {
+    name: Network.LOAD_TP,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadTp"
+  },
+  {
+    name: Network.LOAD_TQ,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadTq"
+  },
+  {
+    name: Network.LOAD_ALPHA,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadAlpha"
+  },
+  {
+    name: Network.LOAD_ALPHA_LONG,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadAlphaLong"
+  },
+  {
+    name: Network.LOAD_BETA,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadBeta"
+  },
+  {
+    name: Network.LOAD_BETA_LONG,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadBetaLong"
+  },
+  {
+    name: Network.LOAD_IS_CONTROLLABLE,
+    type: ParameterType.BOOLEAN,
+    label: "DynamicSimulationNetworkLoadIsControllable"
+  },
+  {
+    name: Network.LOAD_IS_RESTORATIVE,
+    type: ParameterType.BOOLEAN,
+    label: "DynamicSimulationNetworkLoadIsRestorative"
+  },
+  {
+    name: Network.LOAD_Z_PMAX,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadZPMax"
+  },
+  {
+    name: Network.LOAD_Z_QMAX,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkLoadZQMax"
+  },
+  {
+    name: Network.REACTANCE_NO_RECLOSING_DELAY,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkReactanceNoReclosingDelay"
+  },
+  {
+    name: Network.TRANSFORMER_CURRENT_LIMIT_MAX_TIME_OPERATION,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkTransformerCurrentLimitMaxTimeOperation"
+  },
+  {
+    name: Network.TRANSFORMER_T1_ST_HT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkTransformerT1StHT"
+  },
+  {
+    name: Network.TRANSFORMER_T1_ST_THT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkTransformerT1StTHT"
+  },
+  {
+    name: Network.TRANSFORMER_T_NEXT_HT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkTransformerTNextHT"
+  },
+  {
+    name: Network.TRANSFORMER_T_NEXT_THT,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkTransformerTNextTHT"
+  },
+  {
+    name: Network.TRANSFORMER_TO_LV,
+    type: ParameterType.DOUBLE,
+    label: "DynamicSimulationNetworkTransformerTolV"
+  }
+];
+function NetworkParameters({ path }) {
+  return /* @__PURE__ */ jsx(Grid, { container: true, children: params.map((param) => {
+    const { name, type, ...otherParams } = param;
+    return /* @__PURE__ */ jsx(ParameterField, { id: path, name: param.name, type: param.type, ...otherParams }, param.name);
+  }) });
+}
+export {
+  NetworkParameters
+};

package/dist/components/parameters/dynamic-simulation/solver/common-solver/common-solver-parameters-constants.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 declare enum CommonSolver {
+    F_NORM_TOL_ALG = "fNormTolAlg",
+    INITIAL_ADD_TOL_ALG = "initialAddTolAlg",
+    SC_STEP_TOL_ALG = "scStepTolAlg",
+    MX_NEW_T_STEP_ALG = "mxNewTStepAlg",
+    MSBSET_ALG = "msbsetAlg",
+    MX_ITER_ALG = "mxIterAlg",
+    PRINT_FL_ALG = "printFlAlg",
+    F_NORM_TOL_ALG_J = "fNormTolAlgJ",
+    INITIAL_ADD_TOL_ALG_J = "initialAddTolAlgJ",
+    SC_STEP_TOL_ALG_J = "scStepTolAlgJ",
+    MX_NEW_T_STEP_ALG_J = "mxNewTStepAlgJ",
+    MSBSET_ALG_J = "msbsetAlgJ",
+    MX_ITER_ALG_J = "mxIterAlgJ",
+    PRINT_FL_ALG_J = "printFlAlgJ",
+    F_NORM_TOL_ALG_INIT = "fNormTolAlgInit",
+    INITIAL_ADD_TOL_ALG_INIT = "initialAddTolAlgInit",
+    SC_STEP_TOL_ALG_INIT = "scStepTolAlgInit",
+    MX_NEW_T_STEP_ALG_INIT = "mxNewTStepAlgInit",
+    MSBSET_ALG_INIT = "msbsetAlgInit",
+    MX_ITER_ALG_INIT = "mxIterAlgInit",
+    PRINT_FL_ALG_INIT = "printFlAlgInit",
+    MAXIMUM_NUMBER_SLOW_STEP_INCREASE = "maximumNumberSlowStepIncrease",
+    MINIMAL_ACCEPTABLE_STEP = "minimalAcceptableStep"
+}

package/dist/components/parameters/dynamic-simulation/solver/common-solver/common-solver-parameters-constants.js

@@ -0,0 +1,29 @@
+var CommonSolver = /* @__PURE__ */ ((CommonSolver2) => {
+  CommonSolver2["F_NORM_TOL_ALG"] = "fNormTolAlg";
+  CommonSolver2["INITIAL_ADD_TOL_ALG"] = "initialAddTolAlg";
+  CommonSolver2["SC_STEP_TOL_ALG"] = "scStepTolAlg";
+  CommonSolver2["MX_NEW_T_STEP_ALG"] = "mxNewTStepAlg";
+  CommonSolver2["MSBSET_ALG"] = "msbsetAlg";
+  CommonSolver2["MX_ITER_ALG"] = "mxIterAlg";
+  CommonSolver2["PRINT_FL_ALG"] = "printFlAlg";
+  CommonSolver2["F_NORM_TOL_ALG_J"] = "fNormTolAlgJ";
+  CommonSolver2["INITIAL_ADD_TOL_ALG_J"] = "initialAddTolAlgJ";
+  CommonSolver2["SC_STEP_TOL_ALG_J"] = "scStepTolAlgJ";
+  CommonSolver2["MX_NEW_T_STEP_ALG_J"] = "mxNewTStepAlgJ";
+  CommonSolver2["MSBSET_ALG_J"] = "msbsetAlgJ";
+  CommonSolver2["MX_ITER_ALG_J"] = "mxIterAlgJ";
+  CommonSolver2["PRINT_FL_ALG_J"] = "printFlAlgJ";
+  CommonSolver2["F_NORM_TOL_ALG_INIT"] = "fNormTolAlgInit";
+  CommonSolver2["INITIAL_ADD_TOL_ALG_INIT"] = "initialAddTolAlgInit";
+  CommonSolver2["SC_STEP_TOL_ALG_INIT"] = "scStepTolAlgInit";
+  CommonSolver2["MX_NEW_T_STEP_ALG_INIT"] = "mxNewTStepAlgInit";
+  CommonSolver2["MSBSET_ALG_INIT"] = "msbsetAlgInit";
+  CommonSolver2["MX_ITER_ALG_INIT"] = "mxIterAlgInit";
+  CommonSolver2["PRINT_FL_ALG_INIT"] = "printFlAlgInit";
+  CommonSolver2["MAXIMUM_NUMBER_SLOW_STEP_INCREASE"] = "maximumNumberSlowStepIncrease";
+  CommonSolver2["MINIMAL_ACCEPTABLE_STEP"] = "minimalAcceptableStep";
+  return CommonSolver2;
+})(CommonSolver || {});
+export {
+  CommonSolver
+};

package/dist/components/parameters/dynamic-simulation/solver/common-solver/common-solver-parameters-utils.d.ts

@@ -0,0 +1,26 @@
+import { default as yup } from '../../../../../utils/yupConfig';
+export declare const getFormSchema: () => {
+    fNormTolAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    initialAddTolAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    scStepTolAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    mxNewTStepAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    msbsetAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    mxIterAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    printFlAlg: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    fNormTolAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    initialAddTolAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    scStepTolAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    mxNewTStepAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    msbsetAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    mxIterAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    printFlAlgJ: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    fNormTolAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    initialAddTolAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    scStepTolAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    mxNewTStepAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    msbsetAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    mxIterAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    printFlAlgInit: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    maximumNumberSlowStepIncrease: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+    minimalAcceptableStep: yup.NumberSchema<number, yup.AnyObject, undefined, "">;
+};

package/dist/components/parameters/dynamic-simulation/solver/common-solver/common-solver-parameters-utils.js

@@ -0,0 +1,33 @@
+import "../../../../../utils/yupConfig.js";
+import { CommonSolver } from "./common-solver-parameters-constants.js";
+import * as yup from "yup";
+const getFormSchema = () => {
+  return {
+    [CommonSolver.F_NORM_TOL_ALG]: yup.number().required(),
+    [CommonSolver.INITIAL_ADD_TOL_ALG]: yup.number().required(),
+    [CommonSolver.SC_STEP_TOL_ALG]: yup.number().required(),
+    [CommonSolver.MX_NEW_T_STEP_ALG]: yup.number().integer().required(),
+    [CommonSolver.MSBSET_ALG]: yup.number().integer().required(),
+    [CommonSolver.MX_ITER_ALG]: yup.number().integer().required(),
+    [CommonSolver.PRINT_FL_ALG]: yup.number().integer().required(),
+    [CommonSolver.F_NORM_TOL_ALG_J]: yup.number().required(),
+    [CommonSolver.INITIAL_ADD_TOL_ALG_J]: yup.number().required(),
+    [CommonSolver.SC_STEP_TOL_ALG_J]: yup.number().required(),
+    [CommonSolver.MX_NEW_T_STEP_ALG_J]: yup.number().required(),
+    [CommonSolver.MSBSET_ALG_J]: yup.number().integer().required(),
+    [CommonSolver.MX_ITER_ALG_J]: yup.number().integer().required(),
+    [CommonSolver.PRINT_FL_ALG_J]: yup.number().integer().required(),
+    [CommonSolver.F_NORM_TOL_ALG_INIT]: yup.number().required(),
+    [CommonSolver.INITIAL_ADD_TOL_ALG_INIT]: yup.number().required(),
+    [CommonSolver.SC_STEP_TOL_ALG_INIT]: yup.number().required(),
+    [CommonSolver.MX_NEW_T_STEP_ALG_INIT]: yup.number().required(),
+    [CommonSolver.MSBSET_ALG_INIT]: yup.number().integer().required(),
+    [CommonSolver.MX_ITER_ALG_INIT]: yup.number().integer().required(),
+    [CommonSolver.PRINT_FL_ALG_INIT]: yup.number().integer().required(),
+    [CommonSolver.MAXIMUM_NUMBER_SLOW_STEP_INCREASE]: yup.number().integer().required(),
+    [CommonSolver.MINIMAL_ACCEPTABLE_STEP]: yup.number().required()
+  };
+};
+export {
+  getFormSchema
+};

package/dist/components/parameters/dynamic-simulation/solver/common-solver/common-solver-parameters.d.ts

@@ -0,0 +1,3 @@
+export declare function CommonSolverParameters({ path }: Readonly<{
+    path: string;
+}>): import("react/jsx-runtime").JSX.Element;