documentation-hub 5.7.2

package/src/global.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Global TypeScript Type Declarations
+ *
+ * This file provides type definitions for globally accessible APIs,
+ * particularly the Electron IPC bridge exposed via contextBridge in preload.ts
+ */
+
+import type {
+  HyperlinkProcessingOptions,
+  HyperlinkProcessingResult,
+  BatchProcessingOptions,
+  BatchProcessingResult,
+  BatchProgress,
+} from './types/hyperlink';
+import type {
+  BackupCreateResponse,
+  BackupRestoreResponse,
+  BackupListResponse,
+  BackupDeleteResponse,
+  BackupCleanupResponse,
+  BackupVerifyResponse,
+  BackupStorageInfoResponse,
+  BackupSetConfigResponse,
+  BackupConfig,
+} from './types/backup';
+import type {
+  SharePointConfig,
+  DictionarySyncStatus,
+  DictionarySyncResponse,
+  DictionaryInitResponse,
+  DictionaryCredentialsResponse,
+  SyncProgressUpdate,
+} from './types/dictionary';
+
+/**
+ * Hyperlink lookup result type (from local dictionary)
+ */
+export type HyperlinkLookupResult = {
+  Document_ID: string;
+  Content_ID: string;
+  Title: string;
+  Status: string;
+};
+
+/**
+ * ElectronAPI Type Definition
+ *
+ * Mirrors the electronAPI object exposed via contextBridge in electron/preload.ts
+ * This provides full type safety for IPC communication between renderer and main processes
+ */
+export type ElectronAPI = {
+  // Window controls
+  minimizeWindow: () => Promise<void>;
+  maximizeWindow: () => Promise<void>;
+  closeWindow: () => Promise<void>;
+  isMaximized: () => Promise<boolean>;
+  isFullscreen: () => Promise<boolean>;
+  getAppVersion: () => Promise<string>;
+  getPlatform: () => Promise<string>;
+  openDevTools: () => Promise<void>;
+
+  // Always on top (pin window)
+  setAlwaysOnTop: (flag: boolean) => Promise<boolean>;
+  isAlwaysOnTop: () => Promise<boolean>;
+  onAlwaysOnTopChanged: (callback: (isOnTop: boolean) => void) => () => void;
+
+  // File handling
+  selectDocuments: () => Promise<string[]>;
+  processDocument: (path: string) => Promise<any>;
+  showInFolder: (path: string) => Promise<void>;
+  openDocument: (path: string) => Promise<void>;
+  getFileStats: (filePath: string) => Promise<any>;
+  restoreFromBackup: (backupPath: string, targetPath: string) => Promise<any>;
+  getPathsForFiles: (files: File[]) => string[];
+
+  // Export and Reporting
+  selectFolder: () => Promise<string | null>;
+  copyFilesToFolder: (
+    filePaths: string[],
+    destinationFolder: string
+  ) => Promise<{ copied: number; skipped: number }>;
+  getDownloadsPath: () => Promise<string>;
+  createFolder: (folderPath: string) => Promise<boolean>;
+  copyFileToFolder: (sourcePath: string, destFolder: string) => Promise<boolean>;
+  createReportZip: (folderPath: string, zipName: string) => Promise<string>;
+  openOutlookEmail: (subject: string, attachmentPath: string) => Promise<{
+    success: boolean;
+    method: 'outlook' | 'mailto';
+  }>;
+
+  // Document text extraction (for comparison views)
+  extractDocumentText: (filePath: string) => Promise<{
+    success: boolean;
+    textContent?: string[];
+    error?: string;
+  }>;
+
+  // Read file as buffer (for snapshot capture)
+  readFileAsBuffer: (filePath: string) => Promise<ArrayBuffer>;
+
+  // Hyperlink processing
+  selectFiles: () => Promise<string[]>;
+  processHyperlinkDocument: (
+    filePath: string,
+    options: HyperlinkProcessingOptions
+  ) => Promise<HyperlinkProcessingResult>;
+  batchProcessDocuments: (
+    filePaths: string[],
+    options: BatchProcessingOptions
+  ) => Promise<BatchProcessingResult>;
+  validateApi: (apiUrl: string) => Promise<{ valid: boolean; error?: string }>;
+  callPowerAutomateApi: (
+    apiUrl: string,
+    payload: {
+      Lookup_ID: string[];
+      Hyperlinks_Checked: number;
+      Total_Hyperlinks: number;
+      First_Name: string;
+      Last_Name: string;
+      Email: string;
+    },
+    timeout?: number
+  ) => Promise<{
+    success: boolean;
+    statusCode?: number;
+    data?: unknown;
+    error?: string;
+    rawResponse?: string;
+  }>;
+  cancelOperation: (operationId: string) => Promise<void>;
+  onBatchProgress: (callback: (progress: BatchProgress) => void) => () => void;
+
+  // Window events
+  onWindowMaximized: (callback: () => void) => () => void;
+  onWindowUnmaximized: (callback: () => void) => () => void;
+  onWindowFullscreen: (callback: () => void) => () => void;
+  onWindowUnfullscreen: (callback: () => void) => () => void;
+
+  // Export/Import
+  exportSettings: () => Promise<{ success?: boolean; canceled?: boolean; filePath?: string }>;
+  importSettings: () => Promise<{ success?: boolean; canceled?: boolean; data?: any }>;
+  saveExportData: (filePath: string, data: any) => Promise<{ success?: boolean; error?: string }>;
+
+  // Backup operations
+  backup: {
+    create: (documentPath: string) => Promise<BackupCreateResponse>;
+    restore: (backupPath: string, targetPath: string) => Promise<BackupRestoreResponse>;
+    list: (documentPath: string) => Promise<BackupListResponse>;
+    delete: (backupPath: string) => Promise<BackupDeleteResponse>;
+    cleanup: (documentPath: string) => Promise<BackupCleanupResponse>;
+    cleanupAll: () => Promise<BackupCleanupResponse>;
+    verify: (backupPath: string) => Promise<BackupVerifyResponse>;
+    getStorageInfo: () => Promise<BackupStorageInfoResponse>;
+    setConfig: (config: Partial<BackupConfig>) => Promise<BackupSetConfigResponse>;
+  };
+
+  // Dictionary operations (Local SharePoint Dictionary)
+  dictionary: {
+    initialize: () => Promise<DictionaryInitResponse>;
+    configureSync: (config: SharePointConfig) => Promise<{ success: boolean; error?: string }>;
+    setCredentials: (clientSecret: string) => Promise<DictionaryCredentialsResponse>;
+    sync: () => Promise<DictionarySyncResponse>;
+    startScheduler: (intervalHours: number) => Promise<{ success: boolean; error?: string }>;
+    stopScheduler: () => Promise<{ success: boolean; error?: string }>;
+    lookup: (lookupId: string) => Promise<{ success: boolean; result?: HyperlinkLookupResult; error?: string }>;
+    batchLookup: (lookupIds: string[]) => Promise<{ success: boolean; results?: HyperlinkLookupResult[]; error?: string }>;
+    getStatus: () => Promise<{ success: boolean; status?: DictionarySyncStatus; error?: string }>;
+    // Interactive SharePoint retrieval (using browser login)
+    retrieveFromSharePoint: (fileUrl: string) => Promise<{ success: boolean; entriesImported?: number; error?: string }>;
+    sharePointLogin: () => Promise<{ success: boolean; error?: string }>;
+    isSharePointAuthenticated: () => Promise<{ authenticated: boolean }>;
+    onSyncProgress: (callback: (progress: SyncProgressUpdate) => void) => () => void;
+    onSyncComplete: (callback: (result: DictionarySyncResponse) => void) => () => void;
+  };
+
+  // Display/Monitor operations
+  display: {
+    getAllDisplays: () => Promise<Array<{
+      id: number;
+      label: string;
+      bounds: { x: number; y: number; width: number; height: number };
+      workArea: { x: number; y: number; width: number; height: number };
+      scaleFactor: number;
+      isPrimary: boolean;
+    }>>;
+    identifyMonitors: () => Promise<{ success: boolean }>;
+    openComparison: (
+      backupPath: string,
+      processedPath: string,
+      monitorIndex: number
+    ) => Promise<{ success: boolean; error?: string }>;
+  };
+
+  // Auto-updater
+  checkForUpdates: () => Promise<any>;
+  downloadUpdate: () => Promise<void>;
+  installUpdate: () => Promise<void>;
+  getCurrentVersion: () => Promise<string>;
+
+  // SharePoint update source
+  setUpdateProvider: (config: { type: 'github' | 'sharepoint'; sharePointUrl?: string }) => Promise<{ success: boolean; error?: string }>;
+  testSharePointConnection: (url: string) => Promise<{ success: boolean; message: string; authenticated?: boolean }>;
+  sharePointLogin: () => Promise<{ success: boolean; error?: string }>;
+  sharePointLogout: () => Promise<void>;
+
+  // Update event listeners
+  onUpdateChecking: (callback: () => void) => () => void;
+  onUpdateAvailable: (
+    callback: (info: { version: string; releaseDate: string; releaseNotes: string }) => void
+  ) => () => void;
+  onUpdateNotAvailable: (callback: (info: { version: string }) => void) => () => void;
+  onUpdateError: (callback: (error: { message: string }) => void) => () => void;
+  onUpdateDownloadProgress: (
+    callback: (progress: {
+      bytesPerSecond: number;
+      percent: number;
+      transferred: number;
+      total: number;
+    }) => void
+  ) => () => void;
+  onUpdateDownloaded: (
+    callback: (info: { version: string; releaseNotes: string; fallbackUsed?: boolean }) => void
+  ) => () => void;
+  onUpdateFallbackMode: (callback: (data: { message: string }) => void) => () => void;
+  onUpdateExtracting: (callback: (data: { message: string }) => void) => () => void;
+  onUpdateStatus: (callback: (data: { message: string }) => void) => () => void;
+
+  // Manual download
+  openUpdateInBrowser: () => Promise<void>;
+
+  // Certificate Management
+  checkZscalerStatus: () => Promise<any>;
+  getCertificatePath: () => Promise<string>;
+  getInstalledCertificates: () => Promise<string[]>;
+  importCertificate: () => Promise<{ success?: boolean; name?: string; error?: string }>;
+  autoDetectCertificates: () => Promise<{ success: boolean; count?: number }>;
+  removeCertificate: (certPath: string) => Promise<{ success?: boolean }>;
+  testGitHubConnection: () => Promise<any>;
+  openExternal: (url: string) => Promise<void>;
+
+  // Event system helpers
+  on: (channel: string, callback: (...args: any[]) => void) => () => void;
+  removeListener: (channel: string, callback: (...args: any[]) => void) => void;
+
+  // Debug events
+  onDebugNetworkRequest: (callback: (data: any) => void) => () => void;
+  onDebugCertError: (callback: (data: any) => void) => () => void;
+  onDebugNetworkError: (callback: (data: any) => void) => () => void;
+  onDebugTLSError: (callback: (data: any) => void) => () => void;
+  onUpdateManualDownload: (
+    callback: (data: { message: string; downloadUrl: string }) => void
+  ) => () => void;
+
+  // Certificate check events
+  onCertificateCheckComplete: (
+    callback: (data: { success: boolean; error?: string; timestamp: string }) => void
+  ) => () => void;
+  onCertificateConfigured: (
+    callback: (data: { message: string; certPath?: string }) => void
+  ) => () => void;
+};
+
+/**
+ * Extend the Window interface to include electronAPI
+ * This makes window.electronAPI available throughout the application with full type safety
+ */
+declare global {
+  interface Window {
+    electronAPI: ElectronAPI;
+  }
+}
+
+export {};

