@dashadmin/dash-utils 1.3.73 → 1.3.74-srcfree.2

package/src/components/LazyAppLoader.tsx

@@ -1,143 +0,0 @@
-/**
- * Lazy App Loader Utilities
- *
- * Provides utilities for creating lazy-loaded app components with
- * error handling and initialization delays.
- */
-import React from 'react';
-
-export interface LazyAppLoaderConfig {
-    /**
-     * Dynamic import function that returns the module with the app component
-     * Example: () => import('./DASHAppLoader')
-     */
-    importFn: () => Promise<{ default: React.ComponentType<any> }>;
-
-    /**
-     * Delay in milliseconds before loading the component (default: 150ms)
-     * This helps ensure all modules are properly initialized
-     */
-    initDelay?: number;
-
-    /**
-     * Custom fallback component to show if loading fails
-     * If not provided, a default error message is shown
-     */
-    fallbackComponent?: React.ComponentType<any>;
-
-    /**
-     * Error handler callback
-     */
-    onError?: (error: Error) => void;
-}
-
-/**
- * Default fallback component shown when app loading fails
- */
-export const DefaultLoadFailedComponent: React.FC<{ message?: string }> = ({
-    message = 'Failed to load application'
-}) => (
-    <div style={{
-        display: 'flex',
-        justifyContent: 'center',
-        alignItems: 'center',
-        height: '100vh',
-        background: 'linear-gradient(to bottom, var(--bodybg-primary), var(--bodybg-secondary))',
-        color: '#ff4444',
-        flexDirection: 'column',
-        gap: '16px'
-    }}>
-        <div style={{ fontSize: '18px' }}>{message}</div>
-        <button
-            onClick={() => window.location.reload()}
-            style={{
-                padding: '10px 20px',
-                backgroundColor: '#007bff',
-                color: 'white',
-                border: 'none',
-                borderRadius: '4px',
-                cursor: 'pointer'
-            }}
-        >
-            Reload Page
-        </button>
-    </div>
-);
-
-/**
- * Create a lazy-loaded app component with error handling
- *
- * @param config - Configuration options for the lazy loader
- * @returns A React lazy component
- *
- * @example
- * ```tsx
- * const AppComponent = createLazyAppComponent({
- *     importFn: () => import('./DASHAppLoader'),
- *     initDelay: 150,
- *     onError: (error) => console.error('Failed to load app:', error)
- * });
- *
- * // Then use with Suspense:
- * <React.Suspense fallback={<InitialLoader />}>
- *     <AppComponent />
- * </React.Suspense>
- * ```
- */
-export const createLazyAppComponent = (
-    config: LazyAppLoaderConfig
-): React.LazyExoticComponent<React.ComponentType<any>> => {
-    const {
-        importFn,
-        initDelay = 150,
-        fallbackComponent: FallbackComponent,
-        onError
-    } = config;
-
-    return React.lazy(() => {
-        return new Promise<{ default: React.ComponentType<any> }>((resolve) => {
-            setTimeout(() => {
-                importFn()
-                    .then((module) => {
-                        resolve({ default: module.default });
-                    })
-                    .catch((error: Error) => {
-                        console.error('Failed to load app component:', error);
-                        onError?.(error);
-
-                        // Use custom fallback or default
-                        const ErrorComponent: React.FC = FallbackComponent
-                            ? () => React.createElement(FallbackComponent)
-                            : () => React.createElement(DefaultLoadFailedComponent, {
-                                message: `Failed to load: ${error.message}`
-                            });
-
-                        resolve({ default: ErrorComponent });
-                    });
-            }, initDelay);
-        });
-    });
-};
-
-/**
- * Simple version of createLazyAppComponent with minimal configuration
- *
- * @param importFn - Dynamic import function
- * @param initDelay - Optional delay in milliseconds (default: 150)
- * @returns A React lazy component
- *
- * @example
- * ```tsx
- * const AppComponent = createSimpleLazyApp(
- *     () => import('./DASHAppLoader')
- * );
- * ```
- */
-export const createSimpleLazyApp = (
-    importFn: () => Promise<{ default: React.ComponentType<any> }>,
-    initDelay: number = 150
-): React.LazyExoticComponent<React.ComponentType<any>> => {
-    return createLazyAppComponent({ importFn, initDelay });
-};
-
-export default createLazyAppComponent;

package/src/components/MinimalLayout.tsx

