@fgv/ts-res-browser 1.0.0

package/src/utils/browserFileTreeAccessors.ts

@@ -0,0 +1,245 @@
+import { Result, succeed, fail, FileTree } from '@fgv/ts-utils';
+import { ImportedDirectory, ImportedFile } from './fileImport';
+
+/**
+ * Custom FileTreeAccessors implementation for browser environment
+ * that preserves directory structure for ts-res qualifier extraction
+ */
+export class BrowserFileTreeAccessors implements FileTree.IFileTreeAccessors {
+  private readonly rootDirectory: ImportedDirectory;
+  private readonly pathSeparator = '/';
+
+  constructor(rootDirectory: ImportedDirectory) {
+    this.rootDirectory = rootDirectory;
+  }
+
+  public static create(rootDirectory: ImportedDirectory): Result<BrowserFileTreeAccessors> {
+    try {
+      return succeed(new BrowserFileTreeAccessors(rootDirectory));
+    } catch (error) {
+      return fail(
+        `Failed to create BrowserFileTreeAccessors: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  // Path manipulation methods (browser-compatible, no Node.js dependencies)
+  public resolveAbsolutePath(...paths: string[]): string {
+    // Start with root path or first absolute path
+    let result = '';
+
+    for (const path of paths) {
+      if (!path) continue;
+
+      if (path.startsWith('/')) {
+        // Absolute path - replace current result
+        result = path;
+      } else {
+        // Relative path - append to current result
+        result = this.joinPaths(result, path);
+      }
+    }
+
+    // Ensure it starts with / (absolute)
+    if (!result.startsWith('/')) {
+      result = '/' + result;
+    }
+
+    return this.normalizePath(result);
+  }
+
+  public getExtension(path: string): string {
+    const baseName = this.getBaseName(path);
+    const lastDot = baseName.lastIndexOf('.');
+    return lastDot === -1 ? '' : baseName.substring(lastDot);
+  }
+
+  public getBaseName(path: string, suffix?: string): string {
+    if (!path) return '';
+
+    // Remove trailing slashes
+    const normalizedPath = path.replace(/\/+$/, '');
+
+    // Get the last segment
+    const lastSlash = normalizedPath.lastIndexOf('/');
+    let baseName = lastSlash === -1 ? normalizedPath : normalizedPath.substring(lastSlash + 1);
+
+    // Remove suffix if provided
+    if (suffix && baseName.endsWith(suffix)) {
+      baseName = baseName.substring(0, baseName.length - suffix.length);
+    }
+
+    return baseName;
+  }
+
+  public joinPaths(...paths: string[]): string {
+    if (paths.length === 0) return '';
+
+    const parts: string[] = [];
+
+    for (const path of paths) {
+      if (!path) continue;
+
+      // Split by separator and filter empty parts
+      const pathParts = path.split(this.pathSeparator).filter((part) => part.length > 0);
+      parts.push(...pathParts);
+    }
+
+    return '/' + parts.join(this.pathSeparator);
+  }
+
+  // File system access methods
+  public getItem(path: string): Result<FileTree.FileTreeItem> {
+    try {
+      const absolutePath = this.ensureAbsolute(path);
+      const result = this.findItemAtPath(absolutePath);
+
+      if (!result) {
+        return fail(`Item not found at path: ${absolutePath}`);
+      }
+
+      if (result.type === 'file') {
+        return FileTree.FileItem.create(absolutePath, this);
+      } else {
+        return FileTree.DirectoryItem.create(absolutePath, this);
+      }
+    } catch (error) {
+      return fail(`Failed to get item: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  public getFileContents(path: string): Result<string> {
+    try {
+      const absolutePath = this.ensureAbsolute(path);
+      const result = this.findItemAtPath(absolutePath);
+
+      if (!result) {
+        return fail(`File not found at path: ${absolutePath}`);
+      }
+
+      if (result.type !== 'file') {
+        return fail(`Path is not a file: ${absolutePath}`);
+      }
+
+      const file = result.item as ImportedFile;
+      return succeed(file.content);
+    } catch (error) {
+      return fail(`Failed to get file contents: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  public getChildren(path: string): Result<ReadonlyArray<FileTree.FileTreeItem>> {
+    try {
+      const absolutePath = this.ensureAbsolute(path);
+      const result = this.findItemAtPath(absolutePath);
+
+      if (!result) {
+        return fail(`Directory not found at path: ${absolutePath}`);
+      }
+
+      if (result.type !== 'directory') {
+        return fail(`Path is not a directory: ${absolutePath}`);
+      }
+
+      const directory = result.item as ImportedDirectory;
+      const children: FileTree.FileTreeItem[] = [];
+
+      // Add files
+      for (const file of directory.files) {
+        const childPath = this.joinPaths(absolutePath, file.name);
+        const fileItemResult = FileTree.FileItem.create(childPath, this);
+
+        if (fileItemResult.isSuccess()) {
+          children.push(fileItemResult.value);
+        }
+      }
+
+      // Add subdirectories
+      for (const subDirectory of directory.directories) {
+        const childPath = this.joinPaths(absolutePath, subDirectory.name);
+        const dirItemResult = FileTree.DirectoryItem.create(childPath, this);
+
+        if (dirItemResult.isSuccess()) {
+          children.push(dirItemResult.value);
+        }
+      }
+
+      return succeed(children);
+    } catch (error) {
+      return fail(`Failed to get children: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  // Helper methods
+  private ensureAbsolute(path: string): string {
+    return path.startsWith('/') ? path : '/' + path;
+  }
+
+  private normalizePath(path: string): string {
+    if (!path) return '/';
+
+    // Split into parts, filter empty ones, and handle . and ..
+    const parts = path.split('/').filter((part) => part.length > 0 && part !== '.');
+    const normalized: string[] = [];
+
+    for (const part of parts) {
+      if (part === '..') {
+        if (normalized.length > 0) {
+          normalized.pop();
+        }
+      } else {
+        normalized.push(part);
+      }
+    }
+
+    return '/' + normalized.join('/');
+  }
+
+  private findItemAtPath(
+    absolutePath: string
+  ): { item: ImportedDirectory | ImportedFile; type: 'file' | 'directory' } | null {
+    const normalizedPath = this.normalizePath(absolutePath);
+
+    // Handle root path
+    if (normalizedPath === '/' || normalizedPath === '') {
+      return { item: this.rootDirectory, type: 'directory' };
+    }
+
+    // Split path into segments (excluding root slash)
+    const segments = normalizedPath
+      .substring(1)
+      .split('/')
+      .filter((seg) => seg.length > 0);
+
+    let currentDir = this.rootDirectory;
+
+    // Navigate through directory segments
+    for (let i = 0; i < segments.length - 1; i++) {
+      const segment = segments[i];
+      const subDir = currentDir.directories.find((dir) => dir.name === segment);
+
+      if (!subDir) {
+        return null;
+      }
+
+      currentDir = subDir;
+    }
+
+    // Get the final item (file or directory)
+    const finalSegment = segments[segments.length - 1];
+
+    // Check if it's a file
+    const file = currentDir.files.find((f) => f.name === finalSegment);
+    if (file) {
+      return { item: file, type: 'file' };
+    }
+
+    // Check if it's a directory
+    const directory = currentDir.directories.find((d) => d.name === finalSegment);
+    if (directory) {
+      return { item: directory, type: 'directory' };
+    }
+
+    return null;
+  }
+}

package/src/utils/fileImport.ts

@@ -0,0 +1,334 @@
+import { Result, succeed, fail } from '@fgv/ts-utils';
+
+export interface ImportedFile {
+  name: string;
+  path: string;
+  content: string;
+  handle?: FileSystemFileHandle;
+}
+
+export interface ImportedDirectory {
+  name: string;
+  path: string;
+  files: ImportedFile[];
+  directories: ImportedDirectory[];
+}
+
+export interface FileImportOptions {
+  acceptedTypes?: string[];
+  multiple?: boolean;
+  includeDirectories?: boolean;
+}
+
+/**
+ * Check if File System Access API is supported
+ */
+export function isFileSystemAccessSupported(): boolean {
+  return 'showDirectoryPicker' in window && 'showOpenFilePicker' in window;
+}
+
+/**
+ * Modern File System Access API implementation
+ */
+export class ModernFileImporter {
+  /**
+   * Pick a directory using File System Access API
+   */
+  async pickDirectory(): Promise<Result<ImportedDirectory>> {
+    try {
+      if (!isFileSystemAccessSupported()) {
+        return fail('File System Access API not supported');
+      }
+
+      const directoryHandle = await window.showDirectoryPicker({
+        mode: 'read',
+        startIn: 'documents'
+      });
+
+      const importedDirectory = await this.processDirectoryHandle(directoryHandle);
+      return succeed(importedDirectory);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError') {
+        return fail('Directory selection was cancelled');
+      }
+      return fail(`Failed to pick directory: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Pick files using File System Access API
+   */
+  async pickFiles(options: FileImportOptions = {}): Promise<Result<ImportedFile[]>> {
+    try {
+      if (!isFileSystemAccessSupported()) {
+        return fail('File System Access API not supported');
+      }
+
+      const fileHandles = await window.showOpenFilePicker({
+        multiple: options.multiple ?? true,
+        types: options.acceptedTypes
+          ? [
+              {
+                description: 'Resource files',
+                accept: {
+                  'application/json': options.acceptedTypes
+                }
+              }
+            ]
+          : undefined,
+        excludeAcceptAllOption: false
+      });
+
+      const importedFiles: ImportedFile[] = [];
+      for (const fileHandle of fileHandles) {
+        const result = await this.processFileHandle(fileHandle);
+        if (result.isSuccess()) {
+          importedFiles.push(result.value);
+        }
+      }
+
+      return succeed(importedFiles);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError') {
+        return fail('File selection was cancelled');
+      }
+      return fail(`Failed to pick files: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  private async processDirectoryHandle(
+    directoryHandle: FileSystemDirectoryHandle,
+    basePath = ''
+  ): Promise<ImportedDirectory> {
+    const files: ImportedFile[] = [];
+    const directories: ImportedDirectory[] = [];
+    const currentPath = basePath ? `${basePath}/${directoryHandle.name}` : directoryHandle.name;
+
+    for await (const [name, handle] of directoryHandle.entries()) {
+      if (handle.kind === 'file') {
+        const result = await this.processFileHandle(handle as FileSystemFileHandle, currentPath);
+        if (result.isSuccess()) {
+          files.push(result.value);
+        }
+      } else if (handle.kind === 'directory') {
+        const subDirectory = await this.processDirectoryHandle(
+          handle as FileSystemDirectoryHandle,
+          currentPath
+        );
+        directories.push(subDirectory);
+      }
+    }
+
+    return {
+      name: directoryHandle.name,
+      path: currentPath,
+      files,
+      directories
+    };
+  }
+
+  private async processFileHandle(
+    fileHandle: FileSystemFileHandle,
+    basePath = ''
+  ): Promise<Result<ImportedFile>> {
+    try {
+      const file = await fileHandle.getFile();
+      const content = await file.text();
+      const filePath = basePath ? `${basePath}/${file.name}` : file.name;
+
+      return succeed({
+        name: file.name,
+        path: filePath,
+        content,
+        handle: fileHandle
+      });
+    } catch (error) {
+      return fail(
+        `Failed to read file ${fileHandle.name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+/**
+ * Fallback implementation using traditional file input
+ */
+export class FallbackFileImporter {
+  /**
+   * Pick a directory using webkitdirectory attribute
+   */
+  async pickDirectory(): Promise<Result<ImportedDirectory>> {
+    return new Promise((resolve) => {
+      const input = document.createElement('input');
+      input.type = 'file';
+      input.multiple = true;
+      input.webkitdirectory = true;
+
+      input.addEventListener('change', async (event) => {
+        const files = (event.target as HTMLInputElement).files;
+        if (!files || files.length === 0) {
+          resolve(fail('No directory selected'));
+          return;
+        }
+
+        try {
+          const importedDirectory = await this.processFileList(files);
+          resolve(succeed(importedDirectory));
+        } catch (error) {
+          resolve(
+            fail(`Failed to process directory: ${error instanceof Error ? error.message : String(error)}`)
+          );
+        }
+      });
+
+      input.addEventListener('cancel', () => {
+        resolve(fail('Directory selection was cancelled'));
+      });
+
+      input.click();
+    });
+  }
+
+  /**
+   * Pick files using traditional file input
+   */
+  async pickFiles(options: FileImportOptions = {}): Promise<Result<ImportedFile[]>> {
+    return new Promise((resolve) => {
+      const input = document.createElement('input');
+      input.type = 'file';
+      input.multiple = options.multiple ?? true;
+
+      if (options.acceptedTypes) {
+        input.accept = options.acceptedTypes.join(',');
+      }
+
+      input.addEventListener('change', async (event) => {
+        const files = (event.target as HTMLInputElement).files;
+        if (!files || files.length === 0) {
+          resolve(fail('No files selected'));
+          return;
+        }
+
+        try {
+          const importedFiles: ImportedFile[] = [];
+          for (const file of Array.from(files)) {
+            const content = await file.text();
+            importedFiles.push({
+              name: file.name,
+              path: file.name,
+              content
+            });
+          }
+          resolve(succeed(importedFiles));
+        } catch (error) {
+          resolve(fail(`Failed to read files: ${error instanceof Error ? error.message : String(error)}`));
+        }
+      });
+
+      input.addEventListener('cancel', () => {
+        resolve(fail('File selection was cancelled'));
+      });
+
+      input.click();
+    });
+  }
+
+  private async processFileList(files: FileList): Promise<ImportedDirectory> {
+    const fileMap = new Map<string, ImportedFile[]>();
+    const dirMap = new Map<string, ImportedDirectory>();
+
+    // Process all files
+    for (const file of Array.from(files)) {
+      const content = await file.text();
+      const pathParts = file.webkitRelativePath.split('/');
+      const fileName = pathParts[pathParts.length - 1];
+      const dirPath = pathParts.slice(0, -1).join('/');
+
+      const importedFile: ImportedFile = {
+        name: fileName,
+        path: file.webkitRelativePath,
+        content
+      };
+
+      if (!fileMap.has(dirPath)) {
+        fileMap.set(dirPath, []);
+      }
+      fileMap.get(dirPath)!.push(importedFile);
+    }
+
+    // Build directory structure
+    const rootDirName = files[0].webkitRelativePath.split('/')[0];
+    return this.buildDirectoryTree(rootDirName, '', fileMap, dirMap);
+  }
+
+  private buildDirectoryTree(
+    name: string,
+    path: string,
+    fileMap: Map<string, ImportedFile[]>,
+    dirMap: Map<string, ImportedDirectory>
+  ): ImportedDirectory {
+    const currentPath = path ? `${path}/${name}` : name;
+    const files = fileMap.get(currentPath) || [];
+    const directories: ImportedDirectory[] = [];
+
+    // Find subdirectories
+    for (const [filePath] of fileMap) {
+      if (filePath.startsWith(currentPath + '/')) {
+        const relativePath = filePath.substring(currentPath.length + 1);
+        const nextDirName = relativePath.split('/')[0];
+
+        if (relativePath.includes('/') && !directories.some((d) => d.name === nextDirName)) {
+          const subDir = this.buildDirectoryTree(nextDirName, currentPath, fileMap, dirMap);
+          directories.push(subDir);
+        }
+      }
+    }
+
+    return {
+      name,
+      path: currentPath,
+      files,
+      directories
+    };
+  }
+}
+
+/**
+ * Universal file importer that automatically selects the best available method
+ */
+export class FileImporter {
+  private modernImporter = new ModernFileImporter();
+  private fallbackImporter = new FallbackFileImporter();
+
+  /**
+   * Pick a directory using the best available method
+   */
+  async pickDirectory(): Promise<Result<ImportedDirectory>> {
+    if (isFileSystemAccessSupported()) {
+      return this.modernImporter.pickDirectory();
+    } else {
+      return this.fallbackImporter.pickDirectory();
+    }
+  }
+
+  /**
+   * Pick files using the best available method
+   */
+  async pickFiles(options: FileImportOptions = {}): Promise<Result<ImportedFile[]>> {
+    if (isFileSystemAccessSupported()) {
+      return this.modernImporter.pickFiles(options);
+    } else {
+      return this.fallbackImporter.pickFiles(options);
+    }
+  }
+
+  /**
+   * Get the current import method being used
+   */
+  getCurrentMethod(): 'modern' | 'fallback' {
+    return isFileSystemAccessSupported() ? 'modern' : 'fallback';
+  }
+}
+
+// Export singleton instance
+export const fileImporter = new FileImporter();