@dashadmin/dash-app-common 1.3.25 → 1.3.28

package/dist/defaults/extensions/index.js

@@ -1 +1,190 @@
-import{dashDefaultInitializeApp as t,dashDefaultBootstrapApp as s,DashDefaultErrorBoundary as D}from"./bootstrap";import{DashDefaultLoader as r,DashDefaultReactAdminNotification as u,loadDashDefaultAutoAdminComponents as h,dashDefaultAutoAdminComponents as f,dashDefaultStaticComponents as l,getDashDefaultStaticComponents as i,dashDefaultNotificationConfig as n}from"./components";import{useDashDefaultMountTracker as p,useDashDefaultRoutePath as g,useDashDefaultLazyI18nProvider as m,useDashDefaultLazyAutoAdminComponents as P,useDashDefaultLazyResources as y}from"./hooks";import{dashDefaultPublicRoutes as A,dashDefaultPrivateRoutes as C,dashDefaultSharedRoutes as I,DashDefaultRouterWrapper as v,createDashDefaultRouterWrapper as L,getDashDefaultRouterEnvVars as S}from"./router";import{dashDefaultAppSettings as T,getDashDefaultThemeType as R,getDashDefaultAppCommon as B,getDashDefaultAppPath as M,getDashDefaultPanelImages as k,DASH_DEFAULT_INITIAL_APP_STATE as E,getDashDefaultInitialAppState as W,dashDefaultQueryClient as N,createDashDefaultQueryClient as z,dashDefaultQueryClientConfig as F,dashDefaultDevQueryClientConfig as Q,dashDefaultLayoutSettings as O,getDashDefaultTheme as _,getDashDefaultLightTheme as b,getDashDefaultDarkTheme as G,dashDefaultResourceIcons as U}from"./state";import{dashDefaultTranslations as H,dashDefaultAvailableLocales as V,dashDefaultLocale as j,createDashDefaultI18nProvider as w,loadDashDefaultTranslationsAsync as J,createDashDefaultI18nProviderAsync as K,useDashDefaultI18nProvider as X,createDashDefaultI18nProviderWithSettings as Y,createDashDefaultI18nProviderFromAppState as Z}from"./i18n";import{dashDefaultAuthProvider as ee,dashDefaultAuthProviderConfig as ae,dashDefaultAuthProviderOverrides as te,dashDefaultDataProvider as se,dashDefaultDataProviderConfig as De,dashDefaultDataProviderOverrides as oe,dashDefaultDataProviderExtensions as re,dashAuthProvider as ue,dashDataProvider as he}from"./providers";import{dashDefaultExtendedThemeOptions as le,dashDefaultPalette as ie,dashDefaultTypography as ne}from"./theme";import{createDashDefaultDomainAppLayout as pe,createDashDefaultDomainAppLayoutWithIPC as ge,useDashDefaultDomainAppLayout as me,useDashDefaultDomainAppLayoutWithIPC as Pe}from"./layout";import{useDashDefaultIPCListeners as ce,setupDashDefaultIPCListeners as Ae}from"./electron";import{DashDefaultWSMessagesManager as Ie}from"./managers";import{dashDefaultLogoutFromStorage as Le,dashDefaultIsAuthenticated as Se,dashDefaultGetCurrentUser as xe,dashDefaultGetToken as Te,dashDefaultGetResourceConfig as Re,dashDefaultSetResourceConfigs as Be,dashDefaultProcessPostData as Me,dashDefaultProcessFormData as ke,dashDefaultBuildQueryString as Ee,dashDefaultIsFormDataResource as We,DashIPCMessageBrokerContext as Ne,DashIPCMessageBrokerProvider as ze,useDashIPCMessageBroker as Fe,processDashDefaultNotification as Qe,playDashDefaultNotificationSound as Oe,playDashDefaultDigitalWatchAlarm as _e,requestDashDefaultNotificationPermission as be}from"./utils";export{E as DASH_DEFAULT_INITIAL_APP_STATE,D as DashDefaultErrorBoundary,r as DashDefaultLoader,u as DashDefaultReactAdminNotification,v as DashDefaultRouterWrapper,Ie as DashDefaultWSMessagesManager,Ne as DashIPCMessageBrokerContext,ze as DashIPCMessageBrokerProvider,pe as createDashDefaultDomainAppLayout,ge as createDashDefaultDomainAppLayoutWithIPC,w as createDashDefaultI18nProvider,K as createDashDefaultI18nProviderAsync,Z as createDashDefaultI18nProviderFromAppState,Y as createDashDefaultI18nProviderWithSettings,z as createDashDefaultQueryClient,L as createDashDefaultRouterWrapper,ue as dashAuthProvider,he as dashDataProvider,T as dashDefaultAppSettings,ee as dashDefaultAuthProvider,ae as dashDefaultAuthProviderConfig,te as dashDefaultAuthProviderOverrides,f as dashDefaultAutoAdminComponents,V as dashDefaultAvailableLocales,s as dashDefaultBootstrapApp,Ee as dashDefaultBuildQueryString,se as dashDefaultDataProvider,De as dashDefaultDataProviderConfig,re as dashDefaultDataProviderExtensions,oe as dashDefaultDataProviderOverrides,Q as dashDefaultDevQueryClientConfig,le as dashDefaultExtendedThemeOptions,xe as dashDefaultGetCurrentUser,Re as dashDefaultGetResourceConfig,Te as dashDefaultGetToken,t as dashDefaultInitializeApp,Se as dashDefaultIsAuthenticated,We as dashDefaultIsFormDataResource,O as dashDefaultLayoutSettings,j as dashDefaultLocale,Le as dashDefaultLogoutFromStorage,n as dashDefaultNotificationConfig,ie as dashDefaultPalette,C as dashDefaultPrivateRoutes,ke as dashDefaultProcessFormData,Me as dashDefaultProcessPostData,A as dashDefaultPublicRoutes,N as dashDefaultQueryClient,F as dashDefaultQueryClientConfig,U as dashDefaultResourceIcons,Be as dashDefaultSetResourceConfigs,I as dashDefaultSharedRoutes,l as dashDefaultStaticComponents,H as dashDefaultTranslations,ne as dashDefaultTypography,B as getDashDefaultAppCommon,M as getDashDefaultAppPath,G as getDashDefaultDarkTheme,W as getDashDefaultInitialAppState,b as getDashDefaultLightTheme,k as getDashDefaultPanelImages,S as getDashDefaultRouterEnvVars,i as getDashDefaultStaticComponents,_ as getDashDefaultTheme,R as getDashDefaultThemeType,h as loadDashDefaultAutoAdminComponents,J as loadDashDefaultTranslationsAsync,_e as playDashDefaultDigitalWatchAlarm,Oe as playDashDefaultNotificationSound,Qe as processDashDefaultNotification,be as requestDashDefaultNotificationPermission,Ae as setupDashDefaultIPCListeners,me as useDashDefaultDomainAppLayout,Pe as useDashDefaultDomainAppLayoutWithIPC,X as useDashDefaultI18nProvider,ce as useDashDefaultIPCListeners,P as useDashDefaultLazyAutoAdminComponents,m as useDashDefaultLazyI18nProvider,y as useDashDefaultLazyResources,p as useDashDefaultMountTracker,g as useDashDefaultRoutePath,Fe as useDashIPCMessageBroker};
+import {
+  dashDefaultInitializeApp,
+  dashDefaultBootstrapApp,
+  DashDefaultErrorBoundary
+} from "./bootstrap";
+import {
+  DashDefaultLoader,
+  DashDefaultReactAdminNotification,
+  loadDashDefaultAutoAdminComponents,
+  dashDefaultAutoAdminComponents,
+  dashDefaultStaticComponents,
+  getDashDefaultStaticComponents,
+  dashDefaultNotificationConfig
+} from "./components";
+import {
+  useDashDefaultMountTracker,
+  useDashDefaultRoutePath,
+  useDashDefaultLazyI18nProvider,
+  useDashDefaultLazyAutoAdminComponents,
+  useDashDefaultLazyResources
+} from "./hooks";
+import {
+  dashDefaultPublicRoutes,
+  dashDefaultPrivateRoutes,
+  dashDefaultSharedRoutes,
+  DashDefaultRouterWrapper,
+  createDashDefaultRouterWrapper,
+  getDashDefaultRouterEnvVars
+} from "./router";
+import {
+  dashDefaultAppSettings,
+  getDashDefaultThemeType,
+  getDashDefaultAppCommon,
+  getDashDefaultAppPath,
+  getDashDefaultPanelImages,
+  DASH_DEFAULT_INITIAL_APP_STATE,
+  getDashDefaultInitialAppState,
+  dashDefaultQueryClient,
+  createDashDefaultQueryClient,
+  dashDefaultQueryClientConfig,
+  dashDefaultDevQueryClientConfig,
+  dashDefaultLayoutSettings,
+  getDashDefaultTheme,
+  getDashDefaultLightTheme,
+  getDashDefaultDarkTheme,
+  dashDefaultResourceIcons
+} from "./state";
+import {
+  dashDefaultTranslations,
+  dashDefaultAvailableLocales,
+  dashDefaultLocale,
+  createDashDefaultI18nProvider,
+  loadDashDefaultTranslationsAsync,
+  createDashDefaultI18nProviderAsync,
+  useDashDefaultI18nProvider,
+  createDashDefaultI18nProviderWithSettings,
+  createDashDefaultI18nProviderFromAppState
+} from "./i18n";
+import {
+  dashDefaultAuthProvider,
+  dashDefaultAuthProviderConfig,
+  dashDefaultAuthProviderOverrides,
+  dashDefaultDataProvider,
+  dashDefaultDataProviderConfig,
+  dashDefaultDataProviderOverrides,
+  dashDefaultDataProviderExtensions,
+  dashAuthProvider,
+  dashDataProvider
+} from "./providers";
+import {
+  dashDefaultExtendedThemeOptions,
+  dashDefaultPalette,
+  dashDefaultTypography
+} from "./theme";
+import {
+  createDashDefaultDomainAppLayout,
+  createDashDefaultDomainAppLayoutWithIPC,
+  useDashDefaultDomainAppLayout,
+  useDashDefaultDomainAppLayoutWithIPC
+} from "./layout";
+import {
+  useDashDefaultIPCListeners,
+  setupDashDefaultIPCListeners
+} from "./electron";
+import {
+  DashDefaultWSMessagesManager
+} from "./managers";
+import {
+  dashDefaultLogoutFromStorage,
+  dashDefaultIsAuthenticated,
+  dashDefaultGetCurrentUser,
+  dashDefaultGetToken,
+  dashDefaultGetResourceConfig,
+  dashDefaultSetResourceConfigs,
+  dashDefaultProcessPostData,
+  dashDefaultProcessFormData,
+  dashDefaultBuildQueryString,
+  dashDefaultIsFormDataResource,
+  DashIPCMessageBrokerContext,
+  DashIPCMessageBrokerProvider,
+  useDashIPCMessageBroker,
+  processDashDefaultNotification,
+  playDashDefaultNotificationSound,
+  playDashDefaultDigitalWatchAlarm,
+  requestDashDefaultNotificationPermission
+} from "./utils";
+export {
+  DASH_DEFAULT_INITIAL_APP_STATE,
+  DashDefaultErrorBoundary,
+  DashDefaultLoader,
+  DashDefaultReactAdminNotification,
+  DashDefaultRouterWrapper,
+  DashDefaultWSMessagesManager,
+  DashIPCMessageBrokerContext,
+  DashIPCMessageBrokerProvider,
+  createDashDefaultDomainAppLayout,
+  createDashDefaultDomainAppLayoutWithIPC,
+  createDashDefaultI18nProvider,
+  createDashDefaultI18nProviderAsync,
+  createDashDefaultI18nProviderFromAppState,
+  createDashDefaultI18nProviderWithSettings,
+  createDashDefaultQueryClient,
+  createDashDefaultRouterWrapper,
+  dashAuthProvider,
+  dashDataProvider,
+  dashDefaultAppSettings,
+  dashDefaultAuthProvider,
+  dashDefaultAuthProviderConfig,
+  dashDefaultAuthProviderOverrides,
+  dashDefaultAutoAdminComponents,
+  dashDefaultAvailableLocales,
+  dashDefaultBootstrapApp,
+  dashDefaultBuildQueryString,
+  dashDefaultDataProvider,
+  dashDefaultDataProviderConfig,
+  dashDefaultDataProviderExtensions,
+  dashDefaultDataProviderOverrides,
+  dashDefaultDevQueryClientConfig,
+  dashDefaultExtendedThemeOptions,
+  dashDefaultGetCurrentUser,
+  dashDefaultGetResourceConfig,
+  dashDefaultGetToken,
+  dashDefaultInitializeApp,
+  dashDefaultIsAuthenticated,
+  dashDefaultIsFormDataResource,
+  dashDefaultLayoutSettings,
+  dashDefaultLocale,
+  dashDefaultLogoutFromStorage,
+  dashDefaultNotificationConfig,
+  dashDefaultPalette,
+  dashDefaultPrivateRoutes,
+  dashDefaultProcessFormData,
+  dashDefaultProcessPostData,
+  dashDefaultPublicRoutes,
+  dashDefaultQueryClient,
+  dashDefaultQueryClientConfig,
+  dashDefaultResourceIcons,
+  dashDefaultSetResourceConfigs,
+  dashDefaultSharedRoutes,
+  dashDefaultStaticComponents,
+  dashDefaultTranslations,
+  dashDefaultTypography,
+  getDashDefaultAppCommon,
+  getDashDefaultAppPath,
+  getDashDefaultDarkTheme,
+  getDashDefaultInitialAppState,
+  getDashDefaultLightTheme,
+  getDashDefaultPanelImages,
+  getDashDefaultRouterEnvVars,
+  getDashDefaultStaticComponents,
+  getDashDefaultTheme,
+  getDashDefaultThemeType,
+  loadDashDefaultAutoAdminComponents,
+  loadDashDefaultTranslationsAsync,
+  playDashDefaultDigitalWatchAlarm,
+  playDashDefaultNotificationSound,
+  processDashDefaultNotification,
+  requestDashDefaultNotificationPermission,
+  setupDashDefaultIPCListeners,
+  useDashDefaultDomainAppLayout,
+  useDashDefaultDomainAppLayoutWithIPC,
+  useDashDefaultI18nProvider,
+  useDashDefaultIPCListeners,
+  useDashDefaultLazyAutoAdminComponents,
+  useDashDefaultLazyI18nProvider,
+  useDashDefaultLazyResources,
+  useDashDefaultMountTracker,
+  useDashDefaultRoutePath,
+  useDashIPCMessageBroker
+};

