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

package/src/utils/dashBootstrapApp.ts

@@ -1,104 +0,0 @@
-/**
- * Dash Bootstrap Application Utilities
- *
- * Core bootstrap functions for initializing a Dash application.
- * These utilities handle platform detection and environment setup before React renders.
- *
- * NOTE: For tenant styles injection, use injectTenantStyles from 'dash-admin' package.
- */
-import { syncElectronStore } from './electronStoreSync';
-import { applyPlatformBodyClasses } from './platformDetection';
-import { requestNotificationPermission } from './notificationPermission';
-
-export interface DashInitializeAppConfig {
-    /**
-     * Default theme to use for tenant styles
-     * @deprecated Use injectTenantStyles from 'dash-admin' instead
-     */
-    defaultTheme?: string;
-
-    /** Whether to request notification permission (default: true) */
-    requestNotifications?: boolean;
-
-    /** Whether to sync Electron store (default: true) */
-    syncElectron?: boolean;
-
-    /** Whether to apply platform body classes (default: true) */
-    applyPlatformClasses?: boolean;
-}
-
-/**
- * Initialize the Dash application asynchronously
- * Called before React renders to set up the environment
- *
- * @param config - Optional configuration for initialization steps
- *
- * @example
- * ```tsx
- * // With default settings
- * await dashInitializeApp();
- *
- * // With custom configuration
- * await dashInitializeApp({
- *     defaultTheme: 'dark',
- *     requestNotifications: false
- * });
- * ```
- */
-export const dashInitializeApp = async (config: DashInitializeAppConfig = {}): Promise<void> => {
-    const {
-        requestNotifications = true,
-        syncElectron = true,
-        applyPlatformClasses = true
-    } = config;
-
-    // Sync Electron store to localStorage first
-    if (syncElectron) {
-        await syncElectronStore();
-    }
-
-    // Apply platform-specific body classes
-    if (applyPlatformClasses) {
-        applyPlatformBodyClasses();
-    }
-
-    // NOTE: Tenant styles injection should be done by caller using injectTenantStyles from 'dash-admin'
-
-    // Request notification permission
-    if (requestNotifications) {
-        await requestNotificationPermission();
-    }
-};
-
-/**
- * Synchronous bootstrap sequence for immediate execution
- * Use this when you don't need to await the electron store sync
- *
- * NOTE: For tenant styles injection, use injectTenantStyles from 'dash-admin' separately.
- *
- * @example
- * ```tsx
- * // In main.tsx before React renders
- * import { injectTenantStyles } from 'dash-admin';
- *
- * dashBootstrapApp();
- * injectTenantStyles('dark'); // Call separately
- *
- * // Then render React
- * root.render(<App />);
- * ```
- */
-export const dashBootstrapApp = (): void => {
-    // Sync Electron store (async but non-blocking)
-    syncElectronStore();
-
-    // Apply platform-specific body classes
-    applyPlatformBodyClasses();
-
-    // NOTE: Tenant styles injection should be done by caller using injectTenantStyles from 'dash-admin'
-
-    // Request notification permission (non-blocking)
-    requestNotificationPermission();
-};
-
-export default dashBootstrapApp;

package/src/utils/dashDtorage.tsx

@@ -1,51 +0,0 @@
-import { getEnv } from "./envUtils";
-
-interface PersistanceLayer {
-    getItem<T = any>(key: string): T | null;
-    setItem<T = any>(key: string, value: T): void;
-    removeItem(key: string): void;
-    clear(): void;
-}
-
-class LocalStorageLayer implements PersistanceLayer {
-    getItem<T = any>(key: string): T | null {
-        const item = window.localStorage.getItem(key);
-        if (!item) return null;
-        try {
-            return JSON.parse(item);
-        } catch {
-            // Return as string if not valid JSON
-            return item as any;
-        }
-    }
-    setItem<T = any>(key: string, value: T): void {
-        window.localStorage.setItem(key, JSON.stringify(value));
-    }
-    removeItem(key: string): void {
-        window.localStorage.removeItem(key);
-    }
-    clear(): void {
-        window.localStorage.clear();
-    }
-}
-
-export class dashStorage {
-    private static localLayer = new LocalStorageLayer();
-
-    private static get layer(): PersistanceLayer {
-        return dashStorage.localLayer;
-    }
-
-    static getItem<T = any>(key: string): T | null {
-        return this.layer.getItem<T>(key);
-    }
-    static setItem<T = any>(key: string, value: T): void {
-        this.layer.setItem<T>(key, value);
-    }
-    static removeItem(key: string): void {
-        this.layer.removeItem(key);
-    }
-    static clear(): void {
-        this.layer.clear();
-    }
-}

