@centreon/ui 24.4.21 → 24.4.23

package/src/utils/docsURL.ts

@@ -0,0 +1,31 @@
+interface OnPremDocsURL {
+  majorVersion: string;
+  minorVersion: string;
+}
+
+interface DocsURL {
+  isCloudPlatform: boolean;
+  majorVersion: string;
+  minorVersion: string;
+}
+
+export const getOnPremDocsURL = ({
+  majorVersion,
+  minorVersion
+}: OnPremDocsURL): string => {
+  return `https://docs.centreon.com/docs/${majorVersion}.${minorVersion}/alerts-notifications/resources-status/#search-bar`;
+};
+export const cloudDocsURL =
+  'https://docs.centreon.com/cloud/alerts-notifications/resources-status/#search-bar';
+
+export const getDocsURL = ({
+  isCloudPlatform,
+  majorVersion,
+  minorVersion
+}: DocsURL): string => {
+  if (isCloudPlatform) {
+    return cloudDocsURL;
+  }
+
+  return getOnPremDocsURL({ majorVersion, minorVersion });
+};

package/src/utils/getNormalizedId.ts

@@ -1,5 +1,3 @@
-const getNormalizedId = (idToNormalized: string): string => {
+export const getNormalizedId = (idToNormalized: string): string => {
   return idToNormalized?.replace(/[^A-Z0-9]+/gi, '');
 };
-
-export default getNormalizedId;

package/src/utils/index.ts

@@ -0,0 +1,22 @@
+export * from './useLocaleDateTimeFormat';
+export * from './getNormalizedId';
+export * from './statuses';
+export * from './typedMemo';
+export * from './useCopyToClipboard';
+export * from './useDateTimePickerAdapter';
+export * from './useDebounce';
+export * from './useDeepCallback';
+export * from './useDeepMemo';
+export * from './useIntersectionObserver';
+export * from './useKeyObserver';
+export * from './useLoadImage';
+export * from './useMemoComponent';
+export * from './useThemeMode';
+export * from './useViewportIntersection';
+export * from './panelSize';
+export * from './sanitizedHTML';
+export * from './docsURL';
+export * from './useInfiniteScrollListing';
+export * from './useLicenseExpirationWarning';
+export * from './useRefreshInterval';
+export * from './centreonBaseURL';

package/src/utils/panelSize.ts

@@ -0,0 +1,15 @@
+import { gt } from 'ramda';
+
+export enum PanelSize {
+  Small = 550,
+  Medium = 675,
+  Large = 800
+}
+
+interface PanelSizeParams {
+  currentSize: number;
+}
+
+export const togglePanelSize = ({ currentSize }: PanelSizeParams): number => {
+  return gt(currentSize, PanelSize.Medium) ? PanelSize.Small : PanelSize.Large;
+};

package/src/utils/sanitizedHTML.ts

@@ -0,0 +1,18 @@
+import sanitizeHtml, { IOptions } from 'sanitize-html';
+import ReactHtmlParser from 'react-html-parser';
+
+interface UseSanitizedHTMLProps {
+  initialContent: string;
+  sanitizeOptions?: IOptions;
+}
+
+const sanitizedHTML = ({
+  initialContent,
+  sanitizeOptions = {}
+}: UseSanitizedHTMLProps): JSX.Element => {
+  const sanitizedContent = sanitizeHtml(initialContent, sanitizeOptions);
+
+  return ReactHtmlParser(sanitizedContent);
+};
+
+export { sanitizedHTML };

package/src/utils/translatedLabel.ts

@@ -0,0 +1,2 @@
+export const labelLicenseWarning = (module, daysUntilExpiration): string =>
+  `The ${module} license will expire in ${daysUntilExpiration} days`;

package/src/utils/useCopyToClipboard.ts

@@ -10,7 +10,8 @@ interface Props {
   errorMessage: string;
   successMessage: string;
 }
-const useCopyToClipboard = ({
+
+export const useCopyToClipboard = ({
   successMessage,
   errorMessage
 }: Props): Result => {
@@ -53,5 +54,3 @@ const useCopyToClipboard = ({
 
   return { copy };
 };
-
-export default useCopyToClipboard;

package/src/utils/useDateTimePickerAdapter.ts

@@ -0,0 +1,309 @@
+/* eslint-disable class-methods-use-this */
+import { useCallback } from 'react';
+
+import dayjs from 'dayjs';
+import { useAtomValue } from 'jotai';
+import { equals, isNil, not } from 'ramda';
+
+import { AdapterDayjs } from '@mui/x-date-pickers/AdapterDayjs';
+
+import { useLocaleDateTimeFormat } from '@centreon/ui';
+import { userAtom } from '@centreon/ui-context';
+
+interface GetDestinationAndConfiguredTimezoneOffsetProps {
+  endTimezone?: string;
+  startTimezone?: string;
+}
+
+interface UseDateTimePickerAdapterProps {
+  Adapter;
+  desktopPickerMediaQuery: string;
+}
+
+enum DSTState {
+  SUMMER,
+  WINTER,
+  NODST
+}
+
+interface ToTimezonedDateProps {
+  date: Date;
+  timeZone?: string;
+}
+
+interface GetDSTStateProps {
+  date: dayjs.Dayjs;
+  timezoneToUse?: string;
+}
+
+export const useDateTimePickerAdapter = (): UseDateTimePickerAdapterProps => {
+  const { timezone, locale } = useAtomValue(userAtom);
+  const { format } = useLocaleDateTimeFormat();
+
+  const desktopPickerMediaQuery =
+    '@media (pointer: fine) or (min-width: 1024px)';
+
+  const toTimezonedDate = ({
+    date,
+    timeZone = undefined
+  }: ToTimezonedDateProps): Date => {
+    if (isNil(timeZone)) {
+      return new Date(date.toLocaleString('en-US'));
+    }
+
+    return new Date(date.toLocaleString('en-US', { timeZone }));
+  };
+
+  const getDestinationAndConfiguredTimezoneOffset = ({
+    startTimezone = undefined,
+    endTimezone = timezone
+  }: GetDestinationAndConfiguredTimezoneOffsetProps): number => {
+    const now = new Date();
+    const currentTimezoneDate = toTimezonedDate({
+      date: now,
+      timeZone: startTimezone
+    });
+    const destinationTimezoneDate = toTimezonedDate({
+      date: now,
+      timeZone: endTimezone
+    });
+
+    return Math.floor(
+      (currentTimezoneDate.getTime() - destinationTimezoneDate.getTime()) /
+        60 /
+        60 /
+        1000
+    );
+  };
+
+  const getDSTState = useCallback(
+    ({ date, timezoneToUse }: GetDSTStateProps): DSTState => {
+      const hasNoTimezone = isNil(timezoneToUse);
+      const currentYear = toTimezonedDate({
+        date: new Date(),
+        timeZone: timezoneToUse
+      }).getFullYear();
+
+      const january = hasNoTimezone
+        ? dayjs(new Date(currentYear, 0, 1)).utcOffset()
+        : dayjs(new Date(currentYear, 0, 1)).tz(timezoneToUse).utcOffset();
+      const july = hasNoTimezone
+        ? dayjs(new Date(currentYear, 6, 1)).utcOffset()
+        : dayjs(new Date(currentYear, 6, 1)).tz(timezoneToUse).utcOffset();
+
+      if (equals(january, july)) {
+        return DSTState.NODST;
+      }
+
+      return july === date.tz().utcOffset() ? DSTState.SUMMER : DSTState.WINTER;
+    },
+    [timezone]
+  );
+
+  const getDSTStateForCurrentTimezone = useCallback(
+    (date: dayjs.Dayjs): DSTState => {
+      return getDSTState({ date });
+    },
+    []
+  );
+
+  interface Chunk {
+    array: Array<unknown>;
+    size: number;
+  }
+  class Adapter extends AdapterDayjs {
+    public formatByString = (value, formatKey: string): string => {
+      return format({
+        date: value.tz(timezone).toDate(),
+        formatString: formatKey
+      });
+    };
+
+    public format = (date: dayjs.Dayjs, formatKey: string): string => {
+      return this.formatByString(
+        date.tz(timezone, true),
+        this.formats[formatKey]
+      );
+    };
+
+    public startOfWeek = (date: dayjs.Dayjs): dayjs.Dayjs => {
+      if (date.tz(timezone).isUTC()) {
+        return date.tz(timezone).startOf('week').utc();
+      }
+
+      return date.tz(timezone).startOf('week');
+    };
+
+    public setMinutes = (date: dayjs.Dayjs, count: number): dayjs.Dayjs => {
+      return date.minute(count);
+    };
+
+    public setHours = (date: dayjs.Dayjs, count: number): dayjs.Dayjs => {
+      return date.hour(count);
+    };
+
+    public isSameDay = (date: dayjs.Dayjs, comparing: dayjs.Dayjs): boolean => {
+      const isSameYearAndMonth = this.isSameYear(date, comparing)
+        ? this.isSameMonth(date, comparing)
+        : false;
+
+      return (
+        isSameYearAndMonth &&
+        date.tz(timezone).isSame(comparing.tz(timezone), 'day')
+      );
+    };
+
+    public startOfDay = (date: dayjs.Dayjs): dayjs.Dayjs => {
+      return date.tz(timezone).startOf('day') as dayjs.Dayjs;
+    };
+
+    public endOfDay = (date: dayjs.Dayjs): dayjs.Dayjs => {
+      return date.tz(timezone).endOf('day') as dayjs.Dayjs;
+    };
+
+    public startOfMonth = (date: dayjs.Dayjs): dayjs.Dayjs => {
+      if (date.tz(timezone).isUTC()) {
+        return date.tz(timezone).utc();
+      }
+
+      return date.tz(timezone);
+    };
+
+    public endOfMonth = (date: dayjs.Dayjs): dayjs.Dayjs => {
+      return date.tz(timezone).endOf('month') as dayjs.Dayjs;
+    };
+
+    public isSameMonth = (
+      date: dayjs.Dayjs,
+      comparing: dayjs.Dayjs
+    ): boolean => {
+      return date.tz(timezone).isSame(comparing.tz(timezone), 'month');
+    };
+
+    public getMonth = (date: dayjs.Dayjs): number => {
+      return date.tz(timezone).month();
+    };
+
+    public isAfter = (date: dayjs.Dayjs, value: dayjs.Dayjs): boolean => {
+      return date.isAfter(value.endOf('month'));
+    };
+
+    public isBefore = (date: dayjs.Dayjs, value: dayjs.Dayjs): boolean => {
+      return date.isBefore(value.startOf('month'));
+    };
+
+    public getDaysInMonth = (date: dayjs.Dayjs): number => {
+      return date.tz(timezone).daysInMonth();
+    };
+
+    public getWeekdays = (): Array<string> => {
+      const start = dayjs().locale(locale).tz(timezone).startOf('week');
+
+      return [0, 1, 2, 3, 4, 5, 6].map((diff) =>
+        this.formatByString(start.add(diff, 'day'), 'dd')
+      );
+    };
+
+    public getChunkFromArray = ({ array, size }: Chunk): Array<unknown> => {
+      if (!array.length) {
+        return [];
+      }
+      const head = array.slice(0, size);
+      const tail = array.slice(size);
+
+      return [head, ...this.getChunkFromArray({ array: tail, size })];
+    };
+
+    public getWeekArray = (date: dayjs.Dayjs): Array<Array<dayjs.Dayjs>> => {
+      const isMorning = equals(dayjs().tz(timezone).format('a'), 'am');
+      const startOfWeek = date.tz(timezone).startOf('month').startOf('week');
+      const endOfWeek = date.tz(timezone).endOf('month').endOf('week');
+      const start = startOfWeek.startOf('day');
+      const end = endOfWeek.endOf('day');
+      const customStart = isMorning
+        ? startOfWeek.startOf('day')
+        : startOfWeek.startOf('day');
+      const customEnd = isMorning
+        ? endOfWeek.startOf('day')
+        : endOfWeek.startOf('day');
+      const currentStart = start.isUTC()
+        ? start.tz(timezone, true)
+        : customStart;
+      const currentEnd = end.isUTC() ? end.tz(timezone, true) : customEnd;
+      const numberOfDaysInCurrentMonth = currentEnd.diff(
+        currentStart,
+        'd',
+        true
+      );
+      const daysOfMonthWithTimezone = [
+        ...Array(Math.round(numberOfDaysInCurrentMonth)).keys()
+      ].reduce(
+        (acc, _, currentIndex) => {
+          if (acc[currentIndex].isUTC()) {
+            const newCurrent = acc[currentIndex]
+              .utc()
+              .add(1, 'day')
+              .tz(timezone, true);
+
+            return [...acc, newCurrent];
+          }
+          const newCurrent = acc[currentIndex].add(1, 'day');
+
+          return [...acc, newCurrent];
+        },
+        [currentStart]
+      );
+      const weeksArray = this.getChunkFromArray({
+        array: daysOfMonthWithTimezone,
+        size: 7
+      });
+
+      return weeksArray as Array<Array<dayjs.Dayjs>>;
+    };
+
+    public mergeDateAndTime = (
+      date: dayjs.Dayjs,
+      time: dayjs.Dayjs
+    ): dayjs.Dayjs => {
+      const dateWithTimezone = date.tz(timezone).startOf('day');
+      const timeWithTimezone = time.tz(timezone);
+      const dateDSTState = getDSTState({
+        date: dateWithTimezone,
+        timezoneToUse: timezone
+      });
+      const dateDSTStateWithCurrentTimezone =
+        getDSTStateForCurrentTimezone(date);
+
+      if (equals(dateDSTStateWithCurrentTimezone, DSTState.WINTER)) {
+        return dateWithTimezone
+          .add(
+            timeWithTimezone.hour() -
+              getDestinationAndConfiguredTimezoneOffset({
+                endTimezone: 'UTC',
+                startTimezone: dayjs.tz.guess()
+              }),
+            'hour'
+          )
+          .add(timeWithTimezone.minute(), 'minute')
+          .add(timeWithTimezone.second(), 'second');
+      }
+
+      if (not(equals(dateDSTState, DSTState.SUMMER))) {
+        return dateWithTimezone
+          .add(timeWithTimezone.hour(), 'hour')
+          .add(timeWithTimezone.minute(), 'minute')
+          .add(timeWithTimezone.second(), 'second');
+      }
+
+      return dateWithTimezone
+        .hour(timeWithTimezone.hour())
+        .minute(timeWithTimezone.minute())
+        .second(timeWithTimezone.second());
+    };
+  }
+
+  return {
+    Adapter,
+    desktopPickerMediaQuery
+  };
+};

package/src/utils/useDebounce.ts

@@ -1,4 +1,4 @@
-import { useRef, useCallback } from 'react';
+import { useRef, useCallback, useEffect } from 'react';
 
 interface Props {
   functionToDebounce: (...args) => void;
@@ -6,12 +6,17 @@ interface Props {
   wait: number;
 }
 
-const useDebounce = ({
+export const useDebounce = ({
   functionToDebounce,
   wait,
   memoProps = []
 }: Props): ((...args) => void) => {
   const timeoutRef = useRef<number | null>(null);
+  const ref = useRef();
+
+  useEffect(() => {
+    ref.current = functionToDebounce;
+  }, [functionToDebounce]);
 
   return useCallback((...args): void => {
     if (timeoutRef.current) {
@@ -19,9 +24,7 @@ const useDebounce = ({
     }
 
     timeoutRef.current = setTimeout(() => {
-      functionToDebounce(...args);
+      ref.current?.(...args);
     }, wait);
   }, memoProps);
 };
-
-export default useDebounce;

package/src/utils/useDeepCallback.ts

@@ -7,11 +7,9 @@ interface UseDeepCallback<TParameters, TReturn, TMemoProps> {
   deps: Array<TMemoProps>;
 }
 
-const useDeepCallback = <TParameters, TReturn, TMemoProps>({
+export const useDeepCallback = <TParameters, TReturn, TMemoProps>({
   deps,
   callback
 }: UseDeepCallback<TParameters, TReturn, TMemoProps>): ((
   props: TParameters
 ) => TReturn) => useCallback((props) => callback(props), useDeepCompare(deps));
-
-export default useDeepCallback;

package/src/utils/useDeepMemo.ts

@@ -7,10 +7,8 @@ interface UseDeepMemo<TVariable, TMemoProps> {
   variable: TVariable;
 }
 
-const useDeepMemo = <TVariable, TMemoProps>({
+export const useDeepMemo = <TVariable, TMemoProps>({
   deps,
   variable
 }: UseDeepMemo<TVariable, TMemoProps>): TVariable =>
   useMemo(() => variable, useDeepCompare(deps));
-
-export default useDeepMemo;

package/src/utils/useInfiniteScrollListing.ts

@@ -0,0 +1,121 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+import { equals, gte, isNil, reduce } from 'ramda';
+import { PrimitiveAtom, useAtom } from 'jotai';
+import { JsonDecoder } from 'ts.data.json';
+
+import {
+  QueryParameter,
+  buildListingEndpoint,
+  useFetchQuery,
+  useIntersectionObserver
+} from '@centreon/ui';
+
+import type { Listing } from '../api/models';
+import { Parameters } from '../api/buildListingEndpoint/models';
+
+interface UseInfiniteScrollListing<T> {
+  elementRef: (node) => void;
+  elements: Array<T>;
+  isLoading: boolean;
+  total?: number;
+}
+
+interface UseInfiniteScrollListingProps<T> {
+  customQueryParameters?: Array<QueryParameter>;
+  decoder?: JsonDecoder.Decoder<Listing<T>>;
+  endpoint: string;
+  limit?: number;
+  pageAtom: PrimitiveAtom<number>;
+  parameters?: Parameters;
+  queryKeyName: string;
+  suspense?: boolean;
+}
+
+export const useInfiniteScrollListing = <T>({
+  queryKeyName,
+  endpoint,
+  decoder,
+  pageAtom,
+  suspense = true,
+  parameters,
+  customQueryParameters,
+  limit = 100
+}: UseInfiniteScrollListingProps<T>): UseInfiniteScrollListing<T> => {
+  const [maxPage, setMaxPage] = useState(1);
+
+  const elements = useRef<Array<T> | undefined>(undefined);
+
+  const [page, setPage] = useAtom(pageAtom);
+
+  const { data, isLoading, prefetchNextPage, fetchStatus } = useFetchQuery<
+    Listing<T>
+  >({
+    decoder,
+    getEndpoint: (params) =>
+      buildListingEndpoint({
+        baseEndpoint: endpoint,
+        customQueryParameters,
+        parameters: { limit, page: params?.page || page, ...parameters }
+      }),
+    getQueryKey: () => [queryKeyName, page],
+    isPaginated: true,
+    queryOptions: {
+      refetchOnMount: false,
+      refetchOnWindowFocus: false,
+      suspense: suspense && equals(page, 1)
+    }
+  });
+
+  const elementRef = useIntersectionObserver({
+    action: () => {
+      setPage((currentPage) => currentPage + 1);
+    },
+    loading: !equals(fetchStatus, 'idle'),
+    maxPage,
+    page
+  });
+
+  elements.current = useMemo(() => {
+    if (isNil(data) || !equals(fetchStatus, 'idle')) {
+      return elements.current;
+    }
+
+    return reduce<T, Array<T>>(
+      (acc, element) => [...acc, element],
+      equals(page, 1) ? [] : elements.current || [],
+      data.result
+    );
+  }, [page, data, fetchStatus]);
+
+  useEffect(() => {
+    if (isNil(data)) {
+      return;
+    }
+
+    const total = data.meta.total || 1;
+    const newMaxPage = Math.ceil(total / limit);
+
+    setMaxPage(newMaxPage);
+
+    if (gte(page, newMaxPage)) {
+      return;
+    }
+
+    prefetchNextPage({
+      getPrefetchQueryKey: (newPage) => [`dashboards`, newPage],
+      page
+    });
+  }, [data]);
+
+  useEffect(() => {
+    return () => setPage(1);
+  }, []);
+
+  return {
+    elementRef,
+    elements: elements.current || [],
+    isLoading,
+    total: data?.meta.total
+  };
+};

package/src/utils/useIntersectionObserver.ts

@@ -2,16 +2,18 @@ import { useRef, useCallback } from 'react';
 
 interface HookParam {
   action: () => void;
+  intersectionObserverOptions?: IntersectionObserverInit;
   loading: boolean;
   maxPage: number;
   page: number;
 }
 
-const useIntersectionObserver = ({
+export const useIntersectionObserver = ({
   maxPage,
   page,
   loading,
-  action
+  action,
+  intersectionObserverOptions
 }: HookParam): ((node) => void) => {
   const observer = useRef<IntersectionObserver | null>(null);
   const lastElementRef = useCallback(
@@ -30,7 +32,7 @@ const useIntersectionObserver = ({
         if (entry.isIntersecting && page < maxPage) {
           action();
         }
-      });
+      }, intersectionObserverOptions);
 
       if (node && observer.current) {
         observer.current.observe(node);
@@ -41,5 +43,3 @@ const useIntersectionObserver = ({
 
   return lastElementRef;
 };
-
-export default useIntersectionObserver;

package/src/utils/useKeyObserver.tsx

@@ -4,7 +4,7 @@ interface UseKeyObserverProps {
   isShiftKeyDown: boolean;
 }
 
-const useKeyObserver = (): UseKeyObserverProps => {
+export const useKeyObserver = (): UseKeyObserverProps => {
   const [isShiftKeyDown, setIsShiftKeyDown] = useState<boolean>(false);
 
   const pressShift = (): void => setIsShiftKeyDown(true);
@@ -34,5 +34,3 @@ const useKeyObserver = (): UseKeyObserverProps => {
     isShiftKeyDown
   };
 };
-
-export default useKeyObserver;