@gridsuite/commons-ui 0.192.0 → 0.194.0

package/dist/components/dnd-table-v2/dnd-table.js

@@ -0,0 +1,381 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { createPortal } from "react-dom";
+import { useState, useCallback, useRef, useMemo } from "react";
+import { useFormContext, useWatch } from "react-hook-form";
+import { Grid, TableContainer, Table, TableHead, TableRow, TableCell, Box, Tooltip, IconButton, TableBody, Checkbox } from "@mui/material";
+import { DragDropContext, Droppable, Draggable } from "@hello-pangea/dnd";
+import { useIntl } from "react-intl";
+import { AddCircle } from "@mui/icons-material";
+import { MAX_ROWS_NUMBER, SELECTED } from "./dnd-table.type.js";
+import { DndTableBottomLeftButtons } from "./dnd-table-bottom-left-buttons.js";
+import { DndTableBottomRightButtons } from "./dnd-table-bottom-right-buttons.js";
+import { DndTableAddRowsDialog } from "./dnd-table-add-rows-dialog.js";
+import "../overflowableText/OverflowableText.js";
+import "../../utils/conversionUtils.js";
+import "../../utils/types/equipmentType.js";
+import { mergeSx } from "../../utils/styles.js";
+import "../../utils/yupConfig.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import { ErrorInput } from "../inputs/reactHookForm/errorManagement/ErrorInput.js";
+import { FieldErrorAlert } from "../inputs/reactHookForm/errorManagement/FieldErrorAlert.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 "@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/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes.svg?react";
+import "../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../inputs/reactHookForm/expandableInput/ExpandableInput.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";
+import { DndTableRow } from "./dnd-table-row.js";
+const styles = {
+  columnsStyle: {
+    display: "inline-flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    margin: 1,
+    textTransform: "none"
+  }
+};
+function MultiCheckbox({
+  arrayFormName,
+  handleClickCheck,
+  handleClickUncheck,
+  ...props
+}) {
+  const arrayToWatch = useWatch({
+    name: arrayFormName
+  });
+  const allRowSelected = useMemo(
+    () => arrayToWatch ? arrayToWatch?.every((row) => row[SELECTED]) : false,
+    [arrayToWatch]
+  );
+  const someRowSelected = useMemo(
+    () => arrayToWatch ? arrayToWatch?.some((row) => row[SELECTED]) : false,
+    [arrayToWatch]
+  );
+  return /* @__PURE__ */ jsx(
+    Checkbox,
+    {
+      checked: arrayToWatch?.length > 0 && allRowSelected,
+      indeterminate: someRowSelected && !allRowSelected,
+      onChange: (event) => {
+        if (event.target.checked) {
+          handleClickCheck();
+        } else {
+          handleClickUncheck();
+        }
+      },
+      ...props
+    }
+  );
+}
+function DndTable(props) {
+  const {
+    name,
+    useFieldArrayOutput,
+    columnsDefinition,
+    tableHeight,
+    allowedToAddRows = () => Promise.resolve(true),
+    createRows,
+    disabled = false,
+    withResetButton = false,
+    withAddRowsDialog = true,
+    previousValues,
+    disableTableCell,
+    getPreviousValue,
+    isValueModified,
+    disableAddingRows = false,
+    showMoveArrow = true,
+    disableDragAndDrop = false,
+    handleUploadButton = void 0,
+    uploadButtonMessageId = void 0,
+    handleResetButton = void 0,
+    resetButtonMessageId = void 0,
+    maxRows = MAX_ROWS_NUMBER,
+    disabledDeletion,
+    multiselect,
+    onChange,
+    onDelete
+  } = props;
+  const intl = useIntl();
+  const { getValues, setValue, setError, clearErrors } = useFormContext();
+  const {
+    fields: currentRows,
+    // don't use it to access form data ! check doc
+    move,
+    swap,
+    append,
+    remove
+  } = useFieldArrayOutput;
+  const [openAddRowsDialog, setOpenAddRowsDialog] = useState(false);
+  const addNewRows = (numberOfRows) => {
+    if (currentRows.length + numberOfRows > maxRows) {
+      setError(name, {
+        type: "custom",
+        message: intl.formatMessage(
+          {
+            id: "MaximumRowNumberError"
+          },
+          {
+            value: maxRows
+          }
+        )
+      });
+      return;
+    }
+    clearErrors(name);
+    const rowsToAdd = createRows?.(numberOfRows).map((row) => {
+      return { ...row, [SELECTED]: false };
+    });
+    if (rowsToAdd) {
+      append(rowsToAdd);
+    }
+  };
+  const handleAddRowsButton = () => {
+    allowedToAddRows().then((isAllowed) => {
+      if (isAllowed) {
+        if (withAddRowsDialog) {
+          setOpenAddRowsDialog(true);
+        } else {
+          addNewRows(1);
+        }
+      }
+    });
+  };
+  const handleCloseAddRowsDialog = () => {
+    setOpenAddRowsDialog(false);
+  };
+  const deleteSelectedRows = () => {
+    const currentRowsValues = getValues(name);
+    const rowsToDelete = [];
+    for (let i = 0; i < currentRowsValues.length; i++) {
+      if (currentRowsValues[i][SELECTED]) {
+        rowsToDelete.push(i);
+      }
+    }
+    const removedRows = rowsToDelete.map((index) => currentRowsValues[index]);
+    remove(rowsToDelete);
+    onDelete?.(removedRows);
+  };
+  const handleDeleteRow = useCallback(
+    (index) => {
+      const removedRow = getValues(name)[index];
+      remove(index);
+      onDelete?.([removedRow]);
+    },
+    [onDelete, getValues, name, remove]
+  );
+  const selectAllRows = () => {
+    for (let i = 0; i < currentRows.length; i++) {
+      setValue(`${name}[${i}].${SELECTED}`, true);
+    }
+  };
+  const unselectAllRows = () => {
+    for (let i = 0; i < currentRows.length; i++) {
+      setValue(`${name}[${i}].${SELECTED}`, false);
+    }
+  };
+  const moveUpSelectedRows = () => {
+    const currentRowsValues = getValues(name);
+    if (currentRowsValues[0][SELECTED]) {
+      return;
+    }
+    for (let i = 1; i < currentRowsValues.length; i++) {
+      if (currentRowsValues[i][SELECTED]) {
+        swap(i - 1, i);
+      }
+    }
+  };
+  const moveDownSelectedRows = () => {
+    const currentRowsValues = getValues(name);
+    if (currentRowsValues[currentRowsValues.length - 1][SELECTED]) {
+      return;
+    }
+    for (let i = currentRowsValues.length - 2; i >= 0; i--) {
+      if (currentRowsValues[i][SELECTED]) {
+        swap(i, i + 1);
+      }
+    }
+  };
+  const snapshotCellWidthsRef = useRef([]);
+  const cellIdxRef = useRef(0);
+  const onBeforeDragStart = useCallback((start) => {
+    const row = document.querySelector(`[data-rfd-draggable-id="${start.draggableId}"]`);
+    if (row) {
+      snapshotCellWidthsRef.current = Array.from(row.cells, (cell) => cell.offsetWidth);
+    }
+  }, []);
+  const nextSnapshotCellWidthSx = useCallback((isDragging) => {
+    const cellWidths = snapshotCellWidthsRef.current;
+    const cellIdx = cellIdxRef.current;
+    if (!isDragging || cellWidths[cellIdx] == null) {
+      return void 0;
+    }
+    cellIdxRef.current += 1;
+    return { width: cellWidths[cellIdx], boxSizing: "border-box" };
+  }, []);
+  const onDragEnd = (result) => {
+    snapshotCellWidthsRef.current = [];
+    if (!result.destination) {
+      return;
+    }
+    move(result.source.index, result.destination.index);
+  };
+  function renderTableHead() {
+    return /* @__PURE__ */ jsx(TableHead, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+      !disableDragAndDrop && /* @__PURE__ */ jsx(TableCell, { sx: { width: "3%" } }),
+      multiselect && /* @__PURE__ */ jsx(TableCell, { sx: { width: "5%", textAlign: "center" }, children: /* @__PURE__ */ jsx(
+        MultiCheckbox,
+        {
+          arrayFormName: name,
+          handleClickCheck: selectAllRows,
+          handleClickUncheck: unselectAllRows,
+          disabled: disabled || currentRows.length === 0
+        }
+      ) }),
+      columnsDefinition.map((column) => /* @__PURE__ */ jsx(
+        TableCell,
+        {
+          sx: mergeSx(
+            { width: column.width, maxWidth: column.maxWidth, textAlign: "left" },
+            column.sxHeader
+          ),
+          children: /* @__PURE__ */ jsxs(Box, { sx: styles.columnsStyle, children: [
+            column.label,
+            column.extra
+          ] })
+        },
+        column.dataKey
+      )),
+      !disableAddingRows && !multiselect && /* @__PURE__ */ jsx(TableCell, { sx: { width: "5rem", textAlign: "center" }, children: /* @__PURE__ */ jsx(
+        Tooltip,
+        {
+          title: intl.formatMessage({
+            id: "AddRows"
+          }),
+          children: /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(IconButton, { disabled: disableAddingRows, onClick: handleAddRowsButton, children: /* @__PURE__ */ jsx(AddCircle, {}) }) })
+        }
+      ) })
+    ] }) });
+  }
+  const handleChangeRow = useCallback(
+    (index) => {
+      onChange?.(getValues(name)[index]);
+    },
+    [getValues, name, onChange]
+  );
+  function renderTableBody(providedDroppable) {
+    return /* @__PURE__ */ jsxs(TableBody, { children: [
+      currentRows.map((row, index) => /* @__PURE__ */ jsx(
+        Draggable,
+        {
+          draggableId: row.id.toString(),
+          index,
+          isDragDisabled: disableDragAndDrop,
+          children: (provided, snapshot) => {
+            cellIdxRef.current = 0;
+            const tableRow = /* @__PURE__ */ jsx(
+              DndTableRow,
+              {
+                provided,
+                snapshot,
+                rowId: row.id,
+                tableName: name,
+                columnsDefinition,
+                index,
+                disableDragAndDrop,
+                disabled,
+                previousValues,
+                disableTableCell,
+                getPreviousValue,
+                isValueModified,
+                disabledDeletion,
+                onChangeRow: handleChangeRow,
+                onDeleteRow: handleDeleteRow,
+                multiselect,
+                nextSnapshotCellWidthSx
+              }
+            );
+            return snapshot.isDragging ? createPortal(tableRow, document.body) : tableRow;
+          }
+        },
+        row.id
+      )),
+      providedDroppable.placeholder
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Grid, { item: true, container: true, spacing: 1, children: [
+    /* @__PURE__ */ jsxs(Grid, { item: true, container: true, children: [
+      /* @__PURE__ */ jsx(DragDropContext, { onBeforeDragStart, onDragEnd, children: /* @__PURE__ */ jsx(Droppable, { droppableId: "tapTable", isDropDisabled: disabled, children: (provided) => /* @__PURE__ */ jsx(
+        TableContainer,
+        {
+          ref: provided.innerRef,
+          ...provided.droppableProps,
+          sx: {
+            height: tableHeight,
+            border: "solid 1px rgba(0,0,0,0.1)"
+          },
+          children: /* @__PURE__ */ jsxs(Table, { stickyHeader: true, size: "small", padding: "none", children: [
+            renderTableHead(),
+            renderTableBody(provided)
+          ] })
+        }
+      ) }) }),
+      /* @__PURE__ */ jsx(ErrorInput, { name, InputField: FieldErrorAlert })
+    ] }),
+    /* @__PURE__ */ jsxs(Grid, { container: true, item: true, children: [
+      handleResetButton && handleUploadButton && resetButtonMessageId && uploadButtonMessageId ? /* @__PURE__ */ jsx(
+        DndTableBottomLeftButtons,
+        {
+          withResetButton,
+          disableUploadButton: disableAddingRows,
+          disabled,
+          handleUploadButton,
+          uploadButtonMessageId,
+          handleResetButton,
+          resetButtonMessageId
+        }
+      ) : null,
+      multiselect && /* @__PURE__ */ jsx(
+        DndTableBottomRightButtons,
+        {
+          arrayFormName: name,
+          handleAddButton: handleAddRowsButton,
+          handleDeleteButton: deleteSelectedRows,
+          handleMoveUpButton: moveUpSelectedRows,
+          handleMoveDownButton: moveDownSelectedRows,
+          disableAddingRows,
+          showMoveArrow,
+          disabled
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      DndTableAddRowsDialog,
+      {
+        open: openAddRowsDialog,
+        handleAddButton: addNewRows,
+        onClose: handleCloseAddRowsDialog
+      }
+    )
+  ] });
+}
+export {
+  DndTable
+};

package/dist/components/dnd-table-v2/dnd-table.type.d.ts

@@ -0,0 +1,70 @@
+import { JSX, ReactNode } from 'react';
+import { SxProps, Theme } from '@mui/material';
+import { ElementType } from '../../utils/types/elementType';
+import { EquipmentType } from '../../utils/types/equipmentType';
+import { Option } from '../../utils/types/types';
+export declare const SELECTED = "selected";
+export declare const MAX_ROWS_NUMBER = 100;
+export declare enum DndColumnType {
+    TEXT = "TEXT",
+    NUMERIC = "NUMERIC",
+    AUTOCOMPLETE = "AUTOCOMPLETE",
+    SELECT = "SELECT",
+    CHIP_ITEMS = "CHIP_ITEMS",
+    DIRECTORY_ITEMS = "DIRECTORY_ITEMS",
+    SWITCH = "SWITCH",
+    DESCRIPTIONS = "DESCRIPTIONS",
+    CUSTOM = "CUSTOM"
+}
+export interface ColumnBase {
+    dataKey: string;
+    maxWidth?: number | string;
+    width?: number | string;
+    label?: string;
+    sxHeader?: SxProps<Theme>;
+    extra?: JSX.Element;
+    editable?: boolean;
+    type: DndColumnType;
+    initialValue?: any;
+    shouldHandleOnChangeCell?: boolean;
+}
+export interface ColumnText extends ColumnBase {
+    type: DndColumnType.TEXT;
+    showErrorMsg?: boolean;
+}
+export interface ColumnNumeric extends ColumnBase {
+    type: DndColumnType.NUMERIC;
+    adornment?: {
+        text: string;
+    };
+    clearable?: boolean;
+    textAlign?: 'right' | 'left';
+}
+export interface ColumnAutocomplete extends ColumnBase {
+    type: DndColumnType.AUTOCOMPLETE;
+    options: Option[];
+}
+export interface ColumnSelect extends ColumnBase {
+    type: DndColumnType.SELECT;
+    options: Option[];
+}
+export interface ColumnDirectoryItem extends ColumnBase {
+    type: DndColumnType.DIRECTORY_ITEMS;
+    equipmentTypes: EquipmentType[];
+    elementType: ElementType;
+    titleId: string;
+}
+export interface ColumnChipsItem extends ColumnBase {
+    type: DndColumnType.CHIP_ITEMS;
+}
+export interface ColumnSwitchItem extends ColumnBase {
+    type: DndColumnType.SWITCH;
+}
+export interface ColumnDescriptions extends ColumnBase {
+    type: DndColumnType.DESCRIPTIONS;
+}
+export interface ColumnCustom extends ColumnBase {
+    type: DndColumnType.CUSTOM;
+    component: (rowIndex: number) => ReactNode;
+}
+export type DndColumn = ColumnNumeric | ColumnAutocomplete | ColumnSelect | ColumnText | ColumnDirectoryItem | ColumnChipsItem | ColumnSwitchItem | ColumnDescriptions | ColumnCustom;

package/dist/components/dnd-table-v2/dnd-table.type.js

@@ -0,0 +1,19 @@
+const SELECTED = "selected";
+const MAX_ROWS_NUMBER = 100;
+var DndColumnType = /* @__PURE__ */ ((DndColumnType2) => {
+  DndColumnType2["TEXT"] = "TEXT";
+  DndColumnType2["NUMERIC"] = "NUMERIC";
+  DndColumnType2["AUTOCOMPLETE"] = "AUTOCOMPLETE";
+  DndColumnType2["SELECT"] = "SELECT";
+  DndColumnType2["CHIP_ITEMS"] = "CHIP_ITEMS";
+  DndColumnType2["DIRECTORY_ITEMS"] = "DIRECTORY_ITEMS";
+  DndColumnType2["SWITCH"] = "SWITCH";
+  DndColumnType2["DESCRIPTIONS"] = "DESCRIPTIONS";
+  DndColumnType2["CUSTOM"] = "CUSTOM";
+  return DndColumnType2;
+})(DndColumnType || {});
+export {
+  DndColumnType,
+  MAX_ROWS_NUMBER,
+  SELECTED
+};

package/dist/components/dnd-table-v2/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 './dnd-table';
+export * from './dnd-table.type';
+export * from './dnd-table-utils';
+export * from './dnd-table-add-rows-dialog';
+export * from './dnd-table-bottom-left-buttons';
+export * from './dnd-table-bottom-right-buttons';

package/dist/components/dnd-table-v2/index.js

@@ -0,0 +1,16 @@
+import { DndTable } from "./dnd-table.js";
+import { DndColumnType, MAX_ROWS_NUMBER, SELECTED } from "./dnd-table.type.js";
+import { getDefaultRowData } from "./dnd-table-utils.js";
+import { DndTableAddRowsDialog } from "./dnd-table-add-rows-dialog.js";
+import { DndTableBottomLeftButtons } from "./dnd-table-bottom-left-buttons.js";
+import { DndTableBottomRightButtons } from "./dnd-table-bottom-right-buttons.js";
+export {
+  DndColumnType,
+  DndTable,
+  DndTableAddRowsDialog,
+  DndTableBottomLeftButtons,
+  DndTableBottomRightButtons,
+  MAX_ROWS_NUMBER,
+  SELECTED,
+  getDefaultRowData
+};

package/dist/components/filter/constants/FilterConstants.d.ts

@@ -1,4 +1,9 @@
-import { ItemSelectionForCopy } from '../filter.type';
+/**
+ * Copyright (c) 2024, 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 DISTRIBUTION_KEY = "distributionKey";
 export declare const FilterType: {
     EXPERT: {
@@ -10,4 +15,3 @@ export declare const FilterType: {
         label: string;
     };
 };
-export declare const NO_ITEM_SELECTION_FOR_COPY: ItemSelectionForCopy;

package/dist/components/filter/constants/FilterConstants.js

@@ -3,16 +3,7 @@ const FilterType = {
   EXPERT: { id: "EXPERT", label: "filter.expert" },
   EXPLICIT_NAMING: { id: "IDENTIFIER_LIST", label: "filter.explicitNaming" }
 };
-const NO_ITEM_SELECTION_FOR_COPY = {
-  sourceItemUuid: null,
-  nameItem: null,
-  descriptionItem: null,
-  parentDirectoryUuid: null,
-  typeItem: null,
-  specificTypeItem: null
-};
 export {
   DISTRIBUTION_KEY,
-  FilterType,
-  NO_ITEM_SELECTION_FOR_COPY
+  FilterType
 };

package/dist/components/filter/expert/ExpertFilterEditionDialog.js

@@ -7,7 +7,8 @@ import { FetchStatus } from "../../../utils/constants/fetchStatus.js";
 import { FieldConstants } from "../../../utils/constants/fieldConstants.js";
 import "../../../utils/yupConfig.js";
 import { CustomMuiDialog } from "../../dialogs/customMuiDialog/CustomMuiDialog.js";
-import { NO_ITEM_SELECTION_FOR_COPY, FilterType } from "../constants/FilterConstants.js";
+import { FilterType } from "../constants/FilterConstants.js";
+import { NO_ITEM_SELECTION_FOR_COPY } from "../../../utils/directory-utils.js";
 import { FilterForm } from "../FilterForm.js";
 import { saveExpertFilter } from "../utils/filterApi.js";
 import { expertFilterSchema } from "./ExpertFilterForm.js";

package/dist/components/filter/explicitNaming/ExplicitNamingFilterEditionDialog.js

@@ -12,7 +12,8 @@ import { saveExplicitNamingFilter } from "../utils/filterApi.js";
 import { explicitNamingFilterSchema } from "./ExplicitNamingFilterForm.js";
 import { FetchStatus } from "../../../utils/constants/fetchStatus.js";
 import { FilterForm } from "../FilterForm.js";
-import { NO_ITEM_SELECTION_FOR_COPY, FilterType } from "../constants/FilterConstants.js";
+import { FilterType } from "../constants/FilterConstants.js";
+import { NO_ITEM_SELECTION_FOR_COPY } from "../../../utils/directory-utils.js";
 import { HeaderFilterSchema } from "../HeaderFilterForm.js";
 import { FILTER_EQUIPMENTS_ATTRIBUTES } from "./ExplicitNamingFilterConstants.js";
 import { snackWithFallback } from "../../../utils/error.js";

package/dist/components/filter/explicitNaming/ExplicitNamingFilterForm.d.ts

@@ -4,8 +4,8 @@ import { default as yup } from '../../../utils/yupConfig';
 import { DISTRIBUTION_KEY } from '../constants/FilterConstants';
 export declare const explicitNamingFilterSchema: {
     filterEquipmentsAttributes: yup.ArraySchema<{
-        equipmentID?: string | null | undefined;
         distributionKey?: number | null | undefined;
+        equipmentID?: string | null | undefined;
     }[] | undefined, yup.AnyObject, "", "">;
 };
 interface FilterTableRow {

package/dist/components/filter/filter.type.d.ts

@@ -1,23 +1,24 @@
 import { UUID } from 'node:crypto';
-import { FieldConstants, GsLang } from '../../utils';
+import { EquipmentType, FieldConstants, GsLang } from '../../utils';
+import { ItemSelectionForCopy } from '../../utils/types/types';
 import { RuleGroupTypeExport } from './expert/expertFilter.type';
 import { EXPERT_FILTER_QUERY } from './expert/expertFilterConstants';
 import { FILTER_EQUIPMENTS_ATTRIBUTES } from './explicitNaming/ExplicitNamingFilterConstants';
-/**
- * Represent an item/object in directories.
- */
-export type ItemSelectionForCopy = {
-    sourceItemUuid: UUID | null;
-    typeItem: string | null;
-    nameItem: string | null;
-    descriptionItem: string | null;
-    parentDirectoryUuid: UUID | null;
-    specificTypeItem: string | null;
-};
-type EquipmentsFilter = {
+import { FilterType } from './constants/FilterConstants';
+export type EquipmentsFilter = {
     equipmentID: string;
     distributionKey?: number;
 };
+export interface IdentifiableAttributes {
+    id: string;
+    type: EquipmentType;
+    distributionKey: number;
+}
+export interface FilterEquipments {
+    filterId: UUID;
+    identifiableAttributes: IdentifiableAttributes[];
+    notFoundEquipments: string[];
+}
 export interface FilterEditionProps {
     id: string;
     name: string;
@@ -37,11 +38,20 @@ export interface FilterEditionProps {
     description?: string;
     isDeveloperMode: boolean;
 }
-export interface NewFilterType {
-    id: string | null;
+export type NewFilterType = ExpertFilter | ExplicitNamingFilter;
+type BaseFilter = {
+    id?: string | null;
+    name?: string;
     type: string;
     equipmentType: string;
-    rules?: RuleGroupTypeExport;
+};
+export type ExpertFilter = BaseFilter & {
+    type: typeof FilterType.EXPERT.id;
+    rules: RuleGroupTypeExport;
+    topologyKind?: string;
+};
+export type ExplicitNamingFilter = BaseFilter & {
+    type: typeof FilterType.EXPLICIT_NAMING.id;
     filterEquipmentsAttributes?: EquipmentsFilter[];
-}
+};
 export {};

package/dist/components/filter/index.js

@@ -1,6 +1,6 @@
 import { FilterCreationDialog } from "./FilterCreationDialog.js";
 import { FilterForm } from "./FilterForm.js";
-import { DISTRIBUTION_KEY, FilterType, NO_ITEM_SELECTION_FOR_COPY } from "./constants/FilterConstants.js";
+import { DISTRIBUTION_KEY, FilterType } from "./constants/FilterConstants.js";
 import { ExpertFilterEditionDialog } from "./expert/ExpertFilterEditionDialog.js";
 import { ExpertFilterForm, expertFilterSchema, getExpertFilterEmptyFormData } from "./expert/ExpertFilterForm.js";
 import { CombinatorType, DataType, OperatorType } from "./expert/expertFilter.type.js";
@@ -33,7 +33,6 @@ export {
   FilterForm,
   FilterType,
   LOAD_TYPE_OPTIONS,
-  NO_ITEM_SELECTION_FOR_COPY,
   OPERATOR_OPTIONS,
   OperatorType,
   PHASE_REGULATION_MODE_OPTIONS,