unpak.js/dist/ue4/vfs/AsyncLoadingManager.d.ts

Modern TypeScript library for reading Unreal Engine pak files and assets, inspired by CUE4Parse

/**
 * Phase 10: Advanced File Systems - Async Loading Manager
 *
 * Manages prioritized async loading of assets with worker thread support
 * and intelligent preloading based on usage patterns.
 */
import { VirtualFileSystem, LoadPriority } from './VirtualFileSystem';
import { EventEmitter } from 'events';
/**
 * Loading job configuration
 */
export interface ILoadJob {
    /** Unique job ID */
    id: string;
    /** File paths to load */
    filePaths: string[];
    /** Loading priority */
    priority: LoadPriority;
    /** Creation timestamp */
    createdAt: number;
    /** Optional metadata */
    metadata?: Record<string, any>;
}
/**
 * Loading job result
 */
export interface ILoadResult {
    /** Job ID */
    jobId: string;
    /** Success status */
    success: boolean;
    /** Loaded file data map */
    data: Map<string, Buffer>;
    /** Failed file paths */
    failed: string[];
    /** Load duration in ms */
    duration: number;
    /** Optional error */
    error?: Error;
}
/**
 * Preload pattern for intelligent caching
 */
export interface IPreloadPattern {
    /** Pattern name */
    name: string;
    /** File path patterns to match */
    patterns: RegExp[];
    /** Trigger conditions */
    triggers: string[];
    /** Priority for preloaded files */
    priority: LoadPriority;
    /** Maximum files to preload */
    maxFiles?: number;
}
/**
 * Async Loading Manager with intelligent preloading
 *
 * Features:
 * - Priority-based job queue
 * - Batch loading with progress tracking
 * - Intelligent preloading based on patterns
 * - Load balancing across multiple worker threads
 * - Performance metrics and optimization
 */
export declare class AsyncLoadingManager extends EventEmitter {
    private vfs;
    private jobQueue;
    private activeJobs;
    private completedJobs;
    private preloadPatterns;
    private maxConcurrentJobs;
    private isProcessing;
    private accessPatterns;
    private lastAccessTime;
    private metrics;
    constructor(vfs: VirtualFileSystem, maxConcurrentJobs?: number);
    /**
     * Queue a loading job
     */
    queueJob(filePaths: string[], priority?: LoadPriority, metadata?: Record<string, any>): string;
    /**
     * Load files synchronously (returns immediately available data)
     */
    loadSync(filePaths: string[]): Map<string, Buffer>;
    /**
     * Load files asynchronously with priority
     */
    loadAsync(filePaths: string[], priority?: LoadPriority): Promise<Map<string, Buffer>>;
    /**
     * Add a preload pattern
     */
    addPreloadPattern(pattern: IPreloadPattern): void;
    /**
     * Remove a preload pattern
     */
    removePreloadPattern(name: string): boolean;
    /**
     * Trigger preloading based on file access
     */
    triggerPreload(triggerFile: string): void;
    /**
     * Get job status
     */
    getJobStatus(jobId: string): 'queued' | 'active' | 'completed' | 'failed' | 'not_found';
    /**
     * Cancel a queued job
     */
    cancelJob(jobId: string): boolean;
    /**
     * Get performance metrics
     */
    getMetrics(): typeof this.metrics & {
        queueLength: number;
        activeJobs: number;
    };
    /**
     * Clear completed job history
     */
    clearHistory(): void;
    private processJobs;
    private processJob;
    private completeJob;
    private sortJobQueue;
    private executePreload;
    private trackAccess;
    private generateJobId;
    private sleep;
    private setupDefaultPreloadPatterns;
}
//# sourceMappingURL=AsyncLoadingManager.d.ts.map