xm-netcdf-loader 1.0.0

package/dist/netcdf4-wasm/dist/netcdf4.js

@@ -0,0 +1,1049 @@
+// Main NetCDF4 class implementation
+import { Group } from './group.js';
+import { WasmModuleLoader } from './wasm-module.js';
+import { NC_CONSTANTS } from './constants.js';
+import * as NCGet from './netcdf-getters.js';
+export class NetCDF4 extends Group {
+    filename;
+    mode;
+    options;
+    module = null;
+    initialized = false;
+    ncid = -1;
+    _isOpen = false;
+    memorySource;
+    workerSource;
+    worker;
+    workerReady;
+    constructor(filename, mode = 'r', options = {}) {
+        super(null, '', -1);
+        this.filename = filename;
+        this.mode = mode;
+        this.options = options;
+        // Set up self-reference for Group methods
+        this.netcdf = this;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            if (this.workerSource) {
+                // This now handles the WORKERFS mounting
+                await this.setupWorker();
+                this.initialized = true;
+            }
+            else {
+                this.module = await WasmModuleLoader.loadModule(this.options);
+                if (this.memorySource) {
+                    await this.mountMemoryData();
+                }
+            }
+            this.initialized = true;
+            // Automatically open the file if a filename was provided
+            if (this.filename && !this.workerSource) {
+                await this.open();
+            }
+        }
+        catch (error) {
+            if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+                this.module = this.createMockModule();
+                this.initialized = true;
+                if (this.filename)
+                    await this.open();
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    // Python-like factory method
+    static async Dataset(filename, mode = 'r', options = {}) {
+        const dataset = new NetCDF4(filename, mode, options);
+        await dataset.initialize();
+        return dataset;
+    }
+    // Create dataset from Blob
+    static async fromBlob(blob, mode = 'r', options = {}) {
+        const arrayBuffer = await blob.arrayBuffer();
+        return NetCDF4.fromArrayBuffer(arrayBuffer, mode, options);
+    }
+    // Create dataset from ArrayBuffer
+    static async fromArrayBuffer(buffer, mode = 'r', options = {}) {
+        const data = new Uint8Array(buffer);
+        return NetCDF4.fromMemory(data, mode, options);
+    }
+    // Create dataset from memory data (Uint8Array or ArrayBuffer)
+    static async fromMemory(data, mode = 'r', options = {}, filename) {
+        if (!data) {
+            throw new Error('Data cannot be null or undefined');
+        }
+        if (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array)) {
+            throw new Error('Data must be ArrayBuffer or Uint8Array');
+        }
+        const uint8Data = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+        const virtualFilename = filename || `/tmp/netcdf_${Date.now()}_${Math.random().toString(36).substr(2, 9)}.nc`;
+        const dataset = new NetCDF4(virtualFilename, mode, options);
+        dataset.memorySource = {
+            data: uint8Data,
+            filename: virtualFilename
+        };
+        await dataset.initialize();
+        return dataset;
+    }
+    // New factory for Blob/File (local, no full preload)
+    static async fromBlobLazy(blob, options = {}) {
+        // IMPORTANT: Keep this path consistent with the mount logic in the worker
+        const mountPoint = '/working';
+        const baseName = `netcdf_lazy_${Date.now()}.nc`;
+        const fullPath = `${mountPoint}/${baseName}`;
+        const dataset = new NetCDF4(fullPath, 'r', options);
+        // Store the raw blob. The worker will mount it via WORKERFS
+        dataset.workerSource = { blob, filename: fullPath };
+        await dataset.initialize();
+        // After worker is set up, open the file
+        await dataset.open();
+        return dataset;
+    }
+    async open() {
+        if (this._isOpen)
+            return;
+        if (!this.filename || this.filename.trim() === '') {
+            throw new Error('No filename specified');
+        }
+        // Check for valid modes early, before any WASM operations
+        const validModes = ['r', 'w', 'w-', 'a', 'r+'];
+        if (!validModes.includes(this.mode)) {
+            throw new Error(`Unsupported mode: ${this.mode}`);
+        }
+        // Worker path
+        if (this.worker) {
+            // Wait for worker to be ready first
+            await this.workerReady;
+            const modeValue = this.mode === 'r' ? NC_CONSTANTS.NC_NOWRITE : NC_CONSTANTS.NC_WRITE;
+            this.ncid = await this.callWorker('open', { path: this.filename, modeValue });
+            this.groupId = this.ncid;
+            this._isOpen = true;
+            return;
+        }
+        if (this.mode === 'w' || this.mode === 'w-') {
+            // Create new file
+            let createMode = NC_CONSTANTS.NC_CLOBBER;
+            if (this.options.format === 'NETCDF4') {
+                createMode |= NC_CONSTANTS.NC_NETCDF4;
+            }
+            const result = await this.createFile(this.filename, createMode);
+            this.ncid = result;
+            this.groupId = result;
+        }
+        else if (this.mode === 'r' || this.mode === 'a' || this.mode === 'r+') {
+            // Open existing file
+            const modeValue = this.mode === 'r' ? NC_CONSTANTS.NC_NOWRITE : NC_CONSTANTS.NC_WRITE;
+            this.ncid = await this.openFile(this.filename, this.mode);
+            this.groupId = this.ncid;
+            // Load existing data from mock storage if in test mode
+            if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+                this.loadMockDimensions();
+            }
+            else {
+                await this.load();
+            }
+        }
+        this._isOpen = true;
+    }
+    // Property access similar to Python API
+    get file_format() {
+        return this.options.format || 'NETCDF4';
+    }
+    get disk_format() {
+        return this.file_format;
+    }
+    get filepath() {
+        return this.filename || '';
+    }
+    get isopen() {
+        return this._isOpen;
+    }
+    // Check if module is initialized
+    isInitialized() {
+        return this.initialized;
+    }
+    getModule() {
+        if (!this.module) {
+            throw new Error('NetCDF4 module not initialized. Call initialize() first.');
+        }
+        return this.module;
+    }
+    // Close method
+    async close() {
+        if (this._isOpen && this.ncid >= 0) {
+            await this.closeFile(this.ncid);
+            this._isOpen = false;
+            this.ncid = -1;
+        }
+    }
+    // Sync method (flush to disk)
+    async sync() {
+        if (this._isOpen) {
+            // TODO: Implement nc_sync when available
+            console.warn('sync() not yet implemented');
+        }
+    }
+    // Context manager support (Python-like)
+    async __aenter__() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        return this;
+    }
+    async __aexit__() {
+        await this.close();
+    }
+    // Low-level NetCDF operations (used by Group methods)
+    async openFile(path, mode = 'r') {
+        const module = this.getModule();
+        const modeValue = mode === 'r' ? NC_CONSTANTS.NC_NOWRITE :
+            mode === 'w' ? NC_CONSTANTS.NC_WRITE :
+                NC_CONSTANTS.NC_WRITE;
+        const result = module.nc_open(path, modeValue);
+        if (result.result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to open NetCDF file: ${path} (error: ${result.result})`);
+        }
+        return result.ncid;
+    }
+    async createFile(path, mode = NC_CONSTANTS.NC_CLOBBER) {
+        const module = this.getModule();
+        const result = module.nc_create(path, mode);
+        if (result.result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to create NetCDF file: ${path} (error: ${result.result})`);
+        }
+        return result.ncid;
+    }
+    async closeFile(ncid) {
+        if (this.worker) {
+            this.callWorker('close');
+        }
+        else {
+            const module = this.module;
+            if (!module)
+                throw new Error("Failed to load module. Ensure module is initialized before calling methods");
+            const result = module.nc_close(ncid);
+            if (result !== NC_CONSTANTS.NC_NOERR) {
+                throw new Error(`Failed to close NetCDF file with ID: ${ncid} (error: ${result})`);
+            }
+        }
+    }
+    requestId = 0;
+    async callWorker(type, payload = {}) {
+        if (!this.worker)
+            throw new Error("Worker not initialized");
+        const id = ++this.requestId;
+        return new Promise((resolve, reject) => {
+            const handler = (e) => {
+                // Only handle messages that match our request ID
+                if (e.data.id !== id)
+                    return;
+                if (e.data.success) {
+                    resolve(e.data.result);
+                }
+                else {
+                    reject(new Error(e.data.error || `Worker error in ${type}`));
+                }
+                this.worker.removeEventListener('message', handler);
+            };
+            this.worker.addEventListener('message', handler);
+            this.worker.postMessage({
+                id, // Include the ID in the request
+                type,
+                ncid: this.ncid,
+                ...payload
+            });
+        });
+    }
+    async getGlobalAttributes(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getGlobalAttributes', { groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getGlobalAttributes(this.module, this.ncid, groupPath);
+        }
+    }
+    async getFullMetadata(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getFullMetadata', { groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getFullMetadata(this.module, this.ncid, groupPath);
+        }
+    }
+    async getAttributeValues(varid, attname) {
+        if (this.worker) {
+            return this.callWorker('getAttributeValues', { varid, attname });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getAttributeValues(this.module, this.ncid, varid, attname);
+        }
+    }
+    async getDimCount(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getDimCount', { ncid });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDimCount(this.module, ncid);
+        }
+    }
+    async getGroupVariables(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getGroupVariables', { groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getGroupVariables(this.module, this.ncid, groupPath);
+        }
+    }
+    async getVarIDs(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getVarIDs', { ncid });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVarIDs(this.module, ncid);
+        }
+    }
+    async getDimIDs(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getDimIDs', { ncid });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDimIDs(this.module, ncid);
+        }
+    }
+    async getDim(dimid, ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getDim', { dimid, ncid });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDim(this.module, ncid, dimid);
+        }
+    }
+    async getDims(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getDims', { groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDims(this.module, this.ncid, groupPath);
+        }
+    }
+    async getVarCount(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getVarCount', { ncid });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVarCount(this.module, ncid);
+        }
+    }
+    async getAttributeName(varid, attId) {
+        if (this.worker) {
+            return this.callWorker('getAttributeName', { varid, attId });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getAttributeName(this.module, this.ncid, varid, attId);
+        }
+    }
+    async getVariableInfo(variable, groupPath) {
+        if (this.worker) {
+            return this.callWorker('getVariableInfo', { variable, groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVariableInfo(this.module, this.ncid, variable, groupPath);
+        }
+    }
+    async getVariableArray(variable, groupPath) {
+        if (this.worker) {
+            return this.callWorker('getVariableArray', { variable, groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVariableArray(this.module, this.ncid, variable, groupPath);
+        }
+    }
+    async getSlicedVariableArray(variable, start, count, groupPath) {
+        if (this.worker) {
+            return this.callWorker('getSlicedVariableArray', { variable, start, count, groupPath });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getSlicedVariableArray(this.module, this.ncid, variable, start, count, groupPath);
+        }
+    }
+    /**
+     * slicing and indexing convenience method.
+     *
+     * Each element of `selection` corresponds to one dimension of the variable:
+     *   - 'all' or `null`            → all elements of that dimension
+     *   - `number`                   → scalar index (dimension is collapsed)
+     *   - `slice(stop)`              → elements [0, stop)
+     *   - `slice(start, stop)`       → elements [start, stop)
+     *   - `slice(start, stop, step)` → strided subset; steps are always positive, reading is always forward, you can achieve negative step by reversing the dimension after reading
+     *
+     * Strided reads use nc_get_vars_* under the hood.
+     * Returns a flat typed array; caller infers shape from non-collapsed dims.
+     *
+     * @example
+     * // Variable shape [time, lat, lon]
+     * // Read 10 time steps, all lats, first lon:
+     * const data = await dataset.get("temperature", [slice(0, 10), 'all', 0]);
+     *
+     * @example
+     * // Every other element along time:
+     * const data = await dataset.get("temperature", [slice(0, 100, 2), null, null]);
+     *
+     */
+    async get(variable, selection, groupPath, options) {
+        if (this.worker) {
+            return this.callWorker('getVariableArrayWithSelection', {
+                ncid: this.ncid, variable, selection, groupPath, options
+            });
+        }
+        else {
+            return NCGet.getVariableArrayWithSelection(this.module, this.ncid, variable, selection, groupPath, options);
+        }
+    }
+    // Group functions
+    async getGroups(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroups', { ncid });
+        }
+        else {
+            return NCGet.getGroups(this.module, ncid);
+        }
+    }
+    async getGroupsRecursive(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroupsRecursive', { ncid });
+        }
+        else {
+            return NCGet.getGroupsRecursive(this.module, ncid);
+        }
+    }
+    async getGroupNCID(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getGroupNCID', { groupPath });
+        }
+        else {
+            return NCGet.getGroupNCID(this.module, this.ncid, groupPath);
+        }
+    }
+    async getGroupName(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroupName', { ncid });
+        }
+        else {
+            return NCGet.getGroupName(this.module, ncid);
+        }
+    }
+    async getGroupPath(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroupPath', { ncid });
+        }
+        else {
+            return NCGet.getGroupPath(this.module, ncid);
+        }
+    }
+    async defineDimension(ncid, name, size) {
+        const module = this.getModule();
+        const result = module.nc_def_dim(ncid, name, size);
+        if (result.result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to define dimension: ${name} (error: ${result.result})`);
+        }
+        return result.dimid;
+    }
+    async defineVariable(ncid, name, type, dimids) {
+        const module = this.getModule();
+        const result = module.nc_def_var(ncid, name, type, dimids.length, dimids);
+        if (result.result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to define variable: ${name} (error: ${result.result})`);
+        }
+        return result.varid;
+    }
+    async endDefineMode(ncid) {
+        const module = this.getModule();
+        const result = module.nc_enddef(ncid);
+        if (result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to end define mode (error: ${result})`);
+        }
+    }
+    async putVariableDouble(ncid, varid, data) {
+        const module = this.getModule();
+        const result = module.nc_put_var_double(ncid, varid, data);
+        if (result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to write variable data (error: ${result})`);
+        }
+    }
+    async getVariableDouble(ncid, varid, length) {
+        const module = this.getModule();
+        const result = module.nc_get_var_double(ncid, varid, length);
+        if (result.result !== NC_CONSTANTS.NC_NOERR) {
+            throw new Error(`Failed to read variable data (error: ${result.result})`);
+        }
+        if (!result.data) {
+            throw new Error("nc_get_var_double returned no data");
+        }
+        return result.data;
+    }
+    // Create a mock module for testing
+    createMockModule() {
+        // Global mock file storage to simulate persistence across instances
+        if (!global.__netcdf4_mock_files) {
+            global.__netcdf4_mock_files = {};
+        }
+        const mockFiles = global.__netcdf4_mock_files;
+        return {
+            nc_open: (path, mode) => {
+                // Mock implementation that simulates invalid filenames and unsupported modes
+                if (!path || path.trim() === '' || path.includes('unsupported') || !['r', 'w', 'a'].some(m => this.mode.includes(m))) {
+                    return { result: -1, ncid: -1 };
+                }
+                // For reading mode, file should exist in mock storage, otherwise create a minimal entry
+                if (this.mode === 'r' && !mockFiles[path]) {
+                    // For test purposes, allow reading non-existent files but initialize them empty
+                    mockFiles[path] = {
+                        attributes: {},
+                        dimensions: {},
+                        variables: {}
+                    };
+                }
+                return { result: NC_CONSTANTS.NC_NOERR, ncid: 1 };
+            },
+            nc_close: (ncid) => {
+                // In a real implementation, this would flush data to the file
+                // For our mock, we'll keep the data in memory
+                return NC_CONSTANTS.NC_NOERR;
+            },
+            nc_create: (path, mode) => {
+                if (path.includes('unsupported') || ['x', 'invalid'].some(m => this.mode.includes(m))) {
+                    return { result: -1, ncid: -1 };
+                }
+                // Initialize mock file storage
+                mockFiles[path] = {
+                    attributes: {},
+                    dimensions: {},
+                    variables: {}
+                };
+                return { result: NC_CONSTANTS.NC_NOERR, ncid: 1 };
+            },
+            nc_def_dim: (ncid, name, len) => {
+                // Store dimension in mock file
+                if (this.filename && mockFiles[this.filename]) {
+                    mockFiles[this.filename].dimensions[name] = {
+                        size: len,
+                        unlimited: len === NC_CONSTANTS.NC_UNLIMITED
+                    };
+                }
+                return { result: NC_CONSTANTS.NC_NOERR, dimid: 1 };
+            },
+            nc_def_var: (ncid, name, xtype, ndims, dimids) => {
+                // Initialize variable storage
+                if (this.filename && mockFiles[this.filename]) {
+                    mockFiles[this.filename].variables[name] = {
+                        data: new Float64Array(0),
+                        attributes: {}
+                    };
+                    // Return varid based on current variable count (1-based)
+                    const varCount = Object.keys(mockFiles[this.filename].variables).length;
+                    return { result: NC_CONSTANTS.NC_NOERR, varid: varCount };
+                }
+                return { result: NC_CONSTANTS.NC_NOERR, varid: 1 };
+            },
+            nc_put_var_double: (ncid, varid, data) => {
+                // Store data in mock file - try to map varid to variable name
+                if (this.filename && mockFiles[this.filename]) {
+                    const variables = mockFiles[this.filename].variables;
+                    const varNames = Object.keys(variables);
+                    // Map varid to variable name (1-based indexing)
+                    if (varNames.length > 0 && varid >= 1 && varid <= varNames.length) {
+                        const varName = varNames[varid - 1]; // Convert to 0-based
+                        variables[varName].data = new Float64Array(data);
+                    }
+                }
+                return NC_CONSTANTS.NC_NOERR;
+            },
+            nc_get_var_double: (ncid, varid, size) => {
+                // Try to get actual stored data first
+                if (this.filename && mockFiles[this.filename]) {
+                    const variables = mockFiles[this.filename].variables;
+                    const varNames = Object.keys(variables);
+                    // Map varid to variable name (1-based indexing)
+                    if (varNames.length > 0 && varid >= 1 && varid <= varNames.length) {
+                        const varName = varNames[varid - 1]; // Convert to 0-based
+                        const storedData = variables[varName].data;
+                        if (storedData && storedData.length > 0) {
+                            // Return the stored data, resized to requested size if needed
+                            if (size <= 0) {
+                                return { result: NC_CONSTANTS.NC_NOERR, data: new Float64Array(0) };
+                            }
+                            const result = new Float64Array(size);
+                            for (let i = 0; i < size && i < storedData.length; i++) {
+                                result[i] = storedData[i];
+                            }
+                            return { result: NC_CONSTANTS.NC_NOERR, data: result };
+                        }
+                    }
+                }
+                // Fallback to test pattern if no data stored
+                if (size <= 0) {
+                    return { result: NC_CONSTANTS.NC_NOERR, data: new Float64Array(0) };
+                }
+                const data = new Float64Array(size);
+                for (let i = 0; i < size; i++) {
+                    data[i] = i * 0.1; // Simple test pattern
+                }
+                return { result: NC_CONSTANTS.NC_NOERR, data };
+            },
+            nc_enddef: (ncid) => NC_CONSTANTS.NC_NOERR,
+        };
+    }
+    async setupWorker() {
+        if (!this.workerSource)
+            throw new Error('No worker source');
+        // 1. Instantiate the worker if it doesn't exist
+        if (!this.worker) {
+            // Option A: If using Vite/Webpack 5
+            this.worker = new Worker(new URL('./netcdf-worker.js', import.meta.url), { type: 'module' });
+        }
+        this.workerReady = new Promise((resolve, reject) => {
+            // Use a named function so we can remove the listener later
+            const initHandler = (e) => {
+                if (e.data.success) {
+                    this.worker.removeEventListener('message', initHandler);
+                    resolve();
+                }
+                else {
+                    this.worker.removeEventListener('message', initHandler);
+                    reject(new Error(e.data.message));
+                }
+            };
+            this.worker.addEventListener('message', initHandler);
+            // 3. Send the initialization message
+            this.worker.postMessage({
+                type: 'init',
+                blob: this.workerSource.blob,
+                filename: this.workerSource.filename
+            });
+        });
+        return this.workerReady;
+    }
+    // Mount memory data in the WASM virtual file system
+    async mountMemoryData() {
+        if (!this.memorySource || !this.module) {
+            return;
+        }
+        // Skip mounting in test mode (mock module doesn't have FS)
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            return;
+        }
+        try {
+            const module = this.getModule();
+            if (!module.FS) {
+                throw new Error('Emscripten FS not available');
+            }
+            // Ensure the /tmp directory exists
+            try {
+                module.FS.mkdir('/tmp');
+            }
+            catch (e) {
+                // Directory might already exist, ignore error
+            }
+            // Write the memory data to a virtual file
+            module.FS.writeFile(this.memorySource.filename, this.memorySource.data);
+        }
+        catch (error) {
+            throw new Error(`Failed to mount memory data: ${error}`);
+        }
+    }
+    // Get data from memory or file as ArrayBuffer (for writing back to Blob)
+    async toArrayBuffer() {
+        if (!this.module) {
+            throw new Error('NetCDF4 module not initialized');
+        }
+        // Skip in test mode
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            // Return empty buffer in test mode
+            return new ArrayBuffer(0);
+        }
+        try {
+            const module = this.getModule();
+            if (!module.FS || !this.filename) {
+                throw new Error('Cannot read file data');
+            }
+            // Read the file from the virtual file system
+            const data = module.FS.readFile(this.filename);
+            return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        }
+        catch (error) {
+            throw new Error(`Failed to read data as ArrayBuffer: ${error}`);
+        }
+    }
+    // Convert to Blob
+    async toBlob(type = 'application/x-netcdf') {
+        const buffer = await this.toArrayBuffer();
+        return new Blob([buffer], { type });
+    }
+    toString() {
+        const status = this._isOpen ? 'open' : 'closed';
+        const source = this.memorySource ? '(in-memory)' : '';
+        return `<netCDF4.Dataset '${this.filename}'${source}: mode = '${this.mode}', file format = '${this.file_format}', ${status}>`;
+    }
+    /**
+ * Get complete hierarchy of groups, variables, dimensions, and attributes
+ * This is the unified method for exploring the entire file structure
+ * @param groupPath - Optional path to start from a specific group
+ */
+    async getCompleteHierarchy(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getCompleteHierarchy', { groupPath });
+        }
+        else {
+            return NCGet.getCompleteHierarchy(this.module, this.ncid, groupPath);
+        }
+    }
+    /**
+     * Get all variables recursively from all groups
+     * Returns a flat dictionary with full path keys like "/group1/var1"
+     */
+    async getVariables() {
+        if (this.worker) {
+            return this.callWorker('getVariables');
+        }
+        else {
+            return NCGet.getVariables(this.module, this.ncid);
+        }
+    }
+}
+/**
+ * UI-friendly wrapper around NetCDF4
+ * Builds a full dataTree of groups, variables, attributes with enhanced navigation
+ */
+export class DataTree {
+    dataset;
+    tree = {};
+    groupTreeCache = null;
+    constructor(dataset) {
+        this.dataset = dataset;
+    }
+    async buildTree() {
+        this.tree = await this.dataset.getCompleteHierarchy();
+        // Clear cache when tree is rebuilt
+        this.groupTreeCache = null;
+    }
+    // --------------------------------------------------
+    // Core navigation
+    // --------------------------------------------------
+    getGroup(groupPath = '/') {
+        if (!this.tree)
+            return null;
+        if (groupPath === '/' || !groupPath)
+            return this.tree;
+        const parts = groupPath.split('/').filter(Boolean);
+        let current = this.tree;
+        for (const part of parts) {
+            if (!current.groups || !current.groups[part])
+                return null;
+            current = current.groups[part];
+        }
+        return current;
+    }
+    getGroupName(groupPath) {
+        if (!groupPath || groupPath === '/')
+            return 'root';
+        const parts = groupPath.split('/').filter(Boolean);
+        return parts[parts.length - 1];
+    }
+    hasSubgroups(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group ? Object.keys(group.groups || {}).length > 0 : false;
+    }
+    // --------------------------------------------------
+    // Groups (for dropdowns)
+    // --------------------------------------------------
+    /** immediate children only */
+    listGroups(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        if (!group || !group.groups)
+            return [];
+        return Object.entries(group.groups).map(([name, g]) => ({
+            name,
+            path: g.path || `${groupPath === '/' ? '' : groupPath}/${name}`
+        }));
+    }
+    /** every group recursively */
+    listAllGroups() {
+        const result = [];
+        const walk = (g) => {
+            if (!g.groups)
+                return;
+            for (const [name, sub] of Object.entries(g.groups)) {
+                result.push({ name, path: sub.path });
+                walk(sub);
+            }
+        };
+        walk(this.tree);
+        return result;
+    }
+    // --------------------------------------------------
+    // Hierarchical Group Tree
+    // --------------------------------------------------
+    /**
+     * Build a hierarchical tree structure of all groups
+     * Returns a tree with parent-child relationships
+     * Results are cached until buildTree() is called again
+     */
+    buildGroupTree() {
+        // Return cached version if available
+        if (this.groupTreeCache) {
+            return this.groupTreeCache;
+        }
+        const allGroups = this.listAllGroups();
+        // Create root node
+        const root = {
+            name: '/',
+            path: '/',
+            children: [],
+            hasVariables: this.hasVariables('/'),
+            hasAttributes: this.hasAttributes('/'),
+            variableCount: this.getVariableCount('/'),
+            attributeCount: this.getAttributeCount('/')
+        };
+        // Map to store all nodes by path for quick lookup
+        const nodeMap = new Map();
+        nodeMap.set('/', root);
+        // Sort groups by path depth to ensure parents are created before children
+        const sortedGroups = allGroups.sort((a, b) => {
+            const depthA = a.path.split('/').filter(Boolean).length;
+            const depthB = b.path.split('/').filter(Boolean).length;
+            return depthA - depthB;
+        });
+        // Build the tree
+        for (const { name, path } of sortedGroups) {
+            const node = {
+                name,
+                path,
+                children: [],
+                hasVariables: this.hasVariables(path),
+                hasAttributes: this.hasAttributes(path),
+                variableCount: this.getVariableCount(path),
+                attributeCount: this.getAttributeCount(path)
+            };
+            nodeMap.set(path, node);
+            // Find parent path
+            const pathParts = path.split('/').filter(Boolean);
+            const parentPath = pathParts.length === 1
+                ? '/'
+                : '/' + pathParts.slice(0, -1).join('/');
+            const parent = nodeMap.get(parentPath);
+            if (parent) {
+                parent.children.push(node);
+            }
+        }
+        // Cache the result
+        this.groupTreeCache = root;
+        return root;
+    }
+    /**
+     * Get a specific node from the group tree by path
+     */
+    getGroupNode(path) {
+        const tree = this.buildGroupTree();
+        if (path === '/')
+            return tree;
+        const parts = path.split('/').filter(Boolean);
+        let current = tree;
+        for (const part of parts) {
+            const child = current.children.find(c => c.name === part);
+            if (!child)
+                return null;
+            current = child;
+        }
+        return current;
+    }
+    /**
+     * Get breadcrumb trail for a given path
+     * Returns array of {name, path} from root to target
+     */
+    getBreadcrumbs(groupPath) {
+        if (groupPath === '/') {
+            return [{ name: 'root', path: '/' }];
+        }
+        const parts = groupPath.split('/').filter(Boolean);
+        const breadcrumbs = [
+            { name: 'root', path: '/' }
+        ];
+        let currentPath = '';
+        for (const part of parts) {
+            currentPath += '/' + part;
+            breadcrumbs.push({
+                name: part,
+                path: currentPath
+            });
+        }
+        return breadcrumbs;
+    }
+    /**
+     * Search for groups by name (case-insensitive)
+     */
+    searchGroups(query) {
+        const lowerQuery = query.toLowerCase();
+        return this.listAllGroups().filter(g => g.name.toLowerCase().includes(lowerQuery) ||
+            g.path.toLowerCase().includes(lowerQuery));
+    }
+    // --------------------------------------------------
+    // Variables
+    // --------------------------------------------------
+    /** variables inside a group */
+    getAllVariables(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group?.variables || {};
+    }
+    /** check if group has variables */
+    hasVariables(groupPath = '/') {
+        const vars = this.getAllVariables(groupPath);
+        return Object.keys(vars).length > 0;
+    }
+    /** count variables in a group */
+    getVariableCount(groupPath = '/') {
+        return Object.keys(this.getAllVariables(groupPath)).length;
+    }
+    /** get variable names as array */
+    getVariableNames(groupPath = '/') {
+        return Object.keys(this.getAllVariables(groupPath));
+    }
+    /**
+     * Search for variables by name across all groups
+     */
+    searchVariables(query) {
+        const results = [];
+        const lowerQuery = query.toLowerCase();
+        const searchInGroup = (groupPath) => {
+            const vars = this.getAllVariables(groupPath);
+            for (const varName of Object.keys(vars)) {
+                if (varName.toLowerCase().includes(lowerQuery)) {
+                    results.push({
+                        name: varName,
+                        groupPath,
+                        path: `${groupPath === '/' ? '' : groupPath}/${varName}`
+                    });
+                }
+            }
+            // Recurse into subgroups
+            const subgroups = this.listGroups(groupPath);
+            for (const { path } of subgroups) {
+                searchInGroup(path);
+            }
+        };
+        searchInGroup('/');
+        return results;
+    }
+    // --------------------------------------------------
+    // Attributes
+    // --------------------------------------------------
+    /** attributes from the tree (fast) */
+    getAttributes(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group?.attributes || {};
+    }
+    /** check if group has attributes */
+    hasAttributes(groupPath = '/') {
+        const attrs = this.getAttributes(groupPath);
+        return Object.keys(attrs).length > 0;
+    }
+    /** count attributes in a group */
+    getAttributeCount(groupPath = '/') {
+        return Object.keys(this.getAttributes(groupPath)).length;
+    }
+    // --------------------------------------------------
+    // Dimensions
+    // --------------------------------------------------
+    /** get dimensions for a group */
+    getDimensions(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group?.dimensions || {};
+    }
+    /** check if group has dimensions */
+    hasDimensions(groupPath = '/') {
+        const dims = this.getDimensions(groupPath);
+        return Object.keys(dims).length > 0;
+    }
+    /** count dimensions in a group */
+    getDimensionCount(groupPath = '/') {
+        return Object.keys(this.getDimensions(groupPath)).length;
+    }
+    // --------------------------------------------------
+    // Statistics and Summaries
+    // --------------------------------------------------
+    /**
+     * Get summary statistics for a group
+     */
+    getGroupSummary(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        if (!group)
+            return null;
+        return {
+            path: groupPath,
+            name: this.getGroupName(groupPath),
+            variableCount: this.getVariableCount(groupPath),
+            attributeCount: this.getAttributeCount(groupPath),
+            dimensionCount: this.getDimensionCount(groupPath),
+            subgroupCount: this.listGroups(groupPath).length,
+            hasSubgroups: this.hasSubgroups(groupPath)
+        };
+    }
+    /**
+     * Get complete statistics for the entire dataset
+     */
+    getDatasetSummary() {
+        let totalVariables = 0;
+        let totalAttributes = 0;
+        let totalDimensions = 0;
+        let maxDepth = 0;
+        const countInGroup = (groupPath, depth) => {
+            totalVariables += this.getVariableCount(groupPath);
+            totalAttributes += this.getAttributeCount(groupPath);
+            totalDimensions += this.getDimensionCount(groupPath);
+            maxDepth = Math.max(maxDepth, depth);
+            const subgroups = this.listGroups(groupPath);
+            for (const { path } of subgroups) {
+                countInGroup(path, depth + 1);
+            }
+        };
+        countInGroup('/', 0);
+        return {
+            totalGroups: this.listAllGroups().length + 1, // +1 for root
+            totalVariables,
+            totalAttributes,
+            totalDimensions,
+            maxDepth
+        };
+    }
+    // --------------------------------------------------
+    // Heavy operations → still go to dataset
+    // --------------------------------------------------
+    async getVariableArray(variable, groupPath) {
+        return this.dataset.getVariableArray(variable, groupPath);
+    }
+    async getSlicedVariableArray(variable, start, count, groupPath) {
+        return this.dataset.getSlicedVariableArray(variable, start, count, groupPath);
+    }
+    async getVariableInfo(variable, groupPath) {
+        return this.dataset.getVariableInfo(variable, groupPath);
+    }
+}
+//# sourceMappingURL=netcdf4.js.map