@@ -1,22 +0,0 @@
-/**
- * MinimalLayout Component
- *
- * A minimal layout wrapper that simply renders its children.
- * Useful as a pass-through layout when you want React-Admin
- * to use a different layout than the default.
- */
-import React from 'react';
-
-export interface MinimalLayoutProps {
-    children?: React.ReactNode;
-}
-
-/**
- * MinimalLayout - A pass-through layout component
- * Simply renders children without any wrapper elements
- */
-export const MinimalLayout: React.FC<MinimalLayoutProps> = ({ children }) => {
-    return <>{children}</>;
-};
-
-export default MinimalLayout;

package/src/components/RouterComponent.tsx

@@ -1,169 +0,0 @@
-/**
- * DashRouterComponent
- *
- * A smart router component that automatically chooses between
- * HashRouter (for Electron/desktop) and BrowserRouter (for web).
- *
- * Environment detection is automatic when props are not provided.
- */
-import React, { Suspense } from 'react';
-import { BrowserRouter, HashRouter, Routes } from 'react-router-dom';
-import { getEnv } from '../utils/envUtils';
-
-/**
- * Props for DashRouterComponent
- */
-export interface DashRouterComponentProps {
-    /**
-     * Direct children - used when publicRoutes is not provided
-     * @deprecated Use publicRoutes prop instead for cleaner API
-     */
-    children?: React.ReactNode;
-    /** Force a specific router type */
-    forceType?: 'hash' | 'browser';
-    /**
-     * Base path for BrowserRouter
-     * @default getEnv('BASE_PATH') || '/'
-     */
-    basename?: string;
-    /**
-     * Platform type from environment (optional - auto-detected from VITE_PLATFORM_TYPE)
-     * @default getEnv('PLATFORM_TYPE')
-     */
-    platformType?: string;
-    /**
-     * Platform name from environment (optional - auto-detected from VITE_PLATFORM)
-     * @default getEnv('PLATFORM')
-     */
-    platform?: string;
-    /** Loading fallback component shown during lazy loading */
-    loader?: React.ReactNode;
-    /**
-     * Public routes to render inside Routes component.
-     * Can be a function that returns routes (recommended) or pre-created ReactNode.
-     * Using a function ensures routes are created inside Router context.
-     */
-    publicRoutes?: React.ReactNode | (() => React.ReactNode);
-    /** Optional className for the wrapper div */
-    className?: string;
-}
-
-/** @deprecated Use DashRouterComponentProps instead */
-export type RouterComponentProps = DashRouterComponentProps;
-
-/**
- * Determine if HashRouter should be used based on environment
- */
-export const shouldUseHashRouter = (platformType?: string, platform?: string): boolean => {
-    return platformType === 'desktop' || platform === 'electron';
-};
-
-/**
- * Inner component that renders routes inside Router context
- * This ensures route components with hooks are created INSIDE the Router
- */
-const RouterContent: React.FC<{
-    publicRoutes?: React.ReactNode | (() => React.ReactNode);
-    loader?: React.ReactNode;
-    className: string;
-    children?: React.ReactNode;
-}> = ({ publicRoutes, loader, className, children }) => {
-    if (!publicRoutes) {
-        // Legacy: direct children
-        return <>{children}</>;
-    }
-
-    // Resolve routes - call function if it's a function, otherwise use directly
-    // This is called INSIDE the Router context, so useNavigate etc. will work
-    let routes: React.ReactNode;
-    if (typeof publicRoutes === 'function') {
-        routes = (publicRoutes as () => React.ReactNode)();
-    } else {
-        routes = publicRoutes;
-    }
-
-    return (
-        <div className={className}>
-            <Suspense fallback={loader || <div>Loading...</div>}>
-                <Routes>
-                    {routes}
-                </Routes>
-            </Suspense>
-        </div>
-    );
-};
-
-/**
- * DashRouterComponent - Smart router that chooses the appropriate router type
- *
- * Automatically detects platform environment when props are not provided:
- * - platformType: from VITE_PLATFORM_TYPE env var
- * - platform: from VITE_PLATFORM env var
- * - basename: from VITE_BASE_PATH env var (defaults to '/')
- */
-export const DashRouterComponent: React.FC<DashRouterComponentProps> = ({
-    children,
-    forceType,
-    basename,
-    platformType,
-    platform,
-    loader,
-    publicRoutes,
-    className = 'dash-public-app',
-}) => {
-    // Get environment values internally if not provided as props
-    const effectivePlatformType = platformType ?? getEnv('PLATFORM_TYPE');
-    const effectivePlatform = platform ?? getEnv('PLATFORM');
-    const effectiveBasename = basename ?? getEnv('BASE_PATH') ?? '/';
-
-    // Render content using RouterContent component (which runs inside Router context)
-    const content = (
-        <RouterContent
-            publicRoutes={publicRoutes}
-            loader={loader}
-            className={className}
-        >
-            {children}
-        </RouterContent>
-    );
-
-    // If forceType is specified, use that
-    if (forceType === 'hash') {
-        return <HashRouter basename="">{content}</HashRouter>;
-    }
-
-    if (forceType === 'browser') {
-        return <BrowserRouter basename={effectiveBasename}>{content}</BrowserRouter>;
-    }
-
-    // Auto-detect based on platform
-    if (shouldUseHashRouter(effectivePlatformType, effectivePlatform)) {
-        return <HashRouter basename="">{content}</HashRouter>;
-    }
-
-    return <BrowserRouter basename={effectiveBasename}>{content}</BrowserRouter>;
-};
-
-/**
- * Create a DashRouterComponent with pre-configured environment settings
- */
-export const createRouterComponent = (envVars: {
-    PLATFORM_TYPE?: string;
-    PLATFORM?: string;
-}): React.FC<{ children: React.ReactNode }> => {
-    const RouterWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
-        <DashRouterComponent
-            platformType={envVars.PLATFORM_TYPE}
-            platform={envVars.PLATFORM}
-        >
-            {children}
-        </DashRouterComponent>
-    );
-
-    return RouterWrapper;
-};
-
-/** @deprecated Use DashRouterComponent instead */
-export const RouterComponent = DashRouterComponent;
-
-export default DashRouterComponent;

