documentation-hub 5.7.2

package/src/types/backup.ts

@@ -0,0 +1,132 @@
+/**
+ * Backup Service Type Definitions
+ *
+ * These types are shared between main process (BackupService)
+ * and renderer process (via IPC) for type-safe backup operations.
+ */
+
+/**
+ * Information about a single backup file
+ */
+export interface BackupInfo {
+  /** Absolute path to the backup file */
+  path: string;
+
+  /** Filename of the backup (without directory) */
+  filename: string;
+
+  /** Size of backup file in bytes */
+  size: number;
+
+  /** Date when backup was created */
+  created: Date;
+
+  /** Date when backup was last modified */
+  modified: Date;
+
+  /** Path to the original document */
+  originalPath: string;
+
+  /** SHA-256 checksum of backup file (for integrity verification) */
+  checksum?: string;
+}
+
+/**
+ * Metadata stored alongside each backup
+ */
+export interface BackupMetadata {
+  /** Path to the original document */
+  originalPath: string;
+
+  /** Path where backup is stored */
+  backupPath: string;
+
+  /** ISO timestamp of backup creation */
+  timestamp: string;
+
+  /** Size of backed up document in bytes */
+  size: number;
+
+  /** SHA-256 checksum for integrity verification */
+  checksum: string;
+}
+
+/**
+ * Storage statistics for all backups
+ */
+export interface StorageInfo {
+  /** Total size of all backups in bytes */
+  totalSize: number;
+
+  /** Total number of backup files */
+  fileCount: number;
+
+  /** Average size per backup in bytes */
+  averageSize: number;
+
+  /** Path to backup directory */
+  path: string;
+}
+
+/**
+ * Configuration options for BackupService
+ */
+export interface BackupConfig {
+  /** Custom backup directory (default: ~/.dochub/backups) */
+  backupDir?: string;
+
+  /** Maximum age of backups in days (default: 7) */
+  maxBackupAgeDays?: number;
+
+  /** Maximum number of backups to keep per document (default: 5) */
+  maxBackupsPerDocument?: number;
+}
+
+/**
+ * IPC Response types for backup operations
+ */
+
+export interface BackupCreateResponse {
+  success: boolean;
+  backupPath?: string;
+  error?: string;
+}
+
+export interface BackupRestoreResponse {
+  success: boolean;
+  error?: string;
+}
+
+export interface BackupListResponse {
+  success: boolean;
+  backups: BackupInfo[];
+  error?: string;
+}
+
+export interface BackupDeleteResponse {
+  success: boolean;
+  error?: string;
+}
+
+export interface BackupCleanupResponse {
+  success: boolean;
+  deletedCount: number;
+  error?: string;
+}
+
+export interface BackupVerifyResponse {
+  success: boolean;
+  isValid: boolean;
+  error?: string;
+}
+
+export interface BackupStorageInfoResponse {
+  success: boolean;
+  storageInfo?: StorageInfo;
+  error?: string;
+}
+
+export interface BackupSetConfigResponse {
+  success: boolean;
+  error?: string;
+}

package/src/types/dictionary.ts

