load_chunked_json.js

/**
 * 分块JSON文件加载器
 * 用于加载被分割成多个小块的JSON文件
 */

class ChunkedJSONLoader {
    constructor(basePath = '') {
        this.basePath = basePath;
        this.cache = new Map();
    }

    /**
     * 加载分块的JSON文件
     * @param {string} indexFile - 索引文件路径（例如：graph_index_chunks/graph_index_index.json）
     * @returns {Promise<Object>} 合并后的完整数据
     */
    async loadChunkedJSON(indexFile) {
        // 检查缓存
        if (this.cache.has(indexFile)) {
            return this.cache.get(indexFile);
        }

        try {
            // 加载索引文件
            const indexResponse = await fetch(this.basePath + indexFile);
            if (!indexResponse.ok) {
                throw new Error(`无法加载索引文件: ${indexFile}`);
            }
            const index = await indexResponse.json();

            // 并行加载所有块
            const chunkPromises = index.chunk_files.map(chunk => {
                const chunkPath = indexFile.replace('_index.json', '') + '/' + chunk.filename;
                return fetch(this.basePath + chunkPath)
                    .then(response => {
                        if (!response.ok) {
                            throw new Error(`无法加载块文件: ${chunkPath}`);
                        }
                        return response.json();
                    });
            });

            const chunks = await Promise.all(chunkPromises);

            // 合并数据
            let mergedData;
            if (index.chunk_files[0].keys) {
                // 字典类型：按键合并
                mergedData = {};
                chunks.forEach((chunk, index) => {
                    Object.assign(mergedData, chunk);
                });
            } else {
                // 列表类型：按顺序合并
                mergedData = [];
                chunks.forEach(chunk => {
                    mergedData.push(...chunk);
                });
            }

            // 缓存结果
            this.cache.set(indexFile, mergedData);
            return mergedData;

        } catch (error) {
            console.error('加载分块JSON失败:', error);
            throw error;
        }
    }

    /**
     * 智能加载JSON文件（自动检测是否需要分块加载）
     * @param {string} filePath - JSON文件路径
     * @returns {Promise<Object>} JSON数据
     */
    async loadJSON(filePath) {
        // 首先尝试直接加载
        try {
            const response = await fetch(this.basePath + filePath);
            if (response.ok) {
                return await response.json();
            }
        } catch (error) {
            // 如果直接加载失败，尝试分块加载
            console.log(`直接加载失败，尝试分块加载: ${filePath}`);
        }

        // 尝试分块加载
        const baseName = filePath.replace('.json', '');
        const indexFile = `${baseName}_chunks/${baseName}_index.json`;
        
        try {
            return await this.loadChunkedJSON(indexFile);
        } catch (error) {
            console.error(`无法加载文件（直接和分块都失败）: ${filePath}`, error);
            throw error;
        }
    }

    /**
     * 清除缓存
     */
    clearCache() {
        this.cache.clear();
    }
}

// 导出（如果使用模块系统）
if (typeof module !== 'undefined' && module.exports) {
    module.exports = ChunkedJSONLoader;
}