@gridsuite/commons-ui 0.62.0 → 0.63.0

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

@@ -1,4 +1,3 @@
-import { FunctionComponent } from 'react';
 import { default as yup } from '../../../utils/yup-config';
 
 export declare const criteriaBasedFilterSchema: {
@@ -11,5 +10,5 @@ export declare const criteriaBasedFilterSchema: {
 export declare const criteriaBasedFilterEmptyFormData: {
     criteriaBased: any;
 };
-declare const CriteriaBasedFilterForm: FunctionComponent;
+declare function CriteriaBasedFilterForm(): import("react/jsx-runtime").JSX.Element;
 export default CriteriaBasedFilterForm;

package/dist/components/filter/criteria-based/criteria-based-filter-form.js

@@ -1,11 +1,12 @@
 import { jsxs, jsx } from "react/jsx-runtime";
-import { f as filterPropertiesYupSchema, F as FreePropertiesTypes, a as FilterProperties } from "../../../chunks/filter-properties.B7-q_yPf.js";
-import { FieldConstants } from "../../../utils/field-constants.js";
+import Grid from "@mui/material/Grid";
+import FilterProperties, { filterPropertiesYupSchema } from "./filter-properties.js";
+import FieldConstants from "../../../utils/field-constants.js";
 import "../../../utils/yup-config.js";
 import CriteriaBasedForm from "./criteria-based-form.js";
-import Grid from "@mui/material/Grid";
 import { getCriteriaBasedSchema, getCriteriaBasedFormData } from "./criteria-based-filter-utils.js";
 import { FILTER_EQUIPMENTS } from "../utils/filter-form-utils.js";
+import { FreePropertiesTypes } from "./filter-free-properties.js";
 import * as yup from "yup";
 const criteriaBasedFilterSchema = getCriteriaBasedSchema({
   [FieldConstants.ENERGY_SOURCE]: yup.string().nullable(),
@@ -16,7 +17,7 @@ const criteriaBasedFilterEmptyFormData = getCriteriaBasedFormData(null, {
   [FreePropertiesTypes.SUBSTATION_FILTER_PROPERTIES]: [],
   [FreePropertiesTypes.FREE_FILTER_PROPERTIES]: []
 });
-const CriteriaBasedFilterForm = () => {
+function CriteriaBasedFilterForm() {
   return /* @__PURE__ */ jsxs(Grid, { container: true, item: true, spacing: 1, children: [
     /* @__PURE__ */ jsx(
       CriteriaBasedForm,
@@ -27,7 +28,7 @@ const CriteriaBasedFilterForm = () => {
     ),
     /* @__PURE__ */ jsx(FilterProperties, {})
   ] });
-};
+}
 export {
   criteriaBasedFilterEmptyFormData,
   criteriaBasedFilterSchema,

package/dist/components/filter/criteria-based/criteria-based-filter-utils.js

@@ -1,9 +1,9 @@
-import { FieldConstants } from "../../../utils/field-constants.js";
-import { F as FreePropertiesTypes } from "../../../chunks/filter-properties.B7-q_yPf.js";
+import FieldConstants from "../../../utils/field-constants.js";
 import { PROPERTY_VALUES, PROPERTY_VALUES_1, PROPERTY_VALUES_2, PROPERTY_NAME } from "./filter-property.js";
 import { FilterType } from "../constants/filter-constants.js";
 import "../../../utils/yup-config.js";
 import { getRangeInputSchema, getRangeInputDataForm, DEFAULT_RANGE_VALUE } from "../../inputs/react-hook-form/range-input.js";
+import { FreePropertiesTypes } from "./filter-free-properties.js";
 import * as yup from "yup";
 const getCriteriaBasedSchema = (extraFields) => ({
   [FieldConstants.CRITERIA_BASED]: yup.object().shape({
@@ -96,6 +96,31 @@ const backToFrontTweak = (response) => {
   };
   return ret;
 };
+function isNominalVoltageEmpty(nominalVoltage) {
+  return nominalVoltage[FieldConstants.VALUE_1] === null && nominalVoltage[FieldConstants.VALUE_2] === null;
+}
+function cleanNominalVoltages(formValues) {
+  const cleanedFormValues = { ...formValues };
+  if (isNominalVoltageEmpty(cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE])) {
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE] = null;
+  }
+  if (isNominalVoltageEmpty(
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE_1]
+  )) {
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE_1] = null;
+  }
+  if (isNominalVoltageEmpty(
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE_2]
+  )) {
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE_2] = null;
+  }
+  if (isNominalVoltageEmpty(
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE_3]
+  )) {
+    cleanedFormValues[FieldConstants.NOMINAL_VOLTAGE_3] = null;
+  }
+  return cleanedFormValues;
+}
 const frontToBackTweak = (id, filter) => {
   const filterSubstationProperties = filter[FieldConstants.CRITERIA_BASED][FreePropertiesTypes.SUBSTATION_FILTER_PROPERTIES];
   const ret = {
@@ -141,24 +166,6 @@ const frontToBackTweak = (id, filter) => {
   eff.freeProperties = freeProps;
   return ret;
 };
-function cleanNominalVoltages(formValues) {
-  if (isNominalVoltageEmpty(formValues[FieldConstants.NOMINAL_VOLTAGE])) {
-    formValues[FieldConstants.NOMINAL_VOLTAGE] = null;
-  }
-  if (isNominalVoltageEmpty(formValues[FieldConstants.NOMINAL_VOLTAGE_1])) {
-    formValues[FieldConstants.NOMINAL_VOLTAGE_1] = null;
-  }
-  if (isNominalVoltageEmpty(formValues[FieldConstants.NOMINAL_VOLTAGE_2])) {
-    formValues[FieldConstants.NOMINAL_VOLTAGE_2] = null;
-  }
-  if (isNominalVoltageEmpty(formValues[FieldConstants.NOMINAL_VOLTAGE_3])) {
-    formValues[FieldConstants.NOMINAL_VOLTAGE_3] = null;
-  }
-  return formValues;
-}
-function isNominalVoltageEmpty(nominalVoltage) {
-  return nominalVoltage[FieldConstants.VALUE_1] === null && nominalVoltage[FieldConstants.VALUE_2] === null;
-}
 export {
   backToFrontTweak,
   frontToBackTweak,

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

@@ -1,9 +1,8 @@
 import { FormEquipment } from '../utils/filter-form-utils';
-import { FunctionComponent } from 'react';
 
 export interface CriteriaBasedFormProps {
     equipments: Record<string, FormEquipment>;
     defaultValues: Record<string, any>;
 }
-declare const CriteriaBasedForm: FunctionComponent<CriteriaBasedFormProps>;
+declare function CriteriaBasedForm({ equipments, defaultValues, }: CriteriaBasedFormProps): import("react/jsx-runtime").JSX.Element;
 export default CriteriaBasedForm;

package/dist/components/filter/criteria-based/criteria-based-form.js

@@ -1,17 +1,27 @@
 import { jsxs, jsx } from "react/jsx-runtime";
-import { FieldConstants } from "../../../utils/field-constants.js";
 import { useFormContext, useWatch } from "react-hook-form";
 import { Grid } from "@mui/material";
+import { useEffect } from "react";
+import FieldConstants from "../../../utils/field-constants.js";
 import SelectInput from "../../inputs/react-hook-form/select-inputs/select-input.js";
 import InputWithPopupConfirmation from "../../inputs/react-hook-form/select-inputs/input-with-popup-confirmation.js";
-const CriteriaBasedForm = ({
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+function CriteriaBasedForm({
   equipments,
   defaultValues
-}) => {
+}) {
   const { getValues, setValue } = useFormContext();
+  const { snackError } = useSnackMessage();
   const watchEquipmentType = useWatch({
     name: FieldConstants.EQUIPMENT_TYPE
   });
+  useEffect(() => {
+    if (watchEquipmentType && !equipments[watchEquipmentType]) {
+      snackError({
+        headerId: "obsoleteFilter"
+      });
+    }
+  }, [snackError, equipments, watchEquipmentType]);
   const openConfirmationPopup = () => {
     return JSON.stringify(getValues(FieldConstants.CRITERIA_BASED)) !== JSON.stringify(defaultValues);
   };
@@ -37,14 +47,15 @@ const CriteriaBasedForm = ({
         validateButtonLabel: "button.changeType"
       }
     ) }),
-    watchEquipmentType && equipments[watchEquipmentType].fields.map(
+    watchEquipmentType && equipments[watchEquipmentType] && equipments[watchEquipmentType].fields.map(
       (equipment, index) => {
         const EquipmentForm = equipment.renderer;
-        return /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, flexGrow: 1, children: /* @__PURE__ */ jsx(EquipmentForm, { ...equipment.props }) }, index);
+        const uniqueKey = `${watchEquipmentType}-${index}`;
+        return /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, flexGrow: 1, children: /* @__PURE__ */ jsx(EquipmentForm, { ...equipment.props }) }, uniqueKey);
       }
     )
   ] });
