@gridsuite/commons-ui 0.54.0 → 0.56.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,16 +1,16 @@
+import { ElementAttributes } from '../../utils/types.ts';
 import { UUID } from 'crypto';
+import { TreeViewFinderProps } from '../TreeViewFinder/TreeViewFinder';
 import { FunctionComponent } from 'react';
 
-interface DirectoryItemSelectorProps {
+interface DirectoryItemSelectorProps extends TreeViewFinderProps {
     open: boolean;
-    onClose: any;
     types: string[];
     equipmentTypes?: string[];
-    title: 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[];
@@ -20,6 +20,7 @@ interface DirectoryItemSelectorProps {
     cancelButtonProps?: any;
     onlyLeaves?: boolean;
     multiselect?: boolean;
+    expanded?: UUID[];
 }
 declare const DirectoryItemSelector: FunctionComponent<DirectoryItemSelectorProps>;
 export default DirectoryItemSelector;

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

@@ -1,9 +1,9 @@
-import { jsx, Fragment } from "react/jsx-runtime";
+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),
@@ -13,23 +13,14 @@ const styles = {
 };
 const DirectoryItemSelector = ({
   open,
-  onClose,
   types,
   equipmentTypes,
-  title,
   itemFilter,
   fetchDirectoryContent,
   fetchRootFolders,
   fetchElementsInfos,
-  classes,
-  contentText,
-  defaultExpanded,
-  defaultSelected,
-  validationButtonText,
-  className,
-  cancelButtonProps,
-  onlyLeaves = true,
-  multiselect = true
+  expanded,
+  ...otherTreeViewFinderProps
 }) => {
   const [data, setData] = useState([]);
   const [rootDirectories, setRootDirectories] = useState([]);
@@ -39,8 +30,6 @@ const DirectoryItemSelector = ({
   const rootsRef = useRef([]);
   rootsRef.current = rootDirectories;
   const { snackError } = useSnackMessage();
-  const openRef = useRef();
-  openRef.current = open;
   const contentFilter = useCallback(
     () => /* @__PURE__ */ new Set([ElementType.DIRECTORY, ...types]),
     [types]
@@ -88,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,
@@ -105,29 +94,28 @@ const DirectoryItemSelector = ({
       });
     });
   }, [convertRoots, types, snackError, fetchRootFolders]);
-  useEffect(() => {
-    if (open) {
-      updateRootDirectories();
-    }
-  }, [open, updateRootDirectories]);
   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 {
@@ -149,6 +137,16 @@ const DirectoryItemSelector = ({
       fetchElementsInfos
     ]
   );
+  useEffect(() => {
+    if (open) {
+      updateRootDirectories();
+      if (expanded) {
+        expanded.forEach((nodeId) => {
+          fetchDirectory(nodeId);
+        });
+      }
+    }
+  }, [open, updateRootDirectories, expanded, fetchDirectory]);
   function sortHandlingDirectories(a, b) {
     if (a.children && !b.children) {
       return -1;
@@ -157,26 +155,19 @@ const DirectoryItemSelector = ({
     }
     return a.name.localeCompare(b.name);
   }
-  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx(
     TreeViewFinder,
     {
-      multiselect,
       onTreeBrowse: fetchDirectory,
-      data,
-      onlyLeaves,
       sortMethod: sortHandlingDirectories,
-      title,
-      onClose,
+      multiSelect: true,
       open,
-      classes,
-      contentText,
-      defaultExpanded,
-      defaultSelected,
-      validationButtonText,
-      className,
-      cancelButtonProps
+      expanded,
+      onlyLeaves: true,
+      ...otherTreeViewFinderProps,
+      data
     }
-  ) });
+  );
 };
 function updatedTree(prevRoots, prevMap, nodeId, children) {
   var _a;

package/dist/components/FlatParameters/FlatParameters.js

@@ -159,6 +159,9 @@ const FlatParameters = ({
     if (param.name === inEditionParam && uncommitted !== null) {
       return uncommitted;
     } else if (initValues && initValues.hasOwnProperty(param.name)) {
+      if (param.type === "BOOLEAN") {
+        return initValues[param.name] === "false" ? false : initValues[param.name];
+      }
       if (param.type !== "STRING_LIST") {
         return initValues[param.name];
       }

package/dist/components/ReportViewer/log-report.d.ts

@@ -1,12 +1,12 @@
 export default class LogReport {
     constructor(jsonReporter: any, parentReportId: any);
-    id: any;
+    id: string;
     key: any;
     title: any;
     subReports: any[];
     logs: any[];
     parentReportId: any;
-    getId(): any;
+    getId(): string;
     getTitle(): any;
     getSubReports(): any[];
     getLogs(): any[];

package/dist/components/TreeViewFinder/TreeViewFinder.d.ts

@@ -1,59 +1,33 @@
-import { default as PropTypes } from 'prop-types';
-export function generateTreeViewFinderClass(className: any): string;
-declare const _default: import('@emotion/styled').StyledComponent<Pick<PropTypes.InferProps<{
-    open: PropTypes.Validator<boolean>;
-    onClose: PropTypes.Requireable<(...args: any[]) => any>;
-    data: PropTypes.Validator<(PropTypes.InferProps<{
-        id: PropTypes.Validator<string>;
-        name: PropTypes.Validator<string>;
-        children: PropTypes.Requireable<any[]>;
-    }> | null | undefined)[]>;
-    onTreeBrowse: PropTypes.Requireable<(...args: any[]) => any>;
-    classes: PropTypes.Requireable<object>;
-    title: PropTypes.Requireable<string>;
-    contentText: PropTypes.Requireable<string>;
-    validationButtonText: PropTypes.Requireable<string>;
-    defaultSelected: PropTypes.Requireable<(string | null | undefined)[]>;
-    defaultExpanded: PropTypes.Requireable<(string | null | undefined)[]>;
-    onlyLeaves: PropTypes.Requireable<boolean>;
-    multiselect: PropTypes.Requireable<boolean>;
-    sortMethod: PropTypes.Requireable<(...args: any[]) => any>;
-    cancelButtonProps: PropTypes.Requireable<object>;
-    className: PropTypes.Requireable<string>;
-}>, "className" | "title" | "onClose" | "onTreeBrowse" | "contentText" | "validationButtonText" | "cancelButtonProps" | PropTypes.RequiredKeys<{
-    open: PropTypes.Validator<boolean>;
-    onClose: PropTypes.Requireable<(...args: any[]) => any>;
-    data: PropTypes.Validator<(PropTypes.InferProps<{
-        id: PropTypes.Validator<string>;
-        name: PropTypes.Validator<string>;
-        children: PropTypes.Requireable<any[]>;
-    }> | null | undefined)[]>;
-    onTreeBrowse: PropTypes.Requireable<(...args: any[]) => any>;
-    classes: PropTypes.Requireable<object>;
-    title: PropTypes.Requireable<string>;
-    contentText: PropTypes.Requireable<string>;
-    validationButtonText: PropTypes.Requireable<string>;
-    defaultSelected: PropTypes.Requireable<(string | null | undefined)[]>;
-    defaultExpanded: PropTypes.Requireable<(string | null | undefined)[]>;
-    onlyLeaves: PropTypes.Requireable<boolean>;
-    multiselect: PropTypes.Requireable<boolean>;
-    sortMethod: PropTypes.Requireable<(...args: any[]) => any>;
-    cancelButtonProps: PropTypes.Requireable<object>;
-    className: PropTypes.Requireable<string>;
-}>> & {
-    classes?: object | null | undefined;
-    defaultSelected?: (string | null | undefined)[] | null | undefined;
-    defaultExpanded?: (string | null | undefined)[] | null | undefined;
-    onlyLeaves?: boolean | null | undefined;
-    multiselect?: boolean | null | undefined;
-    sortMethod?: ((...args: any[]) => any) | null | undefined;
-} & {} & import("@mui/system").MUIStyledCommonProps<import("@mui/system").Theme>, {}, {}>;
+import { TreeViewClasses } from '@mui/x-tree-view';
+import { ButtonProps, ModalProps } from '@mui/material';
+import { ReactElement } from 'react';
+
+export declare const generateTreeViewFinderClass: (className: string) => string;
+export interface TreeViewFinderNodeProps {
+    id: string;
+    name: string;
+    icon?: ReactElement;
+    childrenCount?: number;
+    children?: TreeViewFinderNodeProps[];
+}
+export interface TreeViewFinderProps {
+    defaultExpanded?: string[];
+    defaultSelected?: string[];
+    selected?: string[];
+    expanded?: string[];
+    multiSelect?: boolean;
+    classes?: Partial<TreeViewClasses>;
+    className?: string;
+    contentText?: string;
+    open: ModalProps['open'];
+    onClose: (nodes: TreeViewFinderNodeProps[]) => void;
+    validationButtonText?: string;
+    cancelButtonProps?: ButtonProps;
+    title?: string;
+    onlyLeaves?: boolean;
+    data?: TreeViewFinderNodeProps[];
+    onTreeBrowse?: (nodeId: string) => void;
+    sortMethod?: (a: TreeViewFinderNodeProps, b: TreeViewFinderNodeProps) => number;
+}
+declare const _default: import('@emotion/styled').StyledComponent<TreeViewFinderProps & import("@mui/system").MUIStyledCommonProps<import("@mui/system").Theme>, {}, {}>;
 export default _default;
-/**
- * This callback type is called `onTreeBrowseCallback` and is displayed as a global symbol.
- */
-export type onTreeBrowseCallback = (nodeId: string) => any;
-/**
- * - callback to update data prop when walk into Tree
- */
-export type onTreeBrowse = (defaultSelected?: any[] | undefined, defaultExpanded?: any[] | undefined, validationButtonText?: string | undefined, onlyLeaves?: boolean | undefined, multiselect?: boolean | undefined, cancelButtonProps?: Object | undefined) => any;