@gridsuite/commons-ui 0.46.0 → 0.48.0

package/dist/components/ElementSearchDialog/element-search-dialog.js

@@ -0,0 +1,139 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useState, useEffect, useCallback } from "react";
+import { Dialog, DialogContent, Autocomplete, TextField } from "@mui/material";
+import PropTypes from "prop-types";
+import { SearchOff, Search } from "@mui/icons-material";
+import { useIntl } from "react-intl";
+const ElementSearchDialog = (props) => {
+  const intl = useIntl();
+  const {
+    open,
+    onClose,
+    searchingLabel,
+    onSearchTermChange,
+    onSelectionChange,
+    elementsFound,
+    // [{ label: aLabel, id: anId }, ...]
+    renderElement,
+    searchTermDisabled,
+    searchTermDisableReason
+  } = props;
+  const [expanded, setExpanded] = useState(false);
+  const [value, setValue] = useState(
+    searchTermDisabled && searchTermDisableReason ? { label: searchTermDisableReason } : null
+  );
+  const [loading, setLoading] = useState(false);
+  useEffect(() => {
+    setLoading(false);
+  }, [elementsFound]);
+  useEffect(() => {
+    if (!searchTermDisabled || !searchTermDisableReason) {
+      setValue(null);
+    } else {
+      setValue({ label: searchTermDisableReason });
+    }
+  }, [searchTermDisabled, searchTermDisableReason]);
+  useEffect(() => {
+    setValue((old) => !open ? null : old);
+  }, [open]);
+  const handleSearchTermChange = (term) => {
+    if (term) {
+      setLoading(true);
+      onSearchTermChange(term);
+      setExpanded(true);
+      setValue({ label: term });
+    } else {
+      setExpanded(false);
+      setValue(null);
+    }
+  };
+  const handleClose = useCallback(() => {
+    setValue(null);
+    setExpanded(false);
+    onClose();
+  }, [onClose]);
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open,
+      onClose: handleClose,
+      disableRestoreFocus: true,
+      "aria-labelledby": "dialog-title-search",
+      fullWidth: true,
+      children: /* @__PURE__ */ jsx(DialogContent, { children: /* @__PURE__ */ jsx(
+        Autocomplete,
+        {
+          id: "element-search",
+          forcePopupIcon: false,
+          open: expanded,
+          onClose: () => {
+            setExpanded(false);
+          },
+          fullWidth: true,
+          freeSolo: true,
+          clearOnBlur: true,
+          onInputChange: (_event, value2) => {
+            if (!searchTermDisabled) {
+              handleSearchTermChange(value2);
+            }
+          },
+          onChange: (_event, newValue, reason) => {
+            if (reason === "selectOption") {
+              onSelectionChange(newValue);
+              setValue(newValue);
+            } else {
+              setValue(null);
+            }
+          },
+          getOptionLabel: (option) => option.label,
+          isOptionEqualToValue: (option, value2) => option.id === value2.id,
+          options: loading ? [] : elementsFound,
+          loading,
+          autoHighlight: true,
+          noOptionsText: intl.formatMessage({
+            id: "element_search/noResult"
+          }),
+          renderOption: (optionProps, element, { inputValue }) => renderElement({
+            ...optionProps,
+            element,
+            inputValue,
+            onClose: handleClose
+          }),
+          renderInput: (params) => /* @__PURE__ */ jsx(
+            TextField,
+            {
+              autoFocus: true,
+              ...params,
+              label: searchingLabel || intl.formatMessage({
+                id: "element_search/label"
+              }),
+              InputProps: {
+                ...params.InputProps,
+                startAdornment: /* @__PURE__ */ jsxs(React.Fragment, { children: [
+                  searchTermDisabled ? /* @__PURE__ */ jsx(SearchOff, { color: "disabled" }) : /* @__PURE__ */ jsx(Search, { color: "disabled" }),
+                  params.InputProps.startAdornment
+                ] })
+              }
+            }
+          ),
+          value,
+          disabled: searchTermDisabled
+        }
+      ) })
+    }
+  );
+};
+ElementSearchDialog.propTypes = {
+  open: PropTypes.bool.isRequired,
+  onClose: PropTypes.func.isRequired,
+  searchingLabel: PropTypes.string,
+  onSearchTermChange: PropTypes.func.isRequired,
+  onSelectionChange: PropTypes.func.isRequired,
+  elementsFound: PropTypes.array.isRequired,
+  renderElement: PropTypes.func.isRequired,
+  searchTermDisabled: PropTypes.bool,
+  searchTermDisableReason: PropTypes.string
+};
+export {
+  ElementSearchDialog as default
+};

package/dist/components/ElementSearchDialog/equipment-item.d.ts