package/src/components/index.ts

@@ -1,16 +0,0 @@
-/**
- * Components Index
- *
- * Export all utility components from dash-utils
- */
-
-export { MinimalLayout, type MinimalLayoutProps } from './MinimalLayout';
-export {
-    DashRouterComponent,
-    RouterComponent, // Backward compatibility alias
-    shouldUseHashRouter,
-    createRouterComponent,
-    type DashRouterComponentProps,
-    type RouterComponentProps // Backward compatibility alias
-} from './RouterComponent';
-

package/src/contexts/IPCMessageBrokerContext.tsx

@@ -1,303 +0,0 @@
-import { useState, useRef, useEffect, createContext, useContext } from "react";
-import { DashIPCServiceType } from "../utils/dashIPCService";
-
-/**
- * IPCMessageBrokerContext
- *
- * This context provides access to messages from the Electron main process,
- * including log messages and subprocess outputs.
- *
- * ## Usage
- *
- * 1. Wrap your component tree with the IPCMessageBrokerProvider:
- *    ```tsx
- *    // In your app root or where you need IPC message access
- *    <IPCMessageBrokerProvider>
- *      <YourComponent />
- *    </IPCMessageBrokerProvider>
- *    ```
- *
- * 2. Use the hook to access messages in any child component:
- *    ```tsx
- *    import { useIPCMessageBroker } from 'dash-utils';
- *
- *    const MyComponent = () => {
- *      const { logMessages, subprocessOutputs, lastMessage, idleStatus } = useIPCMessageBroker();
- *
- *      return (
- *        <div>
- *          <h3>Last Message: {lastMessage}</h3>
- *
- *          <h3>Log Messages:</h3>
- *          <ul>
- *            {logMessages.map((log, index) => (
- *              <li key={index} className={`log-${log.level}`}>
- *                [{log.timestamp}] {log.level}: {log.message}
- *              </li>
- *            ))}
- *          </ul>
- *
- *          <h3>Subprocess Output:</h3>
- *          <ul>
- *            {subprocessOutputs.map((output, index) => (
- *              <li key={index} className={`output-${output.type}`}>
- *                [{output.timestamp}] {output.type}: {output.message}
- *              </li>
- *            ))}
- *          </ul>
- *        </div>
- *      );
- *    };
- *    ```
- *
- * 3. The context also manages idle status and automatic resuscitation of
- *    background processes if they become idle for too long.
- *
- * Note: This context works in both Electron and non-Electron environments.
- * In non-Electron environments, it gracefully degrades and still provides the context API.
- */
-
-export interface LogMessage {
-  level: string;
-  message: string;
-  timestamp: string;
-}
-
-export interface SubprocessOutput {
-  type: string;
-  message: string;
-  timestamp: string;
-  pid?: number;
-  exitCode?: number;
-  error?: string;
-}
-
-export interface IPCMessageBrokerContextType {
-  lastMessage: string | undefined;
-  idleStatus: boolean;
-  logMessages: LogMessage[];
-  subprocessOutputs: SubprocessOutput[];
-  isElectronAvailable: boolean;
-}
-
-export interface IPCMessageBrokerConfig {
-  /** Time in milliseconds before idle status is set (default: 180000 = 3 minutes) */
-  idleTime?: number;
-  /** Time in milliseconds before resuscitation is triggered (default: 360000 = 6 minutes) */
-  resuscitationTime?: number;
-  /** Maximum number of log messages to keep in memory (default: 100) */
-  maxLogMessages?: number;
-  /** Maximum number of subprocess outputs to keep in memory (default: 100) */
-  maxSubprocessOutputs?: number;
-  /** Maximum initialization attempts (default: 5) */
-  maxInitAttempts?: number;
-  /** Delay between initialization attempts in ms (default: 500) */
-  initRetryDelay?: number;
-}
-
-const DEFAULT_CONFIG: Required<IPCMessageBrokerConfig> = {
-  idleTime: 180 * 1000,
-  resuscitationTime: 360 * 1000,
-  maxLogMessages: 100,
-  maxSubprocessOutputs: 100,
-  maxInitAttempts: 5,
-  initRetryDelay: 500,
-};
-
-export const IPCMessageBrokerContext = createContext<IPCMessageBrokerContextType>({
-  lastMessage: undefined,
-  idleStatus: false,
-  logMessages: [],
-  subprocessOutputs: [],
-  isElectronAvailable: false
-});
-
-/** Custom hook for accessing the IPC Message Broker context */
-export const useIPCMessageBroker = () => useContext(IPCMessageBrokerContext);
-// Global type declaration for DashIPCService
-declare global {
-  interface Window {
-    DashIPCService?: DashIPCServiceType;
-  }
-}
-
-interface IPCMessageBrokerProviderProps {
-  children: React.ReactNode;
-  config?: IPCMessageBrokerConfig;
-}
-
-export const IPCMessageBrokerProvider = ({
-  children,
-  config: userConfig
-}: IPCMessageBrokerProviderProps) => {
-  const config = { ...DEFAULT_CONFIG, ...userConfig };
-
-  const [lastMessage, setLastMessage] = useState<string>();
-  const [idleStatus, setIdleStatus] = useState(false);
-  const [idleTimeout, setIdleTimeout] = useState<ReturnType<typeof setTimeout> | null>(null);
-  const [logMessages, setLogMessages] = useState<LogMessage[]>([]);
-  const [subprocessOutputs, setSubprocessOutputs] = useState<SubprocessOutput[]>([]);
-  const [isElectronAvailable, setIsElectronAvailable] = useState<boolean>(false);
-  const initAttempts = useRef(0);
-
-  const resetIdleStatus = () => {
-    setIdleStatus(false);
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
-    }
-    setIdleTimeout(setTimeout(() => {
-      setIdleStatus(true);
-    }, config.idleTime));
-  };
-
-  // Safely call a method if it exists
-  const safeMethodCall = <T extends (...args: any[]) => any>(
-    obj: any,
-    methodName: string,
-    fallback: T | null = null
-  ): T | null => {
-    if (obj && typeof obj[methodName] === 'function') {
-      return obj[methodName].bind(obj);
-    }
-    console.warn(`Method ${methodName} is not available on DashIPCService`);
-    return fallback;
-  };
-
-  // Setup IPC listeners with retry mechanism
-  const setupIPCListeners = () => {
-    if (typeof window === 'undefined') return false;
-
-    // Check if DashIPCService is available
-    if (!window.DashIPCService) {
-      console.log(`DashIPCService not available yet. Attempt ${initAttempts.current + 1}/${config.maxInitAttempts}`);
-      initAttempts.current += 1;
-
-      if (initAttempts.current < config.maxInitAttempts) {
-        setTimeout(setupIPCListeners, config.initRetryDelay);
-      } else {
-        console.warn('Failed to initialize DashIPCService after multiple attempts');
-      }
-      return false;
-    }
-
-    console.log('DashIPCService is available, setting up listeners');
-    setIsElectronAvailable(true);
-
-    const handleMessage = (message: string) => {
-      setLastMessage(message);
-      resetIdleStatus();
-    };
-
-    const handleLogMessage = (logData: LogMessage) => {
-      console.log('Log message received:', logData);
-      setLogMessages(prev => [...prev.slice(-(config.maxLogMessages - 1)), logData]);
-      resetIdleStatus();
-    };
-
-    const handleSubprocessOutput = (data: SubprocessOutput) => {
-      console.log('Subprocess output received:', data);
-      setSubprocessOutputs(prev => [...prev.slice(-(config.maxSubprocessOutputs - 1)), data]);
-      resetIdleStatus();
-    };
-
-    // Safely set up event listeners
-    const onServiceMessage = safeMethodCall(window.DashIPCService, 'onServiceMessage');
-    const onElectronLog = safeMethodCall(window.DashIPCService, 'onElectronLog');
-    const onSubprocessOutput = safeMethodCall(window.DashIPCService, 'onSubprocessOutput');
-    const onStdout = safeMethodCall(window.DashIPCService, 'onStdout');
-
-    // Set up listeners if methods exist
-    if (onServiceMessage) {
-      onServiceMessage((data: any) => {
-        handleMessage(data);
-      });
-    }
-
-    if (onElectronLog) {
-      onElectronLog((data: LogMessage) => {
-        handleLogMessage(data);
-      });
-    }
-
-    if (onSubprocessOutput) {
-      onSubprocessOutput((data: SubprocessOutput) => {
-        handleSubprocessOutput(data);
-      });
-    }
-
-    // Fallback to stdout if onElectronLog is not available
-    if (!onElectronLog && onStdout) {
-      onStdout((message: string) => {
-        // Try to parse stdout messages as log entries
-        try {
-          if (message.includes('{') && message.includes('}')) {
-            const jsonStart = message.indexOf('{');
-            const jsonEnd = message.lastIndexOf('}') + 1;
-            const jsonStr = message.substring(jsonStart, jsonEnd);
-            const data = JSON.parse(jsonStr);
-
-            if (data.level && data.message) {
-              handleLogMessage({
-                level: data.level,
-                message: data.message,
-                timestamp: data.timestamp || new Date().toISOString()
-              });
-              return;
-            }
-          }
-        } catch {
-          // Not JSON or not a log structure, use as plain message
-        }
-
-        // Fallback: treat as a generic log message
-        handleLogMessage({
-          level: 'info',
-          message: message,
-          timestamp: new Date().toISOString()
-        });
-      });
-    }
-
-    // Start initial idle timer
-    resetIdleStatus();
-    return true;
-  };
-
-  useEffect(() => {
-    setupIPCListeners();
-
-    return () => {
-      if (idleTimeout) {
-        clearTimeout(idleTimeout);
-      }
-    };
-  }, []);
-
-  useEffect(() => {
-    if (idleStatus && window.DashIPCService && typeof window.DashIPCService.action === 'function') {
-      const resuscitateTimeout = setTimeout(() => {
-        window.DashIPCService!.action!('resuscitate', null);
-      }, config.resuscitationTime - config.idleTime);
-
-      return () => {
-        clearTimeout(resuscitateTimeout);
-      };
-    }
-  }, [idleStatus, config.resuscitationTime, config.idleTime]);
-
-  const contextValue: IPCMessageBrokerContextType = {
-    lastMessage,
-    idleStatus,
-    logMessages,
-    subprocessOutputs,
-    isElectronAvailable
-  };
-
-  return (
-    <IPCMessageBrokerContext.Provider value={contextValue}>
-      {children}
-    </IPCMessageBrokerContext.Provider>
-  );
-};
-
-export default IPCMessageBrokerProvider;