-};
+}
 export {
   CriteriaBasedForm as default
 };

package/dist/components/filter/criteria-based/filter-free-properties.d.ts

@@ -1,10 +1,12 @@
 import { PredefinedProperties } from '../../../utils/types';
-import { FunctionComponent } from 'react';
-import { FreePropertiesTypes } from './filter-properties';
 
+export declare enum FreePropertiesTypes {
+    SUBSTATION_FILTER_PROPERTIES = "substationFreeProperties",
+    FREE_FILTER_PROPERTIES = "freeProperties"
+}
 interface FilterFreePropertiesProps {
     freePropertiesType: FreePropertiesTypes;
     predefined: PredefinedProperties;
 }
-declare const FilterFreeProperties: FunctionComponent<FilterFreePropertiesProps>;
+declare function FilterFreeProperties({ freePropertiesType, predefined, }: FilterFreePropertiesProps): import("react/jsx-runtime").JSX.Element;
 export default FilterFreeProperties;

package/dist/components/filter/criteria-based/filter-free-properties.js

@@ -1,15 +1,71 @@
-import "react/jsx-runtime";
-import "../../inputs/react-hook-form/error-management/error-input.js";
-import "../../inputs/react-hook-form/error-management/field-error-alert.js";
-import "@mui/material";
-import "../../../utils/field-constants.js";
-import "react-hook-form";
-import "react-intl";
-import { b } from "../../../chunks/filter-properties.B7-q_yPf.js";
-import "./filter-property.js";
-import "@mui/icons-material/Add";
-import "react";
-import "../../../utils/equipment-types.js";
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { Grid, ListItem, Button } from "@mui/material";
+import { useWatch, useFieldArray } from "react-hook-form";
+import { FormattedMessage } from "react-intl";
+import AddIcon from "@mui/icons-material/Add";
+import { useMemo } from "react";
+import ErrorInput from "../../inputs/react-hook-form/error-management/error-input.js";
+import FieldErrorAlert from "../../inputs/react-hook-form/error-management/field-error-alert.js";
+import FieldConstants from "../../../utils/field-constants.js";
+import FilterProperty, { PROPERTY_NAME, PROPERTY_VALUES_1, PROPERTY_VALUES_2, PROPERTY_VALUES } from "./filter-property.js";
+import { Line, Hvdc } from "../../../utils/equipment-types.js";
+var FreePropertiesTypes = /* @__PURE__ */ ((FreePropertiesTypes2) => {
+  FreePropertiesTypes2["SUBSTATION_FILTER_PROPERTIES"] = "substationFreeProperties";
+  FreePropertiesTypes2["FREE_FILTER_PROPERTIES"] = "freeProperties";
+  return FreePropertiesTypes2;
+})(FreePropertiesTypes || {});
+function FilterFreeProperties({
+  freePropertiesType,
+  predefined
+}) {
+  const watchEquipmentType = useWatch({
+    name: FieldConstants.EQUIPMENT_TYPE
+  });
+  const isForLineOrHvdcLineSubstation = (watchEquipmentType === Line.type || watchEquipmentType === Hvdc.type) && freePropertiesType === "substationFreeProperties";
+  const fieldName = `${FieldConstants.CRITERIA_BASED}.${freePropertiesType}`;
+  const {
+    fields: filterProperties,
+    // don't use it to access form data ! check doc,
+    append,
+    remove
+  } = useFieldArray({
+    name: fieldName
+  });
+  function addNewProp() {
+    if (isForLineOrHvdcLineSubstation) {
+      append({
+        [PROPERTY_NAME]: null,
+        [PROPERTY_VALUES_1]: [],
+        [PROPERTY_VALUES_2]: []
+      });
+    } else {
+      append({ [PROPERTY_NAME]: null, [PROPERTY_VALUES]: [] });
+    }
+  }
+  const valuesFields = isForLineOrHvdcLineSubstation ? [
+    { name: PROPERTY_VALUES_1, label: "PropertyValues1" },
+    { name: PROPERTY_VALUES_2, label: "PropertyValues2" }
+  ] : [{ name: PROPERTY_VALUES, label: "PropertyValues" }];
+  const title = useMemo(() => {
+    return freePropertiesType === "freeProperties" ? "FreeProps" : "SubstationFreeProps";
+  }, [freePropertiesType]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(FormattedMessage, { id: title, children: (formattedTitle) => /* @__PURE__ */ jsx("h4", { children: formattedTitle }) }) }),
+    filterProperties.map((prop, index) => /* @__PURE__ */ jsx(ListItem, { children: /* @__PURE__ */ jsx(
+      FilterProperty,
+      {
+        index,
+        valuesFields,
+        predefined,
+        handleDelete: remove,
+        propertyType: freePropertiesType
+      }
+    ) }, prop.id)),
+    /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(Button, { startIcon: /* @__PURE__ */ jsx(AddIcon, {}), onClick: () => addNewProp, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "AddFreePropCrit" }) }) }),
+    /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(ErrorInput, { name: fieldName, InputField: FieldErrorAlert }) })
+  ] });
+}
 export {
-  b as default
+  FreePropertiesTypes,
+  FilterFreeProperties as default
 };

