@earthyscience/netcdf4-wasm 0.1.0 → 0.1.1

package/dist/netcdf4.js

@@ -1,7 +1,8 @@
 // Main NetCDF4 class implementation
 import { Group } from './group.js';
 import { WasmModuleLoader } from './wasm-module.js';
-import { NC_CONSTANTS, DATA_TYPE_SIZE, CONSTANT_DTYPE_MAP } from './constants.js';
+import { NC_CONSTANTS } from './constants.js';
+import * as NCGet from './netcdf-getters.js';
 export class NetCDF4 extends Group {
     filename;
     mode;
@@ -11,6 +12,9 @@ export class NetCDF4 extends Group {
     ncid = -1;
     _isOpen = false;
     memorySource;
+    workerSource;
+    worker;
+    workerReady;
     constructor(filename, mode = 'r', options = {}) {
         super(null, '', -1);
         this.filename = filename;
@@ -20,30 +24,32 @@ export class NetCDF4 extends Group {
         this.netcdf = this;
     }
     async initialize() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
         try {
-            this.module = await WasmModuleLoader.loadModule(this.options);
-            this.initialized = true;
-            // Mount memory data in virtual file system if provided
-            if (this.memorySource) {
-                await this.mountMemoryData();
+            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();
+                }
             }
-            // Auto-open file if filename provided (including empty strings which should error)
-            if (this.filename !== undefined && this.filename !== null) {
+            this.initialized = true;
+            // Automatically open the file if a filename was provided
+            if (this.filename && !this.workerSource) {
                 await this.open();
             }
         }
         catch (error) {
-            // Check if this is a test environment and we should use mock mode
             if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-                // Mock the module for testing
                 this.module = this.createMockModule();
                 this.initialized = true;
-                if (this.filename !== undefined && this.filename !== null) {
+                if (this.filename)
                     await this.open();
-                }
             }
             else {
                 throw error;
@@ -84,9 +90,27 @@ export class NetCDF4 extends Group {
         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}`;
+        console.log('fromBlobLazy: Creating dataset with path:', fullPath);
+        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();
+        console.log('fromBlobLazy: Initialization complete, calling open()');
+        // After worker is set up, open the file
+        await dataset.open();
+        console.log('fromBlobLazy: Open complete, ncid:', dataset.ncid);
+        return dataset;
+    }
     async open() {
         if (this._isOpen)
             return;
+        console.log('open() called, filename:', this.filename, 'worker:', !!this.worker);
         if (!this.filename || this.filename.trim() === '') {
             throw new Error('No filename specified');
         }
@@ -95,6 +119,19 @@ export class NetCDF4 extends Group {
         if (!validModes.includes(this.mode)) {
             throw new Error(`Unsupported mode: ${this.mode}`);
         }
+        // Worker path
+        if (this.worker) {
+            console.log('open(): Using worker path, waiting for workerReady');
+            // Wait for worker to be ready first
+            await this.workerReady;
+            console.log('open(): Worker ready, calling nc_open with path:', this.filename);
+            const modeValue = this.mode === 'r' ? NC_CONSTANTS.NC_NOWRITE : NC_CONSTANTS.NC_WRITE;
+            this.ncid = await this.callWorker('open', { path: this.filename, modeValue });
+            console.log('open(): Received ncid from worker:', this.ncid);
+            this.groupId = this.ncid;
+            this._isOpen = true;
+            return;
+        }
         if (this.mode === 'w' || this.mode === 'w-') {
             // Create new file
             let createMode = NC_CONSTANTS.NC_CLOBBER;
@@ -186,305 +223,171 @@ export class NetCDF4 extends Group {
         return result.ncid;
     }
     async closeFile(ncid) {
-        const module = this.getModule();
-        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})`);
-        }
-    }
-    getGlobalAttributes() {
-        const attributes = {};
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const nattsResult = module.nc_inq_natts(this.ncid);
-        if (nattsResult.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get number of global attributes (error: ${nattsResult.result})`);
-        }
-        const nAtts = nattsResult.natts;
-        const attNames = [];
-        for (let i = 0; i < nAtts; i++) {
-            const name = this.getAttributeName(NC_CONSTANTS.NC_GLOBAL, i);
-            attNames.push(name);
-        }
-        if (attNames.length === 0)
-            return attributes;
-        for (const attname of attNames) {
-            if (!attname)
-                continue;
-            attributes[attname] = this.getAttributeValues(NC_CONSTANTS.NC_GLOBAL, attname);
-        }
-        return attributes;
-    }
-    getFullMetadata() {
-        const varIds = this.getVarIDs();
-        const metas = [];
-        for (const varid of varIds) {
-            const varMeta = this.getVariableInfo(varid);
-            const { attributes, ...varDeets } = varMeta;
-            metas.push({ ...varDeets, ...attributes });
-        }
-        return metas;
-    }
-    getAttributeValues(varid, attname) {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const attInfo = module.nc_inq_att(this.ncid, varid, attname);
-        if (attInfo.result !== NC_CONSTANTS.NC_NOERR) {
-            console.warn(`Failed to get attribute info for ${attname} (error: ${attInfo.result})`);
-            return;
+        if (this.worker) {
+            this.callWorker('close');
         }
-        const attType = attInfo.type;
-        if (!attType)
-            throw new Error("Failed to allocate memory for attribute type.");
-        let attValue;
-        if (attType === 2)
-            attValue = module.nc_get_att_text(this.ncid, varid, attname, attInfo.len);
-        else if (attType === 3)
-            attValue = module.nc_get_att_short(this.ncid, varid, attname, attInfo.len);
-        else if (attType === 4)
-            attValue = module.nc_get_att_int(this.ncid, varid, attname, attInfo.len);
-        else if (attType === 5)
-            attValue = module.nc_get_att_float(this.ncid, varid, attname, attInfo.len);
-        else if (attType === 6)
-            attValue = module.nc_get_att_double(this.ncid, varid, attname, attInfo.len);
-        else if (attType === 10)
-            attValue = module.nc_get_att_longlong(this.ncid, varid, attname, attInfo.len);
-        else
-            attValue = module.nc_get_att_double(this.ncid, varid, attname, attInfo.len);
-        return attValue.data;
-    }
-    getDimCount() {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const result = module.nc_inq_ndims(this.ncid);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get number of dimensions (error: ${result.result})`);
-        }
-        return result.ndims || 0;
-    }
-    getVariables() {
-        const variables = {};
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const varCount = this.getVarCount();
-        const dimIds = this.getDimIDs();
-        for (let varid = 0; varid < varCount; varid++) {
-            if (dimIds.includes(varid))
-                continue; //Don't include spatial Vars
-            const result = module.nc_inq_varname(this.ncid, varid);
-            if (result.result !== NC_CONSTANTS.NC_NOERR || !result.name) {
-                console.warn(`Failed to get variable name for varid ${varid} (error: ${result.result})`);
-                continue;
+        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})`);
             }
-            variables[result.name] = {
-                id: varid
+        }
+    }
+    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() {
+        if (this.worker) {
+            return this.callWorker('getGlobalAttributes');
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getGlobalAttributes(this.module, this.ncid);
         }
-        return variables;
     }
-    getVarIDs() {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const result = module.nc_inq_varids(this.ncid);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get variable IDs (error: ${result.result})`);
+    async getFullMetadata() {
+        if (this.worker) {
+            return this.callWorker('getFullMetadata');
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getFullMetadata(this.module, this.ncid);
         }
-        return result.varids || [0];
     }