package/src/utils/dashDtorage.tsx.old

@@ -1,78 +0,0 @@
-import { getEnv } from "./envUtils";
-
-type StorageType = 'localStorage' | 'electronStore';
-
-interface PersistanceLayer {
-    getItem<T = any>(key: string): T | null;
-    setItem<T = any>(key: string, value: T): void;
-    removeItem(key: string): void;
-    clear(): void;
-}
-
-class LocalStorageLayer implements PersistanceLayer {
-    /*getItem<T = any>(key: string): T | null {
-        const item = window.localStorage.getItem(key);
-        return item ? JSON.parse(item) : null;
-    }*/
-    getItem<T = any>(key: string): T | null {
-        const item = window.localStorage.getItem(key);
-        if (!item) return null;
-        try {
-            return JSON.parse(item);
-        } catch {
-            // Return as string if not valid JSON
-            return item as any;
-        }
-    }
-    setItem<T = any>(key: string, value: T): void {
-        window.localStorage.setItem(key, JSON.stringify(value));
-    }
-    removeItem(key: string): void {
-        window.localStorage.removeItem(key);
-    }
-    clear(): void {
-        window.localStorage.clear();
-    }
-}
-
-class ElectronStoreLayer implements PersistanceLayer {
-    getItem<T = any>(key: string): T | null {
-        return (window as any).electronStore?.get(key) ?? null;
-    }
-    setItem<T = any>(key: string, value: T): void {
-        (window as any).electronStore?.set(key, value);
-    }
-    removeItem(key: string): void {
-        (window as any).electronStore?.delete(key);
-    }
-    clear(): void {
-        (window as any).electronStore?.clear();
-    }
-}
-
-export class dashStorage {
-    private static get layer(): PersistanceLayer {
-        const storageType = (getEnv('APP_STORAGE_TYPE') as StorageType) || 'localStorage';
-        if (storageType === 'electronStore' && (window as any).electronStore) {
-            return dashStorage.electronLayer;
-        } else {
-            return dashStorage.localLayer;
-        }
-    }
-
-    private static localLayer = new LocalStorageLayer();
-    private static electronLayer = new ElectronStoreLayer();
-
-    static getItem<T = any>(key: string): T | null {
-        return this.layer.getItem<T>(key);
-    }
-    static setItem<T = any>(key: string, value: T): void {
-        this.layer.setItem<T>(key, value);
-    }
-    static removeItem(key: string): void {
-        this.layer.removeItem(key);
-    }
-    static clear(): void {
-        this.layer.clear();
-    }
-}

package/src/utils/dashIPCService.ts