package/dist/defaults/extensions/layout/dashDefaultDomainAppLayout.js

@@ -1 +1,58 @@
-import{jsx as e}from"react/jsx-runtime";import D,{useCallback as p,Suspense as s}from"react";import r from"@dashadmin/dash-admin/src/default-theme/DomainAppLayout";import{getEnv as A}from"@dashadmin/dash-constants";const u=D.lazy(()=>import("@dashadmin/dash-utils").then(t=>({default:t.IPCMessageBrokerProvider}))),m=()=>e("div",{style:{display:"flex",justifyContent:"center",alignItems:"center",minHeight:"200px"},children:"Loading..."}),i=()=>{try{return JSON.parse(A("IS_ELECTRON")||"false")}catch{return!1}},y=()=>o=>{const{ThemeComponent:n,children:a}=o;return e(r,{ThemeComponent:n,children:a})},S=()=>o=>{const{ThemeComponent:n,children:a}=o,l=i()?e(s,{fallback:e(m,{}),children:e(u,{children:a})}):a;return e(r,{ThemeComponent:n,children:l})},I=()=>p(t=>{const{ThemeComponent:o,children:n}=t;return e(r,{ThemeComponent:o,children:n})},[]),E=()=>{const t=i();return p(o=>{const{ThemeComponent:n,children:a}=o;return e(r,{ThemeComponent:n,children:t?e(s,{fallback:e(m,{}),children:e(u,{children:a})}):a})},[t])};var P=y;export{y as createDashDefaultDomainAppLayout,S as createDashDefaultDomainAppLayoutWithIPC,P as default,I as useDashDefaultDomainAppLayout,E as useDashDefaultDomainAppLayoutWithIPC};
+import { jsx } from "react/jsx-runtime";
+import React, { useCallback, Suspense } from "react";
+import DASHAppLayout from "dash-admin/src/default-theme/DomainAppLayout";
+import { getEnv } from "dash-constants";
+const IPCMessageBrokerProvider = React.lazy(
+  () => import("dash-utils").then((m) => ({ default: m.IPCMessageBrokerProvider }))
+);
+const DashDefaultLayoutLoadingFallback = () => /* @__PURE__ */ jsx("div", { style: {
+  display: "flex",
+  justifyContent: "center",
+  alignItems: "center",
+  minHeight: "200px"
+}, children: "Loading..." });
+const isElectron = () => {
+  try {
+    return JSON.parse(getEnv("IS_ELECTRON") || "false");
+  } catch (e) {
+    return false;
+  }
+};
+const createDashDefaultDomainAppLayout = () => {
+  const DashDefaultDomainAppLayout = (props) => {
+    const { ThemeComponent, children } = props;
+    return /* @__PURE__ */ jsx(DASHAppLayout, { ThemeComponent, children });
+  };
+  return DashDefaultDomainAppLayout;
+};
+const createDashDefaultDomainAppLayoutWithIPC = () => {
+  const DashDefaultDomainAppLayout = (props) => {
+    const { ThemeComponent, children } = props;
+    const inElectron = isElectron();
+    const LayoutContent = inElectron ? /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(DashDefaultLayoutLoadingFallback, {}), children: /* @__PURE__ */ jsx(IPCMessageBrokerProvider, { children }) }) : children;
+    return /* @__PURE__ */ jsx(DASHAppLayout, { ThemeComponent, children: LayoutContent });
+  };
+  return DashDefaultDomainAppLayout;
+};
+const useDashDefaultDomainAppLayout = () => {
+  return useCallback((props) => {
+    const { ThemeComponent, children } = props;
+    return /* @__PURE__ */ jsx(DASHAppLayout, { ThemeComponent, children });
+  }, []);
+};
+const useDashDefaultDomainAppLayoutWithIPC = () => {
+  const inElectron = isElectron();
+  return useCallback((props) => {
+    const { ThemeComponent, children } = props;
+    const LayoutContent = inElectron ? /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(DashDefaultLayoutLoadingFallback, {}), children: /* @__PURE__ */ jsx(IPCMessageBrokerProvider, { children }) }) : children;
+    return /* @__PURE__ */ jsx(DASHAppLayout, { ThemeComponent, children: LayoutContent });
+  }, [inElectron]);
+};
+var dashDefaultDomainAppLayout_default = createDashDefaultDomainAppLayout;
+export {
+  createDashDefaultDomainAppLayout,
+  createDashDefaultDomainAppLayoutWithIPC,
+  dashDefaultDomainAppLayout_default as default,
+  useDashDefaultDomainAppLayout,
+  useDashDefaultDomainAppLayoutWithIPC
+};