-    getDimIDs() {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const result = module.nc_inq_dimids(this.ncid, 0);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get dimension IDs (error: ${result.result})`);
+    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);
         }
-        return result.dimids || [0];
     }
-    getDim(dimid) {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const result = module.nc_inq_dim(this.ncid, dimid);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get dim (error: ${result.result})`);
-        }
-        const varResult = module.nc_inq_varid(this.ncid, result.name);
-        const varID = varResult.varid;
-        const { result: output, ...dim } = result;
-        const unitResult = this.getAttributeValues(varID, "units");
-        return { ...dim, units: unitResult, id: varID };
-    }
-    getDims() {
-        const dimIDs = this.getDimIDs();
-        const dims = {};
-        for (const dimid of dimIDs) {
-            const dim = this.getDim(dimid);
-            dims[dim.name] = {
-                size: dim.len,
-                units: dim.units,
-                id: dim.id
-            };
+    async getDimCount() {
+        if (this.worker) {
+            return this.callWorker('getDimCount');
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDimCount(this.module, this.ncid);
         }
-        return dims;
     }
-    getVarCount() {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const result = module.nc_inq_nvars(this.ncid);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get number of variables (error: ${result.result})`);
+    async getVariables() {
+        if (this.worker) {
+            return this.callWorker('getVariables');
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVariables(this.module, this.ncid);
         }
-        return result.nvars || 0;
     }
-    getAttributeName(varid, attId) {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const result = module.nc_inq_attname(this.ncid, varid, attId);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get attribute (error: ${result.result})`);
-        }
-        return result.name;
-    }
-    getVariableInfo(variable) {
-        const info = {};
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const isId = typeof variable === "number";
-        let varid = variable;
-        if (!isId) {
-            const result = module.nc_inq_varid(this.ncid, variable);
-            varid = result.varid;
-        }
-        const result = module.nc_inq_var(this.ncid, varid);
-        if (result.result !== NC_CONSTANTS.NC_NOERR) {
-            throw new Error(`Failed to get variable info (error: ${result.result})`);
-        }
-        const typeMultiplier = DATA_TYPE_SIZE[result.type];
-        //Dim Info
-        const dimids = result.dimids;
-        const dims = [];
-        const shape = [];
-        let size = 1;
-        if (dimids) {
-            for (const dimid of dimids) {
-                const dim = this.getDim(dimid);
-                size *= dim.len;
-                dims.push(dim);
-                shape.push(dim.len);
-            }
+    async getVarIDs() {
+        if (this.worker) {
+            return this.callWorker('getVarIDs');
         }
-        //Attribute Info
-        const attNames = [];
-        if (result.natts) {
-            for (let i = 0; i < result.natts; i++) {
-                const attname = this.getAttributeName(varid, i);
-                attNames.push(attname);
-            }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVarIDs(this.module, this.ncid);
         }
-        const atts = {};
-        if (attNames.length > 0) {
-            for (const attname of attNames) {
-                if (!attname)
-                    continue;
-                atts[attname] = this.getAttributeValues(varid, attname);
-            }
+    }
+    async getDimIDs() {
+        if (this.worker) {
+            return this.callWorker('getDimIDs');
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDimIDs(this.module, this.ncid);
+        }
+    }
+    async getDim(dimid) {
+        if (this.worker) {
+            return this.callWorker('getDim', { dimid });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDim(this.module, this.ncid, dimid);
+        }
+    }
+    async getDims() {
+        if (this.worker) {
+            return this.callWorker('getDims');
         }
-        //Chunking Info
-        let chunks;
-        const chunkResult = module.nc_inq_var_chunking(this.ncid, varid);
-        const isChunked = chunkResult.chunking === NC_CONSTANTS.NC_CHUNKED;
-        if (isChunked) {
-            chunks = chunkResult.chunkSizes;
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getDims(this.module, this.ncid);
+        }
+    }
+    async getVarCount() {
+        if (this.worker) {
+            return this.callWorker('getVarCount');
         }
         else {
-            chunks = shape;
-        }
-        const chunkElements = chunks.reduce((a, b) => a * b, 1);
-        //Output 
-        info["name"] = result.name;
-        info["dtype"] = CONSTANT_DTYPE_MAP[result.type];
-        info['nctype'] = result.type;
-        info["shape"] = shape;
-        info['dims'] = dims;
-        info["size"] = size;
-        info["totalSize"] = size * typeMultiplier;
-        info["attributes"] = atts;
-        info["chunked"] = isChunked;
-        info["chunks"] = chunks;
-        info["chunkSize"] = chunkElements * typeMultiplier;
-        return info;
-    }
-    getVariableArray(variable) {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const isId = typeof variable === "number";
-        let varid = isId ? variable : 0;
-        if (!isId) {
-            const result = module.nc_inq_varid(this.ncid, variable);
-            varid = result.varid;
-        }
-        const info = this.getVariableInfo(varid);
-        const arraySize = info.size;
-        const arrayType = info.nctype;
-        if (!arrayType || !arraySize)
-            throw new Error("Failed to allocate memory for array");
-        let arrayData;
-        if (arrayType === 2)
-            arrayData = module.nc_get_var_text(this.ncid, varid, arraySize);
-        else if (arrayType === 3)
-            arrayData = module.nc_get_var_short(this.ncid, varid, arraySize);
-        else if (arrayType === 4)
-            arrayData = module.nc_get_var_int(this.ncid, varid, arraySize);
-        else if (arrayType === 10)
-            arrayData = module.nc_get_var_longlong(this.ncid, varid, arraySize);
-        else if (arrayType === 5)
-            arrayData = module.nc_get_var_float(this.ncid, varid, arraySize);
-        else if (arrayType === 6)
-            arrayData = module.nc_get_var_double(this.ncid, varid, arraySize);
-        else
-            arrayData = module.nc_get_var_double(this.ncid, varid, arraySize);
-        if (!arrayData.data)
-            throw new Error("Failed to read array data");
-        return arrayData.data;
-    }
-    getSlicedVariableArray(variable, start, count) {
-        const module = this.module;
-        if (!module)
-            throw new Error("Failed to load module. Ensure module is initialized before calling methods");
-        const isId = typeof variable === "number";
-        let varid = isId ? variable : 0;
-        if (!isId) {
-            const result = module.nc_inq_varid(this.ncid, variable);
-            varid = result.varid;
-        }
-        const info = this.getVariableInfo(varid);
-        const arrayType = info.nctype;
-        if (!arrayType)
-            throw new Error("Failed to allocate memory for array");
-        let arrayData;
-        if (arrayType === 3)
-            arrayData = module.nc_get_vara_short(this.ncid, varid, start, count);
-        else if (arrayType === 4)
-            arrayData = module.nc_get_vara_int(this.ncid, varid, start, count);
-        else if (arrayType === 5)
-            arrayData = module.nc_get_vara_float(this.ncid, varid, start, count);
-        else if (arrayType === 6)
-            arrayData = module.nc_get_vara_double(this.ncid, varid, start, count);
-        else
-            arrayData = module.nc_get_vara_double(this.ncid, varid, start, count);
-        if (!arrayData.data)
-            throw new Error("Failed to read array data");
-        return arrayData.data;
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVarCount(this.module, this.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) {
+        if (this.worker) {
+            return this.callWorker('getVariableInfo', { variable });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVariableInfo(this.module, this.ncid, variable);
+        }
+    }
+    async getVariableArray(variable) {
+        if (this.worker) {
+            return this.callWorker('getVariableArray', { variable });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getVariableArray(this.module, this.ncid, variable);
+        }
+    }
+    async getSlicedVariableArray(variable, start, count) {
+        if (this.worker) {
+            return this.callWorker('getSlicedVariableArray', { variable, start, count });
+        }
+        else {
+            // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
+            return NCGet.getSlicedVariableArray(this.module, this.ncid, variable, start, count);
+        }
     }
     async defineDimension(ncid, name, size) {
         const module = this.getModule();
@@ -639,6 +542,36 @@ export class NetCDF4 extends Group {
             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) {