@gridsuite/commons-ui 0.238.0 → 0.239.0

package/dist/components/composite/report/report-viewer/log-table/log-table.js

@@ -0,0 +1,423 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { memo, useState, useRef, useMemo, useEffect, useCallback } from "react";
+import { useIntl } from "react-intl";
+import { useTheme, Box, Chip, alpha } from "@mui/material";
+import { Visibility, VisibilityOff } from "@mui/icons-material";
+import { getDefaultSeverityFilter, REPORT_SEVERITY } from "../../report-severity.js";
+import { QuickSearch } from "../../QuickSearch.js";
+import { reportStyles } from "../../report.styles.js";
+import { useReportFetcherContext, useReportFilterContext } from "../context/report-viewer-context.js";
+import { CustomAGGrid } from "../../../customAGGrid/customAggrid.js";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+import { MessageLogCellRenderer } from "../../../customAGGrid/cell-renderers.js";
+import "../../../customAGGrid/context/custom-aggrid-context.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import { FilterTextComparators, FilterDataTypes, TableType } from "../../../customAGGrid/custom-aggrid-types.js";
+import "mathjs";
+import { CustomAggridComparatorFilter } from "../../../customAGGrid/custom-aggrid-filters/custom-aggrid-comparator-filter.js";
+import { makeAgGridCustomHeaderColumn } from "../../../customAGGrid/utils/custom-aggrid-header-utils.js";
+import { AGGRID_LOCALES } from "../../../../../translations/not-intl/aggrid-locales.js";
+import { useStableComputedArray } from "../../../../../hooks/use-stable-computed-array.js";
+import "../../../../ui/overflowableText/OverflowableText.js";
+import "react-hook-form";
+import "../../../../ui/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "../../../../ui/treeViewFinder/TreeViewFinder.js";
+import "../../../../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.svg?react";
+import "../../../../ui/dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../../../ui/reactHookForm/expandableInput/ExpandableInput.js";
+import "../../../../ui/reactHookForm/directory-item-input/directory-item-utils.js";
+import "@hello-pangea/dnd";
+import "../../../../ui/dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../../../../ui/snackbarProvider/SnackbarProvider.js";
+import "mui-nested-menu";
+import "react-resizable-panels";
+import "react-papaparse";
+import { CustomTablePagination } from "../../../../ui/tablepagination/custom-table-pagination.js";
+const getColumnFilterValue = (array, columnName) => array?.find((item) => item.column === columnName)?.value ?? null;
+const applyFiltersToGrid = (api, filters) => {
+  if (!filters?.length) {
+    api.setFilterModel(null);
+    return;
+  }
+  const model = {};
+  filters.forEach((f) => {
+    if (Array.isArray(f.value)) {
+      model[f.column] = { type: "text", filterType: "customInRange", filter: f.value };
+    } else {
+      model[f.column] = { type: f.type, filterType: f.dataType, filter: f.value };
+    }
+  });
+  api.setFilterModel(model);
+  api.onFilterChanged();
+};
+const chipStyle = (severity, severityFilter, theme) => ({
+  backgroundColor: severityFilter.includes(severity) ? REPORT_SEVERITY[severity].colorHexCode : theme.severityChip?.disabledColor ?? theme.palette.action.disabledBackground,
+  cursor: "pointer",
+  border: `1px solid ${theme.palette.divider}`,
+  "&:hover": {
+    backgroundColor: alpha(REPORT_SEVERITY[severity].colorHexCode, 0.5)
+  },
+  "& .MuiChip-deleteIcon": {
+    color: theme.palette.text.primary,
+    fontSize: "1rem"
+  },
+  "& .MuiChip-deleteIcon:hover": {
+    color: theme.palette.text.primary
+  },
+  padding: 0.5
+});
+const styles = {
+  chipContainer: (theme) => ({
+    display: "flex",
+    flexWrap: "wrap",
+    gap: theme.spacing(1)
+  }),
+  toolContainer: (theme) => ({
+    display: "flex",
+    flexDirection: "column",
+    gap: theme.spacing(1),
+    mb: theme.spacing(2)
+  })
+};
+const SEVERITY_COLUMN_FIXED_WIDTH = 115;
+const PAGE_OPTIONS = [15, 30, 50, 100];
+function LogTable({
+  selectedReport,
+  reportType,
+  severities,
+  onRowClick,
+  onFiltersChanged,
+  resetFilters = false
+}) {
+  const intl = useIntl();
+  const theme = useTheme();
+  const { fetchLogs, fetchLogMatches } = useReportFetcherContext();
+  const { filters, updateFilters, pagination, changePagination } = useReportFilterContext();
+  const { page, rowsPerPage } = pagination;
+  const [selectedRowIndex, setSelectedRowIndex] = useState(-1);
+  const [rowData, setRowData] = useState(null);
+  const [searchMatches, setSearchMatches] = useState([]);
+  const [searchResults, setSearchResults] = useState([]);
+  const [currentResultIndex, setCurrentResultIndex] = useState(-1);
+  const [searchTerm, setSearchTerm] = useState("");
+  const [isGridReady, setIsGridReady] = useState(false);
+  const [filtersInitialized, setFiltersInitialized] = useState(false);
+  const [count, setCount] = useState(0);
+  const gridRef = useRef(null);
+  const inputRef = useRef(null);
+  const pendingScrollRef = useRef(null);
+  const severityFilter = useStableComputedArray(
+    () => getColumnFilterValue(filters, "severity") ?? [],
+    [filters]
+  );
+  const messageFilter = useMemo(() => getColumnFilterValue(filters, "message"), [filters]);
+  useEffect(() => {
+    setFiltersInitialized(false);
+  }, [reportType, severities]);
+  const resetSearch = useCallback(() => {
+    setSearchMatches([]);
+    setSearchResults([]);
+    setCurrentResultIndex(-1);
+    setSearchTerm("");
+  }, []);
+  const refreshLogsOnSelectedReport = useCallback(() => {
+    if (severityFilter.length === 0) {
+      setRowData([]);
+      return;
+    }
+    fetchLogs(selectedReport.id, severityFilter, messageFilter, selectedReport.type, page, rowsPerPage)?.then(
+      (pagedLogs) => {
+        const { content, totalElements, totalPages } = pagedLogs;
+        if (totalPages - 1 < page) {
+          changePagination({ page: 0, rowsPerPage });
+        }
+        setCount(totalElements);
+        setSelectedRowIndex(-1);
+        setRowData(content);
+      }
+    );
+  }, [
+    severityFilter,
+    fetchLogs,
+    selectedReport.id,
+    selectedReport.type,
+    messageFilter,
+    page,
+    rowsPerPage,
+    changePagination
+  ]);
+  useEffect(() => {
+    if (severities && severities.length > 0) {
+      const severityNotAlreadyInFilter = severities.some((severity) => !severityFilter.includes(severity));
+      const needsInitialization = resetFilters || !filtersInitialized && severityFilter.length === 0 || !filtersInitialized && severityNotAlreadyInFilter;
+      if (needsInitialization) {
+        updateFilters([
+          {
+            column: "severity",
+            dataType: FilterDataTypes.TEXT,
+            type: FilterTextComparators.EQUALS,
+            value: getDefaultSeverityFilter(severities)
+          }
+        ]);
+        setFiltersInitialized(true);
+      }
+    }
+  }, [severities, resetFilters, filtersInitialized, severityFilter, updateFilters]);
+  useEffect(() => {
+    if (selectedReport.id && selectedReport.type) {
+      refreshLogsOnSelectedReport();
+    }
+  }, [refreshLogsOnSelectedReport, selectedReport]);
+  useEffect(() => {
+    onFiltersChanged();
+    const api = gridRef.current?.api;
+    if (!api || !isGridReady) {
+      return;
+    }
+    applyFiltersToGrid(api, filters);
+  }, [filters, isGridReady, onFiltersChanged]);
+  const COLUMNS_DEFINITIONS = useMemo(
+    () => [
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "report_viewer/severity" }),
+        width: SEVERITY_COLUMN_FIXED_WIDTH,
+        colId: "severity",
+        field: "severity",
+        cellStyle: (params) => ({
+          backgroundColor: params.data?.backgroundColor ?? theme.palette.background.default,
+          textAlign: "center"
+        })
+      }),
+      makeAgGridCustomHeaderColumn({
+        headerName: intl.formatMessage({ id: "report_viewer/message" }),
+        colId: "message",
+        field: "message",
+        context: {
+          filterComponent: CustomAggridComparatorFilter,
+          filterComponentParams: {
+            filterParams: {
+              type: TableType.Logs,
+              tab: reportType,
+              dataType: FilterDataTypes.TEXT,
+              comparators: [FilterTextComparators.CONTAINS]
+            }
+          },
+          forceDisplayFilterIcon: true
+        },
+        flex: 1,
+        cellRenderer: (param) => MessageLogCellRenderer({
+          param,
+          highlightColor: theme.searchedText.highlightColor,
+          currentHighlightColor: theme.searchedText.currentHighlightColor,
+          searchTerm,
+          currentResultIndex,
+          searchResults
+        })
+      })
+    ],
+    [intl, theme, searchTerm, currentResultIndex, searchResults, reportType]
+  );
+  const handleRowClick = useCallback(
+    (row) => {
+      setSelectedRowIndex(row.rowIndex);
+      onRowClick(row.data);
+    },
+    [onRowClick]
+  );
+  const rowStyleFormat = useCallback(
+    (row) => {
+      if (row.rowIndex && row.rowIndex < 0) {
+        return {};
+      }
+      return selectedRowIndex === row.rowIndex ? { backgroundColor: theme.palette.action.selected } : {};
+    },
+    [selectedRowIndex, theme.palette.action.selected]
+  );
+  const onGridReady = ({ api }) => {
+    api?.sizeColumnsToFit();
+    setIsGridReady(true);
+  };
+  const defaultColumnDefinition = {
+    sortable: false,
+    resizable: false,
+    suppressMovable: true
+  };
+  const highlightAndScrollToMatch = useCallback((index, matches) => {
+    if (!gridRef.current || matches.length === 0) {
+      return;
+    }
+    gridRef.current.api.ensureIndexVisible(matches[index], "middle");
+  }, []);
+  const handleSearchResults = useCallback(
+    (matches) => {
+      setSearchResults(matches);
+      setCurrentResultIndex(matches.length > 0 ? 0 : -1);
+      if (matches.length > 0) {
+        highlightAndScrollToMatch(0, matches);
+      }
+    },
+    [highlightAndScrollToMatch]
+  );
+  const handleSearch = useCallback(
+    (term) => {
+      if (!gridRef.current || !term) {
+        resetSearch();
+        return;
+      }
+      setSearchTerm(term);
+      fetchLogMatches(
+        selectedReport.id,
+        severityFilter,
+        messageFilter,
+        selectedReport.type,
+        term,
+        rowsPerPage
+      )?.then((matchesPositions) => {
+        setSearchMatches(matchesPositions);
+        const matches = matchesPositions.map((m) => m.rowIndex);
+        if (matches.length > 0) {
+          changePagination({ page: matchesPositions[0].page, rowsPerPage });
+        }
+        handleSearchResults(matches);
+      });
+    },
+    [
+      fetchLogMatches,
+      handleSearchResults,
+      messageFilter,
+      resetSearch,
+      rowsPerPage,
+      selectedReport.id,
+      selectedReport.type,
+      changePagination,
+      severityFilter
+    ]
+  );
+  const handleNavigate = useCallback(
+    (direction) => {
+      if (!gridRef.current || searchResults.length === 0) {
+        return;
+      }
+      const newIndex = direction === "next" ? (currentResultIndex + 1) % searchResults.length : (currentResultIndex - 1 + searchResults.length) % searchResults.length;
+      pendingScrollRef.current = searchResults[newIndex];
+      changePagination({ page: searchMatches[newIndex].page, rowsPerPage });
+      setCurrentResultIndex(newIndex);
+      highlightAndScrollToMatch(newIndex, searchResults);
+    },
+    [searchResults, changePagination, searchMatches, rowsPerPage, highlightAndScrollToMatch, currentResultIndex]
+  );
+  const handleRowDataUpdated = useCallback(() => {
+    if (pendingScrollRef.current === null || !gridRef.current) {
+      return;
+    }
+    const rowIndex = pendingScrollRef.current;
+    pendingScrollRef.current = null;
+    gridRef.current.api?.ensureIndexVisible(rowIndex, "middle");
+  }, []);
+  const handleChipClick = useCallback(
+    (severity) => {
+      const updatedFilter = severityFilter.includes(severity) ? severityFilter.filter((s) => s !== severity) : [...severityFilter, severity];
+      updateFilters([
+        {
+          column: "severity",
+          dataType: FilterDataTypes.TEXT,
+          type: FilterTextComparators.EQUALS,
+          value: updatedFilter
+        },
+        {
+          column: "message",
+          dataType: FilterDataTypes.TEXT,
+          type: FilterTextComparators.CONTAINS,
+          value: messageFilter
+        }
+      ]);
+    },
+    [updateFilters, severityFilter, messageFilter]
+  );
+  const handleChangePage = useCallback(
+    (_, newPage) => {
+      changePagination({ page: newPage, rowsPerPage });
+      const firstMatchIndex = searchMatches.findIndex((match) => match.page === newPage);
+      setCurrentResultIndex(firstMatchIndex);
+    },
+    [searchMatches, rowsPerPage, changePagination]
+  );
+  const handleChangeRowsPerPage = useCallback(
+    (event) => {
+      changePagination({ page: 0, rowsPerPage: parseInt(event.target.value, 10) });
+    },
+    [changePagination]
+  );
+  useEffect(() => {
+    handleSearch(searchTerm);
+  }, [handleSearch]);
+  return /* @__PURE__ */ jsxs(Box, { sx: reportStyles.mainContainer, children: [
+    /* @__PURE__ */ jsxs(Box, { sx: styles.toolContainer, children: [
+      /* @__PURE__ */ jsx(
+        QuickSearch,
+        {
+          currentResultIndex,
+          onSearch: handleSearch,
+          onNavigate: handleNavigate,
+          resultCount: searchResults.length,
+          resetSearch,
+          placeholder: "searchPlaceholderLog",
+          inputRef
+        }
+      ),
+      /* @__PURE__ */ jsx(Box, { sx: styles.chipContainer, children: severities?.map((severity) => /* @__PURE__ */ jsx(
+        Chip,
+        {
+          label: severity,
+          deleteIcon: severityFilter.includes(severity) ? /* @__PURE__ */ jsx(Visibility, {}) : /* @__PURE__ */ jsx(VisibilityOff, {}),
+          onClick: () => handleChipClick(severity),
+          onDelete: () => handleChipClick(severity),
+          sx: chipStyle(severity, severityFilter, theme)
+        },
+        severity
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { sx: { flex: 1 }, children: /* @__PURE__ */ jsx(
+      CustomAGGrid,
+      {
+        ref: gridRef,
+        columnDefs: COLUMNS_DEFINITIONS,
+        rowData,
+        onCellClicked: handleRowClick,
+        getRowStyle: rowStyleFormat,
+        onGridReady,
+        onRowDataUpdated: handleRowDataUpdated,
+        defaultColDef: defaultColumnDefinition,
+        overrideLocales: AGGRID_LOCALES
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      CustomTablePagination,
+      {
+        component: "div",
+        rowsPerPageOptions: PAGE_OPTIONS,
+        count,
+        rowsPerPage,
+        page,
+        onPageChange: handleChangePage,
+        onRowsPerPageChange: handleChangeRowsPerPage,
+        showFirstButton: true,
+        showLastButton: true
+      }
+    )
+  ] });
+}
+const LogTable$1 = memo(LogTable);
+export {
+  LogTable$1 as default
+};

package/dist/components/composite/report/report-viewer/report-viewer.d.ts

@@ -0,0 +1,8 @@
+import { ComputingAndNetworkModificationType, Report, SeverityLevel } from '../report.type';
+export type ReportViewerProps = {
+    report: Report;
+    reportType: ComputingAndNetworkModificationType;
+    severities: SeverityLevel[] | undefined;
+    resetFilters?: boolean;
+};
+export declare function ReportViewer({ report, reportType, severities, resetFilters, }: Readonly<ReportViewerProps>): import("react").JSX.Element;

package/dist/components/composite/report/report-viewer/report-viewer.js

@@ -0,0 +1,114 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useState, useMemo, useEffect, useCallback, useRef } from "react";
+import { PanelGroup, Panel, PanelResizeHandle } from "react-resizable-panels";
+import { DragIndicator } from "@mui/icons-material";
+import { Box } from "@mui/material";
+import LogTable from "./log-table/log-table.js";
+import { mapReportsTree } from "../report-treeview/report-tree.mapper.js";
+import { VirtualizedTreeview } from "../report-treeview/virtualized-treeview.js";
+import { ReportType } from "../report.type.js";
+import { GLOBAL_REPORT_NODE_LABEL } from "../report.constant.js";
+const styles = {
+  panelHandlerContainer: (theme) => ({
+    display: "flex",
+    alignItems: "center",
+    borderRight: `1px solid ${theme.palette.divider}`
+  })
+};
+function ReportViewer({
+  report,
+  reportType,
+  severities = [],
+  resetFilters = false
+}) {
+  const [expandedTreeReports, setExpandedTreeReports] = useState([]);
+  const [highlightedReportId, setHighlightedReportId] = useState();
+  const [selectedReport, setSelectedReport] = useState({
+    id: report.id,
+    type: report.message === GLOBAL_REPORT_NODE_LABEL ? ReportType.GLOBAL : ReportType.NODE
+  });
+  const reportTree = useMemo(() => mapReportsTree(report), [report]);
+  const reportTreeMap = useMemo(() => {
+    const map = {};
+    const mapReportsById = (item) => {
+      map[item.id] = item;
+      item.subReports.forEach((subReport) => mapReportsById(subReport));
+    };
+    mapReportsById(reportTree);
+    return map;
+  }, [reportTree]);
+  useEffect(() => {
+    const newType = reportTreeMap[reportTree.id]?.type;
+    setSelectedReport((currentSelected) => {
+      if (currentSelected.id !== reportTree.id || currentSelected.type !== newType) {
+        setExpandedTreeReports([reportTree.id]);
+        return { id: reportTree.id, type: newType };
+      }
+      return currentSelected;
+    });
+  }, [reportTree, reportTreeMap]);
+  const onLogRowClick = useCallback(
+    (data) => {
+      setExpandedTreeReports((previouslyExpandedTreeReports) => {
+        const treeReportsToExpand = new Set(previouslyExpandedTreeReports);
+        let parentId = data?.parentId ?? null;
+        while (parentId && reportTreeMap[parentId]?.parentId) {
+          parentId = reportTreeMap[parentId].parentId;
+          if (parentId) {
+            treeReportsToExpand.add(parentId);
+          }
+        }
+        return Array.from(treeReportsToExpand);
+      });
+      setHighlightedReportId(data?.parentId);
+    },
+    [reportTreeMap]
+  );
+  const onFiltersChanged = useCallback(() => {
+    setHighlightedReportId(void 0);
+  }, []);
+  const handleSelectedItem = useCallback(
+    (reportItem) => {
+      setSelectedReport((prevSelectedReport) => {
+        if (prevSelectedReport.id !== reportItem.id) {
+          return { id: reportItem.id, type: reportTreeMap[reportItem.id].type };
+        }
+        return prevSelectedReport;
+      });
+      setHighlightedReportId(void 0);
+    },
+    [reportTreeMap]
+  );
+  const panelGroupRef = useRef(null);
+  const LEFT_PANEL_MIN_SIZE = 15;
+  const LEFT_PANEL_DEFAULT_SIZE = 25;
+  const RIGHT_PANEL_MIN_SIZE = 50;
+  return /* @__PURE__ */ jsxs(PanelGroup, { direction: "horizontal", ref: panelGroupRef, children: [
+    /* @__PURE__ */ jsx(Panel, { id: "treeview-panel", minSize: LEFT_PANEL_MIN_SIZE, defaultSize: LEFT_PANEL_DEFAULT_SIZE, children: /* @__PURE__ */ jsx(
+      VirtualizedTreeview,
+      {
+        expandedTreeReports,
+        setExpandedTreeReports,
+        selectedReportId: selectedReport.id,
+        reportTree,
+        onSelectedItem: handleSelectedItem,
+        highlightedReportId
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Box, { sx: styles.panelHandlerContainer, children: /* @__PURE__ */ jsx(PanelResizeHandle, { children: /* @__PURE__ */ jsx(DragIndicator, { fontSize: "small" }) }) }),
+    /* @__PURE__ */ jsx(Panel, { id: "logtable-panel", minSize: RIGHT_PANEL_MIN_SIZE, children: /* @__PURE__ */ jsx(
+      LogTable,
+      {
+        selectedReport,
+        reportType,
+        severities,
+        onRowClick: onLogRowClick,
+        onFiltersChanged,
+        resetFilters
+      }
+    ) })
+  ] });
+}
+export {
+  ReportViewer
+};

package/dist/components/composite/report/report.constant.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 GLOBAL_REPORT_NODE_LABEL = "Logs";
+export declare const NETWORK_MODIFICATION = "NETWORK_MODIFICATION";

package/dist/components/composite/report/report.constant.js

@@ -0,0 +1,6 @@
+const GLOBAL_REPORT_NODE_LABEL = "Logs";
+const NETWORK_MODIFICATION = "NETWORK_MODIFICATION";
+export {
+  GLOBAL_REPORT_NODE_LABEL,
+  NETWORK_MODIFICATION
+};

package/dist/components/composite/report/report.styles.d.ts

@@ -0,0 +1,10 @@
+import { Theme } from '@mui/material';
+export declare const reportStyles: {
+    readonly mainContainer: (theme: Theme) => {
+        display: "flex";
+        flexDirection: "column";
+        height: string;
+        gap: string;
+        p: string;
+    };
+};

package/dist/components/composite/report/report.styles.js

@@ -0,0 +1,12 @@
+const reportStyles = {
+  mainContainer: (theme) => ({
+    display: "flex",
+    flexDirection: "column",
+    height: "100%",
+    gap: theme.spacing(1),
+    p: theme.spacing(1)
+  })
+};
+export {
+  reportStyles
+};

package/dist/components/composite/report/report.type.d.ts

@@ -0,0 +1,66 @@
+import { NETWORK_MODIFICATION } from './report.constant';
+import { ComputingType } from '../../../utils';
+export type SeverityLevel = 'UNKNOWN' | 'TRACE' | 'DEBUG' | 'DETAIL' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL';
+export type ComputingAndNetworkModificationType = ComputingType | typeof NETWORK_MODIFICATION;
+export type ReportSeverity = {
+    name: SeverityLevel;
+    level: number;
+    colorName: string;
+    colorHexCode: string;
+    displayedByDefault: boolean;
+    displayedByDefaultForReportContainer: boolean;
+};
+export declare enum ReportType {
+    GLOBAL = "GlobalReport",
+    NODE = "NodeReport"
+}
+interface BaseReport<T> {
+    message: string;
+    severity: SeverityLevel;
+    parentId: string | null;
+    id: string;
+    subReports: T[];
+}
+export interface ReportTree extends Omit<BaseReport<ReportTree>, 'severity'> {
+    type: ReportType;
+    severity: ReportSeverity;
+}
+export interface Report extends BaseReport<Report> {
+}
+export type Log = {
+    message: string;
+    severity: string;
+    backgroundColor: string;
+    depth: number;
+    parentId: string;
+};
+export type ReportLog = {
+    message: string;
+    severity: SeverityLevel;
+    depth: number;
+    parentId: string;
+    backgroundColor?: string;
+};
+export type SelectedReportLog = {
+    id: string;
+    type: ReportType;
+};
+export type PagedReportLogs = {
+    content: ReportLog[];
+    totalElements: number;
+    totalPages: number;
+};
+export type PagedLogs = {
+    content: Log[];
+    totalElements: number;
+    totalPages: number;
+};
+export type MatchPosition = {
+    page: number;
+    rowIndex: number;
+};
+export type LogsPaginationConfig = {
+    page: number;
+    rowsPerPage: number;
+};
+export {};

package/dist/components/composite/report/report.type.js

@@ -0,0 +1,8 @@
+var ReportType = /* @__PURE__ */ ((ReportType2) => {
+  ReportType2["GLOBAL"] = "GlobalReport";
+  ReportType2["NODE"] = "NodeReport";
+  return ReportType2;
+})(ReportType || {});
+export {
+  ReportType
+};