package/dist/defaults/extensions/layout/index.js

@@ -1 +1,12 @@
-import{createDashDefaultDomainAppLayout as D,createDashDefaultDomainAppLayoutWithIPC as e,useDashDefaultDomainAppLayout as o,useDashDefaultDomainAppLayoutWithIPC as u}from"./dashDefaultDomainAppLayout";export{D as createDashDefaultDomainAppLayout,e as createDashDefaultDomainAppLayoutWithIPC,o as useDashDefaultDomainAppLayout,u as useDashDefaultDomainAppLayoutWithIPC};
+import {
+  createDashDefaultDomainAppLayout,
+  createDashDefaultDomainAppLayoutWithIPC,
+  useDashDefaultDomainAppLayout,
+  useDashDefaultDomainAppLayoutWithIPC
+} from "./dashDefaultDomainAppLayout";
+export {
+  createDashDefaultDomainAppLayout,
+  createDashDefaultDomainAppLayoutWithIPC,
+  useDashDefaultDomainAppLayout,
+  useDashDefaultDomainAppLayoutWithIPC
+};

package/dist/defaults/extensions/managers/DashDefaultWSMessagesManager.js

@@ -1 +1,84 @@
-import{jsx as C}from"react/jsx-runtime";import{useEffect as a,useState as o}from"react";import{Notification as f}from"react-admin";import d from"@dashadmin/dash-admin/src/contexts/com/useLaravelEcho";import{useAuthContext as g}from"@dashadmin/dash-admin/src/contexts/auth/AuthContext";const H=()=>C(f,{className:"dash-notification",autoHideDuration:8e3,multiLine:!0,anchorOrigin:{vertical:"top",horizontal:"right"}}),L=()=>{const[h,u]=o([]),[s,i]=o(null),t=g(),[r,m]=o(null),[c,v]=o(null);a(()=>{t?.user&&(m(t.user.id),v(t.user.tenant_id))},[t]);const p=()=>{i(null)},{echoChannel:E,isConnected:I,lastEvent:n,ping:x,addListener:y,removeListener:D}=d({type:"private",channel:r?`user.${r}`:null,enabled:!!r}),{echoChannel:M,isConnected:N,lastEvent:l,ping:P,addListener:A,removeListener:B}=d({type:"private",channel:c?`tenant.${c}.system`:null,enabled:!!c});return a(()=>{console.log("Private Tenant Message",n);const e=l?.data;console.log(e),i(e)},[l]),a(()=>{console.log("Private User Message",n);const e=n?.data;console.log(e),i(e)},[n]),a(()=>{u(e=>[...e,s])},[s]),{events:h,lastEvent:s,clear:p}};var O=L;export{H as DashDefaultReactAdminNotification,O as default};
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Notification } from "react-admin";
+import useLaravelEcho from "dash-admin/src/contexts/com/useLaravelEcho";
+import { useAuthContext } from "dash-admin/src/contexts/auth/AuthContext";
+const DashDefaultReactAdminNotification = () => {
+  return /* @__PURE__ */ jsx(
+    Notification,
+    {
+      className: "dash-notification",
+      autoHideDuration: 8e3,
+      multiLine: true,
+      anchorOrigin: { vertical: "top", horizontal: "right" }
+    }
+  );
+};
+const DashDefaultWSMessagesManager = () => {
+  const [events, setEvents] = useState([]);
+  const [lastEvent, setLastEvent] = useState(null);
+  const authContext = useAuthContext();
+  const [userId, setUserId] = useState(null);
+  const [tenantId, setTenantId] = useState(null);
+  useEffect(() => {
+    if (!(authContext == null ? void 0 : authContext.user)) {
+      return;
+    }
+    setUserId(authContext.user.id);
+    setTenantId(authContext.user.tenant_id);
+  }, [authContext]);
+  const clear = () => {
+    setLastEvent(null);
+  };
+  const {
+    echoChannel: channel2,
+    isConnected: isConnected2,
+    lastEvent: event2,
+    ping: pingConnection2,
+    addListener: addListener2,
+    removeListener: reoveListener2
+  } = useLaravelEcho({
+    type: "private",
+    channel: userId ? `user.${userId}` : null,
+    enabled: !!userId
+    // Only enable if userId exists
+  });
+  const {
+    echoChannel: channel3,
+    isConnected: isConnected3,
+    lastEvent: event3,
+    ping: pingConnection3,
+    addListener: addListener3,
+    removeListener: reoveListener3
+  } = useLaravelEcho({
+    type: "private",
+    channel: tenantId ? `tenant.${tenantId}.system` : null,
+    enabled: !!tenantId
+    // Only enable if tenantId exists
+  });
+  useEffect(() => {
+    console.log("Private Tenant Message", event2);
+    const _lastEvent = event3 == null ? void 0 : event3.data;
+    console.log(_lastEvent);
+    setLastEvent(_lastEvent);
+  }, [event3]);
+  useEffect(() => {
+    console.log("Private User Message", event2);
+    const _lastEvent = event2 == null ? void 0 : event2.data;
+    console.log(_lastEvent);
+    setLastEvent(_lastEvent);
+  }, [event2]);
+  useEffect(() => {
+    setEvents((prev) => [...prev, lastEvent]);
+  }, [lastEvent]);
+  return {
+    events,
+    lastEvent,
+    clear
+  };
+};
+var DashDefaultWSMessagesManager_default = DashDefaultWSMessagesManager;
+export {
+  DashDefaultReactAdminNotification,
+  DashDefaultWSMessagesManager_default as default
+};

