@gridsuite/commons-ui 0.55.0 → 0.57.0

package/dist/chunks/filter-properties.GRon8-ML.js

@@ -0,0 +1,195 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import Grid$1 from "@mui/material/Grid";
+import { useMemo, useEffect } from "react";
+import { useWatch, useFieldArray } from "react-hook-form";
+import { FormattedMessage } from "react-intl";
+import { Line, Hvdc, Substation, Load, Generator, TwoWindingTransfo, Battery, ShuntCompensator, VoltageLevel } from "../components/filter/constants/equipment-types.js";
+import { areArrayElementsUnique } from "../utils/functions.js";
+import { FieldConstants } from "../components/filter/constants/field-constants.js";
+import "../utils/yup-config.js";
+import ErrorInput from "../components/react-hook-form/error-management/error-input.js";
+import FieldErrorAlert from "../components/react-hook-form/error-management/field-error-alert.js";
+import { Grid, ListItem, Button } from "@mui/material";
+import FilterProperty, { PROPERTY_NAME, PROPERTY_VALUES_1, PROPERTY_VALUES_2, PROPERTY_VALUES } from "../components/filter/criteria-based/filter-property.js";
+import { usePredefinedProperties } from "../hooks/predefined-properties-hook.js";
+import { FilterType } from "../components/filter/constants/filter-constants.js";
+import * as yup from "yup";
+import AddIcon from "@mui/icons-material/Add";
+const FilterFreeProperties = ({
+  freePropertiesType,
+  predefined
+}) => {
+  const watchEquipmentType = useWatch({
+    name: FieldConstants.EQUIPMENT_TYPE
+  });
+  const isForLineOrHvdcLineSubstation = (watchEquipmentType === Line.type || watchEquipmentType === Hvdc.type) && freePropertiesType === FreePropertiesTypes.SUBSTATION_FILTER_PROPERTIES;
+  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 === FreePropertiesTypes.FREE_FILTER_PROPERTIES ? "FreeProps" : "SubstationFreeProps";
+  }, [freePropertiesType]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(FormattedMessage, { id: title, children: (title2) => /* @__PURE__ */ jsx("h4", { children: title2 }) }) }),
+    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 }) })
+  ] });
+};
+var FreePropertiesTypes = /* @__PURE__ */ ((FreePropertiesTypes2) => {
+  FreePropertiesTypes2["SUBSTATION_FILTER_PROPERTIES"] = "substationFreeProperties";
+  FreePropertiesTypes2["FREE_FILTER_PROPERTIES"] = "freeProperties";
+  return FreePropertiesTypes2;
+})(FreePropertiesTypes || {});
+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;
+  } else {
+    return isForLineOrHvdcLine ? true : (values == null ? void 0 : values.length) > 0;
+  }
+}
+const filterPropertiesYupSchema = {
+  [
+    "substationFreeProperties"
+    /* 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);
+    }
+  ),
+  [
+    "freeProperties"
+    /* 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);
+    }
+  )
+};
+const 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$1, { item: true, container: true, spacing: 1, children: /* @__PURE__ */ jsxs(Grid$1, { item: true, xs: 12, children: [
+    /* @__PURE__ */ jsx(FormattedMessage, { id: "FreePropsCrit", children: (txt) => /* @__PURE__ */ jsx("h3", { children: txt }) }),
+    displayEquipmentProperties && /* @__PURE__ */ jsx(
+      FilterFreeProperties,
+      {
+        freePropertiesType: "freeProperties",
+        predefined: equipmentPredefinedProps
+      }
+    ),
+    displaySubstationProperties && /* @__PURE__ */ jsx(
+      FilterFreeProperties,
+      {
+        freePropertiesType: "substationFreeProperties",
+        predefined: substationPredefinedProps
+      }
+    )
+  ] }) });
+};
+export {
+  FreePropertiesTypes as F,
+  FilterProperties as a,
+  FilterFreeProperties as b,
+  filterPropertiesYupSchema as f
+};

package/dist/components/DirectoryItemSelector/directory-item-selector.d.ts

