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

package/src/components/tools/ZipLoader.tsx

@@ -0,0 +1,302 @@
+import React, { useState, useEffect } from 'react';
+import {
+  ArchiveBoxIcon,
+  FolderOpenIcon,
+  ExclamationTriangleIcon,
+  CheckCircleIcon,
+  ArrowRightIcon
+} from '@heroicons/react/24/outline';
+import { Message } from '../../types/app';
+import { UseResourceManagerReturn } from '../../hooks/useResourceManager';
+import { BrowserZipFileTreeAccessors } from '../../utils/zip/browserZipFileTreeAccessors';
+import { FileTree } from '@fgv/ts-utils';
+
+interface ZipLoaderProps {
+  onMessage: (type: Message['type'], message: string) => void;
+  resourceManager: UseResourceManagerReturn;
+  zipFile?: string;
+  zipPath?: string;
+  onLoadComplete?: () => void;
+}
+
+interface ZipManifest {
+  timestamp: string;
+  input?: {
+    type: 'file' | 'directory';
+    originalPath: string;
+    archivePath: string;
+  };
+  config?: {
+    type: 'file';
+    originalPath: string;
+    archivePath: string;
+  };
+}
+
+const ZipLoader: React.FC<ZipLoaderProps> = ({
+  onMessage,
+  resourceManager,
+  zipFile,
+  zipPath,
+  onLoadComplete
+}) => {
+  const [isLoading, setIsLoading] = useState(false);
+  const [loadingStep, setLoadingStep] = useState<string>('');
+  const [zipFound, setZipFound] = useState<boolean | null>(null);
+  const [manifest, setManifest] = useState<ZipManifest | null>(null);
+  const [autoloadAttempted, setAutoloadAttempted] = useState(false);
+
+  // Auto-load ZIP if we have a specific file reference
+  useEffect(() => {
+    if ((zipFile || zipPath) && !autoloadAttempted) {
+      setAutoloadAttempted(true);
+      handleLoadZip();
+    }
+  }, [zipFile, zipPath, autoloadAttempted]);
+
+  const handleLoadZip = async () => {
+    if (!zipFile && !zipPath) {
+      onMessage('error', 'No ZIP file specified');
+      return;
+    }
+
+    setIsLoading(true);
+    setLoadingStep('Opening file picker...');
+
+    try {
+      // Try to load the ZIP file using File System Access API
+      let fileHandle: FileSystemFileHandle | null = null;
+
+      if ('showOpenFilePicker' in window) {
+        try {
+          const [handle] = await (window as any).showOpenFilePicker({
+            types: [
+              {
+                description: 'ZIP Archives',
+                accept: { 'application/zip': ['.zip'] }
+              }
+            ],
+            startIn: 'downloads',
+            multiple: false
+          });
+          fileHandle = handle;
+          setZipFound(true);
+        } catch (error) {
+          if ((error as DOMException).name !== 'AbortError') {
+            onMessage('warning', 'Could not open file picker. Please select the ZIP file manually.');
+          }
+          setZipFound(false);
+          return;
+        }
+      } else {
+        onMessage('error', 'File System Access API not supported. Please use a modern browser.');
+        setZipFound(false);
+        return;
+      }
+
+      if (!fileHandle) {
+        setZipFound(false);
+        return;
+      }
+
+      setLoadingStep('Reading ZIP archive...');
+      const file = await fileHandle.getFile();
+
+      // Create ZIP FileTree
+      const zipAccessorsResult = await BrowserZipFileTreeAccessors.fromFile(file);
+      if (zipAccessorsResult.isFailure()) {
+        onMessage('error', `Failed to read ZIP: ${zipAccessorsResult.message}`);
+        return;
+      }
+
+      const zipAccessors = zipAccessorsResult.value;
+      const fileTree = FileTree.FileTree.create(zipAccessors);
+      if (fileTree.isFailure()) {
+        onMessage('error', `Failed to create file tree: ${fileTree.message}`);
+        return;
+      }
+
+      setLoadingStep('Reading manifest...');
+
+      // Try to read manifest
+      const manifestResult = fileTree.value.getFile('/manifest.json');
+      if (manifestResult.isSuccess()) {
+        const manifestContents = manifestResult.value.getContents();
+        if (manifestContents.isSuccess()) {
+          const parsedManifest = manifestContents.value as ZipManifest;
+          setManifest(parsedManifest);
+          onMessage('info', `ZIP created: ${new Date(parsedManifest.timestamp).toLocaleString()}`);
+        }
+      }
+
+      // Process resources from the ZIP
+      setLoadingStep('Processing resources...');
+
+      // Look for input directory/files
+      let inputProcessed = false;
+      if (manifest?.input) {
+        const inputPath = `/${manifest.input.archivePath}`;
+        const inputResult = fileTree.value.getItem(inputPath);
+
+        if (inputResult.isSuccess()) {
+          const inputItem = inputResult.value;
+
+          if (inputItem.type === 'directory') {
+            // Process directory
+            await resourceManager.actions.processFileTree(fileTree.value, inputPath);
+            inputProcessed = true;
+          } else if (inputItem.type === 'file') {
+            // Process single file
+            await resourceManager.actions.processFileTree(fileTree.value, inputPath);
+            inputProcessed = true;
+          }
+        }
+      }
+
+      // Fallback: look for common input patterns
+      if (!inputProcessed) {
+        const commonInputPaths = ['/input', '/resources', '/data'];
+        for (const inputPath of commonInputPaths) {
+          const inputResult = fileTree.value.getItem(inputPath);
+          if (inputResult.isSuccess() && inputResult.value.type === 'directory') {
+            await resourceManager.actions.processFileTree(fileTree.value, inputPath);
+            inputProcessed = true;
+            break;
+          }
+        }
+      }
+
+      // Load configuration if present
+      if (manifest?.config) {
+        const configPath = `/${manifest.config.archivePath}`;
+        const configResult = fileTree.value.getFile(configPath);
+
+        if (configResult.isSuccess()) {
+          const configContents = configResult.value.getContents();
+          if (configContents.isSuccess()) {
+            resourceManager.actions.applyConfiguration(configContents.value as any);
+            onMessage('success', 'Configuration loaded from ZIP');
+          }
+        }
+      }
+
+      if (inputProcessed) {
+        onMessage('success', 'Resources loaded successfully from ZIP!');
+        onLoadComplete?.();
+      } else {
+        onMessage('warning', 'ZIP loaded but no resources found. Check ZIP contents.');
+      }
+    } catch (error) {
+      onMessage('error', `Failed to load ZIP: ${error instanceof Error ? error.message : String(error)}`);
+      setZipFound(false);
+    } finally {
+      setIsLoading(false);
+      setLoadingStep('');
+    }
+  };
+
+  const expectedFileName = zipFile || 'ts-res-bundle-*.zip';
+
+  return (
+    <div className="p-6">
+      <div className="flex items-center space-x-3 mb-6">
+        <ArchiveBoxIcon className="h-8 w-8 text-purple-600" />
+        <h2 className="text-2xl font-bold text-gray-900">Load ZIP Archive</h2>
+      </div>
+
+      <div className="max-w-2xl">
+        {/* ZIP File Info */}
+        <div className="bg-blue-50 rounded-lg p-4 mb-6">
+          <div className="flex items-start space-x-3">
+            <ArchiveBoxIcon className="h-5 w-5 text-blue-600 mt-0.5" />
+            <div className="text-sm text-blue-800">
+              <p className="font-medium">ZIP Archive Ready</p>
+              {zipPath && (
+                <p className="mt-1">
+                  <span className="font-medium">Location:</span> {zipPath}
+                </p>
+              )}
+              {zipFile && (
+                <p className="mt-1">
+                  <span className="font-medium">File:</span> {zipFile}
+                </p>
+              )}
+              <p className="mt-2">
+                The CLI has created a ZIP archive containing your resources and configuration. Click below to
+                load it directly into the browser.
+              </p>
+            </div>
+          </div>
+        </div>
+
+        {/* Load Button */}
+        <div className="space-y-4">
+          <button
+            onClick={handleLoadZip}
+            disabled={isLoading}
+            className="w-full flex items-center justify-center space-x-2 px-6 py-3 bg-purple-600 text-white rounded-lg hover:bg-purple-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+          >
+            {isLoading ? (
+              <>
+                <div className="w-5 h-5 border-2 border-white border-t-transparent rounded-full animate-spin"></div>
+                <span>{loadingStep || 'Loading...'}</span>
+              </>
+            ) : (
+              <>
+                <FolderOpenIcon className="w-5 h-5" />
+                <span>Load ZIP Archive</span>
+                <ArrowRightIcon className="w-5 h-5" />
+              </>
+            )}
+          </button>
+
+          {/* Instructions */}
+          <div className="bg-gray-50 rounded-lg p-4">
+            <h3 className="text-sm font-medium text-gray-900 mb-2">Instructions:</h3>
+            <ol className="text-sm text-gray-600 space-y-1 list-decimal list-inside">
+              <li>Click "Load ZIP Archive" above</li>
+              <li>
+                Select the ZIP file: <code className="bg-gray-200 px-1 rounded">{expectedFileName}</code>
+              </li>
+              <li>The browser will automatically process your resources and configuration</li>
+            </ol>
+          </div>
+
+          {/* Manifest Info */}
+          {manifest && (
+            <div className="bg-green-50 rounded-lg p-4">
+              <div className="flex items-start space-x-3">
+                <CheckCircleIcon className="h-5 w-5 text-green-600 mt-0.5" />
+                <div className="text-sm text-green-800">
+                  <p className="font-medium">ZIP Archive Contents</p>
+                  <div className="mt-2 space-y-1">
+                    {manifest.input && <p>📁 Resources: {manifest.input.originalPath}</p>}
+                    {manifest.config && <p>⚙️ Configuration: {manifest.config.originalPath}</p>}
+                  </div>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Error State */}
+          {zipFound === false && (
+            <div className="bg-yellow-50 rounded-lg p-4">
+              <div className="flex items-start space-x-3">
+                <ExclamationTriangleIcon className="h-5 w-5 text-yellow-600 mt-0.5" />
+                <div className="text-sm text-yellow-800">
+                  <p className="font-medium">ZIP File Not Found</p>
+                  <p className="mt-1">
+                    Could not locate or open the ZIP file. Please make sure it exists in your Downloads folder
+                    and try again.
+                  </p>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default ZipLoader;

package/src/hooks/useAppState.ts

@@ -18,6 +18,9 @@ export const useAppState = (): { state: AppState; actions: AppActions } => {
     setState((prev) => ({ ...prev, selectedTool: tool }));
   }, []);
 
+  // Alias for setSelectedTool to match the interface
+  const setActiveTool = setSelectedTool;
+
   const addMessage = useCallback((type: Message['type'], message: string) => {
     const newMessage: Message = {
       id: Date.now().toString(),
@@ -94,6 +97,7 @@ export const useAppState = (): { state: AppState; actions: AppActions } => {
 
   const actions: AppActions = {
     setSelectedTool,
+    setActiveTool,
     addMessage,
     clearMessages,
     updateFilterEnabled,

package/src/hooks/useResourceManager.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback } from 'react';
-import { Result, succeed, fail } from '@fgv/ts-utils';
+import { Result, succeed, fail, FileTree } from '@fgv/ts-utils';
 import {
   ProcessedResources,
   processImportedDirectory,
@@ -7,6 +7,7 @@ import {
   createSimpleContext
 } from '../utils/tsResIntegration';
 import { ImportedDirectory, ImportedFile } from '../utils/fileImport';
+import { FileTreeConverter } from '../utils/fileTreeConverter';
 import { Config } from '@fgv/ts-res';
 
 export interface ResourceManagerState {
@@ -22,6 +23,7 @@ export interface UseResourceManagerReturn {
   actions: {
     processDirectory: (directory: ImportedDirectory) => Promise<void>;
     processFiles: (files: ImportedFile[]) => Promise<void>;
+    processFileTree: (fileTree: FileTree.FileTree, rootPath?: string) => Promise<void>;
     clearError: () => void;
     reset: () => void;
     resolveResource: (resourceId: string, context?: Record<string, string>) => Promise<Result<any>>;
@@ -216,6 +218,54 @@ export const useResourceManager = (): UseResourceManagerReturn => {
     [state.processedResources]
   );
 
+  const processFileTree = useCallback(
+    async (fileTree: FileTree.FileTree, rootPath: string = '/') => {
+      console.log('=== STARTING FILETREE PROCESSING ===');
+      console.log('Root path:', rootPath);
+
+      setState((prev) => ({ ...prev, isProcessing: true, error: null }));
+
+      try {
+        console.log('1. Converting FileTree to ImportedDirectory/Files...');
+
+        const convertResult = FileTreeConverter.convertPath(fileTree, rootPath);
+        if (convertResult.isFailure()) {
+          setState((prev) => ({
+            ...prev,
+            isProcessing: false,
+            error: `Failed to convert FileTree: ${convertResult.message}`
+          }));
+          return;
+        }
+
+        const converted = convertResult.value;
+        console.log('2. FileTree converted successfully');
+
+        // Process based on whether we got a directory or files
+        if (Array.isArray(converted)) {
+          // Got files
+          console.log('3. Processing as files, count:', converted.length);
+          await processFiles(converted);
+        } else {
+          // Got directory
+          console.log('3. Processing as directory:', converted.name);
+          await processDirectory(converted);
+        }
+
+        console.log('4. processFileTree completed successfully');
+      } catch (error) {
+        console.error('=== FILETREE PROCESSING ERROR ===');
+        console.error('Error:', error);
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
+        }));
+      }
+    },
+    [processFiles, processDirectory]
+  );
+
   const applyConfiguration = useCallback((config: Config.Model.ISystemConfiguration) => {
     console.log('Applying configuration:', config.name || 'Unnamed configuration');
     setState((prev) => ({
@@ -233,6 +283,7 @@ export const useResourceManager = (): UseResourceManagerReturn => {
     actions: {
       processDirectory,
       processFiles,
+      processFileTree,
       clearError,
       reset,
       resolveResource,

package/src/hooks/useUrlParams.ts

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { useEffect, useState } from 'react';
+import { parseUrlParameters, IUrlConfigOptions } from '../utils/urlParams';
+
+/**
+ * Hook to parse and provide URL parameters for initial app configuration
+ */
+export function useUrlParams() {
+  const [urlParams, setUrlParams] = useState<IUrlConfigOptions>({});
+  const [hasUrlParams, setHasUrlParams] = useState(false);
+
+  useEffect(() => {
+    const params = parseUrlParameters();
+    setUrlParams(params);
+
+    // Check if any meaningful parameters were provided
+    const hasParams = !!(
+      params.input ||
+      params.config ||
+      params.contextFilter ||
+      params.qualifierDefaults ||
+      params.resourceTypes ||
+      params.maxDistance !== undefined ||
+      params.reduceQualifiers ||
+      params.interactive
+    );
+
+    setHasUrlParams(hasParams);
+  }, []);
+
+  return {
+    urlParams,
+    hasUrlParams
+  };
+}

package/src/types/app.ts

@@ -6,7 +6,14 @@ export interface Message {
   timestamp: Date;
 }
 
-export type Tool = 'import' | 'source' | 'filter' | 'compiled' | 'resolution' | 'configuration';
+export type Tool =
+  | 'import'
+  | 'source'
+  | 'filter'
+  | 'compiled'
+  | 'resolution'
+  | 'configuration'
+  | 'zip-loader';
 
 export interface FilterState {
   enabled: boolean;
@@ -24,6 +31,7 @@ export interface AppState {
 
 export interface AppActions {
   setSelectedTool: (tool: Tool, force?: boolean) => void;
+  setActiveTool: (tool: Tool, force?: boolean) => void; // Alias for setSelectedTool
   addMessage: (type: Message['type'], message: string) => void;
   clearMessages: () => void;
   updateFilterEnabled: (enabled: boolean) => void;

package/src/utils/fileImport.ts

@@ -18,6 +18,7 @@ export interface FileImportOptions {
   acceptedTypes?: string[];
   multiple?: boolean;
   includeDirectories?: boolean;
+  startIn?: string | FileSystemHandle;
 }
 
 /**
@@ -34,7 +35,7 @@ export class ModernFileImporter {
   /**
    * Pick a directory using File System Access API
    */
-  async pickDirectory(): Promise<Result<ImportedDirectory>> {
+  async pickDirectory(options: FileImportOptions = {}): Promise<Result<ImportedDirectory>> {
     try {
       if (!isFileSystemAccessSupported()) {
         return fail('File System Access API not supported');
@@ -42,7 +43,7 @@ export class ModernFileImporter {
 
       const directoryHandle = await window.showDirectoryPicker({
         mode: 'read',
-        startIn: 'documents'
+        startIn: options.startIn || 'documents'
       });
 
       const importedDirectory = await this.processDirectoryHandle(directoryHandle);
@@ -76,7 +77,8 @@ export class ModernFileImporter {
               }
             ]
           : undefined,
-        excludeAcceptAllOption: false
+        excludeAcceptAllOption: false,
+        startIn: options.startIn || 'documents'
       });
 
       const importedFiles: ImportedFile[] = [];
@@ -303,9 +305,9 @@ export class FileImporter {
   /**
    * Pick a directory using the best available method
    */
-  async pickDirectory(): Promise<Result<ImportedDirectory>> {
+  async pickDirectory(options: FileImportOptions = {}): Promise<Result<ImportedDirectory>> {
     if (isFileSystemAccessSupported()) {
-      return this.modernImporter.pickDirectory();
+      return this.modernImporter.pickDirectory(options);
     } else {
       return this.fallbackImporter.pickDirectory();
     }

package/src/utils/fileTreeConverter.ts

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { FileTree, Result, succeed, fail } from '@fgv/ts-utils';
+import { ImportedDirectory, ImportedFile } from './fileImport';
+
+/**
+ * Converts a FileTree item (directory or file) to ImportedDirectory/ImportedFile format
+ * for compatibility with existing resource processing pipeline.
+ */
+export class FileTreeConverter {
+  /**
+   * Converts a FileTree directory to ImportedDirectory format.
+   */
+  public static convertDirectory(
+    fileTree: FileTree.FileTree,
+    directoryPath: string
+  ): Result<ImportedDirectory> {
+    try {
+      const itemResult = fileTree.getItem(directoryPath);
+      if (itemResult.isFailure()) {
+        return fail(`Directory not found: ${directoryPath}`);
+      }
+
+      const item = itemResult.value;
+      if (item.type !== 'directory') {
+        return fail(`Path is not a directory: ${directoryPath}`);
+      }
+
+      const childrenResult = item.getChildren();
+      if (childrenResult.isFailure()) {
+        return fail(`Failed to get directory children: ${childrenResult.message}`);
+      }
+
+      const files: ImportedFile[] = [];
+      const directories: ImportedDirectory[] = [];
+
+      for (const child of childrenResult.value) {
+        if (child.type === 'file') {
+          const fileResult = this.convertFile(child);
+          if (fileResult.isSuccess()) {
+            files.push(fileResult.value);
+          }
+        } else if (child.type === 'directory') {
+          const dirResult = this.convertDirectory(fileTree, child.absolutePath);
+          if (dirResult.isSuccess()) {
+            directories.push(dirResult.value);
+          }
+        }
+      }
+
+      const importedDirectory: ImportedDirectory = {
+        name: item.name,
+        path: item.absolutePath,
+        files,
+        directories
+      };
+
+      return succeed(importedDirectory);
+    } catch (error) {
+      return fail(`Failed to convert directory: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Converts a FileTree file item to ImportedFile format.
+   */
+  public static convertFile(fileItem: FileTree.IFileTreeFileItem): Result<ImportedFile> {
+    try {
+      const contentsResult = fileItem.getRawContents();
+      if (contentsResult.isFailure()) {
+        return fail(`Failed to read file contents: ${contentsResult.message}`);
+      }
+
+      const importedFile: ImportedFile = {
+        name: fileItem.name,
+        path: fileItem.absolutePath,
+        content: contentsResult.value
+      };
+
+      return succeed(importedFile);
+    } catch (error) {
+      return fail(`Failed to convert file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Converts multiple FileTree files to ImportedFile format.
+   */
+  public static convertFiles(fileItems: FileTree.IFileTreeFileItem[]): Result<ImportedFile[]> {
+    try {
+      const importedFiles: ImportedFile[] = [];
+
+      for (const fileItem of fileItems) {
+        const fileResult = this.convertFile(fileItem);
+        if (fileResult.isSuccess()) {
+          importedFiles.push(fileResult.value);
+        } else {
+          return fail(`Failed to convert file ${fileItem.name}: ${fileResult.message}`);
+        }
+      }
+
+      return succeed(importedFiles);
+    } catch (error) {
+      return fail(`Failed to convert files: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Converts a FileTree path to ImportedDirectory or ImportedFile format,
+   * automatically detecting the type.
+   */
+  public static convertPath(
+    fileTree: FileTree.FileTree,
+    path: string
+  ): Result<ImportedDirectory | ImportedFile[]> {
+    try {
+      const itemResult = fileTree.getItem(path);
+      if (itemResult.isFailure()) {
+        return fail(`Path not found: ${path}`);
+      }
+
+      const item = itemResult.value;
+
+      if (item.type === 'directory') {
+        return this.convertDirectory(fileTree, path);
+      } else if (item.type === 'file') {
+        const fileResult = this.convertFile(item);
+        if (fileResult.isSuccess()) {
+          return succeed([fileResult.value]);
+        } else {
+          return fileResult;
+        }
+      } else {
+        return fail(`Unknown item type: ${path}`);
+      }
+    } catch (error) {
+      return fail(`Failed to convert path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}