package/src/hooks/useCapacitorAppStateRefresh.ts

@@ -1,34 +0,0 @@
-import { useEffect } from 'react';
-
-/**
- * Hook to handle Capacitor app state changes
- * Triggers a refresh callback when the app resumes from background
- *
- * @param onResume - Callback function to execute when app resumes
- */
-export const useCapacitorAppStateRefresh = (onResume?: () => void) => {
-    useEffect(() => {
-        const CapacitorApp = (window as any)?.Capacitor?.Plugins?.App;
-        console.log('[useCapacitorAppStateRefresh] Checking for Capacitor App plugin:', !!CapacitorApp);
-
-        if (!CapacitorApp) return;
-
-        const handler = (state: { isActive: boolean }) => {
-            console.log('[useCapacitorAppStateRefresh] App state changed:', state);
-            if (state.isActive) {
-                console.log('[useCapacitorAppStateRefresh] App is resuming, triggering callback');
-                onResume?.();
-            }
-        };
-
-        CapacitorApp.addListener('appStateChange', handler);
-        console.log('[useCapacitorAppStateRefresh] Added appStateChange listener');
-
-        return () => {
-            CapacitorApp.removeAllListeners?.();
-            console.log('[useCapacitorAppStateRefresh] Removed all Capacitor App listeners');
-        };
-    }, [onResume]);
-};
-
-export default useCapacitorAppStateRefresh;