@gridsuite/commons-ui 0.62.0 → 0.63.0

package/dist/components/filter/explicit-naming/explicit-naming-filter-edition-dialog.js

@@ -1,19 +1,139 @@
-import "react/jsx-runtime";
-import "react";
-import "prop-types";
-import "../utils/filter-api.js";
-import "react-hook-form";
-import "@hookform/resolvers/yup";
-import "../../../hooks/useSnackMessage.js";
-import "../../dialogs/custom-mui-dialog.js";
+import { jsx } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from "react";
+import PropTypes from "prop-types";
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { v4 } from "uuid";
+import { saveExplicitNamingFilter } from "../utils/filter-api.js";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import CustomMuiDialog from "../../dialogs/custom-mui-dialog.js";
 import "../../../utils/yup-config.js";
-import { a } from "../../../chunks/criteria-based-filter-edition-dialog.CAT38SvB.js";
-import "../../../utils/field-constants.js";
-import "uuid";
-import "../../../utils/equipment-types.js";
-import "../constants/filter-constants.js";
-import "../../../utils/FetchStatus.js";
-import "yup";
+import { explicitNamingFilterSchema, FILTER_EQUIPMENTS_ATTRIBUTES } from "./explicit-naming-filter-form.js";
+import FieldConstants from "../../../utils/field-constants.js";
+import FilterForm from "../filter-form.js";
+import { noSelectionForCopy } from "../../../utils/equipment-types.js";
+import { FilterType } from "../constants/filter-constants.js";
+import FetchStatus from "../../../utils/FetchStatus.js";
+import * as yup from "yup";
+const formSchema = yup.object().shape({
+  [FieldConstants.NAME]: yup.string().trim().required("nameEmpty"),
+  [FieldConstants.FILTER_TYPE]: yup.string().required(),
+  [FieldConstants.EQUIPMENT_TYPE]: yup.string().required(),
+  ...explicitNamingFilterSchema
+}).required();
+function ExplicitNamingFilterEditionDialog({
+  id,
+  name,
+  titleId,
+  open,
+  onClose,
+  broadcastChannel,
+  selectionForCopy,
+  setSelectionForCopy,
+  getFilterById,
+  activeDirectory,
+  elementExists,
+  language
+}) {
+  var _a;
+  const { snackError } = useSnackMessage();
+  const [dataFetchStatus, setDataFetchStatus] = useState(FetchStatus.IDLE);
+  const formMethods = useForm({
+    resolver: yupResolver(formSchema)
+  });
+  const {
+    reset,
+    formState: { errors }
+  } = formMethods;
+  const nameError = errors[FieldConstants.NAME];
+  const isValidating = (_a = errors.root) == null ? void 0 : _a.isValidating;
+  useEffect(() => {
+    if (id && open) {
+      setDataFetchStatus(FetchStatus.FETCHING);
+      getFilterById(id).then((response) => {
+        setDataFetchStatus(FetchStatus.FETCH_SUCCESS);
+        reset({
+          [FieldConstants.NAME]: name,
+          [FieldConstants.FILTER_TYPE]: FilterType.EXPLICIT_NAMING.id,
+          [FieldConstants.EQUIPMENT_TYPE]: response[FieldConstants.EQUIPMENT_TYPE],
+          [FILTER_EQUIPMENTS_ATTRIBUTES]: response[FILTER_EQUIPMENTS_ATTRIBUTES].map((row) => ({
+            [FieldConstants.AG_GRID_ROW_UUID]: v4(),
+            ...row
+          }))
+        });
+      }).catch((error) => {
+        setDataFetchStatus(FetchStatus.FETCH_ERROR);
+        snackError({
+          messageTxt: error.message,
+          headerId: "cannotRetrieveFilter"
+        });
+      });
+    }
+  }, [id, name, open, reset, snackError, getFilterById]);
+  const onSubmit = useCallback(
+    (filterForm) => {
+      saveExplicitNamingFilter(
+        filterForm[FILTER_EQUIPMENTS_ATTRIBUTES],
+        false,
+        filterForm[FieldConstants.EQUIPMENT_TYPE],
+        filterForm[FieldConstants.NAME],
+        "",
+        // The description can not be edited from this dialog
+        id,
+        (error) => {
+          snackError({
+            messageTxt: error
+          });
+        },
+        onClose
+      );
+      if (selectionForCopy.sourceItemUuid === id) {
+        setSelectionForCopy(noSelectionForCopy);
+        broadcastChannel.postMessage({
+          noSelectionForCopy
+        });
+      }
+    },
+    [
+      broadcastChannel,
+      id,
+      selectionForCopy,
+      onClose,
+      snackError,
+      setSelectionForCopy
+    ]
+  );
+  const isDataReady = dataFetchStatus === FetchStatus.FETCH_SUCCESS;
+  return /* @__PURE__ */ jsx(
+    CustomMuiDialog,
+    {
+      open,
+      onClose,
+      onSave: onSubmit,
+      formSchema,
+      formMethods,
+      titleId,
+      removeOptional: true,
+      disabledSave: !!nameError || !!isValidating,
+      isDataFetching: dataFetchStatus === FetchStatus.FETCHING,
+      language,
+      children: isDataReady && /* @__PURE__ */ jsx(
+        FilterForm,
+        {
+          activeDirectory,
+          elementExists
+        }
+      )
+    }
+  );
+}
+ExplicitNamingFilterEditionDialog.prototype = {
+  id: PropTypes.string,
+  name: PropTypes.string,
+  titleId: PropTypes.string.isRequired,
+  open: PropTypes.bool,
+  onClose: PropTypes.func.isRequired
+};
 export {
-  a as default
+  ExplicitNamingFilterEditionDialog as default
 };

