@m4l/layouts 0.1.38 → 0.1.40

package/components/BaseModule/index.6309486a.js

@@ -1,27 +1,27 @@
-import { ModalProvider as s } from "@m4l/components";
-import { FlagsProvider as u, ModuleDictionaryProvider as c, ModuleSkeletonProvider as m, ModulePrivilegesProvider as a } from "@m4l/core";
-import { jsx as e } from "react/jsx-runtime";
-function h(r) {
+import { ModalProvider } from "@m4l/components";
+import { FlagsProvider, ModuleDictionaryProvider, ModuleSkeletonProvider, ModulePrivilegesProvider } from "@m4l/core";
+import { jsx } from "react/jsx-runtime";
+function BaseModule(props) {
   const {
-    children: o,
-    moduleId: i,
-    moduleNameField: l,
-    skeletonFlags: d,
-    privileges: n,
-    componentsDictionary: t
-  } = r;
-  return /* @__PURE__ */ e(u, {
-    children: /* @__PURE__ */ e(c, {
-      isAuth: !0,
-      moduleId: i,
-      moduleNameField: l,
-      componentsDictionary: t,
-      children: /* @__PURE__ */ e(m, {
-        flags: d,
-        children: /* @__PURE__ */ e(a, {
-          queryPrivileges: n,
-          children: /* @__PURE__ */ e(s, {
-            children: o
+    children,
+    moduleId,
+    moduleNameField,
+    skeletonFlags,
+    privileges,
+    componentsDictionary
+  } = props;
+  return /* @__PURE__ */ jsx(FlagsProvider, {
+    children: /* @__PURE__ */ jsx(ModuleDictionaryProvider, {
+      isAuth: true,
+      moduleId,
+      moduleNameField,
+      componentsDictionary,
+      children: /* @__PURE__ */ jsx(ModuleSkeletonProvider, {
+        flags: skeletonFlags,
+        children: /* @__PURE__ */ jsx(ModulePrivilegesProvider, {
+          queryPrivileges: privileges,
+          children: /* @__PURE__ */ jsx(ModalProvider, {
+            children
           })
         })
       })
@@ -29,5 +29,5 @@ function h(r) {
   });
 }
 export {
-  h as B
+  BaseModule as B
 };

package/components/BaseModule/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { BaseModuleProps } from './types';
-export declare function BaseModule(props: BaseModuleProps): JSX.Element;
+export declare function BaseModule(props: BaseModuleProps): import("react").JSX.Element;
 export default BaseModule;

package/components/MFHostApp/index.420c2626.js

@@ -1,61 +1,61 @@
-import { unstable_HistoryRouter as p } from "react-router-dom";
-import { EnvironmentProvider as v, HostToolsProvider as M, NetworkProvider as P, DomainCountryProvider as f } from "@m4l/core";
-import { LocalesProvider as b, HostThemeProvider as T, FormatterProvider as g } from "@m4l/graphics";
-import { WindowToolsMFProvider as E, DynamicMFParmsProvider as H } from "@m4l/components";
-import { B as _ } from "../BaseModule/index.6309486a.js";
-import { jsx as r } from "react/jsx-runtime";
-function L(t) {
+import { unstable_HistoryRouter } from "react-router-dom";
+import { EnvironmentProvider, HostToolsProvider, NetworkProvider, DomainCountryProvider } from "@m4l/core";
+import { LocalesProvider, HostThemeProvider, FormatterProvider } from "@m4l/graphics";
+import { WindowToolsMFProvider, DynamicMFParmsProvider } from "@m4l/components";
+import { B as BaseModule } from "../BaseModule/index.6309486a.js";
+import { jsx } from "react/jsx-runtime";
+function MFHostApp(props) {
   const {
-    children: n,
-    currentLocale: d,
-    hostTheme: m,
-    environment: s,
-    hostTools: e,
-    axiosOperation: c,
-    formatters: o,
-    moduleId: l,
-    moduleNameField: a,
-    skeletonFlags: u,
-    privileges: h,
-    componentsDictionary: y,
-    dynamicMFStore: i,
-    windowTools: F
-  } = t;
-  return /* @__PURE__ */ r(v, {
-    ...s,
-    children: /* @__PURE__ */ r(M, {
-      ...e,
-      children: /* @__PURE__ */ r(P, {
-        axiosOperation: c,
-        children: /* @__PURE__ */ r(b, {
-          isMicroFrontEnd: !0,
-          localeHost: d,
-          children: /* @__PURE__ */ r(T, {
-            isMicroFrontEnd: !0,
-            ...m,
-            children: /* @__PURE__ */ r(p, {
-              history: e.history,
-              children: /* @__PURE__ */ r(f, {
-                isMicroFrontEnd: !0,
-                id: i?.getState().dynamicMFParameters?.id || 1,
-                currency: o.currencyFormatter.code,
-                currency_decimal_digits: o.currencyFormatter.decimalDigits,
-                decimal_symbol: o.numberFormatter.decimalSymbol,
-                thousands_symbol: o.numberFormatter.thousandsSymbol,
-                children: /* @__PURE__ */ r(_, {
-                  moduleId: l,
-                  moduleNameField: a,
-                  componentsDictionary: y,
-                  skeletonFlags: u,
-                  privileges: h,
-                  children: /* @__PURE__ */ r(g, {
-                    isMicroFrontEnd: !0,
-                    ...o,
-                    children: /* @__PURE__ */ r(E, {
-                      ...F,
-                      children: /* @__PURE__ */ r(H, {
-                        store: i,
-                        children: n
+    children,
+    currentLocale,
+    hostTheme,
+    environment,
+    hostTools,
+    axiosOperation,
+    formatters,
+    moduleId,
+    moduleNameField,
+    skeletonFlags,
+    privileges,
+    componentsDictionary,
+    dynamicMFStore,
+    windowTools
+  } = props;
+  return /* @__PURE__ */ jsx(EnvironmentProvider, {
+    ...environment,
+    children: /* @__PURE__ */ jsx(HostToolsProvider, {
+      ...hostTools,
+      children: /* @__PURE__ */ jsx(NetworkProvider, {
+        axiosOperation,
+        children: /* @__PURE__ */ jsx(LocalesProvider, {
+          isMicroFrontEnd: true,
+          localeHost: currentLocale,
+          children: /* @__PURE__ */ jsx(HostThemeProvider, {
+            isMicroFrontEnd: true,
+            ...hostTheme,
+            children: /* @__PURE__ */ jsx(unstable_HistoryRouter, {
+              history: hostTools.history,
+              children: /* @__PURE__ */ jsx(DomainCountryProvider, {
+                isMicroFrontEnd: true,
+                id: dynamicMFStore?.getState().dynamicMFParameters?.id || 1,
+                currency: formatters.currencyFormatter.code,
+                currency_decimal_digits: formatters.currencyFormatter.decimalDigits,
+                decimal_symbol: formatters.numberFormatter.decimalSymbol,
+                thousands_symbol: formatters.numberFormatter.thousandsSymbol,
+                children: /* @__PURE__ */ jsx(BaseModule, {
+                  moduleId,
+                  moduleNameField,
+                  componentsDictionary,
+                  skeletonFlags,
+                  privileges,
+                  children: /* @__PURE__ */ jsx(FormatterProvider, {
+                    isMicroFrontEnd: true,
+                    ...formatters,
+                    children: /* @__PURE__ */ jsx(WindowToolsMFProvider, {
+                      ...windowTools,
+                      children: /* @__PURE__ */ jsx(DynamicMFParmsProvider, {
+                        store: dynamicMFStore,
+                        children
                       })
                     })
                   })
@@ -69,5 +69,5 @@ function L(t) {
   });
 }
 export {
-  L as M
+  MFHostApp as M
 };

package/components/MFHostApp/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { MFHostAppProps } from './types';
-export declare function MFHostApp(props: MFHostAppProps): JSX.Element;
+export declare function MFHostApp(props: MFHostAppProps): import("react").JSX.Element;
 export default MFHostApp;

package/components/MFIsolationApp/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { MFIsolationAppProps } from './types';
-export declare function MFIsolationApp(props: MFIsolationAppProps): JSX.Element;
+export declare function MFIsolationApp(props: MFIsolationAppProps): import("react").JSX.Element;
 export default MFIsolationApp;

package/components/MFIsolationApp/index.e36cf308.js

@@ -0,0 +1,175 @@
+import { useEffect, useMemo, useCallback } from "react";
+import { unstable_HistoryRouter } from "react-router-dom";
+import { ToastContainer, toast } from "react-toastify";
+import { HostThemeProvider, GlobalStyles, FormatterProvider, LocalesProvider, getLocaleFromNetwork } from "@m4l/graphics";
+import { A as AuthProvider } from "../../contexts/AuthContext/index.6f966215.js";
+import { DomainCountryProvider, EnvironmentProvider, HostToolsProvider, NetworkProvider, axiosOperation } from "@m4l/core";
+import { createBrowserHistory } from "history";
+import EventEmitter from "eventemitter3";
+import { format } from "date-fns";
+import { defaultThemeOptions, fnComponentsOverrides } from "@m4l/styles";
+import { u as useAuth } from "../../hooks/useAuth/index.cb6a3420.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import NProgress from "nprogress";
+import { B as BaseModule } from "../BaseModule/index.6309486a.js";
+import { AreasProvider } from "@m4l/components";
+function MFAuthApp(props) {
+  const {
+    children,
+    user,
+    pwd
+  } = props;
+  const {
+    isAuthenticated,
+    isInitialized,
+    login,
+    user: authUser
+  } = useAuth();
+  useEffect(() => {
+    if (isInitialized && isAuthenticated === false) {
+      login(user, pwd, false);
+    }
+  }, [isInitialized, isAuthenticated]);
+  if (!isAuthenticated)
+    return /* @__PURE__ */ jsx("div", {
+      children: "Pendiente x atenticar"
+    });
+  const domianCountry = {
+    id: 1,
+    currency: "USD",
+    currency_decimal_digits: 2,
+    decimal_symbol: ".",
+    thousands_symbol: ","
+  };
+  if (authUser?.domain_country) {
+    domianCountry.id = authUser?.domain_country.id ?? domianCountry.id;
+    domianCountry.currency = authUser?.domain_country.currency ?? domianCountry.currency;
+    domianCountry.currency_decimal_digits = authUser?.domain_country.currency_decimal_digits ?? domianCountry.currency_decimal_digits;
+    domianCountry.decimal_symbol = authUser?.domain_country.decimal_symbol ?? domianCountry.decimal_symbol;
+    domianCountry.thousands_symbol = authUser?.domain_country?.thousands_symbol ?? domianCountry.thousands_symbol;
+  }
+  return /* @__PURE__ */ jsxs(HostThemeProvider, {
+    hostThemeOptions: defaultThemeOptions,
+    fnComponentsOverrides,
+    isMicroFrontEnd: true,
+    children: [/* @__PURE__ */ jsx(ToastContainer, {}), /* @__PURE__ */ jsx(GlobalStyles, {}), /* @__PURE__ */ jsx(DomainCountryProvider, {
+      ...domianCountry,
+      isMicroFrontEnd: false,
+      children: /* @__PURE__ */ jsx(FormatterProvider, {
+        isMicroFrontEnd: false,
+        dateFormatter: {
+          formatDate: format
+        },
+        currencyFormatter: {
+          code: domianCountry.currency,
+          decimalDigits: domianCountry.currency_decimal_digits
+        },
+        children
+      })
+    })]
+  });
+}
+const history = createBrowserHistory({
+  window
+});
+function MFIsolationApp(props) {
+  const {
+    children,
+    user,
+    pwd,
+    host_api_local,
+    host_api_remote,
+    host_static_assets,
+    environment_assets,
+    moduleId,
+    skeletonFlags,
+    moduleNameField,
+    privileges,
+    componentsDictionary,
+    onLoad,
+    activeAreasNetwork = false,
+    activeCookiesFromNetwork = false
+  } = props;
+  const eventEmitter = useMemo(() => new EventEmitter(), []);
+  const events_add_listener = useCallback((eventName, handler) => {
+    eventEmitter.on(eventName, handler);
+  }, [eventEmitter]);
+  const events_remove_listener = useCallback((eventName, handler) => {
+    if (handler === null) {
+      eventEmitter.removeListener(eventName);
+      return;
+    }
+    eventEmitter.removeListener(eventName, handler);
+  }, [eventEmitter]);
+  const events_emit = useCallback((eventName, arg) => {
+    eventEmitter.emit(eventName, arg);
+  }, [eventEmitter]);
+  const startProgress = () => {
+    NProgress.configure({
+      showSpinner: true
+    });
+    NProgress.start();
+  };
+  const stopProgress = () => {
+    NProgress.done();
+  };
+  const environment = useMemo(() => ({
+    host: "",
+    isLocalhost: true,
+    domain_token: "lab1",
+    host_api_local,
+    host_api_remote,
+    host_static_assets,
+    environment_assets
+  }), []);
+  const hostTools = useMemo(() => ({
+    history,
+    toast,
+    startProgress,
+    stopProgress,
+    events_add_listener,
+    events_remove_listener,
+    events_emit
+  }), []);
+  return /* @__PURE__ */ jsx(EnvironmentProvider, {
+    ...environment,
+    children: /* @__PURE__ */ jsx(HostToolsProvider, {
+      ...hostTools,
+      children: /* @__PURE__ */ jsx(NetworkProvider, {
+        axiosOperation,
+        children: /* @__PURE__ */ jsx(unstable_HistoryRouter, {
+          history,
+          children: /* @__PURE__ */ jsx(LocalesProvider, {
+            isMicroFrontEnd: false,
+            getLocaleFromNetwork,
+            children: /* @__PURE__ */ jsx(AuthProvider, {
+              children: /* @__PURE__ */ jsx(MFAuthApp, {
+                user,
+                pwd,
+                children: /* @__PURE__ */ jsx(BaseModule, {
+                  moduleId,
+                  privileges,
+                  skeletonFlags,
+                  componentsDictionary,
+                  moduleNameField,
+                  children: /* @__PURE__ */ jsx(AreasProvider, {
+                    onLoad,
+                    loadAreasFromNetwork: activeAreasNetwork,
+                    loadCookiesFromNetwork: activeCookiesFromNetwork,
+                    onSelectLayout: (modId) => {
+                      console.log("onSelectLayout", modId);
+                    },
+                    children
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  });
+}
+export {
+  MFIsolationApp as M
+};

package/components/MFIsolationApp/subcomponents/MFAuthApp/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { MFAuthAppProps } from './types';
-export declare function MFAuthApp(props: MFAuthAppProps): JSX.Element;
+export declare function MFAuthApp(props: MFAuthAppProps): import("react").JSX.Element;
 export default MFAuthApp;

package/components/{index.604759d6.js → index.aeb3cf83.js}

@@ -1,4 +1,4 @@
-import "./MFIsolationApp/index.ed197bc0.js";
+import "./MFIsolationApp/index.e36cf308.js";
 import "react-router-dom";
 import "@m4l/core";
 import "@m4l/graphics";

package/contexts/AuthContext/index.6f966215.js

@@ -1,130 +1,160 @@
-import { createContext as T, useReducer as y, useEffect as d } from "react";
-import { useHostTools as E, useNetwork as S, useEnvironment as v, useLocalStorageWithListener as N, EmitEvents as O, getLocalStorage as w, setLocalStorage as r } from "@m4l/core";
-import { jsx as D } from "react/jsx-runtime";
-var n = /* @__PURE__ */ ((e) => (e.Initial = "INITIALIZE", e.Login = "LOGIN", e.Logout = "LOGOUT", e))(n || {});
-const _ = {
-  isAuthenticated: !1,
-  isInitialized: !1,
+import { createContext, useReducer, useEffect } from "react";
+import { useHostTools, useNetwork, useEnvironment, useLocalStorageWithListener, EmitEvents, getLocalStorage, setLocalStorage } from "@m4l/core";
+import { jsx } from "react/jsx-runtime";
+var EnumTypes = /* @__PURE__ */ ((EnumTypes2) => {
+  EnumTypes2["Initial"] = "INITIALIZE";
+  EnumTypes2["Login"] = "LOGIN";
+  EnumTypes2["Logout"] = "LOGOUT";
+  return EnumTypes2;
+})(EnumTypes || {});
+const initialState = {
+  isAuthenticated: false,
+  isInitialized: false,
   user: null
-}, P = (e, t) => {
-  switch (t.type) {
+};
+const JWTReducer = (state, action) => {
+  switch (action.type) {
     case "INITIALIZE":
       return {
-        isAuthenticated: t.payload.isAuthenticated,
-        isInitialized: !0,
-        user: t.payload.user
+        isAuthenticated: action.payload.isAuthenticated,
+        isInitialized: true,
+        user: action.payload.user
       };
     case "LOGIN":
       return {
-        ...e,
-        isAuthenticated: !0,
-        user: t.payload.user
+        ...state,
+        isAuthenticated: true,
+        user: action.payload.user
       };
     case "LOGOUT":
       return {
-        ...e,
-        isAuthenticated: !1,
+        ...state,
+        isAuthenticated: false,
         user: null
       };
     default:
-      return e;
+      return state;
   }
-}, x = T(null);
-function z(e) {
-  e({
-    type: n.Initial,
+};
+const AuthContext = createContext(null);
+function dispatchInitial(dispatch) {
+  dispatch({
+    type: EnumTypes.Initial,
     payload: {
-      isAuthenticated: !1,
+      isAuthenticated: false,
       user: null
     }
   });
 }
-function R(e) {
+function AuthProvider(props) {
+  const {
+    children
+  } = props;
+  const [state, dispatch] = useReducer(JWTReducer, initialState);
+  const {
+    events_add_listener
+  } = useHostTools();
   const {
-    children: t
-  } = e, [h, s] = y(P, _), {
-    events_add_listener: I
-  } = E(), {
-    networkOperation: u
-  } = S(), {
-    domain_token: m
-  } = v(), [f, l] = N(
+    networkOperation
+  } = useNetwork();
+  const {
+    domain_token
+  } = useEnvironment();
+  const [nextValSession, setNextValSession] = useLocalStorageWithListener(
     "vSession",
     new Date().getTime() + ""
   );
-  d(() => {
-    (async () => {
-      u({
+  useEffect(() => {
+    const initialize = async () => {
+      networkOperation({
         method: "GET",
-        endPoint: "auth/login",
+        endPoint: `auth/login`,
         parms: {
-          user_data: !0
+          user_data: true
         },
-        checkUnAuthorized: !1
-      }).then((a) => {
-        s({
-          type: n.Initial,
+        checkUnAuthorized: false
+      }).then((response) => {
+        dispatch({
+          type: EnumTypes.Initial,
           payload: {
-            isAuthenticated: !0,
-            user: a.user
+            isAuthenticated: true,
+            user: response.user
           }
-        }), w("userData", {
-          email: a.user.email,
-          remember: !0
-        })?.email !== a.user.email && r("userData", {
-          email: a.user.email
-        }, !0);
+        });
+        const useSaved = getLocalStorage("userData", {
+          email: response.user.email,
+          remember: true
+        });
+        if (useSaved?.email !== response.user.email) {
+          setLocalStorage("userData", {
+            email: response.user.email
+          }, true);
+        }
       }).catch(() => {
-        z(s);
+        dispatchInitial(dispatch);
       });
-    })();
-  }, [f]);
-  const g = async (i, a, o) => {
-    await u({
-      endPoint: "auth/login",
+    };
+    initialize();
+  }, [nextValSession]);
+  const login = async (email, password, remember) => {
+    await networkOperation({
+      endPoint: `auth/login`,
       method: "POST",
       data: {
-        email: i,
-        password: a,
-        domain_token: m
+        email,
+        password,
+        domain_token
+      }
+    }).then((response) => {
+      const user = response.data;
+      if (remember) {
+        setLocalStorage("userData", {
+          email,
+          remember
+        });
+      } else {
+        setLocalStorage("userData", {
+          email: "",
+          remember
+        });
       }
-    }).then((A) => {
-      const L = A.data;
-      o ? r("userData", {
-        email: i,
-        remember: o
-      }) : r("userData", {
-        email: "",
-        remember: o
-      }), s({
-        type: n.Login,
+      dispatch({
+        type: EnumTypes.Login,
         payload: {
-          user: L
+          user
         }
-      }), l(new Date().getTime() + "");
+      });
+      setNextValSession(new Date().getTime() + "");
+    });
+  };
+  const logout = async (isAuthenticated) => {
+    if (isAuthenticated) {
+      await networkOperation({
+        endPoint: `auth/logout`,
+        method: "POST"
+      });
+    }
+    dispatch({
+      type: EnumTypes.Logout
     });
-  }, c = async (i) => {
-    i && await u({
-      endPoint: "auth/logout",
-      method: "POST"
-    }), s({
-      type: n.Logout
-    }), l(new Date().getTime() + "");
-  }, p = () => {
-    c(!1);
+    setNextValSession(new Date().getTime() + "");
+  };
+  const onNetserviceUnautorized = () => {
+    logout(false);
   };
-  return d(() => {
-    I(O.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, p);
-  }, []), /* @__PURE__ */ D(x.Provider, {
+  useEffect(() => {
+    events_add_listener(EmitEvents.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, onNetserviceUnautorized);
+  }, []);
+  return /* @__PURE__ */ jsx(AuthContext.Provider, {
     value: {
-      ...h,
-      login: g,
-      logout: c
+      ...state,
+      login,
+      logout
     },
-    children: t
+    children
   });
 }
 export {
-  R as A,
-  x as a
+  AuthProvider as A,
+  AuthContext as a
 };

package/contexts/AuthContext/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
 import type { AuthProviderProps, SessionContextType } from './types';
 declare const AuthContext: import("react").Context<SessionContextType | null>;
-declare function AuthProvider(props: AuthProviderProps): JSX.Element;
+declare function AuthProvider(props: AuthProviderProps): import("react").JSX.Element;
 export { AuthContext, AuthProvider };

package/hooks/index.a0c767ed.js

@@ -0,0 +1,4 @@
+import "react";
+import "../layouts/MasterDetailLayout/index.bca0fce5.js";
+import "../contexts/AuthContext/index.6f966215.js";
+import "../layouts/ModuleLayout/index.850f7dcf.js";