@anymux/ui-kit 0.1.0

package/src/file-browser/providers/GitProvider.ts

@@ -0,0 +1,337 @@
+import { IFileBrowserProvider } from './IFileBrowserProvider';
+import { FileBrowserItem, IconDefinition, PreviewData } from '../types/FileBrowserTypes';
+import { LeftPanelMode } from '../models/LeftPanelManagerModel';
+import { ViewModeDefinition } from '../models/RightPanelManagerModel';
+
+// Import Git Browser types (these would be imported from the actual Git Browser app)
+interface GitRepositoryModel {
+  path: string;
+  fileTree: any[];
+  isLoadingFiles: boolean;
+  getFileContent(path: string): Promise<string>;
+  // Add other methods as needed
+}
+
+interface GitWrapperIntegration {
+  path: string;
+  fileTree: any[];
+  isLoadingFiles: boolean;
+  getFileContent(path: string): Promise<string>;
+  // Add other methods as needed
+}
+
+interface GitFileTreeNode {
+  name: string;
+  path: string;
+  type: 'file' | 'directory';
+  size?: number;
+  children?: GitFileTreeNode[];
+}
+
+export class GitProvider implements IFileBrowserProvider {
+  readonly id = 'git';
+  readonly name = 'Git Provider';
+  readonly version = '1.0.0';
+
+  private repository: GitRepositoryModel | GitWrapperIntegration;
+
+  constructor(repository: GitRepositoryModel | GitWrapperIntegration) {
+    this.repository = repository;
+  }
+
+  // Core data operations
+  async loadItems(path: string): Promise<FileBrowserItem[]> {
+    try {
+      const normalizedPath = this.normalizePath(path);
+      
+      // Wait for file tree to load if it's currently loading
+      if (this.repository.isLoadingFiles) {
+        // In a real implementation, we'd wait for the loading to complete
+        // For now, return empty array
+        return [];
+      }
+
+      const fileTree = this.repository.fileTree;
+      if (!fileTree || fileTree.length === 0) {
+        return [];
+      }
+
+      // Find the items for the current path
+      const items = this.getItemsForPath(normalizedPath, fileTree);
+      
+      return items.map(node => this.convertGitNodeToFileBrowserItem(node));
+    } catch (error) {
+      console.error(`Failed to load Git items from ${path}:`, error);
+      throw new Error(`Failed to load Git repository items: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private getItemsForPath(path: string, fileTree: GitFileTreeNode[]): GitFileTreeNode[] {
+    if (path === '/' || path === '') {
+      return fileTree;
+    }
+
+    // Navigate to the specified path
+    const pathSegments = path.split('/').filter(segment => segment !== '');
+    let currentNodes = fileTree;
+
+    for (const segment of pathSegments) {
+      const node = currentNodes.find(n => n.name === segment && n.type === 'directory');
+      if (!node || !node.children) {
+        return [];
+      }
+      currentNodes = node.children;
+    }
+
+    return currentNodes;
+  }
+
+  private convertGitNodeToFileBrowserItem(node: GitFileTreeNode): FileBrowserItem {
+    return {
+      id: node.path,
+      name: node.name,
+      path: node.path,
+      type: node.type === 'directory' ? 'directory' : 'file',
+      size: node.size,
+      lastModified: new Date(), // Git doesn't provide this directly
+      hasChildren: node.type === 'directory' && (node.children?.length || 0) > 0,
+      metadata: {
+        gitPath: node.path,
+        isGitFile: true
+      }
+    };
+  }
+
+  // Dual-panel support
+  getLeftPanelModes(): LeftPanelMode[] {
+    return [
+      {
+        id: 'tree',
+        name: 'Tree',
+        icon: 'folder-tree',
+        component: {} as any, // Will be set by consumer
+        isAvailable: () => true
+      },
+      {
+        id: 'git-graph',
+        name: 'Git Graph',
+        icon: 'git-branch',
+        component: {} as any, // Will be set by consumer
+        isAvailable: () => true
+      }
+    ];
+  }
+
+  getRightPanelViewModes(): ViewModeDefinition[] {
+    return [
+      {
+        id: 'list',
+        name: 'List',
+        icon: 'list',
+        applicableFor: (contentType) => contentType === 'folder'
+      },
+      {
+        id: 'thumbnail',
+        name: 'Thumbnails',
+        icon: 'grid-3x3',
+        applicableFor: (contentType) => contentType === 'folder'
+      },
+      {
+        id: 'git-history',
+        name: 'History',
+        icon: 'history',
+        applicableFor: (contentType) => contentType === 'file'
+      },
+      {
+        id: 'git-diff',
+        name: 'Diff',
+        icon: 'git-compare',
+        applicableFor: (contentType) => contentType === 'file'
+      }
+    ];
+  }
+
+  // Path operations
+  normalizePath(path: string): string {
+    if (!path || path === '') return '/';
+    
+    let normalized = path.startsWith('/') ? path : '/' + path;
+    if (normalized.length > 1 && normalized.endsWith('/')) {
+      normalized = normalized.slice(0, -1);
+    }
+    
+    return normalized;
+  }
+
+  getParentPath(path: string): string | null {
+    const normalized = this.normalizePath(path);
+    if (normalized === '/') return null;
+    
+    const lastSlashIndex = normalized.lastIndexOf('/');
+    if (lastSlashIndex === 0) return '/';
+    
+    return normalized.substring(0, lastSlashIndex);
+  }
+
+  resolvePath(basePath: string, relativePath: string): string {
+    const normalizedBase = this.normalizePath(basePath);
+    
+    if (normalizedBase === '/') {
+      return '/' + relativePath;
+    }
+    
+    return normalizedBase + '/' + relativePath;
+  }
+
+  // Item customization
+  getItemIcon(item: FileBrowserItem): IconDefinition {
+    if (item.type === 'directory') {
+      return { type: 'lucide', name: 'folder-git-2', color: '#3b82f6' };
+    }
+    
+    if (item.name) {
+      const extension = item.name.split('.').pop()?.toLowerCase();
+      switch (extension) {
+        case 'js':
+        case 'ts':
+        case 'mjs':
+        case 'cjs':
+          return { type: 'lucide', name: 'file-code', color: '#f7df1e' };
+        case 'jsx':
+        case 'tsx':
+          return { type: 'lucide', name: 'component', color: '#61dafb' };
+        case 'json':
+          return { type: 'lucide', name: 'braces', color: '#f7df1e' };
+        case 'md':
+        case 'markdown':
+          return { type: 'lucide', name: 'file-text', color: '#083fa1' };
+        case 'gitignore':
+        case 'gitattributes':
+        case 'gitmodules':
+          return { type: 'lucide', name: 'git-branch', color: '#f05032' };
+        case 'html':
+        case 'htm':
+          return { type: 'lucide', name: 'globe', color: '#e34c26' };
+        case 'css':
+        case 'scss':
+        case 'sass':
+        case 'less':
+          return { type: 'lucide', name: 'palette', color: '#1572b6' };
+        case 'jpg':
+        case 'jpeg':
+        case 'png':
+        case 'gif':
+        case 'webp':
+        case 'svg':
+          return { type: 'lucide', name: 'image', color: '#10b981' };
+        default:
+          return { type: 'lucide', name: 'file', color: '#6b7280' };
+      }
+    }
+    
+    return { type: 'lucide', name: 'file', color: '#6b7280' };
+  }
+
+  getItemDisplayName(item: FileBrowserItem): string {
+    return item.name || 'Unknown';
+  }
+
+  // File preview capabilities
+  canPreviewFile(item: FileBrowserItem): boolean {
+    if (item.type !== 'file' || !item.name) return false;
+    
+    const extension = item.name.split('.').pop()?.toLowerCase();
+    const previewableExtensions = [
+      'txt', 'md', 'markdown', 'json', 'js', 'ts', 'jsx', 'tsx', 
+      'html', 'htm', 'css', 'scss', 'sass', 'less', 'xml', 'yaml', 'yml',
+      'csv', 'log', 'ini', 'conf', 'config', 'gitignore', 'gitattributes'
+    ];
+    
+    return previewableExtensions.includes(extension || '');
+  }
+
+  async getFilePreview(item: FileBrowserItem): Promise<PreviewData> {
+    if (!this.canPreviewFile(item)) {
+      throw new Error(`Cannot preview file: ${item.name}`);
+    }
+    
+    try {
+      const content = await this.repository.getFileContent(item.path);
+      
+      return {
+        type: 'text',
+        content: content,
+        metadata: {
+          size: item.size || 0,
+          lastModified: item.lastModified || new Date(),
+          gitPath: item.path,
+          encoding: 'utf8'
+        }
+      };
+    } catch (error) {
+      throw new Error(`Failed to read Git file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  async getItemPreview(item: FileBrowserItem): Promise<PreviewData | null> {
+    if (item.type !== 'file' || !this.canPreviewFile(item)) return null;
+    
+    try {
+      return await this.getFilePreview(item);
+    } catch (error) {
+      console.warn(`Failed to preview Git file ${item.name}:`, error);
+      return null;
+    }
+  }
+
+  // Optional capabilities
+  canPerformAction(action: string, items: FileBrowserItem[]): boolean {
+    switch (action) {
+      case 'git-checkout':
+      case 'git-diff':
+      case 'git-history':
+        return items.length === 1;
+      case 'git-stage':
+      case 'git-unstage':
+        return items.length > 0;
+      default:
+        return false;
+    }
+  }
+
+  async performAction(action: string, items: FileBrowserItem[]): Promise<any> {
+    // Git-specific actions would be implemented here
+    switch (action) {
+      case 'git-checkout':
+        throw new Error('Git checkout action not implemented yet');
+      case 'git-diff':
+        throw new Error('Git diff action not implemented yet');
+      case 'git-history':
+        throw new Error('Git history action not implemented yet');
+      case 'git-stage':
+        throw new Error('Git stage action not implemented yet');
+      case 'git-unstage':
+        throw new Error('Git unstage action not implemented yet');
+      default:
+        throw new Error(`Unknown Git action: ${action}`);
+    }
+  }
+
+  // Lifecycle
+  async initialize(): Promise<void> {
+    // Validate that the repository is accessible
+    try {
+      if (!this.repository.path) {
+        throw new Error('Repository path is not set');
+      }
+    } catch (error) {
+      throw new Error(`Failed to initialize GitProvider: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  dispose(): void {
+    // Clean up any resources if needed
+    // The Git repository models don't specify a dispose method,
+    // so we don't need to do anything here
+  }
+}