package/src/hooks/useDocumentQueue.tsx

@@ -0,0 +1,210 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useSession } from '@/contexts/SessionContext';
+import type { QueueItem } from '@/types/session';
+import { processingTimeEstimator, ProcessingTimeEstimator } from '@/utils/processingTimeEstimator';
+
+export interface UseDocumentQueueOptions {
+  onDocumentComplete?: (documentId: string, success: boolean) => void;
+  onQueueComplete?: () => void;
+  onError?: (documentId: string, error: string) => void;
+}
+
+export interface UseDocumentQueueReturn {
+  // State
+  queue: QueueItem[];
+  isProcessing: boolean;
+  currentDocumentId: string | null;
+  estimatedTimeRemaining: number; // in milliseconds
+  estimatedTimeRemainingFormatted: string; // human-readable format
+
+  // Actions
+  addToQueue: (sessionId: string, documentId: string) => void;
+  addManyToQueue: (sessionId: string, documentIds: string[]) => void;
+  removeFromQueue: (documentId: string) => void;
+  clearQueue: () => void;
+
+  // Utility
+  getQueuePosition: (documentId: string) => number; // -1 if not in queue
+  isInQueue: (documentId: string) => boolean;
+}
+
+export function useDocumentQueue(
+  options: UseDocumentQueueOptions = {}
+): UseDocumentQueueReturn {
+  const { processDocument } = useSession();
+  const { onDocumentComplete, onQueueComplete, onError } = options;
+
+  // Use refs for queue management to prevent stale closures
+  const queueRef = useRef<QueueItem[]>([]);
+  const isProcessingRef = useRef(false);
+  const isMountedRef = useRef(true);
+
+  // State for UI reactivity (synced from refs)
+  const [queue, setQueue] = useState<QueueItem[]>([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [currentDocumentId, setCurrentDocumentId] = useState<string | null>(null);
+  const [estimatedTimeRemaining, setEstimatedTimeRemaining] = useState(0);
+
+  // Sync ref to state for UI updates
+  const syncState = useCallback(() => {
+    if (isMountedRef.current) {
+      setQueue([...queueRef.current]);
+      setIsProcessing(isProcessingRef.current);
+      // Update estimated time remaining
+      const remaining = processingTimeEstimator.estimateRemainingTime(queueRef.current.length);
+      setEstimatedTimeRemaining(remaining);
+    }
+  }, []);
+
+  // Process next document in queue
+  const processNext = useCallback(async () => {
+    // Check if we should process
+    if (isProcessingRef.current || queueRef.current.length === 0) {
+      return;
+    }
+
+    // Get next item that is still queued
+    const nextItem = queueRef.current.find(item => item.status === 'queued');
+    if (!nextItem) {
+      return;
+    }
+
+    // Mark as processing
+    isProcessingRef.current = true;
+    nextItem.status = 'processing';
+    setCurrentDocumentId(nextItem.documentId);
+    syncState();
+
+    // Start timing this document (assume 1 API call per document)
+    processingTimeEstimator.startDocument(nextItem.documentId, 1);
+
+    try {
+      // Process the document (this is the IPC call that makes the API request)
+      await processDocument(nextItem.sessionId, nextItem.documentId);
+
+      // Mark as completed
+      nextItem.status = 'completed';
+      onDocumentComplete?.(nextItem.documentId, true);
+    } catch (error) {
+      // Mark as error
+      nextItem.status = 'error';
+      const errorMessage = error instanceof Error ? error.message : 'Processing failed';
+      onError?.(nextItem.documentId, errorMessage);
+      onDocumentComplete?.(nextItem.documentId, false);
+    }
+
+    // End timing for this document
+    processingTimeEstimator.endDocument();
+
+    // Remove from queue
+    queueRef.current = queueRef.current.filter(item => item.documentId !== nextItem.documentId);
+    isProcessingRef.current = false;
+    setCurrentDocumentId(null);
+    syncState();
+
+    // Check if queue is complete
+    if (queueRef.current.length === 0) {
+      onQueueComplete?.();
+    } else {
+      // Process next item with small delay to prevent overwhelming
+      setTimeout(processNext, 100);
+    }
+  }, [processDocument, syncState, onDocumentComplete, onQueueComplete, onError]);
+
+  // Add single document to queue
+  const addToQueue = useCallback((sessionId: string, documentId: string) => {
+    // Check if already in queue
+    if (queueRef.current.some(item => item.documentId === documentId)) {
+      return;
+    }
+
+    const newItem: QueueItem = {
+      documentId,
+      sessionId,
+      addedAt: new Date(),
+      status: 'queued',
+    };
+
+    queueRef.current = [...queueRef.current, newItem];
+    syncState();
+
+    // Start processing if not already
+    processNext();
+  }, [syncState, processNext]);
+
+  // Add multiple documents to queue
+  const addManyToQueue = useCallback((sessionId: string, documentIds: string[]) => {
+    const newItems: QueueItem[] = documentIds
+      .filter(id => !queueRef.current.some(item => item.documentId === id))
+      .map(documentId => ({
+        documentId,
+        sessionId,
+        addedAt: new Date(),
+        status: 'queued' as const,
+      }));
+
+    if (newItems.length > 0) {
+      queueRef.current = [...queueRef.current, ...newItems];
+      syncState();
+      processNext();
+    }
+  }, [syncState, processNext]);
+
+  // Remove document from queue
+  const removeFromQueue = useCallback((documentId: string) => {
+    queueRef.current = queueRef.current.filter(item => item.documentId !== documentId);
+    syncState();
+  }, [syncState]);
+
+  // Clear entire queue
+  const clearQueue = useCallback(() => {
+    queueRef.current = [];
+    syncState();
+  }, [syncState]);
+
+  // Get queue position for a document
+  const getQueuePosition = useCallback((documentId: string): number => {
+    return queueRef.current.findIndex(item => item.documentId === documentId);
+  }, []);
+
+  // Check if document is in queue
+  const isInQueue = useCallback((documentId: string): boolean => {
+    return queueRef.current.some(item => item.documentId === documentId);
+  }, []);
+
+  // Update estimated time remaining periodically while processing
+  useEffect(() => {
+    if (!isProcessing) return;
+
+    const updateTimer = setInterval(() => {
+      if (isMountedRef.current) {
+        const remaining = processingTimeEstimator.estimateRemainingTime(queueRef.current.length);
+        setEstimatedTimeRemaining(remaining);
+      }
+    }, 1000);
+
+    return () => clearInterval(updateTimer);
+  }, [isProcessing]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  return {
+    queue,
+    isProcessing,
+    currentDocumentId,
+    estimatedTimeRemaining,
+    estimatedTimeRemainingFormatted: ProcessingTimeEstimator.formatTime(estimatedTimeRemaining),
+    addToQueue,
+    addManyToQueue,
+    removeFromQueue,
+    clearQueue,
+    getQueuePosition,
+    isInQueue,
+  };
+}

package/src/hooks/useToast.tsx

@@ -0,0 +1,55 @@
+import { useState, useCallback } from 'react';
+
+export interface Toast {
+  id: string;
+  title: string;
+  description?: string;
+  variant?: 'default' | 'destructive' | 'success';
+  duration?: number;
+}
+
+// Default duration: 3 seconds for quick, unobtrusive notifications
+// Error notifications get slightly longer (4 seconds) for readability
+const DEFAULT_DURATION = 3000;
+const ERROR_DURATION = 4000;
+
+export function useToast() {
+  const [toasts, setToasts] = useState<Toast[]>([]);
+
+  const toast = useCallback(
+    ({ title, description, variant = 'default', duration }: Omit<Toast, 'id'>) => {
+      // Use provided duration, or default based on variant
+      const effectiveDuration = duration ?? (variant === 'destructive' ? ERROR_DURATION : DEFAULT_DURATION);
+
+      const id = Math.random().toString(36).substring(7);
+      const newToast: Toast = { id, title, description, variant, duration: effectiveDuration };
+
+      setToasts((prev) => [...prev, newToast]);
+
+      // Auto-remove toast after duration
+      if (effectiveDuration > 0) {
+        setTimeout(() => {
+          setToasts((prev) => prev.filter((t) => t.id !== id));
+        }, effectiveDuration);
+      }
+
+      return id;
+    },
+    []
+  );
+
+  const dismiss = useCallback((id: string) => {
+    setToasts((prev) => prev.filter((t) => t.id !== id));
+  }, []);
+
+  const dismissAll = useCallback(() => {
+    setToasts([]);
+  }, []);
+
+  return {
+    toasts,
+    toast,
+    dismiss,
+    dismissAll,
+  };
+}

package/src/main.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+import './styles/global.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);