@centreon/ui 23.10.18 → 23.10.20-MON-18490-widgets.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centreon/ui",
-  "version": "23.10.18",
+  "version": "23.10.20-MON-18490-widgets.0",
   "description": "Centreon UI Components",
   "scripts": {
     "eslint": "eslint ./src --ext .js,.jsx,.ts,.tsx --max-warnings 0",
@@ -89,7 +89,9 @@
     "lexical": "0.8.0",
     "notistack": "^2.0.8",
     "react-transition-group": "^4.4.5",
-    "ulog": "^2.0.0-beta.19"
+    "ulog": "^2.0.0-beta.19",
+    "react-grid-layout": "^1.3.4",
+    "react-resizable": "^3.0.5"
   },
   "peerDependencies": {
     "@centreon/ui-context": "file:../ui-context",
@@ -108,6 +110,7 @@
     "ramda": "0.x",
     "react-i18next": "12.x",
     "react-router-dom": "6.x",
+    "react-scale-text": "1.x",
     "resize-observer-polyfill": "1.x",
     "ts.data.json": "2.x",
     "tss-react": "4.x"

package/src/Dashboard/Dashboard.styles.ts

@@ -0,0 +1,83 @@
+import { makeStyles } from 'tss-react/mui';
+
+import { alpha } from '@mui/material';
+
+export const useDashboardLayoutStyles = makeStyles()((theme) => ({
+  container: {
+    '& .react-grid-item': {
+      borderRadius: theme.shape.borderRadius,
+      transition: theme.transitions.create('all', {
+        delay: 0,
+        duration: 100,
+        easing: theme.transitions.easing.easeOut
+      })
+    },
+    '& .react-grid-item.react-draggable-dragging': {
+      boxShadow: theme.shadows[3]
+    },
+    '& .react-grid-item.react-grid-placeholder': {
+      backgroundColor: alpha(theme.palette.primary.main, 0.7)
+    },
+    '& .react-grid-item.resizing': {
+      boxShadow: theme.shadows[3]
+    },
+    '& .react-resizable-handle': {
+      backgroundColor: theme.palette.action.focus,
+      backgroundImage: 'none',
+      borderRadius: theme.shape.borderRadius,
+      display: 'block',
+      opacity: 0,
+      position: 'absolute'
+    },
+    '& .react-resizable-handle.react-resizable-handle-e': {
+      cursor: 'ew-resize',
+      height: `calc(100% - ${theme.spacing(3)})`,
+      marginTop: 0,
+      right: 0,
+      top: 0,
+      transform: 'rotate(0deg)',
+      width: theme.spacing(1)
+    },
+    '& .react-resizable-handle.react-resizable-handle-s': {
+      bottom: 0,
+      cursor: 'ns-resize',
+      height: theme.spacing(1),
+      left: 0,
+      marginLeft: 0,
+      transform: 'rotate(0deg)',
+      width: `calc(100% - ${theme.spacing(3)})`
+    },
+    '& .react-resizable-handle.react-resizable-handle-se': {
+      bottom: 0,
+      cursor: 'nwse-resize',
+      height: theme.spacing(2),
+      right: 0,
+      transform: 'rotate(0deg)',
+      width: theme.spacing(2)
+    },
+    '& .react-resizable-handle::after': {
+      content: 'none'
+    },
+    '& .react-resizable-handle:hover': {
+      opacity: 1
+    }
+  }
+}));
+
+export const useDashboardItemStyles = makeStyles()((theme) => ({
+  widgetContainer: {
+    height: '100%',
+    width: '100%'
+  },
+  widgetContent: {
+    height: '100%',
+    padding: theme.spacing(1, 2)
+  },
+  widgetHeader: {
+    '&:hover': {
+      backgroundColor: theme.palette.action.hover
+    },
+    cursor: 'move',
+    padding: theme.spacing(0.5, 2)
+  }
+}));

package/src/Dashboard/DashboardLayout.stories.tsx

@@ -0,0 +1,104 @@
+import { ComponentMeta } from '@storybook/react';
+import { Layout } from 'react-grid-layout';
+
+import { Typography } from '@mui/material';
+
+import FluidTypography from '../Typography/FluidTypography';
+
+import { DashboardLayout } from '.';
+
+interface CustomLayout extends Layout {
+  content: string;
+  shouldUseFluidTypography: boolean;
+}
+
+const dashboardLayout: Array<CustomLayout> = [
+  {
+    content: 'Hello world',
+    h: 4,
+    i: 'a',
+    shouldUseFluidTypography: false,
+    w: 6,
+    x: 0,
+    y: 0
+  },
+  {
+    content: 'This is a panel',
+    h: 3,
+    i: 'b',
+    minW: 2,
+    shouldUseFluidTypography: false,
+    w: 7,
+    x: 1,
+    y: 7
+  },
+  {
+    content: 'And the last panel with fluid typography',
+    h: 7,
+    i: 'c',
+    shouldUseFluidTypography: true,
+    w: 6,
+    x: 6,
+    y: 6
+  }
+];
+
+const generateLayout = (maxElements: number): Array<CustomLayout> => {
+  return Array(maxElements)
+    .fill(0)
+    .map((_, i): CustomLayout => {
+      return {
+        content: `${i}`,
+        h: 3,
+        i: i.toString(),
+        shouldUseFluidTypography: false,
+        w: 3,
+        x: (i * 3) % 12,
+        y: Math.floor(i / 12)
+      };
+    });
+};
+
+interface DashboardTemplateProps {
+  header?: JSX.Element;
+  layout?: Array<CustomLayout>;
+}
+
+const Header = (): JSX.Element => (
+  <Typography variant="body2">The title</Typography>
+);
+
+const DashboardTemplate = ({
+  header,
+  layout = dashboardLayout
+}: DashboardTemplateProps): JSX.Element => (
+  <DashboardLayout.Layout<CustomLayout> layout={layout}>
+    {layout.map(({ i, content, shouldUseFluidTypography }) => (
+      <DashboardLayout.Item header={header} key={i}>
+        {shouldUseFluidTypography ? (
+          <FluidTypography text={content} />
+        ) : (
+          <Typography>{content}</Typography>
+        )}
+      </DashboardLayout.Item>
+    ))}
+  </DashboardLayout.Layout>
+);
+
+export default {
+  argTypes: {},
+  component: DashboardTemplate,
+  title: 'Dashboard'
+} as ComponentMeta<typeof DashboardTemplate>;
+
+export const normal = DashboardTemplate.bind({});
+
+export const withManyPanels = DashboardTemplate.bind({});
+withManyPanels.args = {
+  layout: generateLayout(1000)
+};
+
+export const withItemHeader = DashboardTemplate.bind({});
+withItemHeader.args = {
+  header: <Header />
+};

package/src/Dashboard/Grid.tsx

@@ -0,0 +1,70 @@
+import { FC, useMemo } from 'react';
+
+import { Grid as VisxGrid } from '@visx/visx';
+import { scaleLinear } from '@visx/scale';
+
+import { useTheme } from '@mui/material';
+
+import useMemoComponent from '../utils/useMemoComponent';
+
+import { maxColumns, rowHeight } from './utils';
+
+interface Props {
+  columns: number;
+  height: number;
+  width: number;
+}
+
+const Grid: FC<Props> = ({ width, height, columns }) => {
+  const theme = useTheme();
+
+  const xScale = useMemo(
+    () =>
+      scaleLinear({
+        domain: [0, maxColumns],
+        range: [0, width]
+      }),
+    [width]
+  );
+
+  const numberOfRows = Math.floor(height / (rowHeight + 16));
+
+  const yScale = useMemo(
+    () =>
+      scaleLinear({
+        domain: [0, numberOfRows],
+        range: [0, height]
+      }),
+    [height]
+  );
+
+  const tick = maxColumns / columns;
+
+  const xTickValues = Array(columns)
+    .fill(0)
+    .map((_, index) => index * tick);
+
+  return useMemoComponent({
+    Component: (
+      <svg style={{ height, position: 'absolute', width }}>
+        <VisxGrid.GridColumns
+          height={height}
+          scale={xScale}
+          stroke={theme.palette.divider}
+          tickValues={xTickValues}
+          width={width}
+        />
+        <VisxGrid.GridRows
+          height={height}
+          scale={yScale}
+          stroke={theme.palette.divider}
+          top={-10}
+          width={width}
+        />
+      </svg>
+    ),
+    memoProps: [height, width, columns]
+  });
+};
+
+export default Grid;

package/src/Dashboard/Item.tsx

@@ -0,0 +1,72 @@
+import { CSSProperties, ForwardedRef, MouseEvent, forwardRef } from 'react';
+
+import { isNil } from 'ramda';
+
+import { Card } from '@mui/material';
+
+import useMemoComponent from '../utils/useMemoComponent';
+
+import { useDashboardItemStyles } from './Dashboard.styles';
+
+interface DashboardItemProps {
+  children: JSX.Element;
+  className?: string;
+  header?: JSX.Element;
+  key: string;
+  onMouseDown?: (e: MouseEvent<HTMLDivElement>) => void;
+  onMouseUp?: (e: MouseEvent<HTMLDivElement>) => void;
+  onTouchEnd?: (e) => void;
+  style?: CSSProperties;
+}
+
+const Item = forwardRef(
+  (
+    {
+      children,
+      key,
+      style,
+      className,
+      header,
+      onMouseDown,
+      onMouseUp,
+      onTouchEnd
+    }: DashboardItemProps,
+    ref: ForwardedRef<HTMLDivElement>
+  ): JSX.Element => {
+    const { classes } = useDashboardItemStyles();
+
+    const hasHeader = !isNil(header);
+
+    const listeners = {
+      onMouseDown,
+      onMouseUp,
+      onTouchEnd
+    };
+
+    const cardContainerListeners = !hasHeader ? listeners : {};
+
+    return useMemoComponent({
+      Component: (
+        <div
+          className={className}
+          key={key}
+          ref={ref}
+          style={style}
+          {...cardContainerListeners}
+        >
+          <Card className={classes.widgetContainer}>
+            {header && (
+              <div {...listeners} className={classes.widgetHeader}>
+                {header}
+              </div>
+            )}
+            <div className={classes.widgetContent}>{children}</div>
+          </Card>
+        </div>
+      ),
+      memoProps: [key, style, className, header]
+    });
+  }
+);
+
+export default Item;

package/src/Dashboard/Layout.tsx

@@ -0,0 +1,74 @@
+import { useEffect, useState } from 'react';
+
+import { Responsive } from '@visx/visx';
+import GridLayout, { WidthProvider, Layout } from 'react-grid-layout';
+import 'react-grid-layout/css/styles.css';
+
+import { Responsive as ResponsiveHeight, useMemoComponent } from '..';
+
+import { useDashboardLayoutStyles } from './Dashboard.styles';
+import { getColumnsFromScreenSize, getLayout, rowHeight } from './utils';
+import Grid from './Grid';
+
+const ReactGridLayout = WidthProvider(GridLayout);
+
+interface DashboardLayoutProps<T> {
+  changeLayout?: (newLayout: Array<Layout>) => void;
+  children: Array<JSX.Element>;
+  displayGrid?: boolean;
+  layout: Array<T>;
+}
+
+const Layout = <T extends Layout>({
+  children,
+  changeLayout,
+  displayGrid,
+  layout
+}: DashboardLayoutProps<T>): JSX.Element => {
+  const { classes } = useDashboardLayoutStyles();
+
+  const [columns, setColumns] = useState(getColumnsFromScreenSize());
+
+  const resize = (): void => {
+    setColumns(getColumnsFromScreenSize());
+  };
+
+  useEffect(() => {
+    window.addEventListener('resize', resize);
+
+    return (): void => {
+      window.removeEventListener('resize', resize);
+    };
+  }, []);
+
+  return useMemoComponent({
+    Component: (
+      <ResponsiveHeight>
+        <Responsive.ParentSize>
+          {({ width, height }): JSX.Element => (
+            <div className={classes.container}>
+              {displayGrid && (
+                <Grid columns={columns} height={height} width={width} />
+              )}
+              <ReactGridLayout
+                cols={columns}
+                containerPadding={[4, 0]}
+                layout={getLayout(layout)}
+                margin={[20, 20]}
+                resizeHandles={['s', 'e', 'se']}
+                rowHeight={rowHeight}
+                width={width}
+                onLayoutChange={changeLayout}
+              >
+                {children}
+              </ReactGridLayout>
+            </div>
+          )}
+        </Responsive.ParentSize>
+      </ResponsiveHeight>
+    ),
+    memoProps: [columns, layout, displayGrid]
+  });
+};
+
+export default Layout;

package/src/Dashboard/index.tsx

@@ -0,0 +1,9 @@
+import Layout from './Layout';
+import Item from './Item';
+
+export * from './utils';
+
+export const DashboardLayout = {
+  Item,
+  Layout
+};

package/src/Dashboard/utils.ts

@@ -0,0 +1,28 @@
+import { lt } from 'ramda';
+import { Layout } from 'react-grid-layout';
+
+export const maxColumns = 12;
+const minColumns = 1;
+const breakpoint = 768;
+
+export const rowHeight = 64;
+
+export const getIsSmallScreenSize = (): boolean =>
+  lt(window.innerWidth, breakpoint);
+
+export const getColumnsFromScreenSize = (): number =>
+  getIsSmallScreenSize() ? minColumns : maxColumns;
+
+export const getLayout = <T extends Layout>(layout: Array<T>): Array<T> => {
+  const isSmallScreenSize = getIsSmallScreenSize();
+  if (!isSmallScreenSize) {
+    return layout;
+  }
+
+  return layout
+    .sort((a, b) => a.x + a.y - (b.x + b.y))
+    .map((widget) => ({
+      ...widget,
+      w: 1
+    }));
+};

package/src/InputField/Select/Autocomplete/index.stories.tsx

@@ -85,7 +85,7 @@ const AutoSizeAutocompleteField = ({
   endAdornment,
   customPadding
 }: AutoSizeAutocompleteFieldProps): JSX.Element => {
-  const [value, setValue] = React.useState(autoSizeOptions[1]);
+  const [value, setValue] = React.useState(null);
 
   const change = (_, newValue): void => {
     setValue(newValue);
@@ -108,12 +108,3 @@ const AutoSizeAutocompleteField = ({
 export const autoSize = (): JSX.Element => {
   return <AutoSizeAutocompleteField />;
 };
-
-export const autoSizeWithCustomPadding = (): JSX.Element => {
-  return (
-    <AutoSizeAutocompleteField
-      customPadding={5}
-      endAdornment={<EndAdornment />}
-    />
-  );
-};

package/src/Typography/FluidTypography/index.stories.tsx

@@ -0,0 +1,63 @@
+import { ComponentMeta } from '@storybook/react';
+
+import { Box } from '@mui/material';
+
+import FluidTypography, { FluidTypographyProps } from '.';
+
+interface Props extends FluidTypographyProps {
+  height?: string | number;
+  width?: string | number;
+}
+
+const FluidTypographyTemplate = ({
+  width = '900px',
+  height = '700px',
+  text,
+  variant
+}: Props): JSX.Element => {
+  return (
+    <Box sx={{ height, width }}>
+      <FluidTypography text={text} variant={variant} />
+    </Box>
+  );
+};
+
+export default {
+  argTypes: {
+    height: { control: 'text' },
+    text: { control: 'text' },
+    variant: { control: 'text' },
+    width: { control: 'text' }
+  },
+  component: FluidTypographyTemplate,
+  title: 'Fluid Typography'
+} as ComponentMeta<typeof FluidTypographyTemplate>;
+
+export const basic = FluidTypographyTemplate.bind({});
+basic.args = {
+  text: 'Hello world'
+};
+
+export const with200pxWidth = FluidTypographyTemplate.bind({});
+with200pxWidth.args = {
+  height: '200px',
+  text: 'Hello world',
+  width: '200px'
+};
+
+export const with20pxHeight = FluidTypographyTemplate.bind({});
+with20pxHeight.args = {
+  height: '20px',
+  text: 'Hello world'
+};
+
+export const withLongText = FluidTypographyTemplate.bind({});
+withLongText.args = {
+  text: 'This is a very long text becaaaaaaause it has a lot to sayyyyy !!!!!!!!'
+};
+
+export const withHeading5Variant = FluidTypographyTemplate.bind({});
+withHeading5Variant.args = {
+  text: 'Hello world',
+  variant: 'h5'
+};

package/src/Typography/FluidTypography/index.tsx

@@ -0,0 +1,51 @@
+import { useRef } from 'react';
+
+import { Typography, TypographyProps } from '@mui/material';
+
+import useFluidResizeObserver from './useFluidResizeObserver';
+
+type CustomTypographyProps = Pick<TypographyProps, 'variant'>;
+export interface FluidTypographyProps extends CustomTypographyProps {
+  className?: string;
+  text: string;
+}
+
+const FluidTypography = ({
+  text,
+  variant = 'body1',
+  className
+}: FluidTypographyProps): JSX.Element => {
+  const containerRef = useRef<HTMLElement>();
+  const parentRef = useRef<HTMLElement>();
+
+  const size = useFluidResizeObserver({ ref: containerRef });
+  const parentSize = useFluidResizeObserver({ isParent: true, ref: parentRef });
+
+  return (
+    <div
+      ref={parentRef}
+      style={{
+        height: `${parentSize.height}px`,
+        width: `100%`
+      }}
+    >
+      <div ref={containerRef} style={{ height: '100%', width: '100%' }}>
+        <Typography
+          className={className}
+          sx={{
+            fontSize: `clamp(10px, min(${Math.floor(
+              size.width / 6
+            )}px, ${Math.floor(size.height / 6)}px), min(${size.width}px, ${
+              size.height
+            }px))`
+          }}
+          variant={variant}
+        >
+          {text}
+        </Typography>
+      </div>
+    </div>
+  );
+};
+
+export default FluidTypography;

package/src/Typography/FluidTypography/useFluidResizeObserver.ts

@@ -0,0 +1,56 @@
+import {
+  MutableRefObject,
+  useCallback,
+  useEffect,
+  useRef,
+  useState
+} from 'react';
+
+interface Size {
+  height: number;
+  width: number;
+}
+
+interface UseFluidResizeObserver {
+  isParent?: boolean;
+  ref: MutableRefObject<HTMLElement | undefined>;
+}
+
+const useFluidResizeObserver = ({
+  ref,
+  isParent
+}: UseFluidResizeObserver): Size => {
+  const [size, setSize] = useState<Size>({ height: 0, width: 0 });
+
+  const observer = useRef<ResizeObserver | null>(null);
+
+  const resizeObserver = useCallback(
+    (element) => {
+      if (observer.current) {
+        observer.current.disconnect();
+      }
+
+      observer.current = new ResizeObserver(
+        ([entry]: Array<ResizeObserverEntry>) => {
+          setSize({
+            height: entry.target?.getBoundingClientRect().height || 0,
+            width: entry.target?.getBoundingClientRect().width || 0
+          });
+        }
+      );
+
+      if (element && observer.current) {
+        observer.current.observe(element);
+      }
+    },
+    [ref.current]
+  );
+
+  useEffect(() => {
+    resizeObserver(isParent ? ref.current?.parentElement : ref.current);
+  }, [ref.current]);
+
+  return size;
+};
+
+export default useFluidResizeObserver;

package/src/Typography/{index.stories.tsx → Typography.stories.tsx}

@@ -1,16 +1,16 @@
 import { ComponentMeta, ComponentStory } from '@storybook/react';
 
-import TypographtStory from '.';
+import TypographyStory from './story.utils';
 
 export default {
   argTypes: {},
-  component: TypographtStory,
+  component: TypographyStory,
   title: 'Typography'
-} as ComponentMeta<typeof TypographtStory>;
+} as ComponentMeta<typeof TypographyStory>;
 
-const TemplateTypographtStory: ComponentStory<typeof TypographtStory> = (
+const TemplateTypographtStory: ComponentStory<typeof TypographyStory> = (
   args
-) => <TypographtStory {...args} />;
+) => <TypographyStory {...args} />;
 
 export const typography = (): JSX.Element => (
   <TemplateTypographtStory text="Hello world" />

package/src/index.ts

@@ -155,3 +155,6 @@ export { default as ActionsList } from './ActionsList';
 export { getStatusColors, SeverityCode } from './utils/statuses';
 
 export type { ResponseError, CatchErrorProps } from './api/customFetch';
+
+export { default as FluidTypography } from './Typography/FluidTypography';
+export * from './Dashboard';