package/dist/components/filter/explicit-naming/explicit-naming-filter-form.d.ts

@@ -1,8 +1,7 @@
-import { UUID } from 'crypto';
 import { DISTRIBUTION_KEY } from '../constants/filter-constants';
 import { default as yup } from '../../../utils/yup-config';
-import { FieldConstants } from '../../../utils/field-constants';
-import { FunctionComponent } from 'react';
+import { default as FieldConstants } from '../../../utils/field-constants';
+import { UUID } from 'crypto';
 
 export declare const FILTER_EQUIPMENTS_ATTRIBUTES = "filterEquipmentsAttributes";
 export declare const explicitNamingFilterSchema: {
@@ -21,10 +20,10 @@ export declare function getExplicitNamingFilterEmptyFormData(): {
 };
 export interface FilterForExplicitConversionProps {
     id: UUID;
-    equipmentType: String;
+    equipmentType: string;
 }
 interface ExplicitNamingFilterFormProps {
     sourceFilterForExplicitNamingConversion?: FilterForExplicitConversionProps;
 }
-declare const ExplicitNamingFilterForm: FunctionComponent<ExplicitNamingFilterFormProps>;
+declare function ExplicitNamingFilterForm({ sourceFilterForExplicitNamingConversion, }: ExplicitNamingFilterFormProps): import("react/jsx-runtime").JSX.Element;
 export default ExplicitNamingFilterForm;

package/dist/components/filter/explicit-naming/explicit-naming-filter-form.js

@@ -1,27 +1,244 @@
-import "react/jsx-runtime";
-import "react";
-import "../../../utils/field-constants.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useCallback } from "react";
+import { useIntl } from "react-intl";
+import { useFormContext, useWatch } from "react-hook-form";
+import Grid from "@mui/material/Grid";
+import { v4 } from "uuid";
+import FieldConstants from "../../../utils/field-constants.js";
 import "../../../utils/yup-config.js";
-import { d, f, e, g } from "../../../chunks/criteria-based-filter-edition-dialog.CAT38SvB.js";
-import "react-intl";
-import "react-hook-form";
-import "@mui/material/Grid";
-import "../../inputs/react-hook-form/select-inputs/select-input.js";
-import "../../../utils/equipment-types.js";
-import "../../inputs/react-hook-form/ag-grid-table/cell-editors/numericEditor.js";
-import "../../inputs/react-hook-form/select-inputs/input-with-popup-confirmation.js";
-import "uuid";
-import "../../inputs/react-hook-form/utils/functions.js";
-import "../constants/filter-constants.js";
-import "../utils/filter-form-utils.js";
-import "../../../hooks/useSnackMessage.js";
-import "../../../utils/ElementType.js";
-import "../../dialogs/modify-element-selection.js";
-import "../../../services/study.js";
-import "yup";
+import CustomAgGridTable, { ROW_DRAGGING_SELECTION_COLUMN_DEF } from "../../inputs/react-hook-form/ag-grid-table/custom-ag-grid-table.js";
+import SelectInput from "../../inputs/react-hook-form/select-inputs/select-input.js";
+import { Generator, Load } from "../../../utils/equipment-types.js";
+import NumericEditor from "../../inputs/react-hook-form/ag-grid-table/cell-editors/numericEditor.js";
+import InputWithPopupConfirmation from "../../inputs/react-hook-form/select-inputs/input-with-popup-confirmation.js";
+import { toFloatOrNullValue } from "../../inputs/react-hook-form/utils/functions.js";
+import { DISTRIBUTION_KEY, FilterType } from "../constants/filter-constants.js";
+import { FILTER_EQUIPMENTS } from "../utils/filter-form-utils.js";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import { ElementType } from "../../../utils/ElementType.js";
+import ModifyElementSelection from "../../dialogs/modify-element-selection.js";
+import { exportFilter } from "../../../services/study.js";
+import * as yup from "yup";
+const FILTER_EQUIPMENTS_ATTRIBUTES = "filterEquipmentsAttributes";
+function isGeneratorOrLoad(equipmentType) {
+  return equipmentType === Generator.type || equipmentType === Load.type;
+}
+const explicitNamingFilterSchema = {
+  [FILTER_EQUIPMENTS_ATTRIBUTES]: yup.array().of(
+    yup.object().shape({
+      [FieldConstants.EQUIPMENT_ID]: yup.string().nullable(),
+      [DISTRIBUTION_KEY]: yup.number().nullable()
+    })
+  ).compact(
+    (row) => !row[DISTRIBUTION_KEY] && !row[FieldConstants.EQUIPMENT_ID]
+  ).when([FieldConstants.FILTER_TYPE], {
+    is: FilterType.EXPLICIT_NAMING.id,
+    then: (schema) => schema.min(1, "emptyFilterError").when([FieldConstants.EQUIPMENT_TYPE], {
+      is: (equipmentType) => isGeneratorOrLoad(equipmentType),
+      then: (innerSchema) => innerSchema.test(
+        "noKeyWithoutId",
+        "distributionKeyWithMissingIdError",
+        (array) => {
+          return !array.some(
+            (row) => !row[FieldConstants.EQUIPMENT_ID]
+          );
+        }
+      ).test(
+        "ifOneKeyThenKeyEverywhere",
+        "missingDistributionKeyError",
+        (array) => {
+          return !(array.some(
+            (row) => row[DISTRIBUTION_KEY]
+          ) && array.some(
+            (row) => !row[DISTRIBUTION_KEY]
+          ));
+        }
+      )
+    })
+  })
+};
+function makeDefaultRowData() {
+  return {
+    [FieldConstants.AG_GRID_ROW_UUID]: v4(),
+    [FieldConstants.EQUIPMENT_ID]: "",
+    [DISTRIBUTION_KEY]: null
+  };
+}
+function makeDefaultTableRows() {
+  return [makeDefaultRowData(), makeDefaultRowData(), makeDefaultRowData()];
+}
+function getExplicitNamingFilterEmptyFormData() {
+  return {
+    [FILTER_EQUIPMENTS_ATTRIBUTES]: makeDefaultTableRows()
+  };
+}
+function ExplicitNamingFilterForm({
+  sourceFilterForExplicitNamingConversion
+}) {
+  const intl = useIntl();
+  const { snackError } = useSnackMessage();
+  const { getValues, setValue } = useFormContext();
+  const watchEquipmentType = useWatch({
+    name: FieldConstants.EQUIPMENT_TYPE
+  });
+  useEffect(() => {
+    if (watchEquipmentType && !(watchEquipmentType in FILTER_EQUIPMENTS)) {
+      snackError({
+        headerId: "obsoleteFilter"
+      });
+    }
+  }, [snackError, watchEquipmentType]);
+  const forGeneratorOrLoad = isGeneratorOrLoad(watchEquipmentType);
+  useEffect(() => {
+    if (sourceFilterForExplicitNamingConversion) {
+      setValue(
+        FieldConstants.EQUIPMENT_TYPE,
+        sourceFilterForExplicitNamingConversion.equipmentType
+      );
+    }
+  }, [sourceFilterForExplicitNamingConversion, setValue]);
+  const columnDefs = useMemo(() => {
+    const newColumnDefs = [
+      ...ROW_DRAGGING_SELECTION_COLUMN_DEF,
+      {
+        headerName: intl.formatMessage({
+          id: FieldConstants.EQUIPMENT_ID
+        }),
+        field: FieldConstants.EQUIPMENT_ID,
+        editable: true,
+        singleClickEdit: true,
+        valueParser: (params) => {
+          var _a;
+          return ((_a = params.newValue) == null ? void 0 : _a.trim()) ?? null;
+        }
+      }
+    ];
+    if (forGeneratorOrLoad) {
+      newColumnDefs.push({
+        headerName: intl.formatMessage({ id: DISTRIBUTION_KEY }),
+        field: DISTRIBUTION_KEY,
+        editable: true,
+        singleClickEdit: true,
+        cellEditor: NumericEditor,
+        maxWidth: 200
+      });
+    }
+    return newColumnDefs;
+  }, [intl, forGeneratorOrLoad]);
+  const defaultColDef = useMemo(
+    () => ({
+      suppressMovable: true
+    }),
+    []
+  );
+  const csvFileHeaders = useMemo(() => {
+    const newCsvFileHeaders = [
+      intl.formatMessage({ id: FieldConstants.EQUIPMENT_ID })
+    ];
+    if (forGeneratorOrLoad) {
+      newCsvFileHeaders.push(
+        intl.formatMessage({ id: DISTRIBUTION_KEY })
+      );
+    }
+    return newCsvFileHeaders;
+  }, [intl, forGeneratorOrLoad]);
+  const getDataFromCsvFile = useCallback((csvData) => {
+    if (csvData) {
+      return csvData.map((value) => {
+        var _a, _b;
+        return {
+          [FieldConstants.AG_GRID_ROW_UUID]: v4(),
+          [FieldConstants.EQUIPMENT_ID]: (_a = value[0]) == null ? void 0 : _a.trim(),
+          [DISTRIBUTION_KEY]: toFloatOrNullValue((_b = value[1]) == null ? void 0 : _b.trim())
+        };
+      });
+    }
+    return [];
+  }, []);
+  const openConfirmationPopup = () => {
+    return getValues(FILTER_EQUIPMENTS_ATTRIBUTES).some(
+      (row) => row[DISTRIBUTION_KEY] || row[FieldConstants.EQUIPMENT_ID]
+    );
+  };
+  const handleResetOnConfirmation = () => {
+    setValue(FILTER_EQUIPMENTS_ATTRIBUTES, makeDefaultTableRows());
+  };
+  const onStudySelected = (studyUuid) => {
+    exportFilter(studyUuid, sourceFilterForExplicitNamingConversion == null ? void 0 : sourceFilterForExplicitNamingConversion.id).then((matchingEquipments) => {
+      setValue(
+        FILTER_EQUIPMENTS_ATTRIBUTES,
+        matchingEquipments.length === 0 ? makeDefaultTableRows() : matchingEquipments.map((equipment) => ({
+          [FieldConstants.AG_GRID_ROW_UUID]: v4(),
+          [FieldConstants.EQUIPMENT_ID]: equipment.id,
+          [DISTRIBUTION_KEY]: equipment.distributionKey
+        }))
+      );
+    }).catch(
+      (error) => snackError({
+        messageTxt: error.message,
+        headerId: "convertIntoExplicitNamingFilterError"
+      })
+    );
+  };
+  return /* @__PURE__ */ jsxs(Grid, { container: true, item: true, spacing: 2, children: [
+    /* @__PURE__ */ jsxs(Grid, { item: true, xs: 12, children: [
+      /* @__PURE__ */ jsx(
+        InputWithPopupConfirmation,
+        {
+          Input: SelectInput,
+          name: FieldConstants.EQUIPMENT_TYPE,
+          options: Object.values(FILTER_EQUIPMENTS),
+          disabled: sourceFilterForExplicitNamingConversion,
+          label: "equipmentType",
+          shouldOpenPopup: openConfirmationPopup,
+          resetOnConfirmation: handleResetOnConfirmation,
+          message: "changeTypeMessage",
+          validateButtonLabel: "button.changeType"
+        }
+      ),
+      sourceFilterForExplicitNamingConversion && /* @__PURE__ */ jsx(
+        ModifyElementSelection,
+        {
+          elementType: ElementType.STUDY,
+          onElementValidated: onStudySelected,
+          dialogOpeningButtonLabel: "selectStudyDialogButton",
+          dialogTitleLabel: "selectStudyDialogTitle",
+          dialogMessageLabel: "selectStudyText",
+          noElementMessageLabel: "noSelectedStudyText"
+        }
+      )
+    ] }),
+    watchEquipmentType && /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(
+      CustomAgGridTable,
+      {
+        name: FILTER_EQUIPMENTS_ATTRIBUTES,
+        columnDefs,
+        defaultColDef,
+        makeDefaultRowData,
+        pagination: true,
+        paginationPageSize: 100,
+        suppressRowClickSelection: true,
+        alwaysShowVerticalScroll: true,
+        stopEditingWhenCellsLoseFocus: true,
+        csvProps: {
+          fileName: intl.formatMessage({
+            id: "filterCsvFileName"
+          }),
+          fileHeaders: csvFileHeaders,
+          getDataFromCsv: getDataFromCsvFile
+        },
+        cssProps: {
+          "& .ag-root-wrapper-body": {
+            maxHeight: "430px"
+          }
+        }
+      }
+    ) })
+  ] });
+}
 export {
-  d as FILTER_EQUIPMENTS_ATTRIBUTES,
-  f as default,
-  e as explicitNamingFilterSchema,
-  g as getExplicitNamingFilterEmptyFormData
+  FILTER_EQUIPMENTS_ATTRIBUTES,
+  ExplicitNamingFilterForm as default,
+  explicitNamingFilterSchema,
+  getExplicitNamingFilterEmptyFormData
 };