package/dist/components/filter/criteria-based/filter-properties.d.ts

@@ -1,10 +1,5 @@
 import { default as yup } from '../../../utils/yup-config';
-import { FunctionComponent } from 'react';
 
-export declare enum FreePropertiesTypes {
-    SUBSTATION_FILTER_PROPERTIES = "substationFreeProperties",
-    FREE_FILTER_PROPERTIES = "freeProperties"
-}
 export declare const filterPropertiesYupSchema: {
     substationFreeProperties: yup.ArraySchema<{
         prop_values?: (string | undefined)[] | undefined;
@@ -17,5 +12,5 @@ export declare const filterPropertiesYupSchema: {
         name_property: string;
     }[] | undefined, yup.AnyObject, "", "">;
 };
-declare const FilterProperties: FunctionComponent;
+declare function FilterProperties(): any;
 export default FilterProperties;

package/dist/components/filter/criteria-based/filter-properties.js

@@ -1,19 +1,127 @@
-import "react/jsx-runtime";
-import "@mui/material/Grid";
-import "react";
-import "react-hook-form";
-import "react-intl";
-import "../../../utils/equipment-types.js";
-import "../../../utils/functions.js";
-import "../../../utils/field-constants.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import Grid from "@mui/material/Grid";
+import { useMemo, useEffect } from "react";
+import { useWatch } from "react-hook-form";
+import { FormattedMessage } from "react-intl";
+import { Line, Hvdc, Substation, Load, Generator, TwoWindingTransfo, Battery, ShuntCompensator, VoltageLevel } from "../../../utils/equipment-types.js";
+import { areArrayElementsUnique } from "../../../utils/functions.js";
+import FieldConstants from "../../../utils/field-constants.js";
 import "../../../utils/yup-config.js";
-import { F, a, f } from "../../../chunks/filter-properties.B7-q_yPf.js";
-import "./filter-property.js";
-import "../../../hooks/predefined-properties-hook.js";
-import "../constants/filter-constants.js";
-import "yup";
+import FilterFreeProperties, { FreePropertiesTypes } from "./filter-free-properties.js";
+import { PROPERTY_NAME, PROPERTY_VALUES, PROPERTY_VALUES_1, PROPERTY_VALUES_2 } from "./filter-property.js";
+import usePredefinedProperties from "../../../hooks/predefined-properties-hook.js";
+import { FilterType } from "../constants/filter-constants.js";
+import * as yup from "yup";
+function propertyValuesTest(values, context, doublePropertyValues) {
+  const rootLevelForm = context.from[context.from.length - 1];
+  const filterType = rootLevelForm.value[FieldConstants.FILTER_TYPE];
+  if (filterType !== FilterType.CRITERIA_BASED.id) {
+    return true;
+  }
+  const equipmentType = rootLevelForm.value[FieldConstants.EQUIPMENT_TYPE];
+  const isForLineOrHvdcLine = equipmentType === Line.type || equipmentType === Hvdc.type;
+  if (doublePropertyValues) {
+    return isForLineOrHvdcLine ? (values == null ? void 0 : values.length) > 0 : true;
+  }
+  return isForLineOrHvdcLine || (values == null ? void 0 : values.length) > 0;
+}
+const filterPropertiesYupSchema = {
+  [FreePropertiesTypes.SUBSTATION_FILTER_PROPERTIES]: yup.array().of(
+    yup.object().shape({
+      [PROPERTY_NAME]: yup.string().required(),
+      [PROPERTY_VALUES]: yup.array().of(yup.string()).test(
+        "can not be empty if not line",
+        "YupRequired",
+        (values, context) => propertyValuesTest(values, context, false)
+      ),
+      [PROPERTY_VALUES_1]: yup.array().of(yup.string()).test(
+        "can not be empty if line",
+        "YupRequired",
+        (values, context) => propertyValuesTest(values, context, true)
+      ),
+      [PROPERTY_VALUES_2]: yup.array().of(yup.string()).test(
+        "can not be empty if line",
+        "YupRequired",
+        (values, context) => propertyValuesTest(values, context, true)
+      )
+    })
+  ).test(
+    "distinct names",
+    "filterPropertiesNameUniquenessError",
+    (properties, context) => {
+      const rootLevelForm = context.from[context.from.length - 1];
+      const filterType = rootLevelForm.value[FieldConstants.FILTER_TYPE];
+      if (filterType !== FilterType.CRITERIA_BASED.id) {
+        return true;
+      }
+      const names = properties.filter((prop) => !!prop[PROPERTY_NAME]).map((prop) => prop[PROPERTY_NAME]);
+      return areArrayElementsUnique(names);
+    }
+  ),
+  [FreePropertiesTypes.FREE_FILTER_PROPERTIES]: yup.array().of(
+    yup.object().shape({
+      [PROPERTY_NAME]: yup.string().required(),
+      [PROPERTY_VALUES]: yup.array().of(yup.string()).test(
+        "can not be empty if not line",
+        "YupRequired",
+        (values, context) => propertyValuesTest(values, context, false)
+      )
+    })
+  ).test(
+    "distinct names",
+    "filterPropertiesNameUniquenessError",
+    (properties, context) => {
+      const rootLevelForm = context.from[context.from.length - 1];
+      const filterType = rootLevelForm.value[FieldConstants.FILTER_TYPE];
+      if (filterType !== FilterType.CRITERIA_BASED.id) {
+        return true;
+      }
+      const names = properties.filter((prop) => !!prop[PROPERTY_NAME]).map((prop) => prop[PROPERTY_NAME]);
+      return areArrayElementsUnique(names);
+    }
+  )
+};
+function FilterProperties() {
+  const watchEquipmentType = useWatch({
+    name: FieldConstants.EQUIPMENT_TYPE
+  });
+  const [equipmentPredefinedProps, setEquipmentType] = usePredefinedProperties(watchEquipmentType);
+  const [substationPredefinedProps, setSubstationType] = usePredefinedProperties(null);
+  const displayEquipmentProperties = useMemo(() => {
+    return watchEquipmentType === Substation.type || watchEquipmentType === Load.type || watchEquipmentType === Generator.type || watchEquipmentType === Line.type || watchEquipmentType === TwoWindingTransfo.type || watchEquipmentType === Battery.type || watchEquipmentType === ShuntCompensator.type || watchEquipmentType === VoltageLevel.type;
+  }, [watchEquipmentType]);
+  const displaySubstationProperties = useMemo(() => {
+    return watchEquipmentType !== Substation.type && watchEquipmentType !== null;
+  }, [watchEquipmentType]);
+  useEffect(() => {
+    if (displayEquipmentProperties) {
+      setEquipmentType(watchEquipmentType);
+    }
+  }, [displayEquipmentProperties, watchEquipmentType, setEquipmentType]);
+  useEffect(() => {
+    if (displaySubstationProperties) {
+      setSubstationType(Substation.type);
+    }
+  }, [displaySubstationProperties, setSubstationType]);
+  return watchEquipmentType && /* @__PURE__ */ jsx(Grid, { item: true, container: true, spacing: 1, children: /* @__PURE__ */ jsxs(Grid, { item: true, xs: 12, children: [
+    /* @__PURE__ */ jsx(FormattedMessage, { id: "FreePropsCrit", children: (txt) => /* @__PURE__ */ jsx("h3", { children: txt }) }),
+    displayEquipmentProperties && /* @__PURE__ */ jsx(
+      FilterFreeProperties,
+      {
+        freePropertiesType: FreePropertiesTypes.FREE_FILTER_PROPERTIES,
+        predefined: equipmentPredefinedProps
+      }
+    ),
+    displaySubstationProperties && /* @__PURE__ */ jsx(
+      FilterFreeProperties,
+      {
+        freePropertiesType: FreePropertiesTypes.SUBSTATION_FILTER_PROPERTIES,
+        predefined: substationPredefinedProps
+      }
+    )
+  ] }) });
+}
 export {
-  F as FreePropertiesTypes,
-  a as default,
-  f as filterPropertiesYupSchema
+  FilterProperties as default,
+  filterPropertiesYupSchema
 };

package/dist/components/filter/criteria-based/filter-property.d.ts

@@ -1,5 +1,4 @@
 import { PredefinedProperties } from '../../../utils/types';
-import { FunctionComponent } from 'react';
 
 export declare const PROPERTY_NAME = "name_property";
 export declare const PROPERTY_VALUES = "prop_values";
@@ -15,5 +14,5 @@ interface FilterPropertyProps {
     predefined: PredefinedProperties;
     propertyType: string;
 }
-declare const FilterProperty: FunctionComponent<FilterPropertyProps>;
+declare function FilterProperty(props: FilterPropertyProps): import("react/jsx-runtime").JSX.Element;
 export default FilterProperty;

package/dist/components/filter/criteria-based/filter-property.js

@@ -6,40 +6,40 @@ import Grid from "@mui/material/Grid";
 import { useFormContext, useWatch } from "react-hook-form";
 import AutocompleteInput from "../../inputs/react-hook-form/autocomplete-inputs/autocomplete-input.js";
 import MultipleAutocompleteInput from "../../inputs/react-hook-form/autocomplete-inputs/multiple-autocomplete-input.js";
-import { FieldConstants } from "../../../utils/field-constants.js";
+import FieldConstants from "../../../utils/field-constants.js";
 const PROPERTY_NAME = "name_property";
 const PROPERTY_VALUES = "prop_values";
 const PROPERTY_VALUES_1 = "prop_values1";
 const PROPERTY_VALUES_2 = "prop_values2";
-const FilterProperty = (props) => {
+function FilterProperty(props) {
+  const { propertyType, index, predefined, valuesFields, handleDelete } = props;
   const { setValue } = useFormContext();
   const watchName = useWatch({
-    name: `${FieldConstants.CRITERIA_BASED}.${props.propertyType}[${props.index}].${PROPERTY_NAME}`
+    name: `${FieldConstants.CRITERIA_BASED}.${propertyType}[${index}].${PROPERTY_NAME}`
   });
   const predefinedNames = useMemo(() => {
-    return Object.keys(props.predefined ?? []).sort();
-  }, [props.predefined]);
+    return Object.keys(predefined ?? []).sort();
+  }, [predefined]);
   const predefinedValues = useMemo(() => {
-    var _a;
-    const predefinedForName = (_a = props.predefined) == null ? void 0 : _a[watchName];
+    const predefinedForName = predefined == null ? void 0 : predefined[watchName];
     if (!predefinedForName) {
       return [];
     }
     return [...new Set(predefinedForName)].sort();
-  }, [watchName, props.predefined]);
+  }, [watchName, predefined]);
   const onNameChange = useCallback(() => {
-    props.valuesFields.forEach(
+    valuesFields.forEach(
       (valuesField) => setValue(
-        `${FieldConstants.CRITERIA_BASED}.${props.propertyType}[${props.index}].${valuesField.name}`,
+        `${FieldConstants.CRITERIA_BASED}.${propertyType}[${index}].${valuesField.name}`,
         []
       )
     );
-  }, [setValue, props.index, props.valuesFields, props.propertyType]);
+  }, [setValue, index, valuesFields, propertyType]);
   return /* @__PURE__ */ jsxs(Grid, { container: true, item: true, spacing: 1, columns: 21, children: [
     /* @__PURE__ */ jsx(Grid, { item: true, xs: 6, children: /* @__PURE__ */ jsx(
       AutocompleteInput,
       {
-        name: `${FieldConstants.CRITERIA_BASED}.${props.propertyType}[${props.index}].${PROPERTY_NAME}`,
+        name: `${FieldConstants.CRITERIA_BASED}.${propertyType}[${index}].${PROPERTY_NAME}`,
         label: "PropertyName",
         options: predefinedNames,
         autoSelect: true,
@@ -47,17 +47,17 @@ const FilterProperty = (props) => {
         onChangeCallback: onNameChange
       }
     ) }),
-    props.valuesFields.map((valuesField) => /* @__PURE__ */ jsx(Grid, { item: true, xs: true, children: /* @__PURE__ */ jsx(
+    valuesFields.map((valuesField) => /* @__PURE__ */ jsx(Grid, { item: true, xs: true, children: /* @__PURE__ */ jsx(
       MultipleAutocompleteInput,
       {
-        name: `${FieldConstants.CRITERIA_BASED}.${props.propertyType}[${props.index}].${valuesField.name}`,
+        name: `${FieldConstants.CRITERIA_BASED}.${propertyType}[${index}].${valuesField.name}`,
         label: valuesField.label,
         options: predefinedValues
       }
     ) }, valuesField.name)),
-    /* @__PURE__ */ jsx(Grid, { item: true, xs: 1, alignSelf: "center", children: /* @__PURE__ */ jsx(IconButton, { onClick: () => props.handleDelete(props.index), children: /* @__PURE__ */ jsx(DeleteIcon, {}) }) })
+    /* @__PURE__ */ jsx(Grid, { item: true, xs: 1, alignSelf: "center", children: /* @__PURE__ */ jsx(IconButton, { onClick: () => handleDelete(index), children: /* @__PURE__ */ jsx(DeleteIcon, {}) }) })
   ] });
-};
+}
 export {
   PROPERTY_NAME,
   PROPERTY_VALUES,

package/dist/components/filter/expert/expert-filter-constants.d.ts

@@ -1,5 +1,5 @@
-import { Field } from 'react-querybuilder';
 import { CombinatorType, DataType, FieldType, OperatorType } from './expert-filter.type';
+import { Field } from 'react-querybuilder';
 
 export declare enum RULES {
     EMPTY_RULE = "emptyRule",

package/dist/components/filter/expert/expert-filter-edition-dialog.d.ts

@@ -1,6 +1,5 @@
-import { elementExistsType } from '../criteria-based/criteria-based-filter-edition-dialog';
+import { ElementExistsType } from '../../../utils/ElementType';
 import { UUID } from 'crypto';
-import { FunctionComponent } from 'react';
 
 export interface ExpertFilterEditionDialogProps {
     id: string;
@@ -15,8 +14,8 @@ export interface ExpertFilterEditionDialogProps {
     }>;
     setSelectionForCopy: (selection: any) => void;
     activeDirectory?: UUID;
-    elementExists?: elementExistsType;
+    elementExists?: ElementExistsType;
     language?: string;
 }
-declare const ExpertFilterEditionDialog: FunctionComponent<ExpertFilterEditionDialogProps>;
+declare function ExpertFilterEditionDialog({ id, name, titleId, open, onClose, broadcastChannel, selectionForCopy, getFilterById, setSelectionForCopy, activeDirectory, elementExists, language, }: ExpertFilterEditionDialogProps): import("react/jsx-runtime").JSX.Element;
 export default ExpertFilterEditionDialog;