netcdf4-wasm/dist/variable.js

NetCDF4 library compiled to WebAssembly with TypeScript bindings

"use strict";
// Variable class similar to netcdf4-python
Object.defineProperty(exports, "__esModule", { value: true });
exports.Variable = void 0;
class Variable {
    constructor(netcdf, name, datatype, dimensions, varid, ncid) {
        this.netcdf = netcdf;
        this.name = name;
        this.datatype = datatype;
        this.dimensions = dimensions;
        this.varid = varid;
        this.ncid = ncid;
        this._attributes = {};
    }
    // Attribute access (Python-like)
    setAttr(name, value) {
        this._attributes[name] = value;
        // Store in mock file system if in test mode
        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
            const mockFiles = global.__netcdf4_mock_files;
            const dataset = this.netcdf;
            if (mockFiles && dataset.filename && mockFiles[dataset.filename] && mockFiles[dataset.filename].variables[this.name]) {
                mockFiles[dataset.filename].variables[this.name].attributes[name] = value;
            }
        }
        // TODO: Implement actual NetCDF attribute setting
    }
    getAttr(name) {
        return this._attributes[name];
    }
    attrs() {
        return Object.keys(this._attributes);
    }
    // Data access methods
    async getValue() {
        // Check if we're in test mode and have stored data
        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
            const mockFiles = global.__netcdf4_mock_files;
            const dataset = this.netcdf;
            if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
                const variables = mockFiles[dataset.filename].variables;
                if (variables[this.name] && variables[this.name].data) {
                    const storedData = variables[this.name].data;
                    if (this.datatype === 'f4' || this.datatype === 'float') {
                        return new Float32Array(storedData);
                    }
                    return storedData;
                }
            }
        }
        const totalSize = this.dimensions.reduce((acc, dimName) => {
            const dim = this.netcdf.dimensions[dimName];
            if (!dim)
                return acc * 1;
            // Handle unlimited dimensions - use actual current size if available
            let actualSize = dim.size;
            if (dim.isUnlimited) {
                // In test mode, try to get the actual size from stored data
                if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
                    const mockFiles = global.__netcdf4_mock_files;
                    const dataset = this.netcdf;
                    if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
                        const variables = mockFiles[dataset.filename].variables;
                        if (variables[this.name] && variables[this.name].data) {
                            // Calculate size based on the current variable's shape
                            const storedData = variables[this.name].data;
                            actualSize = Math.max(1, Math.floor(storedData.length / acc));
                        }
                        else {
                            actualSize = 1; // Default for unlimited dimension
                        }
                    }
                }
                else {
                    actualSize = 1; // Default for unlimited dimension in real mode
                }
            }
            return acc * Math.max(actualSize, 1);
        }, 1);
        if (this.datatype === 'f8' || this.datatype === 'double') {
            return await this.netcdf.getVariableDouble(this.ncid, this.varid, totalSize);
        }
        else if (this.datatype === 'f4' || this.datatype === 'float') {
            // Convert from double to float32 for now (until we add proper float32 support)
            const doubleData = await this.netcdf.getVariableDouble(this.ncid, this.varid, totalSize);
            return new Float32Array(doubleData);
        }
        throw new Error(`Data type ${this.datatype} not yet supported`);
    }
    async setValue(data) {
        // Store data in mock file system if in test mode
        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
            const mockFiles = global.__netcdf4_mock_files;
            const dataset = this.netcdf;
            if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
                const variables = mockFiles[dataset.filename].variables;
                if (variables[this.name]) {
                    variables[this.name].data = data instanceof Float64Array ? data : new Float64Array(data);
                }
            }
        }
        if (this.datatype === 'f8' || this.datatype === 'double') {
            const doubleData = data instanceof Float64Array ? data : new Float64Array(data);
            return await this.netcdf.putVariableDouble(this.ncid, this.varid, doubleData);
        }
        else if (this.datatype === 'f4' || this.datatype === 'float') {
            // Convert to double for storage (until we add proper float32 support)
            const doubleData = data instanceof Float64Array ? data : new Float64Array(data);
            return await this.netcdf.putVariableDouble(this.ncid, this.varid, doubleData);
        }
        throw new Error(`Data type ${this.datatype} not yet supported`);
    }
    // Array-like access methods
    async __getitem__(index) {
        // TODO: Implement slicing support similar to Python
        if (typeof index === 'number') {
            const data = await this.getValue();
            return data[index];
        }
        throw new Error('Advanced indexing not yet implemented');
    }
    async __setitem__(index, value) {
        // TODO: Implement slicing support similar to Python
        throw new Error('Item assignment not yet implemented');
    }
    // Property-style attribute access
    get units() { return this._attributes.units; }
    set units(value) { this.setAttr('units', value); }
    get long_name() { return this._attributes.long_name; }
    set long_name(value) { this.setAttr('long_name', value); }
    get standard_name() { return this._attributes.standard_name; }
    set standard_name(value) { this.setAttr('standard_name', value); }
    get scale_factor() { return this._attributes.scale_factor; }
    set scale_factor(value) { this.setAttr('scale_factor', value); }
    get add_offset() { return this._attributes.add_offset; }
    set add_offset(value) { this.setAttr('add_offset', value); }
    get _FillValue() { return this._attributes._FillValue; }
    set _FillValue(value) { this.setAttr('_FillValue', value); }
    // Additional CF convention attributes
    get calendar() { return this._attributes.calendar; }
    set calendar(value) { this.setAttr('calendar', value); }
    get axis() { return this._attributes.axis; }
    set axis(value) { this.setAttr('axis', value); }
    toString() {
        const dimStr = this.dimensions.length > 0 ? `(${this.dimensions.join(', ')})` : '()';
        return `<netCDF4.Variable '${this.name}': dimensions ${dimStr}, size = [${this.dimensions.map(d => this.netcdf.dimensions[d]?.size || '?').join(' x ')}], type = '${this.datatype}'>`;
    }
}
exports.Variable = Variable;
//# sourceMappingURL=variable.js.map