@fgv/ts-res-browser 5.0.0-2 → 5.0.0-21

package/src/utils/browserFileTreeAccessors.ts

@@ -1,245 +0,0 @@
-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

@@ -1,336 +0,0 @@
-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;
-  startIn?: string | FileSystemHandle;
-}
-
-/**
- * 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(options: FileImportOptions = {}): Promise<Result<ImportedDirectory>> {
-    try {
-      if (!isFileSystemAccessSupported()) {
-        return fail('File System Access API not supported');
-      }
-
-      const directoryHandle = await window.showDirectoryPicker({
-        mode: 'read',
-        startIn: options.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,
-        startIn: options.startIn || 'documents'
-      });
-
-      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(options: FileImportOptions = {}): Promise<Result<ImportedDirectory>> {
-    if (isFileSystemAccessSupported()) {
-      return this.modernImporter.pickDirectory(options);
-    } 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();