@gridsuite/commons-ui 0.271.0 → 0.272.1

package/dist/features/results/shortcircuit/shortcircuit-analysis-result-table.js

@@ -0,0 +1,451 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import { useIntl } from "react-intl";
+import { useTheme, Button, Box } from "@mui/material";
+import { ShortCircuitAnalysisType } from "./shortcircuit-analysis-result.type.js";
+import "@mui/icons-material";
+import { OverflowableText } from "../../../components/ui/overflowableText/OverflowableText.js";
+import { unitToKiloUnit } from "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import { getRows } from "../../../utils/functions.js";
+import "react-hook-form";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../../components/ui/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "../../../components/ui/treeViewFinder/TreeViewFinder.js";
+import "../../../components/ui/reactHookForm/numbers/RangeInput.js";
+import "@material-symbols/svg-400/outlined/left_panel_open.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_output.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_input.svg?react";
+import "@material-symbols/svg-400/outlined/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes-fill.svg?react";
+import "../../../components/ui/dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../../components/ui/reactHookForm/expandableInput/ExpandableInput.js";
+import "../../../components/ui/reactHookForm/directory-item-input/directory-item-utils.js";
+import "@hello-pangea/dnd";
+import "../../../components/ui/dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../../../components/ui/snackbarProvider/SnackbarProvider.js";
+import "mui-nested-menu";
+import "react-resizable-panels";
+import "react-papaparse";
+import "react-dom";
+import "autosuggest-highlight/match";
+import "autosuggest-highlight/parse";
+import "clsx";
+import "../../../components/composite/filter/FilterCreationDialog.js";
+import "../../../components/composite/filter/HeaderFilterForm.js";
+import "../../../components/composite/filter/explicitNaming/ExplicitNamingFilterForm.js";
+import "../../../components/composite/filter/expert/ExpertFilterForm.js";
+import "../../../components/composite/filter/expert/ExpertFilterEditionDialog.js";
+import "../../../components/composite/filter/expert/expertFilterConstants.js";
+import "react-querybuilder";
+import "uuid";
+import "../../../components/composite/filter/explicitNaming/ExplicitNamingFilterEditionDialog.js";
+import "../../../components/composite/filter/utils/filterFormUtils.js";
+import "@react-querybuilder/material";
+import "../../../components/composite/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "../../../components/composite/reactQueryBuilder/PropertyValueEditor.js";
+import "../../../components/composite/agGridTable/BottomTableButtons.js";
+import "../../../components/composite/agGridTable/CustomAgGridTable.js";
+import "ag-grid-community";
+import { CustomAGGrid } from "../../../components/composite/customAGGrid/customAggrid.js";
+import { DefaultCellRenderer } from "../../../components/composite/customAGGrid/cell-renderers.js";
+import "../../../components/composite/customAGGrid/context/custom-aggrid-context.js";
+import { FilterTextComparators, FilterDataTypes, FilterNumberComparators, TableType } from "../../../components/composite/customAGGrid/custom-aggrid-types.js";
+import { CustomAggridAutocompleteFilter } from "../../../components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-autocomplete-filter.js";
+import { CustomAggridComparatorFilter } from "../../../components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-comparator-filter.js";
+import "mathjs";
+import { makeAgGridCustomHeaderColumn } from "../../../components/composite/customAGGrid/utils/custom-aggrid-header-utils.js";
+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 { mappingTabs } from "./shortcircuit-analysis-result-content.js";
+import { getNoRowsMessage } from "../utils/no-rows-message.js";
+import { AGGRID_LOCALES } from "../../../translations/not-intl/aggrid-locales.js";
+import { useIntlResultStatusMessages } from "../hooks/useIntlResultStatusMessages.js";
+import { createMultiEnumFilterParams } from "../common/utils.js";
+const SHORTCIRCUIT_ANALYSIS_RESULT_SORT_STORE = "shortcircuitAnalysisResult";
+const textFilterParams = {
+  dataType: FilterDataTypes.TEXT,
+  comparators: [FilterTextComparators.STARTS_WITH, FilterTextComparators.CONTAINS]
+};
+const numericFilterParams = {
+  dataType: FilterDataTypes.NUMBER,
+  comparators: [
+    FilterNumberComparators.EQUALS,
+    FilterNumberComparators.NOT_EQUAL,
+    FilterNumberComparators.LESS_THAN_OR_EQUAL,
+    FilterNumberComparators.GREATER_THAN_OR_EQUAL
+  ]
+};
+const resultsStyles = {
+  sldLink: {
+    color: "node.background",
+    maxWidth: "100%"
+  }
+};
+function ShortCircuitAnalysisResultTable({
+  result,
+  analysisType,
+  isFetching,
+  filterEnums,
+  onRowDataUpdated,
+  onDisplayedColumnsChanged,
+  shortCircuitAnalysisStatus,
+  columnFilters,
+  onGridReady,
+  onVoltageLevelClick
+}) {
+  const intl = useIntl();
+  const theme = useTheme();
+  const voltageLevelIdRenderer = useCallback(
+    (props) => {
+      const { value } = props || {};
+      const onClick = () => {
+        onVoltageLevelClick?.(value);
+      };
+      if (value) {
+        return /* @__PURE__ */ jsx(Button, { sx: resultsStyles.sldLink, onClick, children: /* @__PURE__ */ jsx(OverflowableText, { text: value }) });
+      }
+      return null;
+    },
+    [onVoltageLevelClick]
+  );
+  const getEnumLabel = useCallback(
+    (value) => value ? intl.formatMessage({
+      id: value,
+      defaultMessage: value
+    }) : "",
+    [intl]
+  );
+  const columns = useMemo(() => {
+    const isAllBusesAnalysisType = analysisType === ShortCircuitAnalysisType.ALL_BUSES;
+    const onlyIfIsAllBuses = (data, defaultData = {}) => isAllBusesAnalysisType ? data : defaultData;
+    const onlyIfIsOneBus = (data, defaultData = {}) => !isAllBusesAnalysisType ? data : defaultData;
+    const sortParams = {
+      table: SHORTCIRCUIT_ANALYSIS_RESULT_SORT_STORE,
+      tab: mappingTabs(analysisType)
+    };
+    const filterParams = {
+      type: TableType.ShortcircuitAnalysis,
+      tab: mappingTabs(analysisType)
+    };
+    const inputFilterParams = (field, filterDefinition) => {
+      return {
+        filterComponent: CustomAggridComparatorFilter,
+        filterComponentParams: {
+          filterParams: {
+            ...filterDefinition,
+            ...filterParams
+          }
+        }
+      };
+    };
+    const autocompleteFilterParams = (colId) => {
+      return {
+        filterComponent: CustomAggridAutocompleteFilter,
+        filterComponentParams: {
+          filterParams: {
+            dataType: FilterDataTypes.TEXT,
+            ...filterParams
+          },
+          options: filterEnums[colId] ?? [],
+          getOptionLabel: getEnumLabel
+        }
+      };
+    };
+    return [
+      {
+        ...makeAgGridCustomHeaderColumn({
+          headerName: intl.formatMessage({ id: "IDNode" }),
+          colId: "elementId",
+          field: "elementId",
+          context: {
+            ...onlyIfIsAllBuses({ sortParams, ...inputFilterParams("elementId", textFilterParams) })
+          }
+        }),
+        minWidth: 180
+      },
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "busVoltageLevel" }),
+        colId: "voltageLevel",
+        field: "voltageLevel",
+        cellRenderer: voltageLevelIdRenderer,
+        context: {
+          ...onlyIfIsAllBuses({ sortParams, ...inputFilterParams("voltageLevel", textFilterParams) })
+        }
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "Type" }),
+        colId: "faultType",
+        field: "faultType",
+        filterParams: createMultiEnumFilterParams,
+        context: {
+          ...onlyIfIsAllBuses({ sortParams, ...autocompleteFilterParams("faultType") })
+        },
+        valueGetter: (value) => value.data.faultType,
+        valueFormatter: (params) => getEnumLabel(params.value)
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "Feeders" }),
+        colId: "connectableId",
+        field: "connectableId",
+        context: {
+          sortParams: onlyIfIsAllBuses({ ...sortParams, isChildren: true }, sortParams),
+          ...inputFilterParams("connectableId", textFilterParams)
+        }
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "IscKA" }),
+        colId: "current",
+        field: "current",
+        context: {
+          numeric: true,
+          fractionDigits: 2,
+          sortParams,
+          ...inputFilterParams("current", numericFilterParams)
+        },
+        valueGetter: (params) => unitToKiloUnit(params.data?.current)
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "Side" }),
+        colId: "side",
+        field: "side",
+        hide: isAllBusesAnalysisType,
+        filterParams: createMultiEnumFilterParams,
+        context: {
+          ...onlyIfIsOneBus({ sortParams, ...autocompleteFilterParams("side") })
+        },
+        valueGetter: (value) => value.data.side,
+        valueFormatter: (params) => getEnumLabel(params.value)
+      }),
+      {
+        ...makeAgGridCustomHeaderColumn({
+          headerName: intl.formatMessage({ id: "LimitType" }),
+          colId: "limitType",
+          field: "limitType",
+          filterParams: createMultiEnumFilterParams,
+          context: {
+            ...onlyIfIsAllBuses({ sortParams, ...autocompleteFilterParams("limitType") })
+          },
+          valueGetter: (value) => value.data.limitType,
+          valueFormatter: (params) => getEnumLabel(params.value)
+        }),
+        minWidth: 150
+      },
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "IscMinKA" }),
+        colId: "limitMin",
+        field: "limitMin",
+        context: {
+          numeric: true,
+          fractionDigits: 2,
+          ...onlyIfIsAllBuses({ sortParams, ...inputFilterParams("limitMin", numericFilterParams) })
+        },
+        valueGetter: (params) => unitToKiloUnit(params.data?.limitMin)
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "IscMaxKA" }),
+        colId: "limitMax",
+        field: "limitMax",
+        context: {
+          numeric: true,
+          fractionDigits: 2,
+          ...onlyIfIsAllBuses({ sortParams, ...inputFilterParams("limitMax", numericFilterParams) })
+        },
+        valueGetter: (params) => unitToKiloUnit(params.data?.limitMax)
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "PscMVA" }),
+        colId: "shortCircuitPower",
+        field: "shortCircuitPower",
+        context: {
+          numeric: true,
+          fractionDigits: 2,
+          ...onlyIfIsAllBuses({ sortParams, ...inputFilterParams("shortCircuitPower", numericFilterParams) })
+        }
+      }),
+      {
+        ...makeAgGridCustomHeaderColumn({
+          headerName: intl.formatMessage({ id: "deltaCurrentIpMin" }),
+          colId: "deltaCurrentIpMin",
+          field: "deltaCurrentIpMin",
+          context: {
+            numeric: true,
+            fractionDigits: 2,
+            ...onlyIfIsAllBuses({
+              sortParams,
+              ...inputFilterParams("deltaCurrentIpMin", numericFilterParams)
+            })
+          },
+          valueGetter: (params) => unitToKiloUnit(params.data?.deltaCurrentIpMin)
+        }),
+        minWidth: 180
+      },
+      {
+        ...makeAgGridCustomHeaderColumn({
+          headerName: intl.formatMessage({ id: "deltaCurrentIpMax" }),
+          colId: "deltaCurrentIpMax",
+          field: "deltaCurrentIpMax",
+          context: {
+            numeric: true,
+            fractionDigits: 2,
+            ...onlyIfIsAllBuses({
+              sortParams,
+              ...inputFilterParams("deltaCurrentIpMax", numericFilterParams)
+            })
+          },
+          valueGetter: (params) => unitToKiloUnit(params.data?.deltaCurrentIpMax)
+        }),
+        minWidth: 180
+      },
+      {
+        field: "linkedElementId",
+        hide: true
+      }
+    ];
+  }, [analysisType, intl, voltageLevelIdRenderer, filterEnums, getEnumLabel]);
+  const messages = useIntlResultStatusMessages(intl, true, (columnFilters?.length ?? 0) > 0);
+  const getRowStyle = useCallback(
+    (params) => {
+      if (!params?.data?.linkedElementId) {
+        return {
+          backgroundColor: theme.selectedRow.background
+        };
+      }
+      return void 0;
+    },
+    [theme.selectedRow.background]
+  );
+  const defaultColDef = useMemo(
+    () => ({
+      suppressMovable: true,
+      resizable: true,
+      flex: 1,
+      cellRenderer: DefaultCellRenderer
+    }),
+    []
+  );
+  const handleRowDataUpdated = useCallback(
+    (event) => {
+      if (event?.api) {
+        onRowDataUpdated(event);
+      }
+    },
+    [onRowDataUpdated]
+  );
+  const getCurrent = useCallback(
+    (x) => {
+      let current = Number.NaN;
+      if (analysisType === ShortCircuitAnalysisType.ALL_BUSES) {
+        current = x.current;
+      } else if (analysisType === ShortCircuitAnalysisType.ONE_BUS) {
+        current = x.positiveMagnitude;
+      }
+      return current;
+    },
+    [analysisType]
+  );
+  const flattenResult = useCallback(
+    (shortCircuitAnalysisResult) => {
+      const rows2 = [];
+      shortCircuitAnalysisResult?.forEach((faultResult) => {
+        const { fault } = faultResult;
+        const limitViolations = faultResult.limitViolations ?? [];
+        let firstLimitViolation;
+        if (limitViolations.length > 0) {
+          const lv = limitViolations[0];
+          firstLimitViolation = {
+            limitType: lv.limitType
+          };
+        }
+        const current = getCurrent(faultResult);
+        const { deltaCurrentIpMax } = faultResult.shortCircuitLimits;
+        const { deltaCurrentIpMin } = faultResult.shortCircuitLimits;
+        rows2.push({
+          faultId: fault.id,
+          elementId: fault.elementId,
+          voltageLevel: fault.voltageLevelId,
+          faultType: fault.faultType,
+          shortCircuitPower: faultResult.shortCircuitPower,
+          limitMin: faultResult.shortCircuitLimits.ipMin,
+          limitMax: faultResult.shortCircuitLimits.ipMax,
+          deltaCurrentIpMax,
+          deltaCurrentIpMin,
+          current,
+          connectableId: "",
+          ...firstLimitViolation
+        });
+        limitViolations.slice(1).forEach((lv) => {
+          rows2.push({
+            limitType: lv.limitType,
+            limitMin: lv.limitType === "LOW_SHORT_CIRCUIT_CURRENT" ? lv.limit : null,
+            limitMax: lv.limitType === "HIGH_SHORT_CIRCUIT_CURRENT" ? lv.limit : null,
+            current: lv.value,
+            elementId: "",
+            voltageLevel: "",
+            faultType: "",
+            connectableId: ""
+          });
+        });
+        const feederResults = faultResult.feederResults ?? [];
+        feederResults.forEach((feederResult) => {
+          const feederCurrent = getCurrent(feederResult);
+          const side = analysisType === ShortCircuitAnalysisType.ONE_BUS ? feederResult.side : void 0;
+          rows2.push({
+            connectableId: feederResult.connectableId,
+            linkedElementId: fault.id,
+            current: feederCurrent,
+            elementId: "",
+            voltageLevel: "",
+            faultType: "",
+            limitType: "",
+            side
+          });
+        });
+      });
+      return rows2;
+    },
+    [getCurrent, analysisType]
+  );
+  const rows = useMemo(() => {
+    if (result) {
+      return flattenResult(result);
+    }
+    return void 0;
+  }, [flattenResult, result]);
+  const message = getNoRowsMessage(messages, rows, shortCircuitAnalysisStatus, !isFetching);
+  const rowsToShow = getRows(rows, shortCircuitAnalysisStatus);
+  return /* @__PURE__ */ jsx(Box, { sx: { flexGrow: 1 }, children: /* @__PURE__ */ jsx(
+    CustomAGGrid,
+    {
+      rowData: rowsToShow,
+      defaultColDef,
+      onGridReady,
+      getRowStyle,
+      columnDefs: columns,
+      overlayNoRowsTemplate: message,
+      onRowDataUpdated: handleRowDataUpdated,
+      onDisplayedColumnsChanged,
+      overrideLocales: AGGRID_LOCALES,
+      onModelUpdated: ({ api }) => {
+        if (api.getDisplayedRowCount()) {
+          api.hideOverlay();
+        } else {
+          api.showNoRowsOverlay();
+        }
+      }
+    }
+  ) });
+}
+export {
+  SHORTCIRCUIT_ANALYSIS_RESULT_SORT_STORE,
+  ShortCircuitAnalysisResultTable,
+  numericFilterParams,
+  resultsStyles,
+  textFilterParams
+};

