@loaders.gl/netcdf 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/iobuffer/iobuffer.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOBuffer = void 0;
+const DEFAULT_BYTE_LENGTH = 1024 * 8;
+class IOBuffer {
+    /**
+     * @param data - The data to construct the IOBuffer with.
+     * If data is a number, it will be the new buffer's length<br>
+     * If data is `undefined`, the buffer will be initialized with a default length of 8Kb<br>
+     * If data is an ArrayBuffer, SharedArrayBuffer, an ArrayBufferView (Typed Array), an IOBuffer instance,
+     * or a Node.js Buffer, a view will be created over the underlying ArrayBuffer.
+     * @param options
+     */
+    constructor(data = DEFAULT_BYTE_LENGTH, options = {}) {
+        this.textDecoder = new TextDecoder();
+        this.textEncoder = new TextEncoder();
+        let dataIsGiven = false;
+        if (typeof data === 'number') {
+            data = new ArrayBuffer(data);
+        }
+        else {
+            dataIsGiven = true;
+            this.lastWrittenByte = data.byteLength;
+        }
+        const offset = options.offset ? options.offset >>> 0 : 0;
+        const byteLength = data.byteLength - offset;
+        let dvOffset = offset;
+        if (ArrayBuffer.isView(data) || data instanceof IOBuffer) {
+            if (data.byteLength !== data.buffer.byteLength) {
+                dvOffset = data.byteOffset + offset;
+            }
+            data = data.buffer;
+        }
+        if (dataIsGiven) {
+            this.lastWrittenByte = byteLength;
+        }
+        else {
+            this.lastWrittenByte = 0;
+        }
+        this.buffer = data;
+        this.length = byteLength;
+        this.byteLength = byteLength;
+        this.byteOffset = dvOffset;
+        this.offset = 0;
+        this.littleEndian = true;
+        this._data = new DataView(this.buffer, dvOffset, byteLength);
+        this._mark = 0;
+        this._marks = [];
+    }
+    /**
+     * Checks if the memory allocated to the buffer is sufficient to store more
+     * bytes after the offset.
+     * @param byteLength - The needed memory in bytes.
+     * @returns `true` if there is sufficient space and `false` otherwise.
+     */
+    available(byteLength = 1) {
+        return this.offset + byteLength <= this.length;
+    }
+    /**
+     * Check if little-endian mode is used for reading and writing multi-byte
+     * values.
+     * @returns `true` if little-endian mode is used, `false` otherwise.
+     */
+    isLittleEndian() {
+        return this.littleEndian;
+    }
+    /**
+     * Set little-endian mode for reading and writing multi-byte values.
+     */
+    setLittleEndian() {
+        this.littleEndian = true;
+        return this;
+    }
+    /**
+     * Check if big-endian mode is used for reading and writing multi-byte values.
+     * @returns `true` if big-endian mode is used, `false` otherwise.
+     */
+    isBigEndian() {
+        return !this.littleEndian;
+    }
+    /**
+     * Switches to big-endian mode for reading and writing multi-byte values.
+     */
+    setBigEndian() {
+        this.littleEndian = false;
+        return this;
+    }
+    /**
+     * Move the pointer n bytes forward.
+     * @param n - Number of bytes to skip.
+     */
+    skip(n = 1) {
+        this.offset += n;
+        return this;
+    }
+    /**
+     * Move the pointer to the given offset.
+     * @param offset
+     */
+    seek(offset) {
+        this.offset = offset;
+        return this;
+    }
+    /**
+     * Store the current pointer offset.
+     * @see {@link IOBuffer#reset}
+     */
+    mark() {
+        this._mark = this.offset;
+        return this;
+    }
+    /**
+     * Move the pointer back to the last pointer offset set by mark.
+     * @see {@link IOBuffer#mark}
+     */
+    reset() {
+        this.offset = this._mark;
+        return this;
+    }
+    /**
+     * Push the current pointer offset to the mark stack.
+     * @see {@link IOBuffer#popMark}
+     */
+    pushMark() {
+        this._marks.push(this.offset);
+        return this;
+    }
+    /**
+     * Pop the last pointer offset from the mark stack, and set the current
+     * pointer offset to the popped value.
+     * @see {@link IOBuffer#pushMark}
+     */
+    popMark() {
+        const offset = this._marks.pop();
+        if (offset === undefined) {
+            throw new Error('Mark stack empty');
+        }
+        this.seek(offset);
+        return this;
+    }
+    /**
+     * Move the pointer offset back to 0.
+     */
+    rewind() {
+        this.offset = 0;
+        return this;
+    }
+    /**
+     * Make sure the buffer has sufficient memory to write a given byteLength at
+     * the current pointer offset.
+     * If the buffer's memory is insufficient, this method will create a new
+     * buffer (a copy) with a length that is twice (byteLength + current offset).
+     * @param byteLength
+     */
+    ensureAvailable(byteLength = 1) {
+        if (!this.available(byteLength)) {
+            const lengthNeeded = this.offset + byteLength;
+            const newLength = lengthNeeded * 2;
+            const newArray = new Uint8Array(newLength);
+            newArray.set(new Uint8Array(this.buffer));
+            this.buffer = newArray.buffer;
+            this.length = this.byteLength = newLength;
+            this._data = new DataView(this.buffer);
+        }
+        return this;
+    }
+    /**
+     * Read a byte and return false if the byte's value is 0, or true otherwise.
+     * Moves pointer forward by one byte.
+     */
+    readBoolean() {
+        return this.readUint8() !== 0;
+    }
+    /**
+     * Read a signed 8-bit integer and move pointer forward by 1 byte.
+     */
+    readInt8() {
+        return this._data.getInt8(this.offset++);
+    }
+    /**
+     * Read an unsigned 8-bit integer and move pointer forward by 1 byte.
+     */
+    readUint8() {
+        return this._data.getUint8(this.offset++);
+    }
+    /**
+     * Alias for {@link IOBuffer#readUint8}.
+     */
+    readByte() {
+        return this.readUint8();
+    }
+    /**
+     * Read `n` bytes and move pointer forward by `n` bytes.
+     */
+    readBytes(n = 1) {
+        const bytes = new Uint8Array(n);
+        for (let i = 0; i < n; i++) {
+            bytes[i] = this.readByte();
+        }
+        return bytes;
+    }
+    /**
+     * Read a 16-bit signed integer and move pointer forward by 2 bytes.
+     */
+    readInt16() {
+        const value = this._data.getInt16(this.offset, this.littleEndian);
+        this.offset += 2;
+        return value;
+    }
+    /**
+     * Read a 16-bit unsigned integer and move pointer forward by 2 bytes.
+     */
+    readUint16() {
+        const value = this._data.getUint16(this.offset, this.littleEndian);
+        this.offset += 2;
+        return value;
+    }
+    /**
+     * Read a 32-bit signed integer and move pointer forward by 4 bytes.
+     */
+    readInt32() {
+        const value = this._data.getInt32(this.offset, this.littleEndian);
+        this.offset += 4;
+        return value;
+    }
+    /**
+     * Read a 32-bit unsigned integer and move pointer forward by 4 bytes.
+     */
+    readUint32() {
+        const value = this._data.getUint32(this.offset, this.littleEndian);
+        this.offset += 4;
+        return value;
+    }
+    /**
+     * Read a 32-bit floating number and move pointer forward by 4 bytes.
+     */
+    readFloat32() {
+        const value = this._data.getFloat32(this.offset, this.littleEndian);
+        this.offset += 4;
+        return value;
+    }
+    /**
+     * Read a 64-bit floating number and move pointer forward by 8 bytes.
+     */
+    readFloat64() {
+        const value = this._data.getFloat64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    /**
+     * Read a 1-byte ASCII character and move pointer forward by 1 byte.
+     */
+    readChar() {
+        return String.fromCharCode(this.readInt8());
+    }
+    /**
+     * Read `n` 1-byte ASCII characters and move pointer forward by `n` bytes.
+     */
+    readChars(n = 1) {
+        let result = '';
+        for (let i = 0; i < n; i++) {
+            result += this.readChar();
+        }
+        return result;
+    }
+    /**
+     * Read the next `n` bytes, return a UTF-8 decoded string and move pointer
+     * forward by `n` bytes.
+     */
+    readUtf8(n = 1) {
+        return this.textDecoder.decode(this.readBytes(n));
+    }
+    /**
+     * Write 0xff if the passed value is truthy, 0x00 otherwise and move pointer
+     * forward by 1 byte.
+     */
+    writeBoolean(value) {
+        this.writeUint8(value ? 0xff : 0x00);
+        return this;
+    }
+    /**
+     * Write `value` as an 8-bit signed integer and move pointer forward by 1 byte.
+     */
+    writeInt8(value) {
+        this.ensureAvailable(1);
+        this._data.setInt8(this.offset++, value);
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as an 8-bit unsigned integer and move pointer forward by 1
+     * byte.
+     */
+    writeUint8(value) {
+        this.ensureAvailable(1);
+        this._data.setUint8(this.offset++, value);
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * An alias for {@link IOBuffer#writeUint8}.
+     */
+    writeByte(value) {
+        return this.writeUint8(value);
+    }
+    /**
+     * Write all elements of `bytes` as uint8 values and move pointer forward by
+     * `bytes.length` bytes.
+     */
+    writeBytes(bytes) {
+        this.ensureAvailable(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+            this._data.setUint8(this.offset++, bytes[i]);
+        }
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as a 16-bit signed integer and move pointer forward by 2
+     * bytes.
+     */
+    writeInt16(value) {
+        this.ensureAvailable(2);
+        this._data.setInt16(this.offset, value, this.littleEndian);
+        this.offset += 2;
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as a 16-bit unsigned integer and move pointer forward by 2
+     * bytes.
+     */
+    writeUint16(value) {
+        this.ensureAvailable(2);
+        this._data.setUint16(this.offset, value, this.littleEndian);
+        this.offset += 2;
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as a 32-bit signed integer and move pointer forward by 4
+     * bytes.
+     */
+    writeInt32(value) {
+        this.ensureAvailable(4);
+        this._data.setInt32(this.offset, value, this.littleEndian);
+        this.offset += 4;
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as a 32-bit unsigned integer and move pointer forward by 4
+     * bytes.
+     */
+    writeUint32(value) {
+        this.ensureAvailable(4);
+        this._data.setUint32(this.offset, value, this.littleEndian);
+        this.offset += 4;
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as a 32-bit floating number and move pointer forward by 4
+     * bytes.
+     */
+    writeFloat32(value) {
+        this.ensureAvailable(4);
+        this._data.setFloat32(this.offset, value, this.littleEndian);
+        this.offset += 4;
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write `value` as a 64-bit floating number and move pointer forward by 8
+     * bytes.
+     */
+    writeFloat64(value) {
+        this.ensureAvailable(8);
+        this._data.setFloat64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+        this._updateLastWrittenByte();
+        return this;
+    }
+    /**
+     * Write the charCode of `str`'s first character as an 8-bit unsigned integer
+     * and move pointer forward by 1 byte.
+     */
+    writeChar(str) {
+        return this.writeUint8(str.charCodeAt(0));
+    }
+    /**
+     * Write the charCodes of all `str`'s characters as 8-bit unsigned integers
+     * and move pointer forward by `str.length` bytes.
+     */
+    writeChars(str) {
+        for (let i = 0; i < str.length; i++) {
+            this.writeUint8(str.charCodeAt(i));
+        }
+        return this;
+    }
+    /**
+     * UTF-8 encode and write `str` to the current pointer offset and move pointer
+     * forward according to the encoded length.
+     */
+    writeUtf8(str) {
+        const bytes = this.textEncoder.encode(str);
+        return this.writeBytes(bytes);
+    }
+    /**
+     * Export a Uint8Array view of the internal buffer.
+     * The view starts at the byte offset and its length
+     * is calculated to stop at the last written byte or the original length.
+     */
+    toArray() {
+        return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
+    }
+    /**
+     * Update the last written byte offset
+     * @private
+     */
+    _updateLastWrittenByte() {
+        if (this.offset > this.lastWrittenByte) {
+            this.lastWrittenByte = this.offset;
+        }
+    }
+}
+exports.IOBuffer = IOBuffer;

package/dist/netcdf-loader.d.ts

@@ -0,0 +1,52 @@
+import type { Loader, LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { NetCDFHeader } from './netcdfjs/netcdf-types';
+export declare type NetCDF = {
+    loaderData: NetCDFHeader;
+    data: {
+        [variableName: string]: any[][];
+    };
+};
+export declare type NetCDFLoaderOptions = LoaderOptions & {
+    netcdf?: {
+        loadData?: boolean;
+    };
+};
+/**
+ * Worker loader for NETCDF
+ */
+export declare const NetCDFWorkerLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    options: {
+        netcdf: {
+            loadVariables: boolean;
+        };
+    };
+};
+/**
+ * Loader for the NetCDF format
+ */
+export declare const NetCDFLoader: {
+    parse: (arrayBuffer: any, options: any) => Promise<NetCDF>;
+    binary: boolean;
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    options: {
+        netcdf: {
+            loadVariables: boolean;
+        };
+    };
+};
+export declare const _typecheckNetCDFWorkerLoader: Loader;
+export declare const _typecheckNetCDFLoader: LoaderWithParser;
+//# sourceMappingURL=netcdf-loader.d.ts.map

package/dist/netcdf-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"netcdf-loader.d.ts","sourceRoot":"","sources":["../src/netcdf-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;AAO1D,oBAAY,MAAM,GAAG;IACnB,UAAU,EAAE,YAAY,CAAC;IACzB,IAAI,EAAE;QAAC,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,CAAA;KAAC,CAAC;CACzC,CAAC;AAEF,oBAAY,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;CAiB9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CAIxB,CAAC;AAiBF,eAAO,MAAM,4BAA4B,EAAE,MAA2B,CAAC;AACvE,eAAO,MAAM,sBAAsB,EAAE,gBAA+B,CAAC"}

package/dist/netcdf-loader.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckNetCDFLoader = exports._typecheckNetCDFWorkerLoader = exports.NetCDFLoader = exports.NetCDFWorkerLoader = void 0;
+const netcdf_reader_1 = require("./netcdfjs/netcdf-reader");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Worker loader for NETCDF
+ */
+exports.NetCDFWorkerLoader = {
+    name: 'NetCDF',
+    id: 'mvt',
+    module: 'mvt',
+    version: VERSION,
+    extensions: ['cdf', 'nc'],
+    mimeTypes: [
+        'application/netcdf',
+        'application/x-netcdf'
+        // 'application/octet-stream'
+    ],
+    category: 'image',
+    options: {
+        netcdf: {
+            loadVariables: false
+        }
+    }
+};
+/**
+ * Loader for the NetCDF format
+ */
+exports.NetCDFLoader = {
+    ...exports.NetCDFWorkerLoader,
+    parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),
+    binary: true
+};
+function parseNetCDF(arrayBuffer, options) {
+    const reader = new netcdf_reader_1.NetCDFReader(arrayBuffer);
+    const variables = {};
+    if (options?.netcdf?.loadData) {
+        for (const variable of reader.variables) {
+            variables[variable.name] = reader.getDataVariable(variable);
+        }
+    }
+    return {
+        loaderData: reader.header,
+        data: variables
+    };
+}
+// Type tests
+exports._typecheckNetCDFWorkerLoader = exports.NetCDFWorkerLoader;
+exports._typecheckNetCDFLoader = exports.NetCDFLoader;

package/dist/netcdfjs/netcdf-reader.d.ts

@@ -0,0 +1,68 @@
+import { IOBuffer } from '../iobuffer/iobuffer';
+import type { NetCDFHeader, NetCDFDimension, NetCDFRecordDimension, NetCDFAttribute, NetCDFVariable } from './netcdf-types';
+/**
+ * Reads a NetCDF v3.x file
+ * https://www.unidata.ucar.edu/software/netcdf/docs/file_format_specifications.html
+ * @param {ArrayBuffer} data - ArrayBuffer or any Typed Array (including Node.js' Buffer from v4) with the data
+ * @constructor
+ */
+export declare class NetCDFReader {
+    header: NetCDFHeader;
+    buffer: IOBuffer;
+    constructor(data: any);
+    /**
+     * @return {string} - Version for the NetCDF format
+     */
+    get version(): "classic format" | "64-bit offset format";
+    /**
+     * Get metadata for the record dimension
+     */
+    get recordDimension(): NetCDFRecordDimension;
+    /**
+     * Get list of dimensions (each with `name` and `size`)
+     */
+    get dimensions(): NetCDFDimension[];
+    /**
+     * Get list of global attributes with:
+     *  * `name`: String with the name of the attribute
+     *  * `type`: String with the type of the attribute
+     *  * `value`: A number or string with the value of the attribute
+     */
+    get attributes(): NetCDFAttribute[];
+    /**
+     * Get list of variables
+     */
+    get variables(): NetCDFVariable[];
+    /**
+     * Check if an attribute exists
+     * @param attributeName - Name of the attribute to find
+     * @return
+     */
+    attributeExists(attributeName: string): boolean;
+    /**
+     * Returns the value of an attribute
+     * @param attributeName
+     * @return Value of the attributeName or null
+     */
+    getAttribute(attributeName: string): string | null;
+    /**
+     * Check if a dataVariable exists
+     * @param variableName - Name of the variable to find
+     * @return
+     */
+    dataVariableExists(variableName: string): boolean;
+    /**
+     * Returns the value of a variable as a string
+     * @param variableName
+     * @return Value of the variable as a string or null
+     */
+    getDataVariableAsString(variableName: string): string | null;
+    /**
+     * Retrieves the data for a given variable
+     * @param variableName - Name of the variable to search or variable object
+     * @return List with the variable values
+     */
+    getDataVariable(variableName: string | object): any[];
+    toString(): string;
+}
+//# sourceMappingURL=netcdf-reader.d.ts.map

package/dist/netcdfjs/netcdf-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"netcdf-reader.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/netcdf-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAC9C,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,eAAe,EACf,cAAc,EACf,MAAM,gBAAgB,CAAC;AAIxB;;;;;GAKG;AACH,qBAAa,YAAY;IAChB,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,QAAQ,CAAC;gBAEZ,IAAI,KAAA;IAqBhB;;OAEG;IACH,IAAI,OAAO,8CAKV;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,qBAAqB,CAE3C;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,eAAe,EAAE,CAElC;IAED;;;;;OAKG;IACH,IAAI,UAAU,IAAI,eAAe,EAAE,CAElC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,cAAc,EAAE,CAEhC;IAED;;;;OAIG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;IAK/C;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMlD;;;;OAIG;IACH,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAOjD;;;;OAIG;IACH,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAM5D;;;;OAIG;IACH,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,EAAE;IA2BrD,QAAQ,IAAI,MAAM;CA4BnB"}