@@ -0,0 +1,125 @@
+/**
+ * Dictionary Types for Local SharePoint Dictionary Integration
+ *
+ * These types define the structure for storing and querying the
+ * SharePoint Dictionary.xlsx file locally using SQLite.
+ */
+
+/**
+ * Represents a single entry from the Dictionary.xlsx file
+ * Matches the structure of the "Dictionary_Table" in "Daily_Inventory" sheet
+ */
+export interface DictionaryEntry {
+  Document_ID: string;
+  Content_ID: string;
+  Title: string;
+  Summary: string;
+  Type: string;
+  Release_Date: string;
+  Expiration_Date: string;
+  Status: string;
+  Owner: string;
+  BPO: string;
+  LOB: string;
+  Last_Published_By: string;
+}
+
+/**
+ * Result of a dictionary lookup operation
+ */
+export interface DictionaryLookupResult {
+  found: boolean;
+  entry?: DictionaryEntry;
+  lookupId: string;
+  lookupType: 'Document_ID' | 'Content_ID';
+}
+
+/**
+ * Batch lookup result for multiple IDs
+ */
+export interface DictionaryBatchLookupResult {
+  results: Map<string, DictionaryLookupResult>;
+  found: number;
+  notFound: number;
+  totalRequested: number;
+}
+
+/**
+ * Current status of the dictionary sync operation
+ */
+export interface DictionarySyncStatus {
+  enabled: boolean;
+  lastSyncTime: string | null;
+  lastSyncSuccess: boolean;
+  totalEntries: number;
+  syncInProgress: boolean;
+  syncProgress: number;
+  syncError: string | null;
+  nextScheduledSync: string | null;
+  fileHash: string | null;
+}
+
+/**
+ * SharePoint configuration for dictionary download
+ */
+export interface SharePointConfig {
+  siteUrl: string;
+  documentLibraryPath: string;
+  tenantId: string;
+  clientId: string;
+}
+
+/**
+ * Progress update during sync operation
+ */
+export interface SyncProgressUpdate {
+  phase: 'authenticating' | 'downloading' | 'parsing' | 'importing' | 'complete' | 'error';
+  progress: number;
+  message: string;
+  entriesProcessed?: number;
+  totalEntries?: number;
+}
+
+/**
+ * Response from dictionary initialization
+ */
+export interface DictionaryInitResponse {
+  success: boolean;
+  totalEntries: number;
+  error?: string;
+}
+
+/**
+ * Response from dictionary sync operation
+ */
+export interface DictionarySyncResponse {
+  success: boolean;
+  entriesImported: number;
+  duration: number;
+  error?: string;
+}
+
+/**
+ * Response from setting credentials
+ */
+export interface DictionaryCredentialsResponse {
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * IPC channel names for dictionary operations
+ */
+export const DICTIONARY_IPC_CHANNELS = {
+  INITIALIZE: 'dictionary:initialize',
+  CONFIGURE_SYNC: 'dictionary:configure-sync',
+  SYNC: 'dictionary:sync',
+  START_SCHEDULER: 'dictionary:start-scheduler',
+  STOP_SCHEDULER: 'dictionary:stop-scheduler',
+  LOOKUP: 'dictionary:lookup',
+  BATCH_LOOKUP: 'dictionary:batch-lookup',
+  GET_STATUS: 'dictionary:get-status',
+  SET_CREDENTIALS: 'dictionary:set-credentials',
+  SYNC_PROGRESS: 'dictionary:sync-progress',
+  SYNC_COMPLETE: 'dictionary:sync-complete',
+} as const;

package/src/types/document-processing.ts

@@ -0,0 +1,331 @@
+/**
+ * Core type definitions for document processing
+ * Following TypeScript 2025 best practices with strict type safety
+ */
+
+import JSZip from 'jszip';
+
+// Template literal types for document parts
+export type DocumentPart = `word/${
+  | 'document.xml'
+  | 'styles.xml'
+  | 'numbering.xml'
+  | 'settings.xml'
+  | 'fontTable.xml'
+  | 'header1.xml'
+  | 'footer1.xml'}`;
+
+// Relationship types in OpenXML
+export type RelationshipType =
+  | 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink'
+  | 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles'
+  | 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header'
+  | 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer';
+
+// Document structure with readonly properties for immutability
+export interface DocumentStructure {
+  readonly parts: ReadonlyArray<string>;
+  readonly relationships: ReadonlyArray<RelationshipInfo>;
+  readonly hasStyles: boolean;
+  readonly hasNumbering: boolean;
+  readonly statistics: Readonly<DocumentStatistics>;
+}
+
+export interface DocumentStatistics {
+  paragraphCount: number;
+  tableCount: number;
+  imageCount: number;
+  hyperlinkCount: number;
+  wordCount?: number;
+  characterCount?: number;
+}
+
+export interface RelationshipInfo {
+  readonly id: string;
+  readonly type: RelationshipType;
+  readonly target: string;
+  readonly targetMode?: 'External' | 'Internal';
+}
+
+// Processing options with granular control
+export interface DocumentProcessingOptions {
+  createBackup?: boolean;
+  validateBeforeProcessing?: boolean;
+  preserveOriginalFormatting?: boolean;
+  processInChunks?: boolean;
+  chunkSize?: number;
+  timeout?: number; // in milliseconds
+  maxRetries?: number;
+  retryDelay?: number; // in milliseconds
+}
+
+// Processing result with detailed feedback
+export interface ProcessingResult {
+  success: boolean;
+  documentPath: string;
+  backupPath?: string;
+  startTime: Date;
+  endTime: Date;
+  duration: number; // in milliseconds
+  statistics: ProcessingStatistics;
+  errors: ProcessingError[];
+  warnings: ProcessingWarning[];
+}
+
+export interface ProcessingStatistics {
+  totalElements: number;
+  processedElements: number;
+  skippedElements: number;
+  modifiedElements: number;
+  hyperlinksProcessed?: number;
+  stylesApplied?: number;
+  replacementsMade?: number;
+}
+
+export interface ProcessingError {
+  code: string;
+  message: string;
+  element?: string;
+  location?: string;
+  stack?: string;
+  recoverable: boolean;
+}
+
+export interface ProcessingWarning {
+  code: string;
+  message: string;
+  element?: string;
+  location?: string;
+  suggestion?: string;
+}
+
+// Document operation types
+export type DocumentOperation =
+  | HyperlinkOperation
+  | StyleOperation
+  | TextOperation
+  | StructureOperation;
+
+export interface BaseOperation {
+  id: string;
+  type: 'hyperlink' | 'style' | 'text' | 'structure';
+  description: string;
+  critical?: boolean; // If true, failure stops all processing
+  priority?: number; // Higher priority operations execute first
+}
+
+export interface HyperlinkOperation extends BaseOperation {
+  type: 'hyperlink';
+  action: 'update' | 'validate' | 'remove' | 'append';
+  targetPattern?: RegExp;
+  replacement?: string;
+  contentId?: string;
+}
+
+export interface StyleOperation extends BaseOperation {
+  type: 'style';
+  action: 'apply' | 'remove' | 'modify';
+  styleName: string;
+  properties?: Record<string, unknown>;
+}
+
+export interface TextOperation extends BaseOperation {
+  type: 'text';
+  action: 'replace' | 'remove' | 'format';
+  pattern: string | RegExp;
+  replacement?: string;
+  caseSensitive?: boolean;
+  wholeWord?: boolean;
+}
+
+export interface StructureOperation extends BaseOperation {
+  type: 'structure';
+  action: 'reorder' | 'indent' | 'align';
+  target: 'lists' | 'tables' | 'paragraphs' | 'images';
+  options?: Record<string, unknown>;
+}
+
+// Batch processing types
+export interface BatchProcessingOptions extends DocumentProcessingOptions {
+  concurrency?: number; // Number of documents to process in parallel
+  continueOnError?: boolean;
+  progressCallback?: (progress: BatchProgress) => void;
+}
+
+export interface BatchProgress {
+  totalFiles: number;
+  processedFiles: number;
+  currentFile?: string;
+  currentFileProgress?: number; // 0-100
+  overallProgress: number; // 0-100
+  errors: number;
+  warnings: number;
+  estimatedTimeRemaining?: number; // in milliseconds
+}
+
+export interface BatchResult {
+  totalFiles: number;
+  successfulFiles: number;
+  failedFiles: number;
+  results: ProcessingResult[];
+  duration: number;
+  errors: BatchError[];
+}
+
+export interface BatchError extends ProcessingError {
+  filePath: string;
+  fileIndex: number;
+}
+
+// Document metadata
+export interface DocumentMetadata {
+  title?: string;
+  subject?: string;
+  creator?: string;
+  keywords?: string[];
+  description?: string;
+  lastModifiedBy?: string;
+  revision?: string;
+  created?: Date;
+  modified?: Date;
+  lastPrinted?: Date;
+  category?: string;
+  contentStatus?: string;
+  language?: string;
+}
+
+// XML parsing types
+export interface ParsedXML {
+  root: XMLElement;
+  namespaces: Record<string, string>;
+  encoding?: string;
+  version?: string;
+}
+
+export interface XMLElement {
+  name: string;
+  attributes: Record<string, string>;
+  children: XMLElement[];
+  text?: string;
+  namespace?: string;
+}
+
+// Utility type for deep readonly
+export type DeepReadonly<T> = {
+  readonly [P in keyof T]: T[P] extends object
+    ? T[P] extends (...args: any[]) => any
+      ? T[P]
+      : DeepReadonly<T[P]>
+    : T[P];
+};
+
+// Either pattern for error handling
+export type Either<L, R> = { ok: false; error: L } | { ok: true; value: R };
+
+// Result type for operations that can fail
+export type Result<T, E = Error> = Either<E, T>;
+
+// Conditional type for operation results
+export type OperationResult<T> = T extends { critical: true }
+  ? { success: true; data: T } | { success: false; error: Error }
+  : { success: boolean; data?: T; warning?: string };
+
+// Document processing context
+export interface ProcessingContext {
+  document: JSZip;
+  documentPath: string;
+  backupPath?: string;
+  operations: DocumentOperation[];
+  options: DocumentProcessingOptions;
+  statistics: ProcessingStatistics;
+  errors: ProcessingError[];
+  warnings: ProcessingWarning[];
+  metadata?: DocumentMetadata;
+  cache: Map<string, unknown>;
+  startTime: Date;
+}
+
+// Stream processing types for large documents
+export interface StreamOptions {
+  chunkSize: number;
+  encoding?: BufferEncoding;
+  highWaterMark?: number;
+}
+
+export interface ProcessedChunk {
+  index: number;
+  content: string | Buffer;
+  progress: number;
+  bytesProcessed: number;
+  totalBytes?: number;
+}
+
+// Change tracking types
+export interface DocumentChange {
+  id: string;
+  timestamp: Date;
+  type: 'addition' | 'deletion' | 'modification' | 'move';
+  element: string;
+  originalContent?: string;
+  newContent?: string;
+  originalPosition?: number;
+  newPosition?: number;
+  author?: string;
+  description?: string;
+}
+
+export interface ChangeSet {
+  documentId: string;
+  documentPath: string;
+  changes: DocumentChange[];
+  summary: ChangeSummary;
+}
+
+export interface ChangeSummary {
+  totalChanges: number;
+  additions: number;
+  deletions: number;
+  modifications: number;
+  moves: number;
+  authors: string[];
+  startTime: Date;
+  endTime: Date;
+}
+
+// Validation types
+export interface ValidationOptions {
+  checkStructure?: boolean;
+  checkRelationships?: boolean;
+  checkStyles?: boolean;
+  checkHyperlinks?: boolean;
+  checkImages?: boolean;
+  checkMetadata?: boolean;
+  strictMode?: boolean;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  issues: ValidationIssue[];
+  suggestions: ValidationSuggestion[];
+  score?: number; // 0-100 quality score
+}
+
+export interface ValidationIssue {
+  severity: 'error' | 'warning' | 'info';
+  code: string;
+  message: string;
+  location?: string;
+  element?: string;
+  fixable: boolean;
+  autoFix?: () => Promise<void>;
+}
+
+export interface ValidationSuggestion {
+  type: string;
+  message: string;
+  impact: 'high' | 'medium' | 'low';
+  implementation?: string;
+}
+
+// Export all types
+export type { JSZip as DocumentArchive };