@gridsuite/commons-ui 0.55.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,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 {

package/dist/components/dialogs/custom-mui-dialog.d.ts

@@ -0,0 +1,21 @@
+import { MergedFormContextProps } from '../react-hook-form/provider/custom-form-provider';
+import { FieldErrors, UseFormReturn } from 'react-hook-form';
+import { default as React, FunctionComponent } from 'react';
+
+import * as yup from 'yup';
+interface ICustomMuiDialog {
+    open: boolean;
+    formSchema: yup.AnySchema;
+    formMethods: UseFormReturn<any> | MergedFormContextProps;
+    onClose: (event: React.MouseEvent) => void;
+    onSave: (data: any) => void;
+    onValidationError?: (errors: FieldErrors) => void;
+    titleId: string;
+    disabledSave?: boolean;
+    removeOptional?: boolean;
+    onCancel?: () => void;
+    children: React.ReactNode;
+    isDataFetching?: boolean;
+}
+declare const CustomMuiDialog: FunctionComponent<ICustomMuiDialog>;
+export default CustomMuiDialog;

package/dist/components/dialogs/custom-mui-dialog.js

@@ -0,0 +1,87 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { Dialog, LinearProgress, DialogTitle, Grid, DialogContent, DialogActions } from "@mui/material";
+import SubmitButton from "../react-hook-form/utils/submit-button.js";
+import CancelButton from "../react-hook-form/utils/cancel-button.js";
+import CustomFormProvider from "../react-hook-form/provider/custom-form-provider.js";
+const styles = {
+  dialogPaper: {
+    ".MuiDialog-paper": {
+      width: "auto",
+      minWidth: "1100px",
+      margin: "auto"
+    }
+  }
+};
+const CustomMuiDialog = ({
+  open,
+  formSchema,
+  formMethods,
+  onClose,
+  onSave,
+  isDataFetching = false,
+  onValidationError,
+  titleId,
+  disabledSave,
+  removeOptional = false,
+  onCancel,
+  children
+}) => {
+  const { handleSubmit } = formMethods;
+  const handleCancel = (event) => {
+    onCancel && onCancel();
+    onClose(event);
+  };
+  const handleClose = (event, reason) => {
+    if (reason === "backdropClick" && onCancel) {
+      onCancel();
+    }
+    onClose(event);
+  };
+  const handleValidate = (data) => {
+    onSave(data);
+    onClose(data);
+  };
+  const handleValidationError = (errors) => {
+    onValidationError && onValidationError(errors);
+  };
+  return /* @__PURE__ */ jsx(
+    CustomFormProvider,
+    {
+      ...formMethods,
+      validationSchema: formSchema,
+      removeOptional,
+      children: /* @__PURE__ */ jsxs(
+        Dialog,
+        {
+          sx: styles.dialogPaper,
+          open,
+          onClose: handleClose,
+          fullWidth: true,
+          children: [
+            isDataFetching && /* @__PURE__ */ jsx(LinearProgress, {}),
+            /* @__PURE__ */ jsx(DialogTitle, { children: /* @__PURE__ */ jsx(Grid, { item: true, xs: 11, children: /* @__PURE__ */ jsx(FormattedMessage, { id: titleId }) }) }),
+            /* @__PURE__ */ jsx(DialogContent, { children }),
+            /* @__PURE__ */ jsxs(DialogActions, { children: [
+              /* @__PURE__ */ jsx(CancelButton, { onClick: handleCancel }),
+              /* @__PURE__ */ jsx(
+                SubmitButton,
+                {
+                  variant: "outlined",
+                  disabled: disabledSave,
+                  onClick: handleSubmit(
+                    handleValidate,
+                    handleValidationError
+                  )
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    }
+  );
+};
+export {
+  CustomMuiDialog as default
+};

package/dist/components/dialogs/description-modification-dialog.d.ts

@@ -0,0 +1,11 @@
+import { FunctionComponent } from 'react';
+
+export interface IDescriptionModificationDialog {
+    elementUuid: string;
+    description: string;
+    open: boolean;
+    onClose: () => void;
+    updateElement: (uuid: string, data: Record<string, string>) => Promise<void>;
+}
+declare const DescriptionModificationDialog: FunctionComponent<IDescriptionModificationDialog>;
+export default DescriptionModificationDialog;

package/dist/components/dialogs/description-modification-dialog.js

@@ -0,0 +1,71 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import "../../utils/yup-config.js";
+import { FieldConstants } from "../filter/constants/field-constants.js";
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useSnackMessage } from "../../hooks/useSnackMessage.js";
+import CustomMuiDialog from "./custom-mui-dialog.js";
+import ExpandingTextField from "../react-hook-form/ExpandingTextField.js";
+import { Box } from "@mui/material";
+import * as yup from "yup";
+const schema = yup.object().shape({
+  [FieldConstants.DESCRIPTION]: yup.string().max(500, "descriptionLimitError")
+});
+const DescriptionModificationDialog = ({ elementUuid, description, open, onClose, updateElement }) => {
+  const { snackError } = useSnackMessage();
+  const emptyFormData = {
+    [FieldConstants.DESCRIPTION]: description ?? ""
+  };
+  const methods = useForm({
+    defaultValues: emptyFormData,
+    resolver: yupResolver(schema)
+  });
+  const { reset } = methods;
+  const onCancel = () => {
+    reset({
+      [FieldConstants.DESCRIPTION]: ""
+    });
+    onClose();
+  };
+  const onSubmit = useCallback(
+    (data) => {
+      updateElement(elementUuid, {
+        [FieldConstants.DESCRIPTION]: data[FieldConstants.DESCRIPTION].trim()
+      }).catch((error) => {
+        snackError({
+          messageTxt: error.message,
+          headerId: "descriptionModificationError"
+        });
+      });
+    },
+    [elementUuid, updateElement, snackError]
+  );
+  return /* @__PURE__ */ jsxs(
+    CustomMuiDialog,
+    {
+      open,
+      onClose: onCancel,
+      onSave: onSubmit,
+      formSchema: schema,
+      formMethods: methods,
+      titleId: "description",
+      removeOptional: true,
+      children: [
+        /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: /* @__PURE__ */ jsx(
+          ExpandingTextField,
+          {
+            name: FieldConstants.DESCRIPTION,
+            label: "descriptionProperty",
+            minRows: 3,
+            rows: 5
+          }
+        ) }),
+        " "
+      ]
+    }
+  );
+};
+export {
+  DescriptionModificationDialog as default
+};

package/dist/components/dialogs/popup-confirmation-dialog.d.ts

@@ -0,0 +1,11 @@
+import { FunctionComponent } from 'react';
+
+export interface PopupConfirmationDialogProps {
+    message: string;
+    validateButtonLabel: string;
+    openConfirmationPopup: boolean;
+    setOpenConfirmationPopup: (value: boolean) => void;
+    handlePopupConfirmation: () => void;
+}
+declare const PopupConfirmationDialog: FunctionComponent<PopupConfirmationDialogProps>;
+export default PopupConfirmationDialog;

package/dist/components/dialogs/popup-confirmation-dialog.js

@@ -0,0 +1,38 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import Dialog from "@mui/material/Dialog";
+import DialogTitle from "@mui/material/DialogTitle";
+import DialogContent from "@mui/material/DialogContent";
+import { DialogContentText } from "@mui/material";
+import DialogActions from "@mui/material/DialogActions";
+import Button from "@mui/material/Button";
+import { FormattedMessage } from "react-intl";
+import CancelButton from "../react-hook-form/utils/cancel-button.js";
+const PopupConfirmationDialog = ({
+  message,
+  validateButtonLabel,
+  openConfirmationPopup,
+  setOpenConfirmationPopup,
+  handlePopupConfirmation
+}) => {
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      open: openConfirmationPopup,
+      "aria-labelledby": "dialog-title-change-equipment-type",
+      children: [
+        /* @__PURE__ */ jsx(DialogTitle, { id: "dialog-title-change-equipment-type", children: "Confirmation" }),
+        /* @__PURE__ */ jsx(DialogContent, { children: /* @__PURE__ */ jsx(DialogContentText, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: message }) }) }),
+        /* @__PURE__ */ jsxs(DialogActions, { children: [
+          /* @__PURE__ */ jsx(CancelButton, { onClick: () => setOpenConfirmationPopup(false) }),
+          /* @__PURE__ */ jsx(Button, { onClick: handlePopupConfirmation, variant: "outlined", children: /* @__PURE__ */ jsx(FormattedMessage, { id: validateButtonLabel ?? "validate" }) })
+        ] })
+      ]
+    }
+  );
+};
+PopupConfirmationDialog.defaultProps = {
+  validateButtonLabel: void 0
+};
+export {
+  PopupConfirmationDialog as default
+};

package/dist/components/filter/constants/equipment-types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2021, 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 Line: {
+    label: string;
+    type: string;
+};
+export declare const Generator: {
+    label: string;
+    type: string;
+};
+export declare const Load: {
+    label: string;
+    type: string;
+};
+export declare const Battery: {
+    label: string;
+    type: string;
+};
+export declare const SVC: {
+    label: string;
+    type: string;
+};
+export declare const DanglingLine: {
+    label: string;
+    type: string;
+};
+export declare const LCC: {
+    label: string;
+    type: string;
+};
+export declare const VSC: {
+    label: string;
+    type: string;
+};
+export declare const Hvdc: {
+    label: string;
+    type: string;
+};
+export declare const BusBar: {
+    label: string;
+    type: string;
+};
+export declare const TwoWindingTransfo: {
+    label: string;
+    type: string;
+};
+export declare const ThreeWindingTransfo: {
+    label: string;
+    type: string;
+};
+export declare const ShuntCompensator: {
+    label: string;
+    type: string;
+};
+export declare const VoltageLevel: {
+    label: string;
+    type: string;
+};
+export declare const Substation: {
+    label: string;
+    type: string;
+};
+export declare const noSelectionForCopy: {
+    sourceCaseUuid: null;
+    name: null;
+    description: null;
+    parentDirectoryUuid: null;
+};

package/dist/components/filter/constants/equipment-types.js

@@ -0,0 +1,63 @@
+const Line = { label: "Lines", type: "LINE" };
+const Generator = { label: "Generators", type: "GENERATOR" };
+const Load = { label: "Loads", type: "LOAD" };
+const Battery = { label: "Batteries", type: "BATTERY" };
+const SVC = {
+  label: "StaticVarCompensators",
+  type: "STATIC_VAR_COMPENSATOR"
+};
+const DanglingLine = { label: "DanglingLines", type: "DANGLING_LINE" };
+const LCC = {
+  label: "LccConverterStations",
+  type: "LCC_CONVERTER_STATION"
+};
+const VSC = {
+  label: "VscConverterStations",
+  type: "VSC_CONVERTER_STATION"
+};
+const Hvdc = { label: "HvdcLines", type: "HVDC_LINE" };
+const BusBar = { label: "BusBarSections", type: "BUSBAR_SECTION" };
+const TwoWindingTransfo = {
+  label: "TwoWindingsTransformers",
+  type: "TWO_WINDINGS_TRANSFORMER"
+};
+const ThreeWindingTransfo = {
+  label: "ThreeWindingsTransformers",
+  type: "THREE_WINDINGS_TRANSFORMER"
+};
+const ShuntCompensator = {
+  label: "ShuntCompensators",
+  type: "SHUNT_COMPENSATOR"
+};
+const VoltageLevel = {
+  label: "VoltageLevels",
+  type: "VOLTAGE_LEVEL"
+};
+const Substation = {
+  label: "Substations",
+  type: "SUBSTATION"
+};
+const noSelectionForCopy = {
+  sourceCaseUuid: null,
+  name: null,
+  description: null,
+  parentDirectoryUuid: null
+};
+export {
+  Battery,
+  BusBar,
+  DanglingLine,
+  Generator,
+  Hvdc,
+  LCC,
+  Line,
+  Load,
+  SVC,
+  ShuntCompensator,
+  Substation,
+  ThreeWindingTransfo,
+  TwoWindingTransfo,
+  VSC,
+  VoltageLevel,
+  noSelectionForCopy
+};