@@ -1,204 +0,0 @@
-// Electron IPC Service Types
-export interface SpeechPayload {
-    message: string;
-    lang?: string;
-}
-
-export interface SubprocessOutput {
-    type: 'stdout' | 'stderr' | 'exit' | 'error' | 'print-stdout' | 'print-stderr';
-    message: string;
-    timestamp: string;
-    pid?: number;
-    exitCode?: number;
-    error?: string;
-    code?: string;
-}
-
-export interface ElectronLogData {
-    level: 'info' | 'error' | 'warn' | 'debug' | 'verbose';
-    message: string;
-    timestamp: string;
-}
-
-/**
- * DashIPCService
- *
- * Utility for interacting with Electron IPC (Inter-Process Communication).
- * Provides a safe wrapper around the DashIPCService that may be injected
- * by the Electron preload script.
- */
-
-/**
- * Extended Interface for the DashIPCService exposed by Electron
- */
-export interface DashIPCServiceType {
-    runPythonScript: (filePath: string, scriptPath: string, args: string[]) => void;
-    action: (action: string, payload: any) => void;
-    speak: (payload: string | SpeechPayload) => void;
-    playSound: (soundName: string) => void;
-    stopSound: () => void;
-    notify: (title: string, message: string) => void;
-    onPythonOutput: (callback: (data: any) => void) => void;
-    onServiceMessage: (callback: (data: any) => void) => void;
-    onStdout: (callback: (data: string) => void) => void;
-    onElectronLog: (callback: (logData: ElectronLogData) => void) => void;
-    onSubprocessOutput: (callback: (data: SubprocessOutput) => void) => void;
-    windowControls: (action: 'minimize' | 'maximize' | 'close') => void;
-    startDrag: () => void;
-    // Print service - calls print_service directly
-    print: (urlOrTest: string) => Promise<any>;
-    // Legacy/optional methods
-    send?: (channel: string, data?: any) => void;
-    invoke?: (channel: string, data?: any) => Promise<any>;
-}
-
-/**
- * Electron Store Type
- */
-export interface ElectronStoreType {
-    get: (key: string) => Promise<any>;
-    set: (key: string, value: any) => Promise<void>;
-    delete: (key: string) => Promise<void>;
-    clear: () => Promise<void>;
-    getAll: () => Promise<Record<string, any>>;
-    syncToLocalStorage: () => Promise<Record<string, any>>;
-}
-
-/**
- * Extend Window interface to include DashIPCService and ElectronStore
- */
-declare global {
-    interface Window {
-        DashIPCService?: DashIPCServiceType;
-        electronStore?: ElectronStoreType;
-    }
-}
-
-/**
- * Check if DashIPCService is available (running in Electron)
- */
-export const isDashIPCServiceAvailable = (): boolean => {
-    return typeof window !== 'undefined' && !!window.DashIPCService;
-};
-
-/**
- * Check if running in Electron environment
- */
-export const isElectron = (): boolean => {
-    return isDashIPCServiceAvailable();
-};
-
-/**
- * Get the DashIPCService instance
- * Returns undefined if not running in Electron
- */
-export const getDashIPCService = (): DashIPCServiceType | undefined => {
-    if (typeof window !== 'undefined') {
-        return window.DashIPCService;
-    }
-    return undefined;
-};
-
-/**
- * Safe wrapper for window control actions
- */
-export const windowControl = (action: 'minimize' | 'maximize' | 'close'): boolean => {
-    const ipc = getDashIPCService();
-    if (ipc) {
-        ipc.windowControls(action);
-        return true;
-    }
-    return false;
-};
-
-/**
- * Start window dragging (for custom title bars)
- */
-export const startWindowDrag = (): boolean => {
-    const ipc = getDashIPCService();
-    if (ipc) {
-        ipc.startDrag();
-        return true;
-    }
-    return false;
-};
-
-/**
- * Execute an IPC action
- */
-export const executeIPCAction = (action: string, payload: any): boolean => {
-    const ipc = getDashIPCService();
-    if (ipc) {
-        ipc.action(action, payload);
-        return true;
-    }
-    return false;
-};
-
-/**
- * Register a callback for stdout events
- */
-export const onIPCStdout = (callback: (data: string) => void): boolean => {
-    const ipc = getDashIPCService();
-    if (ipc && ipc.onStdout) {
-        ipc.onStdout(callback);
-        return true;
-    }
-    return false;
-};
-
-/**
- * Register a callback for Electron log events
- */
-export const onElectronLog = (callback: (logData: ElectronLogData) => void): boolean => {
-    const ipc = getDashIPCService();
-    if (ipc && ipc.onElectronLog) {
-        ipc.onElectronLog(callback);
-        return true;
-    }
-    return false;
-};
-
-/**
- * Register a callback for subprocess output events
- */
-export const onSubprocessOutput = (callback: (data: SubprocessOutput) => void): boolean => {
-    const ipc = getDashIPCService();
-    if (ipc && ipc.onSubprocessOutput) {
-        ipc.onSubprocessOutput(callback);
-        return true;
-    }
-    return false;
-};
-
-/**
- * Hook for using DashIPCService in React components
- */
-export const useDashIPCService = () => {
-    const ipcService = getDashIPCService();
-
-    return {
-        isAvailable: isDashIPCServiceAvailable(),
-        isElectron: isElectron(),
-        service: ipcService,
-        windowControl,
-        startWindowDrag,
-        executeAction: executeIPCAction,
-        onStdout: onIPCStdout,
-        onElectronLog,
-        onSubprocessOutput,
-    };
-};
-
-export default {
-    isDashIPCServiceAvailable,
-    isElectron,
-    getDashIPCService,
-    windowControl,
-    startWindowDrag,
-    executeIPCAction,
-    onIPCStdout,
-    onElectronLog,
-    onSubprocessOutput,
-    useDashIPCService,
-};

