@gridsuite/commons-ui 0.46.0 → 0.48.0

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

@@ -0,0 +1,57 @@
+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>;
+}>, "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>;
+}>> & {
+    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>, {}, {}>;
+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;
+import PropTypes from 'prop-types';

package/dist/components/TreeViewFinder/TreeViewFinder.js

@@ -0,0 +1,288 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from "react";
+import { useIntl } from "react-intl";
+import PropTypes from "prop-types";
+import { toNestedGlobalSelectors, makeComposeClasses } from "../../utils/styles.js";
+import { styled } from "@mui/system";
+import { Dialog, DialogTitle, DialogContent, DialogContentText, DialogActions, Button, Typography } from "@mui/material";
+import { TreeView, TreeItem } from "@mui/lab";
+import { ChevronRight, ExpandMore, Check } from "@mui/icons-material";
+import CancelButton from "../react-hook-form/utils/cancel-button.js";
+const cssDialogPaper = "dialogPaper";
+const cssLabelRoot = "labelRoot";
+const cssLabelText = "labelText";
+const cssLabelIcon = "labelIcon";
+const cssIcon = "icon";
+const defaultStyles = {
+  [cssDialogPaper]: {
+    minWidth: "50%"
+  },
+  [cssLabelRoot]: {
+    display: "flex",
+    alignContent: "center",
+    alignItems: "center"
+  },
+  [cssLabelText]: {
+    fontWeight: "inherit",
+    flexGrow: 1
+  },
+  [cssLabelIcon]: {
+    display: "flex",
+    alignContent: "center",
+    alignItems: "center",
+    marginRight: "4px"
+  },
+  [cssIcon]: {}
+};
+const generateTreeViewFinderClass = (className) => `GsiTreeViewFinder-${className}`;
+const composeClasses = makeComposeClasses(generateTreeViewFinderClass);
+const TreeViewFinder = (props) => {
+  const intl = useIntl();
+  const {
+    classes,
+    title,
+    contentText,
+    open,
+    data,
+    defaultExpanded,
+    defaultSelected,
+    onClose,
+    onTreeBrowse,
+    validationButtonText,
+    onlyLeaves,
+    multiselect,
+    sortMethod,
+    className,
+    cancelButtonProps
+  } = props;
+  const [mapPrintedNodes, setMapPrintedNodes] = useState({});
+  const [expanded, setExpanded] = useState(defaultExpanded);
+  const [selected, setSelected] = useState(defaultSelected);
+  const isSelectable = (node) => {
+    return onlyLeaves ? isLeaf(node) : true;
+  };
+  const isLeaf = (node) => {
+    return node && node.children === void 0;
+  };
+  const computeMapPrintedNodes = useCallback((nodes) => {
+    let newMapPrintedNodes = {};
+    nodes.forEach((node) => {
+      newMapPrintedNodes[node.id] = node;
+      if (!isLeaf(node)) {
+        Object.assign(
+          newMapPrintedNodes,
+          computeMapPrintedNodes(node.children)
+        );
+      }
+    });
+    return newMapPrintedNodes;
+  }, []);
+  useEffect(() => {
+    let newMapPrintedNodes = computeMapPrintedNodes(data);
+    console.debug(
+      "data updated, new mapPrintedNodes (nbNodes = ",
+      Object.keys(newMapPrintedNodes).length,
+      ") : ",
+      newMapPrintedNodes
+    );
+    setMapPrintedNodes(newMapPrintedNodes);
+  }, [data, computeMapPrintedNodes]);
+  const computeSelectedNodes = () => {
+    return selected.map((nodeId) => {
+      return mapPrintedNodes[nodeId];
+    });
+  };
+  const handleNodeToggle = (e, nodeIds) => {
+    nodeIds.every((nodeId) => {
+      if (!expanded.includes(nodeId)) {
+        onTreeBrowse && onTreeBrowse(nodeId);
+        return false;
+      }
+      return true;
+    });
+    setExpanded(nodeIds);
+  };
+  const handleNodeSelect = (e, values) => {
+    if (multiselect) {
+      setSelected(
+        values.filter((nodeId) => isSelectable(mapPrintedNodes[nodeId]))
+      );
+    } else {
+      if (selected.includes(values)) {
+        setSelected([]);
+      } else {
+        setSelected(
+          isSelectable(mapPrintedNodes[values]) ? [values] : []
+        );
+      }
+    }
+  };
+  const getValidationButtonText = () => {
+    if (validationButtonText) {
+      return validationButtonText;
+    } else {
+      return intl.formatMessage(
+        { id: "treeview_finder/addElementsValidation" },
+        {
+          nbElements: selected.length
+        }
+      );
+    }
+  };
+  const getNodeIcon = (node) => {
+    if (!node) {
+      return null;
+    }
+    if (isSelectable(node) && selected.find((nodeId) => nodeId === node.id)) {
+      return /* @__PURE__ */ jsx(Check, { className: composeClasses(classes, cssLabelIcon) });
+    } else {
+      if (node.icon) {
+        return /* @__PURE__ */ jsx("div", { className: composeClasses(classes, cssLabelIcon), children: node.icon });
+      } else {
+        return null;
+      }
+    }
+  };
+  const renderTreeItemLabel = (node) => {
+    return /* @__PURE__ */ jsxs("div", { className: composeClasses(classes, cssLabelRoot), children: [
+      getNodeIcon(node),
+      /* @__PURE__ */ jsx(Typography, { className: composeClasses(classes, cssLabelText), children: node.name })
+    ] });
+  };
+  const showChevron = (node) => {
+    return !!(node.childrenCount == null || node.childrenCount && node.childrenCount > 0);
+  };
+  const renderTree = (node) => {
+    if (!node) {
+      return;
+    }
+    return /* @__PURE__ */ jsx(
+      TreeItem,
+      {
+        nodeId: node.id,
+        label: renderTreeItemLabel(node),
+        expandIcon: showChevron(node) ? /* @__PURE__ */ jsx(
+          ChevronRight,
+          {
+            className: composeClasses(classes, cssIcon)
+          }
+        ) : null,
+        collapseIcon: showChevron(node) ? /* @__PURE__ */ jsx(
+          ExpandMore,
+          {
+            className: composeClasses(classes, cssIcon)
+          }
+        ) : null,
+        children: Array.isArray(node.children) ? node.children.length ? node.children.sort(sortMethod).map((child) => renderTree(child)) : [false] : null
+      },
+      node.id
+    );
+  };
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      open,
+      onClose: (e, r) => {
+        if (r === "escapeKeyDown" || r === "backdropClick") {
+          onClose([]);
+          setSelected([]);
+        }
+      },
+      "aria-labelledby": "TreeViewFindertitle",
+      className,
+      classes: {
+        paper: composeClasses(classes, cssDialogPaper)
+      },
+      children: [
+        /* @__PURE__ */ jsx(DialogTitle, { id: "TreeViewFindertitle", children: title ? title : intl.formatMessage(
+          { id: "treeview_finder/finderTitle" },
+          { multiselect }
+        ) }),
+        /* @__PURE__ */ jsxs(DialogContent, { children: [
+          /* @__PURE__ */ jsx(DialogContentText, { children: contentText ? contentText : intl.formatMessage(
+            { id: "treeview_finder/contentText" },
+            { multiselect }
+          ) }),
+          /* @__PURE__ */ jsx(
+            TreeView,
+            {
+              expanded,
+              selected,
+              onNodeToggle: handleNodeToggle,
+              onNodeSelect: handleNodeSelect,
+              multiSelect: multiselect,
+              children: data && Array.isArray(data) ? data.sort(sortMethod).map((child) => renderTree(child)) : null
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs(DialogActions, { children: [
+          /* @__PURE__ */ jsx(
+            CancelButton,
+            {
+              style: { float: "left", margin: "5px" },
+              onClick: () => {
+                onClose([]);
+                setSelected([]);
+              },
+              ...cancelButtonProps
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outlined",
+              style: { float: "left", margin: "5px" },
+              onClick: () => {
+                onClose(computeSelectedNodes());
+                setSelected([]);
+              },
+              disabled: selected.length === 0,
+              children: getValidationButtonText()
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+TreeViewFinder.propTypes = {
+  // Controlled
+  open: PropTypes.bool.isRequired,
+  onClose: PropTypes.func,
+  data: PropTypes.arrayOf(
+    PropTypes.shape({
+      id: PropTypes.string.isRequired,
+      name: PropTypes.string.isRequired,
+      children: PropTypes.array
+    })
+  ).isRequired,
+  onTreeBrowse: PropTypes.func,
+  //uncontrolled
+  classes: PropTypes.object,
+  title: PropTypes.string,
+  contentText: PropTypes.string,
+  validationButtonText: PropTypes.string,
+  defaultSelected: PropTypes.arrayOf(PropTypes.string),
+  defaultExpanded: PropTypes.arrayOf(PropTypes.string),
+  onlyLeaves: PropTypes.bool,
+  multiselect: PropTypes.bool,
+  sortMethod: PropTypes.func,
+  cancelButtonProps: PropTypes.object
+};
+TreeViewFinder.defaultProps = {
+  defaultSelected: [],
+  defaultExpanded: [],
+  onlyLeaves: true,
+  multiselect: false,
+  sortMethod: void 0,
+  classes: {}
+};
+const nestedGlobalSelectorsStyles = toNestedGlobalSelectors(
+  defaultStyles,
+  generateTreeViewFinderClass
+);
+const TreeViewFinder$1 = styled(TreeViewFinder)(nestedGlobalSelectorsStyles);
+export {
+  TreeViewFinder$1 as default,
+  generateTreeViewFinderClass
+};

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

@@ -0,0 +1 @@
+export { default, generateTreeViewFinderClass } from "./TreeViewFinder";

package/dist/components/react-hook-form/autocomplete-input.d.ts

@@ -0,0 +1,30 @@
+export default AutocompleteInput;
+declare function AutocompleteInput({ name, label, options, outputTransform, inputTransform, readOnly, previousValue, allowNewValue, onChangeCallback, formProps, ...props }: {
+    [x: string]: any;
+    name: any;
+    label: any;
+    options: any;
+    outputTransform?: typeof identity | undefined;
+    inputTransform?: typeof identity | undefined;
+    readOnly?: boolean | undefined;
+    previousValue: any;
+    allowNewValue: any;
+    onChangeCallback: any;
+    formProps: any;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace AutocompleteInput {
+    namespace propTypes {
+        const name: PropTypes.Validator<string>;
+        const label: PropTypes.Requireable<string>;
+        const options: PropTypes.Validator<any[]>;
+        const outputTransform: PropTypes.Requireable<(...args: any[]) => any>;
+        const inputTransform: PropTypes.Requireable<(...args: any[]) => any>;
+        const readOnly: PropTypes.Requireable<boolean>;
+        const previousValue: PropTypes.Requireable<any>;
+        const allowNewValue: PropTypes.Requireable<boolean>;
+        const onChangeCallback: PropTypes.Requireable<(...args: any[]) => any>;
+        const formProps: PropTypes.Requireable<object>;
+    }
+}
+import { identity } from './utils/functions';
+import PropTypes from 'prop-types';

package/dist/components/react-hook-form/autocomplete-input.js

@@ -0,0 +1,96 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import PropTypes from "prop-types";
+import { Autocomplete, TextField } from "@mui/material";
+import { useFormContext, useController } from "react-hook-form";
+import { isFieldRequired, genHelperPreviousValue, genHelperError, identity } from "./utils/functions.js";
+import FieldLabel from "./utils/field-label.js";
+const AutocompleteInput = ({
+  name,
+  label,
+  options,
+  outputTransform = identity,
+  //transform materialUi input value before sending it to react hook form, mostly used to deal with select fields that need to return a string
+  inputTransform = identity,
+  //transform react hook form value before sending it to materialUi input, mostly used to deal with select fields that need to return a string
+  readOnly = false,
+  previousValue,
+  allowNewValue,
+  onChangeCallback,
+  // method called when input value is changing
+  formProps,
+  ...props
+}) => {
+  const { validationSchema, getValues, removeOptional } = useFormContext();
+  const {
+    field: { onChange, value, ref },
+    fieldState: { error }
+  } = useController({ name });
+  const handleChange = (value2) => {
+    onChangeCallback && onChangeCallback();
+    if (!allowNewValue || typeof value2 !== "string") {
+      onChange(outputTransform(value2));
+      return;
+    }
+    const matchingOption = options.find((option) => option.id === value2);
+    if (matchingOption) {
+      onChange(outputTransform(matchingOption));
+      return;
+    }
+    onChange(outputTransform(value2));
+  };
+  return /* @__PURE__ */ jsx(
+    Autocomplete,
+    {
+      value: inputTransform(value),
+      onChange: (_, data) => handleChange(data),
+      ...allowNewValue && {
+        freeSolo: true,
+        autoComplete: true,
+        blurOnSelect: true,
+        autoSelect: false,
+        onInputChange: (_, data) => {
+          handleChange(data);
+        }
+      },
+      options,
+      renderInput: ({ inputProps, ...rest }) => /* @__PURE__ */ jsx(
+        TextField,
+        {
+          ...label && {
+            label: FieldLabel({
+              label,
+              optional: !isFieldRequired(
+                name,
+                validationSchema,
+                getValues()
+              ) && !(props == null ? void 0 : props.disabled) && !removeOptional
+            })
+          },
+          inputRef: ref,
+          inputProps: { ...inputProps, readOnly },
+          ...genHelperPreviousValue(previousValue),
+          ...genHelperError(error == null ? void 0 : error.message),
+          ...formProps,
+          ...rest
+        }
+      ),
+      ...props
+    }
+  );
+};
+AutocompleteInput.propTypes = {
+  name: PropTypes.string.isRequired,
+  label: PropTypes.string,
+  options: PropTypes.array.isRequired,
+  outputTransform: PropTypes.func,
+  inputTransform: PropTypes.func,
+  readOnly: PropTypes.bool,
+  previousValue: PropTypes.any,
+  allowNewValue: PropTypes.bool,
+  onChangeCallback: PropTypes.func,
+  formProps: PropTypes.object
+};
+export {
+  AutocompleteInput as default
+};

package/dist/components/react-hook-form/booleans/boolean-input.d.ts

@@ -0,0 +1,16 @@
+export default BooleanInput;
+declare function BooleanInput({ name, label, formProps, Input }: {
+    name: any;
+    label: any;
+    formProps: any;
+    Input: any;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace BooleanInput {
+    namespace propTypes {
+        const name: PropTypes.Validator<string>;
+        const label: PropTypes.Requireable<string>;
+        const formProps: PropTypes.Requireable<object>;
+        const Input: PropTypes.Validator<NonNullable<PropTypes.ReactComponentLike>>;
+    }
+}
+import PropTypes from 'prop-types';

package/dist/components/react-hook-form/booleans/boolean-input.js

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import PropTypes from "prop-types";
+import { useIntl } from "react-intl";
+import { FormControlLabel } from "@mui/material";
+import { useController } from "react-hook-form";
+const BooleanInput = ({ name, label, formProps, Input }) => {
+  const {
+    field: { onChange, value, ref }
+  } = useController({ name });
+  const intl = useIntl();
+  const handleChangeValue = useCallback(
+    (event) => {
+      onChange(event.target.checked);
+    },
+    [onChange]
+  );
+  const CustomInput = /* @__PURE__ */ jsx(
+    Input,
+    {
+      checked: value,
+      onChange: (e) => handleChangeValue(e),
+      inputRef: ref,
+      inputProps: {
+        "aria-label": "primary checkbox"
+      },
+      ...formProps
+    }
+  );
+  if (label) {
+    return /* @__PURE__ */ jsx(
+      FormControlLabel,
+      {
+        control: CustomInput,
+        label: intl.formatMessage({ id: label })
+      }
+    );
+  }
+  return CustomInput;
+};
+BooleanInput.propTypes = {
+  name: PropTypes.string.isRequired,
+  label: PropTypes.string,
+  formProps: PropTypes.object,
+  Input: PropTypes.elementType.isRequired
+};
+export {
+  BooleanInput as default
+};

package/dist/components/react-hook-form/booleans/checkbox-input.d.ts

@@ -0,0 +1,14 @@
+export default CheckboxInput;
+declare function CheckboxInput({ name, label, formProps }: {
+    name: any;
+    label: any;
+    formProps: any;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace CheckboxInput {
+    namespace propTypes {
+        const name: PropTypes.Validator<string>;
+        const label: PropTypes.Requireable<string>;
+        const formProps: PropTypes.Requireable<object>;
+    }
+}
+import PropTypes from 'prop-types';

package/dist/components/react-hook-form/booleans/checkbox-input.js

@@ -0,0 +1,24 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import PropTypes from "prop-types";
+import BooleanInput from "./boolean-input.js";
+import { Checkbox } from "@mui/material";
+const CheckboxInput = ({ name, label, formProps }) => {
+  return /* @__PURE__ */ jsx(
+    BooleanInput,
+    {
+      name,
+      label,
+      formProps,
+      Input: Checkbox
+    }
+  );
+};
+CheckboxInput.propTypes = {
+  name: PropTypes.string.isRequired,
+  label: PropTypes.string,
+  formProps: PropTypes.object
+};
+export {
+  CheckboxInput as default
+};

package/dist/components/react-hook-form/booleans/switch-input.d.ts

@@ -0,0 +1,14 @@
+export default SwitchInput;
+declare function SwitchInput({ name, label, formProps }: {
+    name: any;
+    label: any;
+    formProps: any;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace SwitchInput {
+    namespace propTypes {
+        const name: PropTypes.Validator<string>;
+        const label: PropTypes.Requireable<string>;
+        const formProps: PropTypes.Requireable<object>;
+    }
+}
+import PropTypes from 'prop-types';

package/dist/components/react-hook-form/booleans/switch-input.js

@@ -0,0 +1,24 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import PropTypes from "prop-types";
+import BooleanInput from "./boolean-input.js";
+import { Switch } from "@mui/material";
+const SwitchInput = ({ name, label, formProps }) => {
+  return /* @__PURE__ */ jsx(
+    BooleanInput,
+    {
+      name,
+      label,
+      formProps,
+      Input: Switch
+    }
+  );
+};
+SwitchInput.propTypes = {
+  name: PropTypes.string.isRequired,
+  label: PropTypes.string,
+  formProps: PropTypes.object
+};
+export {
+  SwitchInput as default
+};

package/dist/components/react-hook-form/directory-items-input.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2023, 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/.
+ */
+/// <reference types="node" />
+import { FunctionComponent } from 'react';
+import { UUID } from 'crypto';
+export declare const NAME = "name";
+interface DirectoryItemsInputProps {
+    label: string | undefined;
+    name: string;
+    elementType: string;
+    equipmentTypes?: string[];
+    itemFilter?: any;
+    titleId?: string;
+    hideErrorMessage?: boolean;
+    onRowChanged?: (a: boolean) => void;
+    onChange?: (e: any) => void;
+    disable?: boolean;
+    fetchDirectoryContent: (directoryUuid: UUID, elementTypes: string[]) => Promise<any>;
+    fetchRootFolders: (types: string[]) => Promise<any>;
+    fetchElementsInfos: (ids: UUID[], elementTypes: string[]) => Promise<any>;
+    labelRequiredFromContext?: boolean;
+}
+declare const DirectoryItemsInput: FunctionComponent<DirectoryItemsInputProps>;
+export default DirectoryItemsInput;