package/dist/defaults/extensions/managers/index.js

@@ -1 +1,5 @@
-import{default as t,DashDefaultReactAdminNotification as s}from"./DashDefaultWSMessagesManager";export{s as DashDefaultReactAdminNotification,t as DashDefaultWSMessagesManager};
+import { default as default2, DashDefaultReactAdminNotification } from "./DashDefaultWSMessagesManager";
+export {
+  DashDefaultReactAdminNotification,
+  default2 as DashDefaultWSMessagesManager
+};

package/dist/defaults/extensions/providers/dashDefaultAuthProvider.js

@@ -1 +1,220 @@
-import{createDashAuthProvider as p}from"@dashadmin/dash-auto-admin";import{getEnv as i}from"@dashadmin/dash-constants";import{DASHAppConstants as u,DASHAdminSystemConstants as g}from"@dashadmin/dash-constants";import{setAuthEvent as h}from"@dashadmin/dash-admin/src/contexts/auth";import{AuthPersistenceService as c,syncDeviceStoreToLocalStorage as f,syncLocalStorageToDeviceStore as d}from"@dashadmin/dash-auth";import{useAxios as l}from"@dashadmin/dash-axios-hook";import{dashStorage as s}from"@dashadmin/dash-utils";import{dashDefaultLogoutFromStorage as n}from"../utils/dashDefaultAuthProviderUtils";const A={useAxios:l,storage:s,authPersistence:c,syncToDeviceStore:d,syncFromDeviceStore:f,setAuthEvent:h,logoutFromStorage:n,getAuthEndpoint:()=>i("APP_GETAUTH_ENDPOINT")||"/auth",guestRole:u.system.GUEST_ROLE,enableTenantImpersonation:JSON.parse(g.system.ENABLE_TENANT_IMPERSONATION?.toString()||"false")},E={login:async({username:e,password:o})=>{await f();const t=l();if(!(e&&o))return Promise.reject();try{const r=await t.post("/login",{email:e,password:o});if(r.status>=200&&r.status<=299){const m=r.data.redirectTo;r.data!==""&&s.setItem("token",r.data.token);try{const{data:a}=await t.get(i("APP_GETAUTH_ENDPOINT"));return c.saveAuth(a),s.setItem("authenticated","true"),s.setItem("user",JSON.stringify(a.user)),s.setItem("roles",a.user?.roles?JSON.stringify(a.user.roles):JSON.stringify(u.system.GUEST_ROLE)),h({authenticated:!0,user:a.user,auth:a.auth,token:r.data.token,roles:a.user?.roles}),await d(),m?Promise.resolve({redirectTo:m}):Promise.resolve(a)}catch(a){return console.error("Error getting user auth"),n("login get auth error"),Promise.reject(a)}}}catch(r){return console.error(r),n("login error logout"),Promise.reject(r)}return n("login default error logout"),Promise.reject()},logout:async(e,o)=>(await n("logout"),Promise.resolve(o||"/login")),getIdentity:async()=>{const e=l();if(!s.getItem("token"))return Promise.reject("No token present");try{const{data:t}=await e.get(i("APP_GETAUTH_ENDPOINT"));return s.setItem("roles",t.user?.roles?JSON.stringify(t.user.roles):JSON.stringify(u.system.GUEST_ROLE)),s.setItem("authenticated","true"),s.setItem("user",JSON.stringify(t.user)),JSON.parse(g.system.ENABLE_TENANT_IMPERSONATION.toString())&&t.user?.tenant_id&&(s.setItem("tenant_id",t.user?.tenant_id),s.setItem("user_id",t.user?.id)),await Promise.resolve(t)}catch(t){return n("get identity error logout"),Promise.reject(t)}finally{await d()}},checkAuth:async()=>{const e=JSON.parse(s.getItem("authenticated")||"false"),o=JSON.parse(s.getItem("user")||"null");return e&&o?.id&&c.getAuth()?Promise.resolve():Promise.reject()},checkError:e=>{const o=e?.response?.status;if(window.dispatchEvent(new MessageEvent("dash-global-loader",{data:!1})),o){const t={};switch(o){case 400:case 401:case 403:case 500:return window.dispatchEvent(new MessageEvent("GlobalError",{data:{error:e.response.data||e}})),Promise.resolve();case 422:case 409:return t.error="An undefined error has occurred, please try again later",e.response.data?.errors?Object.keys(e.response.data?.errors).forEach(r=>{t[r]=e.response.data?.errors[r].join(" , ")}):e.response.data?.message&&(t.error=e.response.data?.message),window.dispatchEvent(new MessageEvent("GlobalError",{data:{error:t}})),Promise.resolve();default:return window.dispatchEvent(new MessageEvent("GlobalError",{data:{error:e.response.data||e}})),Promise.resolve()}}else{const t={};return Object.keys(e).forEach(r=>{t[r]=Array.isArray(e[r])?e[r].join(" , "):e[r]}),Promise.resolve()}}},v=p(A,E);var D=v;export{v as dashDefaultAuthProvider,A as dashDefaultAuthProviderConfig,E as dashDefaultAuthProviderOverrides,D as default};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var _a;
+import {
+  createDashAuthProvider
+} from "dash-auto-admin";
+import { getEnv } from "dash-constants";
+import { DASHAppConstants, DASHAdminSystemConstants } from "dash-constants";
+import { setAuthEvent } from "dash-admin/src/contexts/auth";
+import { AuthPersistenceService, syncDeviceStoreToLocalStorage, syncLocalStorageToDeviceStore } from "dash-auth";
+import { useAxios } from "dash-axios-hook";
+import { dashStorage } from "dash-utils";
+import { dashDefaultLogoutFromStorage } from "../utils/dashDefaultAuthProviderUtils";
+const dashDefaultAuthProviderConfig = {
+  useAxios,
+  storage: dashStorage,
+  authPersistence: AuthPersistenceService,
+  syncToDeviceStore: syncLocalStorageToDeviceStore,
+  syncFromDeviceStore: syncDeviceStoreToLocalStorage,
+  setAuthEvent,
+  logoutFromStorage: dashDefaultLogoutFromStorage,
+  getAuthEndpoint: () => getEnv("APP_GETAUTH_ENDPOINT") || "/auth",
+  guestRole: DASHAppConstants.system.GUEST_ROLE,
+  enableTenantImpersonation: JSON.parse(
+    ((_a = DASHAdminSystemConstants.system.ENABLE_TENANT_IMPERSONATION) == null ? void 0 : _a.toString()) || "false"
+  )
+};
+const dashDefaultAuthProviderOverrides = {
+  /**
+   * Dash default login implementation with Dash-specific logic
+   */
+  login: (_0) => __async(null, [_0], function* ({ username, password }) {
+    var _a2, _b;
+    yield syncDeviceStoreToLocalStorage();
+    const axios = useAxios();
+    if (!(username && password)) {
+      return Promise.reject();
+    }
+    try {
+      const loginResponse = yield axios.post("/login", {
+        email: username,
+        password
+      });
+      if (loginResponse.status >= 200 && loginResponse.status <= 299) {
+        const redirectTo = loginResponse.data.redirectTo;
+        if (loginResponse.data !== "") {
+          dashStorage.setItem("token", loginResponse.data.token);
+        }
+        try {
+          const { data: auth } = yield axios.get(getEnv("APP_GETAUTH_ENDPOINT"));
+          AuthPersistenceService.saveAuth(auth);
+          dashStorage.setItem("authenticated", "true");
+          dashStorage.setItem("user", JSON.stringify(auth.user));
+          dashStorage.setItem(
+            "roles",
+            ((_a2 = auth.user) == null ? void 0 : _a2.roles) ? JSON.stringify(auth.user.roles) : JSON.stringify(DASHAppConstants.system.GUEST_ROLE)
+          );
+          setAuthEvent({
+            authenticated: true,
+            user: auth.user,
+            auth: auth.auth,
+            token: loginResponse.data.token,
+            roles: (_b = auth.user) == null ? void 0 : _b.roles
+          });
+          yield syncLocalStorageToDeviceStore();
+          if (redirectTo) {
+            return Promise.resolve({ redirectTo });
+          } else {
+            return Promise.resolve(auth);
+          }
+        } catch (error) {
+          console.error("Error getting user auth");
+          dashDefaultLogoutFromStorage("login get auth error");
+          return Promise.reject(error);
+        }
+      }
+    } catch (error) {
+      console.error(error);
+      dashDefaultLogoutFromStorage("login error logout");
+      return Promise.reject(error);
+    }
+    dashDefaultLogoutFromStorage("login default error logout");
+    return Promise.reject();
+  }),
+  /**
+   * Dash default logout implementation
+   */
+  logout: (params, redirectTo) => __async(null, null, function* () {
+    yield dashDefaultLogoutFromStorage("logout");
+    return Promise.resolve(redirectTo || "/login");
+  }),
+  /**
+   * Dash default getIdentity implementation
+   */
+  getIdentity: () => __async(null, null, function* () {
+    var _a2, _b, _c, _d;
+    const axios = useAxios();
+    const token = dashStorage.getItem("token");
+    if (!token) {
+      return Promise.reject("No token present");
+    }
+    try {
+      const { data: auth } = yield axios.get(getEnv("APP_GETAUTH_ENDPOINT"));
+      dashStorage.setItem(
+        "roles",
+        ((_a2 = auth.user) == null ? void 0 : _a2.roles) ? JSON.stringify(auth.user.roles) : JSON.stringify(DASHAppConstants.system.GUEST_ROLE)
+      );
+      dashStorage.setItem("authenticated", "true");
+      dashStorage.setItem("user", JSON.stringify(auth.user));
+      if (JSON.parse(
+        DASHAdminSystemConstants.system.ENABLE_TENANT_IMPERSONATION.toString()
+      ) && ((_b = auth.user) == null ? void 0 : _b.tenant_id)) {
+        dashStorage.setItem("tenant_id", (_c = auth.user) == null ? void 0 : _c.tenant_id);
+        dashStorage.setItem("user_id", (_d = auth.user) == null ? void 0 : _d.id);
+      }
+      return yield Promise.resolve(auth);
+    } catch (error) {
+      dashDefaultLogoutFromStorage("get identity error logout");
+      return Promise.reject(error);
+    } finally {
+      yield syncLocalStorageToDeviceStore();
+    }
+  }),
+  /**
+   * Dash default checkAuth implementation
+   */
+  checkAuth: () => __async(null, null, function* () {
+    const isAuthenticated = JSON.parse(dashStorage.getItem("authenticated") || "false");
+    const user = JSON.parse(dashStorage.getItem("user") || "null");
+    if (isAuthenticated && (user == null ? void 0 : user.id)) {
+      const persistedAuth = AuthPersistenceService.getAuth();
+      if (persistedAuth) {
+        return Promise.resolve();
+      }
+    }
+    return Promise.reject();
+  }),
+  /**
+   * Dash default checkError implementation with Dash error handling
+   */
+  checkError: (error) => {
+    var _a2, _b, _c, _d, _e;
+    const errorStatus = (_a2 = error == null ? void 0 : error.response) == null ? void 0 : _a2.status;
+    window.dispatchEvent(
+      new MessageEvent("dash-global-loader", { data: false })
+    );
+    if (errorStatus) {
+      const errors = {};
+      switch (errorStatus) {
+        case 400:
+        case 401:
+        case 403:
+        case 500:
+          window.dispatchEvent(
+            new MessageEvent("GlobalError", {
+              data: { error: error.response.data || error }
+            })
+          );
+          return Promise.resolve();
+        case 422:
+        case 409:
+          errors.error = "An undefined error has occurred, please try again later";
+          if ((_b = error.response.data) == null ? void 0 : _b.errors) {
+            Object.keys((_c = error.response.data) == null ? void 0 : _c.errors).forEach((key) => {
+              var _a3;
+              errors[key] = (_a3 = error.response.data) == null ? void 0 : _a3.errors[key].join(" , ");
+            });
+          } else if ((_d = error.response.data) == null ? void 0 : _d.message) {
+            errors.error = (_e = error.response.data) == null ? void 0 : _e.message;
+          }
+          window.dispatchEvent(
+            new MessageEvent("GlobalError", { data: { error: errors } })
+          );
+          return Promise.resolve();
+        default:
+          window.dispatchEvent(
+            new MessageEvent("GlobalError", {
+              data: { error: error.response.data || error }
+            })
+          );
+          return Promise.resolve();
+      }
+    } else {
+      const _errors = {};
+      Object.keys(error).forEach((key) => {
+        _errors[key] = Array.isArray(error[key]) ? error[key].join(" , ") : error[key];
+      });
+      return Promise.resolve();
+    }
+  }
+};
+const dashDefaultAuthProvider = createDashAuthProvider(
+  dashDefaultAuthProviderConfig,
+  dashDefaultAuthProviderOverrides
+);
+var dashDefaultAuthProvider_default = dashDefaultAuthProvider;
+export {
+  dashDefaultAuthProvider,
+  dashDefaultAuthProviderConfig,
+  dashDefaultAuthProviderOverrides,
+  dashDefaultAuthProvider_default as default
+};