package/dist/components/filter/filter-creation-dialog.d.ts

@@ -1,17 +1,16 @@
+import { ElementExistsType } from '../../utils/ElementType';
 import { UUID } from 'crypto';
-import { elementExistsType } from './criteria-based/criteria-based-filter-edition-dialog';
-import { FunctionComponent } from 'react';
 
 export interface FilterCreationDialogProps {
     open: boolean;
     onClose: () => void;
     activeDirectory?: UUID;
-    elementExists?: elementExistsType;
+    elementExists?: ElementExistsType;
     language?: string;
     sourceFilterForExplicitNamingConversion?: {
         id: UUID;
         equipmentType: string;
     };
 }
-declare const FilterCreationDialog: FunctionComponent<FilterCreationDialogProps>;
+declare function FilterCreationDialog({ open, onClose, activeDirectory, elementExists, language, sourceFilterForExplicitNamingConversion, }: FilterCreationDialogProps): import("react/jsx-runtime").JSX.Element;
 export default FilterCreationDialog;

package/dist/components/filter/filter-creation-dialog.js

@@ -1,16 +1,128 @@
-import "react/jsx-runtime";
-import "react";
-import "./utils/filter-api.js";
-import "react-hook-form";
-import "../../hooks/useSnackMessage.js";
-import "../dialogs/custom-mui-dialog.js";
-import "./criteria-based/criteria-based-filter-form.js";
-import { F } from "../../chunks/criteria-based-filter-edition-dialog.CAT38SvB.js";
-import "../../utils/field-constants.js";
+import { jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { saveExplicitNamingFilter, saveCriteriaBasedFilter, saveExpertFilter } from "./utils/filter-api.js";
+import { useSnackMessage } from "../../hooks/useSnackMessage.js";
+import CustomMuiDialog from "../dialogs/custom-mui-dialog.js";
+import { criteriaBasedFilterEmptyFormData, criteriaBasedFilterSchema } from "./criteria-based/criteria-based-filter-form.js";
+import { getExplicitNamingFilterEmptyFormData, explicitNamingFilterSchema, FILTER_EQUIPMENTS_ATTRIBUTES } from "./explicit-naming/explicit-naming-filter-form.js";
+import FieldConstants from "../../utils/field-constants.js";
 import "../../utils/yup-config.js";
-import "@hookform/resolvers/yup";
-import "./constants/filter-constants.js";
-import "yup";
+import FilterForm from "./filter-form.js";
+import { getExpertFilterEmptyFormData, expertFilterSchema, EXPERT_FILTER_QUERY } from "./expert/expert-filter-form.js";
+import { FilterType } from "./constants/filter-constants.js";
+import * as yup from "yup";
+const emptyFormData = {
+  [FieldConstants.NAME]: "",
+  [FieldConstants.DESCRIPTION]: "",
+  [FieldConstants.FILTER_TYPE]: FilterType.CRITERIA_BASED.id,
+  [FieldConstants.EQUIPMENT_TYPE]: null,
+  ...criteriaBasedFilterEmptyFormData,
+  ...getExplicitNamingFilterEmptyFormData(),
+  ...getExpertFilterEmptyFormData()
+};
+const formSchema = yup.object().shape({
+  [FieldConstants.NAME]: yup.string().trim().required("nameEmpty"),
+  [FieldConstants.DESCRIPTION]: yup.string().max(500, "descriptionLimitError"),
+  [FieldConstants.FILTER_TYPE]: yup.string().required(),
+  [FieldConstants.EQUIPMENT_TYPE]: yup.string().required(),
+  ...criteriaBasedFilterSchema,
+  ...explicitNamingFilterSchema,
+  ...expertFilterSchema
+}).required();
+function FilterCreationDialog({
+  open,
+  onClose,
+  activeDirectory,
+  elementExists,
+  language,
+  sourceFilterForExplicitNamingConversion = void 0
+}) {
+  var _a;
+  const { snackError } = useSnackMessage();
+  const formMethods = useForm({
+    defaultValues: emptyFormData,
+    resolver: yupResolver(formSchema)
+  });
+  const {
+    formState: { errors }
+  } = formMethods;
+  const nameError = errors[FieldConstants.NAME];
+  const isValidating = (_a = errors.root) == null ? void 0 : _a.isValidating;
+  const onSubmit = useCallback(
+    (filterForm) => {
+      if (filterForm[FieldConstants.FILTER_TYPE] === FilterType.EXPLICIT_NAMING.id) {
+        saveExplicitNamingFilter(
+          filterForm[FILTER_EQUIPMENTS_ATTRIBUTES],
+          true,
+          filterForm[FieldConstants.EQUIPMENT_TYPE],
+          filterForm[FieldConstants.NAME],
+          filterForm[FieldConstants.DESCRIPTION],
+          null,
+          (error) => {
+            snackError({
+              messageTxt: error
+            });
+          },
+          onClose,
+          activeDirectory
+        );
+      } else if (filterForm[FieldConstants.FILTER_TYPE] === FilterType.CRITERIA_BASED.id) {
+        saveCriteriaBasedFilter(
+          filterForm,
+          activeDirectory,
+          onClose,
+          (error) => {
+            snackError({
+              messageTxt: error
+            });
+          }
+        );
+      } else if (filterForm[FieldConstants.FILTER_TYPE] === FilterType.EXPERT.id) {
+        saveExpertFilter(
+          null,
+          filterForm[EXPERT_FILTER_QUERY],
+          filterForm[FieldConstants.EQUIPMENT_TYPE],
+          filterForm[FieldConstants.NAME],
+          filterForm[FieldConstants.DESCRIPTION],
+          true,
+          activeDirectory,
+          onClose,
+          (error) => {
+            snackError({
+              messageTxt: error
+            });
+          }
+        );
+      }
+    },
+    [activeDirectory, snackError, onClose]
+  );
+  return /* @__PURE__ */ jsx(
+    CustomMuiDialog,
+    {
+      open,
+      onClose,
+      onSave: onSubmit,
+      formSchema,
+      formMethods,
+      titleId: sourceFilterForExplicitNamingConversion ? "convertIntoExplicitNamingFilter" : "createNewFilter",
+      removeOptional: true,
+      disabledSave: !!nameError || !!isValidating,
+      language,
+      children: /* @__PURE__ */ jsx(
+        FilterForm,
+        {
+          creation: true,
+          activeDirectory,
+          elementExists,
+          sourceFilterForExplicitNamingConversion
+        }
+      )
+    }
+  );
+}
 export {
-  F as default
+  FilterCreationDialog as default
 };

package/dist/components/filter/filter-form.d.ts

@@ -1,15 +1,14 @@
-import { elementExistsType } from './criteria-based/criteria-based-filter-edition-dialog';
+import { ElementExistsType } from '../../utils/ElementType';
 import { UUID } from 'crypto';
-import { FunctionComponent } from 'react';
 
 interface FilterFormProps {
     creation?: boolean;
     activeDirectory?: UUID;
-    elementExists?: elementExistsType;
+    elementExists?: ElementExistsType;
     sourceFilterForExplicitNamingConversion?: {
         id: UUID;
         equipmentType: string;
     };
 }
-export declare const FilterForm: FunctionComponent<FilterFormProps>;
-export {};
+declare function FilterForm(props: FilterFormProps): import("react/jsx-runtime").JSX.Element;
+export default FilterForm;