@applica-software-guru/react-admin 1.0.46 → 1.0.51

package/src/dev/useCliErrorCatcher.ts

@@ -0,0 +1,142 @@
+/* eslint-disable prefer-rest-params */
+/* eslint-disable no-console */
+import * as React from 'react';
+
+export type CatchResultProps = {
+  catch: boolean;
+  display: boolean;
+  log: boolean;
+  error?: string;
+};
+
+class CatchResult {
+  catch: boolean;
+  display: boolean;
+  log: boolean;
+  error?: string;
+
+  constructor({ catch: catchErr, display: displayErr, log: logErr, error }: CatchResultProps) {
+    this.catch = catchErr;
+    this.display = displayErr;
+    this.log = logErr;
+    this.error = error;
+  }
+
+  isCatched() {
+    return this.catch;
+  }
+
+  logError() {
+    return this.log;
+  }
+
+  displayError() {
+    return this.display;
+  }
+}
+
+export type CliErrorCatcherBodyBuilderProps = (error: string | any) => any;
+
+type CliErrorCatcherPutProps = {
+  apiUrl: string;
+  endpoint?: string;
+  message: string;
+  bodyBuilder: CliErrorCatcherBodyBuilderProps;
+};
+
+const putError = ({ apiUrl, endpoint, message, bodyBuilder }: CliErrorCatcherPutProps) =>
+  fetch(`${apiUrl}${endpoint}`, {
+    method: 'PUT',
+    headers: new Headers({
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    }),
+    body: JSON.stringify(bodyBuilder(message))
+  });
+
+export type UseCliErrorCatcherProps = {
+  /**
+   * Definisce l'URL del server API.
+   */
+  apiUrl: string;
+  /**
+   * Definisce se il catcher è abilitato.
+   */
+  enabled?: boolean;
+  /**
+   * Definisce l'endpoint del server API su cui inviare l'errore.
+   * Questo parametro viene aggiunto all'URL del server API (apiUrl) attraverso una semplice concatenazione.
+   *
+   * @example
+   * // Serve più per ricordarti come funziona quando lo utilizzerai attivamente dopo tanto tempo (ti conosco bene Roberto, dimenticherai tutto!).
+   * let apiUrl = 'http://localhost:3000';
+   * let endpoint = '/ui-errors/put';
+   * let url = apiUrl + endpoint;
+   * // url = 'http://localhost:3000/ui-errors/put'
+   */
+  endpoint?: string;
+  /**
+   * Definisce se l'applicazione chiamante è in caricamento.
+   * In tal caso il catcher non viene attivato.
+   */
+  loading?: boolean;
+  /**
+   * Definisce la funzione che determina se l'errore deve essere catturato.
+   *
+   * @param error
+   * @returns {CatchResult} Restituisce un oggetto di tipo CatchResult.
+   */
+  catcherFn?: (error: string | any) => CatchResult;
+  /**
+   * Definisce la funzione che costruisce il body da inviare al server API.
+   */
+  bodyBuilder?: CliErrorCatcherBodyBuilderProps;
+};
+
+const useCliErrorCatcher = ({
+  enabled = true,
+  apiUrl,
+  endpoint = '/ui-errors/put',
+  loading,
+  catcherFn = (error) => new CatchResult({ catch: error != undefined, display: false, log: false }),
+  bodyBuilder = (error) => ({ message: error })
+}: UseCliErrorCatcherProps) => {
+  React.useMemo(() => {
+    if (loading) {
+      return;
+    }
+    if (!enabled) {
+      return;
+    }
+
+    const consoleError = console.error;
+
+    console.error = function (error, ...args) {
+      if (!error || typeof error !== 'string') {
+        consoleError.apply(console, arguments as any);
+        return;
+      }
+      const message = error.replace(/%s/g, () => args.shift());
+      const catchResult = catcherFn(message);
+      if (!catchResult.isCatched()) {
+        consoleError.apply(console, arguments as any);
+        return;
+      }
+
+      if (catchResult.logError()) {
+        putError({ apiUrl, endpoint, message, bodyBuilder });
+      }
+
+      if (catchResult.displayError()) {
+        consoleError.apply(console, arguments as any);
+      } else {
+        // eslint-disable-next-line prefer-spread
+        console.debug.apply(console, arguments as any);
+      }
+    };
+  }, [apiUrl, loading, bodyBuilder, endpoint, catcherFn, enabled]);
+  return true;
+};
+export { CatchResult };
+
+export default useCliErrorCatcher;

package/src/i18n/{useI18nCatcher.jsx → useI18nCatcher.ts}

@@ -3,9 +3,33 @@ import * as React from 'react';
 
 import { useLocaleState } from 'react-admin';
 
-const queued = [];
+const queued: string[] = [];
 