@@ -1,3 +1,4 @@
+import { ElementAttributes } from '../../utils/types.ts';
 import { UUID } from 'crypto';
 import { TreeViewFinderProps } from '../TreeViewFinder/TreeViewFinder';
 import { FunctionComponent } from 'react';
@@ -7,9 +8,18 @@ interface DirectoryItemSelectorProps extends TreeViewFinderProps {
     types: string[];
     equipmentTypes?: string[];
     itemFilter?: any;
-    fetchDirectoryContent: (directoryUuid: UUID, elementTypes: string[]) => Promise<any>;
-    fetchRootFolders: (types: string[]) => Promise<any>;
-    fetchElementsInfos: (ids: UUID[], elementTypes: string[], equipmentTypes: string[]) => Promise<any>;
+    fetchDirectoryContent?: (directoryUuid: UUID, elementTypes: string[]) => Promise<ElementAttributes[]>;
+    fetchRootFolders?: (types: string[]) => Promise<ElementAttributes[]>;
+    fetchElementsInfos?: (ids: UUID[], elementTypes: string[], equipmentTypes: string[]) => Promise<ElementAttributes[]>;
+    classes?: any;
+    contentText?: string;
+    defaultExpanded?: string[];
+    defaultSelected?: string[];
+    validationButtonText?: string;
+    className?: string;
+    cancelButtonProps?: any;
+    onlyLeaves?: boolean;
+    multiselect?: boolean;
     expanded?: UUID[];
 }
 declare const DirectoryItemSelector: FunctionComponent<DirectoryItemSelectorProps>;

package/dist/components/DirectoryItemSelector/directory-item-selector.js

@@ -2,8 +2,8 @@ import { jsx } from "react/jsx-runtime";
 import { useState, useRef, useCallback, useEffect } from "react";
 import { getFileIcon } from "../../utils/ElementIcon.js";
 import { ElementType } from "../../utils/ElementType.js";
-import { useSnackMessage } from "../../hooks/useSnackMessage.js";
 import TreeViewFinder from "../TreeViewFinder/TreeViewFinder.js";
+import { useSnackMessage } from "../../hooks/useSnackMessage.js";
 const styles = {
   icon: (theme) => ({
     marginRight: theme.spacing(1),
@@ -77,7 +77,7 @@ const DirectoryItemSelector = ({
     [convertRoots]
   );
   const updateRootDirectories = useCallback(() => {
-    fetchRootFolders(types).then((data2) => {
+    fetchRootFolders && fetchRootFolders(types).then((data2) => {
       let [nrs, mdr] = updatedTree(
         rootsRef.current,
         nodeMap.current,
@@ -96,22 +96,26 @@ const DirectoryItemSelector = ({
   }, [convertRoots, types, snackError, fetchRootFolders]);
   const fetchDirectory = useCallback(
     (nodeId) => {
-      fetchDirectoryContent(nodeId, types).then((children) => {
+      fetchDirectoryContent && fetchDirectoryContent(nodeId, types).then((children) => {
         const childrenMatchedTypes = children.filter(
           (item) => contentFilter().has(item.type)
         );
         if (childrenMatchedTypes.length > 0 && equipmentTypes && equipmentTypes.length > 0) {
-          fetchElementsInfos(
-            childrenMatchedTypes.map((e) => e.elementUuid),
+          fetchElementsInfos && fetchElementsInfos(
+            childrenMatchedTypes.map(
+              (e) => e.elementUuid
+            ),
             types,
             equipmentTypes
           ).then((childrenWithMetadata) => {
-            const children2 = itemFilter ? childrenWithMetadata.filter((val) => {
-              if (val.type === ElementType.DIRECTORY) {
-                return true;
+            const children2 = itemFilter ? childrenWithMetadata.filter(
+              (val) => {
+                if (val.type === ElementType.DIRECTORY) {
+                  return true;
+                }
+                return itemFilter(val);
               }
-              return itemFilter(val);
-            }) : childrenWithMetadata;
+            ) : childrenWithMetadata;
             addToDirectory(nodeId, children2);
           });
         } else {