@gridsuite/commons-ui 0.223.0 → 0.224.0

package/dist/utils/types/pcc-min.type.js

@@ -1,4 +1,3 @@
-import { fetchElementNames } from "../../services/directory.js";
 import { FILTERS } from "../constants/filterConstant.js";
 function mapPccMinParameters(parametersInfos) {
   return {
@@ -6,26 +5,6 @@ function mapPccMinParameters(parametersInfos) {
     [FILTERS]: parametersInfos.filters?.map((filter) => filter.filterId)
   };
 }
-function getFilterIdentifierIds(params) {
-  return new Set(params[FILTERS]);
-}
-function enrichPccMinParameters(parameters) {
-  const allElementIds = getFilterIdentifierIds(parameters);
-  const elementNamesPromise = allElementIds.size === 0 ? Promise.resolve(null) : fetchElementNames(allElementIds);
-  return elementNamesPromise.then((elementNames) => {
-    const mapIdsToFilterIdentifiers = (ids) => {
-      return ids ? ids.map((id) => ({
-        filterId: id,
-        filterName: elementNames?.[id] ?? null
-      })) : [];
-    };
-    return {
-      ...parameters,
-      [FILTERS]: mapIdsToFilterIdentifiers(parameters[FILTERS])
-    };
-  });
-}
 export {
-  enrichPccMinParameters,
   mapPccMinParameters
 };

package/dist/utils/types/security-analysis.type.d.ts

@@ -0,0 +1,26 @@
+import { UUID } from 'node:crypto';
+import { ILimitReductionsByVoltageLevel } from '../../features/parameters/common/limitreductions/columns-definitions';
+import { IdName } from './types';
+export type ContingencyListsInfos = {
+    contingencyLists: UUID[];
+    description: string;
+    activated: boolean;
+};
+export type ContingencyListsInfosEnriched = Omit<ContingencyListsInfos, 'contingencyLists'> & {
+    contingencyLists: IdName[];
+};
+export type SAParameters = {
+    uuid?: UUID;
+    provider: string;
+    contingencyListsInfos: ContingencyListsInfos[];
+    limitReductions: ILimitReductionsByVoltageLevel[];
+    flowProportionalThreshold: number;
+    lowVoltageProportionalThreshold: number;
+    lowVoltageAbsoluteThreshold: number;
+    highVoltageProportionalThreshold: number;
+    highVoltageAbsoluteThreshold: number;
+};
+export type SAParametersEnriched = Omit<SAParameters, 'contingencyListsInfos'> & {
+    contingencyListsInfos: ContingencyListsInfosEnriched[];
+};
+export declare function mapSecurityAnalysisParameters(parameters: SAParametersEnriched): SAParameters;

package/dist/utils/types/security-analysis.type.js

@@ -0,0 +1,14 @@
+function mapSecurityAnalysisParameters(parameters) {
+  return {
+    ...parameters,
+    contingencyListsInfos: parameters.contingencyListsInfos?.map((clInfos) => {
+      return {
+        ...clInfos,
+        contingencyLists: clInfos.contingencyLists.map((c) => c.id)
+      };
+    })
+  };
+}
+export {
+  mapSecurityAnalysisParameters
+};

package/dist/utils/types/sensitivity-analysis.type.d.ts

@@ -1,4 +1,5 @@
 import { UUID } from 'node:crypto';
+import { IdName } from './types';
 export declare enum DistributionType {
     PROPORTIONAL = "PROPORTIONAL",
     PROPORTIONAL_MAXP = "PROPORTIONAL_MAXP",
@@ -9,11 +10,7 @@ export declare enum SensitivityType {
     DELTA_MW = "DELTA_MW",
     DELTA_A = "DELTA_A"
 }
-interface EquipmentsContainer {
-    containerId: string;
-    containerName: string;
-}
-type EquipmentsInfos = EquipmentsContainer | UUID;
+type EquipmentsInfos = IdName | UUID;
 interface SensitivityParamsCommon<T extends EquipmentsInfos> {
     contingencies?: T[];
     activated?: boolean | null;
@@ -55,7 +52,7 @@ export interface SensitivityAnalysisParameters<T extends EquipmentsInfos> {
     sensitivityPST?: SensitivityPST<T>[];
     sensitivityNodes?: SensitivityNodes<T>[];
 }
-export type SensitivityAnalysisParametersInfosEnriched = SensitivityAnalysisParameters<EquipmentsContainer>;
+export type SensitivityAnalysisParametersInfosEnriched = SensitivityAnalysisParameters<IdName>;
 export type SensitivityAnalysisParametersInfos = SensitivityAnalysisParameters<UUID>;
 export interface FactorsCount {
     resultCount: number | null;
@@ -99,5 +96,4 @@ export type SensitivityResultFilterOptions = {
     allVariableIds?: string[];
 };
 export declare function mapSensitivityAnalysisParameters(parameters: SensitivityAnalysisParametersInfosEnriched): SensitivityAnalysisParametersInfos;
-export declare function enrichSensitivityAnalysisParameters(parameters: SensitivityAnalysisParametersInfos): Promise<SensitivityAnalysisParametersInfosEnriched>;
 export {};

package/dist/utils/types/sensitivity-analysis.type.js

@@ -1,4 +1,3 @@
-import { fetchElementNames } from "../../services/directory.js";
 var DistributionType = /* @__PURE__ */ ((DistributionType2) => {
   DistributionType2["PROPORTIONAL"] = "PROPORTIONAL";
   DistributionType2["PROPORTIONAL_MAXP"] = "PROPORTIONAL_MAXP";
@@ -12,140 +11,55 @@ var SensitivityType = /* @__PURE__ */ ((SensitivityType2) => {
   return SensitivityType2;
 })(SensitivityType || {});
 function mapSensitivityAnalysisParameters(parameters) {
-  const mapEquipmentsContainerToIds = (containers) => {
-    return containers ? containers.map((c) => c.containerId) : [];
+  const mapIdNamesToIds = (objects) => {
+    return objects?.map((c) => c.id) ?? [];
   };
   return {
     ...parameters,
     sensitivityInjectionsSet: parameters.sensitivityInjectionsSet?.map((injectionsSet) => {
       return {
         ...injectionsSet,
-        monitoredBranches: mapEquipmentsContainerToIds(injectionsSet.monitoredBranches),
-        injections: mapEquipmentsContainerToIds(injectionsSet.injections),
-        contingencies: mapEquipmentsContainerToIds(injectionsSet.contingencies)
+        monitoredBranches: mapIdNamesToIds(injectionsSet.monitoredBranches),
+        injections: mapIdNamesToIds(injectionsSet.injections),
+        contingencies: mapIdNamesToIds(injectionsSet.contingencies)
       };
     }),
     sensitivityInjection: parameters.sensitivityInjection?.map((injection) => {
       return {
         ...injection,
-        monitoredBranches: mapEquipmentsContainerToIds(injection.monitoredBranches),
-        injections: mapEquipmentsContainerToIds(injection.injections),
-        contingencies: mapEquipmentsContainerToIds(injection.contingencies)
+        monitoredBranches: mapIdNamesToIds(injection.monitoredBranches),
+        injections: mapIdNamesToIds(injection.injections),
+        contingencies: mapIdNamesToIds(injection.contingencies)
       };
     }),
     sensitivityHVDC: parameters.sensitivityHVDC?.map((hvdc) => {
       return {
         ...hvdc,
-        monitoredBranches: mapEquipmentsContainerToIds(hvdc.monitoredBranches),
-        hvdcs: mapEquipmentsContainerToIds(hvdc.hvdcs),
-        contingencies: mapEquipmentsContainerToIds(hvdc.contingencies)
+        monitoredBranches: mapIdNamesToIds(hvdc.monitoredBranches),
+        hvdcs: mapIdNamesToIds(hvdc.hvdcs),
+        contingencies: mapIdNamesToIds(hvdc.contingencies)
       };
     }),
     sensitivityPST: parameters.sensitivityPST?.map((pst) => {
       return {
         ...pst,
-        monitoredBranches: mapEquipmentsContainerToIds(pst.monitoredBranches),
-        psts: mapEquipmentsContainerToIds(pst.psts),
-        contingencies: mapEquipmentsContainerToIds(pst.contingencies)
+        monitoredBranches: mapIdNamesToIds(pst.monitoredBranches),
+        psts: mapIdNamesToIds(pst.psts),
+        contingencies: mapIdNamesToIds(pst.contingencies)
       };
     }),
     sensitivityNodes: parameters.sensitivityNodes?.map((nodes) => {
       return {
         ...nodes,
-        monitoredVoltageLevels: mapEquipmentsContainerToIds(nodes.monitoredVoltageLevels),
-        equipmentsInVoltageRegulation: mapEquipmentsContainerToIds(nodes.equipmentsInVoltageRegulation),
-        contingencies: mapEquipmentsContainerToIds(nodes.contingencies)
+        monitoredVoltageLevels: mapIdNamesToIds(nodes.monitoredVoltageLevels),
+        equipmentsInVoltageRegulation: mapIdNamesToIds(nodes.equipmentsInVoltageRegulation),
+        contingencies: mapIdNamesToIds(nodes.contingencies)
       };
     })
   };
 }
-function getEquipmentsContainerIds(parameters) {
-  const allContainerIds = /* @__PURE__ */ new Set();
-  parameters.sensitivityInjection?.forEach((i) => {
-    i.monitoredBranches?.forEach((id) => allContainerIds.add(id));
-    i.injections?.forEach((id) => allContainerIds.add(id));
-    i.contingencies?.forEach((id) => allContainerIds.add(id));
-  });
-  parameters.sensitivityInjectionsSet?.forEach((is) => {
-    is.monitoredBranches?.forEach((id) => allContainerIds.add(id));
-    is.injections?.forEach((id) => allContainerIds.add(id));
-    is.contingencies?.forEach((id) => allContainerIds.add(id));
-  });
-  parameters.sensitivityHVDC?.forEach((hvdc) => {
-    hvdc.monitoredBranches?.forEach((id) => allContainerIds.add(id));
-    hvdc.hvdcs?.forEach((id) => allContainerIds.add(id));
-    hvdc.contingencies?.forEach((id) => allContainerIds.add(id));
-  });
-  parameters.sensitivityPST?.forEach((pst) => {
-    pst.monitoredBranches?.forEach((id) => allContainerIds.add(id));
-    pst.psts?.forEach((id) => allContainerIds.add(id));
-    pst.contingencies?.forEach((id) => allContainerIds.add(id));
-  });
-  parameters.sensitivityNodes?.forEach((n) => {
-    n.monitoredVoltageLevels?.forEach((id) => allContainerIds.add(id));
-    n.equipmentsInVoltageRegulation?.forEach((id) => allContainerIds.add(id));
-    n.contingencies?.forEach((id) => allContainerIds.add(id));
-  });
-  return allContainerIds;
-}
-function enrichSensitivityAnalysisParameters(parameters) {
-  const allElementIds = getEquipmentsContainerIds(parameters);
-  const elementNamesPromise = allElementIds.size === 0 ? Promise.resolve(null) : fetchElementNames(allElementIds);
-  return elementNamesPromise.then((elementNames) => {
-    const mapIdsToEquipmentsContainer = (ids) => {
-      return ids ? ids.map((id) => ({
-        containerId: id,
-        containerName: elementNames?.[id] ?? null
-      })) : [];
-    };
-    return {
-      ...parameters,
-      sensitivityInjectionsSet: parameters.sensitivityInjectionsSet ? parameters.sensitivityInjectionsSet.map((is) => {
-        return {
-          ...is,
-          monitoredBranches: mapIdsToEquipmentsContainer(is.monitoredBranches),
-          injections: mapIdsToEquipmentsContainer(is.injections),
-          contingencies: mapIdsToEquipmentsContainer(is.contingencies)
-        };
-      }) : [],
-      sensitivityInjection: parameters.sensitivityInjection ? parameters.sensitivityInjection.map((i) => {
-        return {
-          ...i,
-          monitoredBranches: mapIdsToEquipmentsContainer(i.monitoredBranches),
-          injections: mapIdsToEquipmentsContainer(i.injections),
-          contingencies: mapIdsToEquipmentsContainer(i.contingencies)
-        };
-      }) : [],
-      sensitivityHVDC: parameters.sensitivityHVDC ? parameters.sensitivityHVDC.map((hvdc) => {
-        return {
-          ...hvdc,
-          monitoredBranches: mapIdsToEquipmentsContainer(hvdc.monitoredBranches),
-          hvdcs: mapIdsToEquipmentsContainer(hvdc.hvdcs),
-          contingencies: mapIdsToEquipmentsContainer(hvdc.contingencies)
-        };
-      }) : [],
-      sensitivityPST: parameters.sensitivityPST ? parameters.sensitivityPST.map((pst) => {
-        return {
-          ...pst,
-          monitoredBranches: mapIdsToEquipmentsContainer(pst.monitoredBranches),
-          psts: mapIdsToEquipmentsContainer(pst.psts),
-          contingencies: mapIdsToEquipmentsContainer(pst.contingencies)
-        };
-      }) : [],
-      sensitivityNodes: parameters.sensitivityNodes ? parameters.sensitivityNodes.map((n) => {
-        return {
-          ...n,
-          monitoredVoltageLevels: mapIdsToEquipmentsContainer(n.monitoredVoltageLevels),
-          equipmentsInVoltageRegulation: mapIdsToEquipmentsContainer(n.equipmentsInVoltageRegulation),
-          contingencies: mapIdsToEquipmentsContainer(n.contingencies)
-        };
-      }) : []
-    };
-  });
-}
 export {
   DistributionType,
   SensitivityType,
-  enrichSensitivityAnalysisParameters,
   mapSensitivityAnalysisParameters
 };

package/dist/utils/types/types.d.ts

@@ -77,3 +77,10 @@ export type ItemSelectionForCopy = {
     parentDirectoryUuid: UUID | null;
     specificTypeItem: string | null;
 };
+/**
+ * A directory element uuid but enriched with the corresponding name.
+ */
+export interface IdName {
+    id: UUID;
+    name?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gridsuite/commons-ui",
-    "version": "0.223.0",
+    "version": "0.224.0",
     "description": "common react components for gridsuite applications",
     "author": "gridsuite team",
     "homepage": "https://github.com/gridsuite",

package/dist/features/parameters/security-analysis/types.d.ts

@@ -1,20 +0,0 @@
-import { UUID } from 'node:crypto';
-import { CONTINGENCY_LISTS_INFOS, 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 '../common/constants';
-import { ContingencyListsInfos, ContingencyListsInfosEnriched } from '../common/contingency-table/types';
-import { ILimitReductionsByVoltageLevel } from '../common/limitreductions/columns-definitions';
-export type SAParameters = {
-    uuid?: UUID;
-    [PARAM_SA_PROVIDER]: string;
-    [CONTINGENCY_LISTS_INFOS]: ContingencyListsInfos[];
-    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 type SAParametersEnriched = Omit<SAParameters, typeof CONTINGENCY_LISTS_INFOS> & {
-    [CONTINGENCY_LISTS_INFOS]: ContingencyListsInfosEnriched[];
-};
-export declare function mapSecurityAnalysisParameters(parameters: SAParametersEnriched): SAParameters;
-export declare function enrichSecurityAnalysisParameters(parameters: SAParameters): Promise<SAParametersEnriched>;

package/dist/features/parameters/security-analysis/types.js

@@ -1,42 +0,0 @@
-import { fetchElementNames } from "../../../services/directory.js";
-import { NAME, ID } from "../common/parameter-table/constants.js";
-function mapSecurityAnalysisParameters(parameters) {
-  return {
-    ...parameters,
-    contingencyListsInfos: parameters.contingencyListsInfos?.map((clInfos) => {
-      return {
-        ...clInfos,
-        contingencyLists: clInfos.contingencyLists.map((c) => c.id)
-      };
-    })
-  };
-}
-function getEquipmentsContainerIds(params) {
-  const allContainerIds = params.contingencyListsInfos ? params.contingencyListsInfos.flatMap((cli) => cli.contingencyLists ?? []) : [];
-  return new Set(allContainerIds);
-}
-function enrichSecurityAnalysisParameters(parameters) {
-  const allElementIds = getEquipmentsContainerIds(parameters);
-  const elementNamesPromise = allElementIds.size === 0 ? Promise.resolve(null) : fetchElementNames(allElementIds);
-  return elementNamesPromise.then((elementNames) => {
-    const mapIdsToIdNames = (ids) => {
-      return ids ? ids.map((id) => ({
-        [ID]: id,
-        [NAME]: elementNames?.[id] ?? null
-      })) : [];
-    };
-    return {
-      ...parameters,
-      contingencyListsInfos: parameters.contingencyListsInfos ? parameters.contingencyListsInfos.map((cli) => {
-        return {
-          ...cli,
-          contingencyLists: mapIdsToIdNames(cli.contingencyLists)
-        };
-      }) : []
-    };
-  });
-}
-export {
-  enrichSecurityAnalysisParameters,
-  mapSecurityAnalysisParameters
-};