package/dist/features/results/shortcircuit/shortcircuit-analysis-result.d.ts

@@ -0,0 +1,53 @@
+import { UUID } from 'node:crypto';
+import { DisplayedColumnsChangedEvent, GridReadyEvent, RowDataUpdatedEvent } from 'ag-grid-community';
+import { ShortcircuitFilterConfig } from './shortcircuit-analysis-result-content';
+import { SCAFaultResult, SCAFeederResult, SCAPagedResults, ShortCircuitAnalysisType } from './shortcircuit-analysis-result.type';
+import { ShortcircuitColumnFilter } from './shortcircuit-analysis-result-table';
+import { ComputingType, RunningStatus } from '../../../utils';
+import { PaginationConfig, SortConfig } from '../../../components';
+import { GlobalFilters } from '../../global-filter';
+export type FetchPagedResultsParams = {
+    studyUuid: UUID | null;
+    currentNodeUuid: UUID | undefined;
+    currentRootNetworkUuid: UUID;
+    type: ShortCircuitAnalysisType;
+    selector: {
+        page: number;
+        size: number;
+        filter: ShortcircuitFilterConfig[] | null;
+        sort: SortConfig[] | undefined;
+    };
+    globalFilters?: GlobalFilters;
+};
+export type FetchFilterEnumValuesParams = {
+    studyUuid: UUID;
+    currentNodeUuid: UUID;
+    currentRootNetworkUuid: UUID;
+    computingType: ComputingType;
+    filterType: string;
+};
+export interface IShortCircuitAnalysisGlobalResultProps {
+    analysisType: ShortCircuitAnalysisType;
+    analysisStatus: RunningStatus;
+    result: SCAFaultResult[] | undefined;
+    updateResult: (result: SCAFaultResult[] | SCAFeederResult[] | null) => void;
+    customTablePaginationProps?: any;
+    onGridColumnsChanged: (params: GridReadyEvent) => void;
+    onRowDataUpdated: (event: RowDataUpdatedEvent) => void;
+    onDisplayedColumnsChanged: (event: DisplayedColumnsChangedEvent) => void;
+    studyUuid: UUID | null;
+    currentNodeUuid: UUID | null | undefined;
+    currentRootNetworkUuid: UUID | null | undefined;
+    sortConfig?: SortConfig[];
+    columnFilters?: ShortcircuitColumnFilter[];
+    globalFilters?: GlobalFilters;
+    pagination: PaginationConfig;
+    onPageChange: (newPage: number) => void;
+    onRowsPerPageChange: (newRowsPerPage: number) => void;
+    fetchPagedResults: (params: FetchPagedResultsParams) => Promise<SCAPagedResults | null>;
+    fetchFilterEnumValues: (params: FetchFilterEnumValuesParams) => Promise<string[]>;
+    mapFieldsToColumnsFilter?: (filters: ShortcircuitFilterConfig[], mapping: Record<string, string>) => ShortcircuitFilterConfig[];
+    onVoltageLevelClick?: (voltageLevelId: string) => void;
+    onGridReady?: (params: GridReadyEvent) => void;
+}
+export declare function ShortCircuitAnalysisResult({ analysisType, analysisStatus, result, updateResult, customTablePaginationProps, onGridColumnsChanged, onRowDataUpdated, onDisplayedColumnsChanged, studyUuid, currentNodeUuid, currentRootNetworkUuid, sortConfig, columnFilters, globalFilters, pagination, onPageChange, onRowsPerPageChange, fetchPagedResults, fetchFilterEnumValues, mapFieldsToColumnsFilter, onVoltageLevelClick, onGridReady, }: IShortCircuitAnalysisGlobalResultProps): import("react").JSX.Element;