@@ -0,0 +1,16 @@
+export function EquipmentItem({ inputValue, suffixRenderer, element, showsJustText, ...props }: {
+    [x: string]: any;
+    inputValue: any;
+    suffixRenderer?: {
+        ({ props, element }: {
+            props: any;
+            element: any;
+        }): import("react/jsx-runtime").JSX.Element;
+        propTypes: {
+            element: import("prop-types").Requireable<object>;
+            props: import("prop-types").Requireable<object>;
+        };
+    } | undefined;
+    element: any;
+    showsJustText?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ElementSearchDialog/equipment-item.js

@@ -0,0 +1,77 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "./element-search-dialog.js";
+import { TagRenderer } from "./tag-renderer.js";
+import match from "autosuggest-highlight/match";
+import parse from "autosuggest-highlight/parse";
+import clsx from "clsx";
+import { FormattedMessage } from "react-intl";
+import { OverflowableText } from "../OverflowableText/overflowable-text.js";
+import "react";
+import { EQUIPMENT_TYPE } from "../../utils/EquipmentType.js";
+import { Box } from "@mui/material";
+import { mergeSx } from "../../utils/styles.js";
+const EquipmentItem = ({
+  inputValue,
+  suffixRenderer = TagRenderer,
+  element,
+  showsJustText = false,
+  ...props
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  let matches = match(element.label, inputValue, {
+    insideWords: true,
+    findAllOccurrences: true
+  });
+  let parts = parse(element.label, matches);
+  return /* @__PURE__ */ jsx("li", { ...props, children: /* @__PURE__ */ jsxs(
+    Box,
+    {
+      className: (_a = props.classes) == null ? void 0 : _a.equipmentOption,
+      sx: (_b = props.styles) == null ? void 0 : _b.equipmentOption,
+      children: [
+        !showsJustText && /* @__PURE__ */ jsx(
+          Box,
+          {
+            component: "span",
+            className: clsx(
+              (_c = props.classes) == null ? void 0 : _c.equipmentTag,
+              (_d = props.classes) == null ? void 0 : _d.equipmentTypeTag
+            ),
+            sx: mergeSx(
+              (_e = props.styles) == null ? void 0 : _e.equipmentTag,
+              (_f = props.styles) == null ? void 0 : _f.equipmentTypeTag
+            ),
+            children: /* @__PURE__ */ jsx(
+              FormattedMessage,
+              {
+                id: EQUIPMENT_TYPE[element.type].tagLabel
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          OverflowableText,
+          {
+            text: parts.map((e) => e.text).join(),
+            className: (_g = props.classes) == null ? void 0 : _g.result,
+            sx: (_h = props.styles) == null ? void 0 : _h.result,
+            children: parts.map((part, index) => /* @__PURE__ */ jsx(
+              "span",
+              {
+                style: {
+                  fontWeight: part.highlight ? "bold" : "inherit"
+                },
+                children: part.text
+              },
+              index
+            ))
+          }
+        ),
+        !showsJustText && suffixRenderer({ props, element })
+      ]
+    }
+  ) }, element.key);
+};
+export {
+  EquipmentItem
+};

package/dist/components/ElementSearchDialog/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./element-search-dialog";
+export { TagRenderer } from "./tag-renderer";

package/dist/components/ElementSearchDialog/tag-renderer.d.ts

@@ -0,0 +1,11 @@
+export function TagRenderer({ props, element }: {
+    props: any;
+    element: any;
+}): import("react/jsx-runtime").JSX.Element;
+export namespace TagRenderer {
+    namespace propTypes {
+        const element: PropTypes.Requireable<object>;
+        const props: PropTypes.Requireable<object>;
+    }
+}
+import PropTypes from 'prop-types';

package/dist/components/ElementSearchDialog/tag-renderer.js

@@ -0,0 +1,34 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { OverflowableText } from "../OverflowableText/overflowable-text.js";
+import clsx from "clsx";
+import "react";
+import { EQUIPMENT_TYPE } from "../../utils/EquipmentType.js";
+import PropTypes from "prop-types";
+import { mergeSx } from "../../utils/styles.js";
+const TagRenderer = ({ props, element }) => {
+  var _a, _b, _c, _d;
+  if (element.type !== EQUIPMENT_TYPE.SUBSTATION.name && element.type !== EQUIPMENT_TYPE.VOLTAGE_LEVEL.name) {
+    return /* @__PURE__ */ jsx(
+      OverflowableText,
+      {
+        text: element.voltageLevelLabel,
+        className: clsx(
+          (_a = props.classes) == null ? void 0 : _a.equipmentTag,
+          (_b = props.classes) == null ? void 0 : _b.equipmentVlTag
+        ),
+        sx: mergeSx(
+          (_c = props.styles) == null ? void 0 : _c.equipmentTag,
+          (_d = props.styles) == null ? void 0 : _d.equipmentVlTag
+        )
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(Fragment, {});
+};
+TagRenderer.propTypes = {
+  element: PropTypes.object,
+  props: PropTypes.object
+};
+export {
+  TagRenderer
+};

package/dist/components/FlatParameters/FlatParameters.d.ts

@@ -0,0 +1,10 @@
+export function extractDefault(paramDescription: any): any;
+export function FlatParameters({ paramsAsArray, initValues, onChange, variant, showSeparator, selectionWithDialog, }: {
+    paramsAsArray: any;
+    initValues: any;
+    onChange: any;
+    variant?: string | undefined;
+    showSeparator?: boolean | undefined;
+    selectionWithDialog?: ((param: any) => boolean) | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export default FlatParameters;