-const putMessage = ({ apiUrl, endpoint, locale, message, bodyBuilder }) =>
+export type I18nCatcherBodyBuilderResultProps =
+  | {
+      lang: string;
+      code: string;
+      text: string;
+    }
+  | {
+      message: {
+        lang: string;
+        code: string;
+        text: string;
+      };
+    };
+
+export type I18nCatcherBodyBuilderProps = (lang: string, message: string) => I18nCatcherBodyBuilderResultProps;
+
+type PutMessageProps = {
+  apiUrl: string;
+  endpoint?: string;
+  locale: string;
+  message: string;
+  bodyBuilder: I18nCatcherBodyBuilderProps;
+};
+
+const putMessage = ({ apiUrl, endpoint, locale, message, bodyBuilder }: PutMessageProps): any =>
   message != null &&
   message !== 'undefined' &&
   message.indexOf('[') === -1 &&
@@ -18,22 +42,34 @@ const putMessage = ({ apiUrl, endpoint, locale, message, bodyBuilder }) =>
       Accept: 'application/json',
       'Content-Type': 'application/json'
     }),
-    body: JSON.stringify(bodyBuilder(locale, message))
+    body: JSON.stringify(bodyBuilder(locale, message) || {})
   });
 
+export type UseI18nCatcherProps = {
+  apiUrl: string;
+  enabled?: boolean;
+  endpoint?: string;
+  loading?: boolean;
+  bodyBuilder: I18nCatcherBodyBuilderProps;
+};
+
+/**
+ * Hook che consente di catturare ed inoltrare al server API le stringhe non tradotte.
+ *
+ * @param {UseI18nCatcherProps}
+ * @returns {boolean}
+ */
 const useI18nCatcher = ({
   apiUrl,
   enabled = true,
   endpoint = '/languages/put-message',
   loading,
-  bodyBuilder = (locale, message) => ({
-    code: locale,
-    message: {
-      code: message,
-      text: message
-    }
+  bodyBuilder = (lang, message) => ({
+    lang,
+    code: message,
+    text: message
   })
-}) => {
+}: UseI18nCatcherProps) => {
   const [locale] = useLocaleState();
   React.useMemo(() => {
     if (loading) {
@@ -62,7 +98,9 @@ const useI18nCatcher = ({
         return;
       }
 
-      consoleError.apply(console, arguments);
+      // eslint-disable-next-line prefer-rest-params
+      // eslint-disable-next-line prefer-rest-params
+      consoleError.apply(console, arguments as any);
     };
   }, [apiUrl, locale, loading, bodyBuilder, endpoint, enabled]);
   return true;

package/src/types.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+
+/**
+ * Definisce le proprietà di un elemento del menu.
+ */
+export type MenuItemProps = {
+  id: string;
+  /**
+   * Titolo da attribure all'elemento del menu.
+   * Il titolo deve essere una stringa localizzata: es. ra.menu.item.foo
+   */
+  title: string;
+  /**
+   * Icona da attribuire all'elemento del menu.
+   */
+  icon: React.ReactNode;
+  /**
+   * Tipo di elemento del menu.
+   * - item: elemento di menu normale
+   * - group: gruppo di elementi di menu
+   * - collapse: gruppo di elementi di menu con collapse
+   */
+  type: 'item' | 'group' | 'collapse';
+  /**
+   * URL da attribuire all'elemento del menu.
+   * Può puntare ad una risorsa o ad una pagina personalizzata purché la stessa sia stata registrata nell'appliazione.
+   *
+   * @example
+   * /entities/user
+   * /pages/foo
+   */
+  url: string;
+  /**
+   * Indica se l'elemento del menu è una risorsa.
+   */
+  resource: boolean;
+  /**
+   * Elenco dei ruoli che possono accedere all'elemento del menu.
+   * Se l'utente collegato non contiene almeno uno dei ruoli specificati l'elemento del menu non viene visualizzato.
+   *
+   * @example
+   * ["ROLE_ADMIN", "ROLE_USER"]
+   */
+  roles: string[];
+  /**
+   * Elenco dei figli dell'elemento del menu.
+   * Valido solo per i tipi "group" e "collapse".
+   */
+  children?: MenuItemProps[];
+};
+
+/**
+ * Indica come deve essere configurato il menu dell'applicazione.
+ */
+export type MenuProps = MenuItemProps[];

package/src/AdminContext.jsx

@@ -1,24 +0,0 @@
-import { CoreAdminContext } from 'react-admin';
-import PropTypes from 'prop-types';
-import { ScrollTop } from './components';
-import { ThemeCustomization } from './themes';
-
-const AdminContext = ({ children, theme, ...props }) => (
-  <CoreAdminContext {...props}>
-    <ThemeCustomization themeOverrides={theme}>
-      <ScrollTop>{children}</ScrollTop>
-    </ThemeCustomization>
-  </CoreAdminContext>
-);
-
-AdminContext.displayName = 'ApplicaAdminContext';
-AdminContext.defaultProps = {
-  ...CoreAdminContext.defaultProps
-};
-AdminContext.propTypes = {
-  ...CoreAdminContext.propTypes,
-  children: PropTypes.node.isRequired,
-  theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func])
-};
-
-export default AdminContext;

package/src/contexts/MenuConfigContext.jsx

@@ -1,93 +0,0 @@
-import MenuPropTypes from './MenuPropTypes';
-import PropTypes from 'prop-types';
-import { createContext } from 'react';
-import { useLocalStorage } from '../hooks';
-
-const initialState = {
-  openItem: ['dashboard'],
-  openComponent: 'buttons',
-  selectedID: null,
-  drawerOpen: false,
-  componentDrawerOpen: true,
-  menuDashboard: {},
-  error: null
-};
-
-const MenuConfigContext = createContext(initialState);
-
-const MenuConfigProvider = ({ menu: groups, children }) => {
-  const [menu, setMenu] = useLocalStorage('menu-config', { ...initialState });
-
-  const activeItem = (openItem) => {
-    setMenu((menu) => ({
-      ...menu,
-      openItem
-    }));
-  };
-
-  const activeID = (selectedID) => {
-    setMenu((menu) => ({
-      ...menu,
-      selectedID
-    }));
-  };
-
-  const activeComponent = (openComponent) => {
-    setMenu((menu) => ({
-      ...menu,
-      openComponent
-    }));
-  };
-
-  const openDrawer = (drawerOpen) => {
-    setMenu((menu) => ({
-      ...menu,
-      drawerOpen
-    }));
-  };
-
-  const openComponentDrawer = (componentDrawerOpen) => {
-    setMenu((menu) => ({
-      ...menu,
-      componentDrawerOpen
-    }));
-  };
-
-  const getMenuSuccess = (menuDashboard) => {
-    setMenu((menu) => ({
-      ...menu,
-      menuDashboard
-    }));
-  };
-
-  const hasError = (error) => {
-    setMenu((menu) => ({
-      ...menu,
-      error
-    }));
-  };
-  return (
-    <MenuConfigContext.Provider
-      value={{
-        ...menu,
-        groups,
-        activeItem,
-        activeComponent,
-        openDrawer,
-        openComponentDrawer,
-        activeID,
-        getMenuSuccess,
-        hasError
-      }}
-    >
-      {children}
-    </MenuConfigContext.Provider>
-  );
-};
-
-MenuConfigProvider.propTypes = {
-  children: PropTypes.node,
-  menu: PropTypes.arrayOf(MenuPropTypes)
-};
-
-export { MenuConfigContext, MenuConfigProvider };

package/src/dev/useCliErrorCatcher.jsx

@@ -1,86 +0,0 @@
-/* eslint-disable no-console */
-import * as React from 'react';
-
-class CatchResult {
-  constructor({ catch: catchErr, display: displayErr, log: logErr, error }) {
-    this.catch = catchErr;
-    this.display = displayErr;
-    this.log = logErr;
-    this.error = error;
-  }
-
-  isCatched() {
-    return this.catch;
-  }
-
-  logError() {
-    return this.log;
-  }
-
-  displayError() {
-    return this.display;
-  }
-}
-
-const putError = ({ apiUrl, endpoint, locale, message, bodyBuilder }) =>
-  fetch(`${apiUrl}${endpoint}`, {
-    method: 'PUT',
-    headers: new Headers({
-      Accept: 'application/json',
-      'Content-Type': 'application/json'
-    }),
-    body: JSON.stringify(bodyBuilder(locale, message))
-  });
-
-const useCliErrorCatcher = ({
-  enabled = true,
-  apiUrl,
-  endpoint = '/ui-errors/put',
-  loading,
-  catcherFn = (error) => new CatchResult({ catch: error != undefined, display: false, log: false }),
-  bodyBuilder = (locale, message) => ({
-    code: locale,
-    message: {
-      code: message,
-      text: message
-    }
-  })
-}) => {
-  React.useMemo(() => {
-    if (loading) {
-      return;
-    }
-    if (!enabled) {
-      return;
-    }
-
-    const consoleError = console.error;
-
-    console.error = function (error, ...args) {
-      if (!error || typeof error !== 'string') {
-        consoleError.apply(console, arguments);
-        return;
-      }
-      const message = error.replace(/%s/g, () => args.shift());
-      const catchResult = catcherFn(message);
-      if (!catchResult.isCatched()) {
-        consoleError.apply(console, arguments);
-        return;
-      }
-
-      if (catchResult.logError()) {
-        putError({ apiUrl, endpoint, message, bodyBuilder });
-      }
-
-      if (catchResult.displayError()) {
-        consoleError.apply(console, arguments);
-      } else {
-        console.debug.apply(console, arguments);
-      }
-    };
-  }, [apiUrl, loading, bodyBuilder, endpoint, catcherFn, enabled]);
-  return true;
-};
-export { CatchResult };
-
-export default useCliErrorCatcher;