package/src/utils/dataProviderUtils.ts

@@ -1,221 +0,0 @@
-/**
- * Data Provider Utilities
- *
- * Helper functions for data provider operations.
- * These utilities are used by data providers across Dash applications.
- */
-
-/**
- * Generic resource configuration interface
- * Apps can extend this with their own properties
- */
-export interface IResourceConfig {
-    model?: string;
-    isFormData?: boolean;
-    dataTransform?: (data: Record<string, any>, operation: string) => Record<string, any>;
-    [key: string]: any;
-}
-
-/**
- * Resource configuration manager
- * Manages resource configurations for data provider operations
- */
-class ResourceConfigManager<T extends IResourceConfig = IResourceConfig> {
-    private configs: T[] = [];
-
-    /**
-     * Set resource configurations
-     */
-    setConfigs(configs: T[]): void {
-        this.configs = configs;
-    }
-
-    /**
-     * Get all resource configurations
-     */
-    getConfigs(): T[] {
-        return this.configs;
-    }
-
-    /**
-     * Get resource configuration by resource path
-     */
-    getConfig(resource: string): T | undefined {
-        // Try to find by model path (exact match)
-        const config = this.configs.find(r => r.model === resource);
-        if (config) return config;
-
-        // Try to find by matching the resource path (partial match)
-        return this.configs.find(r => {
-            const modelPath = r.model || '';
-            return resource.startsWith(modelPath) || modelPath.startsWith(resource);
-        });
-    }
-
-    /**
-     * Clear all configurations
-     */
-    clear(): void {
-        this.configs = [];
-    }
-}
-
-// Singleton instance
-let resourceConfigManager: ResourceConfigManager | null = null;
-
-/**
- * Get the resource config manager instance
- */
-export const getResourceConfigManager = <T extends IResourceConfig = IResourceConfig>(): ResourceConfigManager<T> => {
-    if (!resourceConfigManager) {
-        resourceConfigManager = new ResourceConfigManager<T>();
-    }
-    return resourceConfigManager as ResourceConfigManager<T>;
-};
-
-/**
- * Set resource configurations (convenience function)
- */
-export const setResourceConfigs = <T extends IResourceConfig = IResourceConfig>(configs: T[]): void => {
-    getResourceConfigManager<T>().setConfigs(configs);
-};
-
-/**
- * Get resource configuration by resource path (convenience function)
- */
-export const getResourceConfig = <T extends IResourceConfig = IResourceConfig>(resource: string): T | undefined => {
-    return getResourceConfigManager<T>().getConfig(resource);
-};
-
-/**
- * Process post data before sending to backend
- * Applies resource-specific transformations
- */
-export const processPostData = <T extends IResourceConfig = IResourceConfig>(
-    resource: string,
-    data: Record<string, any>,
-    operation: 'create' | 'update' | 'getList' | 'import' | string
-): Record<string, any> => {
-    const config = getResourceConfig<T>(resource);
-
-    // Clone data to avoid mutations
-    let processedData = { ...data };
-
-    // Remove undefined values for cleaner payloads
-    Object.keys(processedData).forEach(key => {
-        if (processedData[key] === undefined) {
-            delete processedData[key];
-        }
-    });
-
-    // Apply resource-specific transformations if defined
-    if (config?.dataTransform) {
-        processedData = config.dataTransform(processedData, operation);
-    }
-
-    return processedData;
-};
-
-/**
- * Process data into FormData for file uploads
- */
-export const processFormData = (
-    resource: string,
-    data: Record<string, any>
-): FormData => {
-    const formData = new FormData();
-
-    const appendToFormData = (key: string, value: any, prefix = ''): void => {
-        const fieldName = prefix ? `${prefix}[${key}]` : key;
-
-        if (value === null || value === undefined) {
-            return;
-        }
-
-        if (value instanceof File) {
-            formData.append(fieldName, value);
-        } else if (typeof FileList !== 'undefined' && value instanceof FileList) {
-            Array.from(value).forEach((file, index) => {
-                formData.append(`${fieldName}[${index}]`, file);
-            });
-        } else if (Array.isArray(value)) {
-            value.forEach((item, index) => {
-                if (typeof item === 'object' && !(item instanceof File)) {
-                    Object.keys(item).forEach(itemKey => {
-                        appendToFormData(itemKey, item[itemKey], `${fieldName}[${index}]`);
-                    });
-                } else {
-                    formData.append(`${fieldName}[${index}]`, item);
-                }
-            });
-        } else if (typeof value === 'object' && !(value instanceof Date)) {
-            if (value.rawFile && value.rawFile instanceof File) {
-                formData.append(fieldName, value.rawFile);
-            } else {
-                Object.keys(value).forEach(objKey => {
-                    appendToFormData(objKey, value[objKey], fieldName);
-                });
-            }
-        } else if (typeof value === 'boolean') {
-            formData.append(fieldName, value ? '1' : '0');
-        } else {
-            formData.append(fieldName, String(value));
-        }
-    };
-
-    Object.keys(data).forEach(key => {
-        appendToFormData(key, data[key]);
-    });
-
-    return formData;
-};
-
-/**
- * Build query string from params
- * Supports arrays and nested objects
- */
-export const buildQueryString = (params: Record<string, any>): string => {
-    const searchParams = new URLSearchParams();
-
-    Object.keys(params).forEach(key => {
-        const value = params[key];
-        if (value !== undefined && value !== null) {
-            if (Array.isArray(value)) {
-                value.forEach(item => {
-                    searchParams.append(`${key}[]`, String(item));
-                });
-            } else if (typeof value === 'object') {
-                searchParams.append(key, JSON.stringify(value));
-            } else {
-                searchParams.append(key, String(value));
-            }
-        }
-    });
-
-    return searchParams.toString();
-};
-
-/**
- * Check if resource is configured for FormData uploads
- */
-export const isFormDataResource = <T extends IResourceConfig = IResourceConfig>(
-    resource: string,
-    params?: { data?: { isFormData?: boolean }; meta?: { isFormData?: boolean } }
-): boolean => {
-    const config = getResourceConfig<T>(resource);
-    return (
-        config?.isFormData === true ||
-        params?.data?.isFormData === true ||
-        params?.meta?.isFormData === true
-    );
-};
-
-export default {
-    getResourceConfigManager,
-    setResourceConfigs,
-    getResourceConfig,
-    processPostData,
-    processFormData,
-    buildQueryString,
-    isFormDataResource
-};

package/src/utils/electronStoreSync.ts

@@ -1,34 +0,0 @@
-/**
- * Electron Store Sync Utility
- *
- * Synchronizes Electron store with localStorage on app startup.
- */
-
-/**
- * Sync Electron store to localStorage
- * Should be called early in app initialization
- */
-export const syncElectronStore = async (): Promise<void> => {
-    if (typeof window === 'undefined' || !window.electronStore) {
-        return;
-    }
-
-    try {
-        const all = await window.electronStore.syncToLocalStorage();
-        Object.entries(all).forEach(([key, value]) => {
-            window.localStorage.setItem(key, JSON.stringify(value));
-        });
-        console.log('Electron store synced to localStorage');
-    } catch (error) {
-        console.error('Failed to sync Electron store:', error);
-    }
-};
-
-/**
- * Check if Electron store is available
- */
-export const hasElectronStore = (): boolean => {
-    return typeof window !== 'undefined' && !!window.electronStore;
-};
-
-export default syncElectronStore;