Invoerformulier om uw gegevens te registreren

Advanced Directory Operations

// Node.js Advanced Directory Reader
import { promises as fs } from 'fs';
import path from 'path';
import { Worker } from 'worker_threads';
import EventEmitter from 'events';

class AdvancedDirectoryReader extends EventEmitter {
  constructor(options = {}) {
    super();
    this.options = {
      recursive: false,
      includeHidden: false,
      sortBy: 'name', // name, size, modified, type
      sortOrder: 'asc',
      concurrent: 5,
      cache: true,
      watchChanges: false,
      ...options
    };
    
    this.cache = new Map();
    this.watchers = new Map();
  }
  
  async readDirectory(dirPath, options = {}) {
    const opts = { ...this.options, ...options };
    const normalizedPath = path.normalize(dirPath);
    
    // Security: Validate path
    if (!this.isPathSafe(normalizedPath)) {
      throw new Error('Invalid or unsafe path provided');
    }
    
    // Check cache
    if (opts.cache && this.cache.has(normalizedPath)) {
      const cached = this.cache.get(normalizedPath);
      if (Date.now() - cached.timestamp < 30000) { // 30s cache
        return cached.data;
      }
    }
    
    try {
      const results = await this.processDirectory(normalizedPath, opts);
      
      // Cache results
      if (opts.cache) {
        this.cache.set(normalizedPath, {
          data: results,
          timestamp: Date.now()
        });
      }
      
      // Setup watcher if requested
      if (opts.watchChanges && !this.watchers.has(normalizedPath)) {
        this.setupWatcher(normalizedPath);
      }
      
      this.emit('directoryRead', normalizedPath, results);
      return results;
      
    } catch (error) {
      this.emit('error', error, normalizedPath);
      throw error;
    }
  }
  
  async processDirectory(dirPath, options) {
    const items = await fs.readdir(dirPath, { withFileTypes: true });
    const results = [];
    
    // Process items concurrently
    const chunks = this.chunkArray(items, options.concurrent);
    
    for (const chunk of chunks) {
      const promises = chunk.map(item => this.processItem(dirPath, item, options));
      const chunkResults = await Promise.all(promises);
      results.push(...chunkResults.filter(Boolean));
    }
    
    // Sort results
    return this.sortItems(results, options.sortBy, options.sortOrder);
  }
}

// Directory Component for React Applications
const DirectoryExplorer = ({ rootPath, onFileSelect }) => {
  const [currentPath, setCurrentPath] = useState(rootPath);
  const [items, setItems] = useState([]);
  const [loading, setLoading] = useState(false);
  const [sortBy, setSortBy] = useState('name');
  const [viewMode, setViewMode] = useState('list'); // list or grid
  
  const reader = useRef(new AdvancedDirectoryReader());
  
  useEffect(() => {
    loadDirectory(currentPath);
  }, [currentPath, sortBy]);
  
  const loadDirectory = async (path) => {
    setLoading(true);
    try {
      const result = await reader.current.readDirectory(path, {
        sortBy: sortBy,
        includeHidden: false
      });
      setItems(result);
    } catch (error) {
      console.error('Failed to load directory:', error);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    

      

         setCurrentPath(path.dirname(currentPath))}>
          ← Back
        
        {currentPath}
         setSortBy(e.target.value)}>
          Name
          Size
          Modified
        
      
      
      {loading ? (
        
Loading directory...
      ) : (
        

          {items.map(item => (
            
 {
                if (item.type === 'directory') {
                  setCurrentPath(item.path);
                } else {
                  onFileSelect?.(item);
                }
              }}
            >
              

                {item.type === 'directory' ? '📁' : '📄'}
              
              

                
{item.name}
                

                  {item.type === 'file' && (
                    {formatFileSize(item.size)}
                  )}
                  
                    {new Date(item.modified).toLocaleDateString()}
                  
                
              
            
          ))}
        
      )}
    
  );
};