@loaders.gl/netcdf 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/netcdfjs/read-header.js

@@ -1,197 +1,230 @@
-import { readType, num2str } from './read-type';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readName = exports.readNetCDFHeader = void 0;
+const read_type_1 = require("./read-type");
+// Grammar constants
 const ZERO = 0;
 const NC_DIMENSION = 10;
 const NC_VARIABLE = 11;
 const NC_ATTRIBUTE = 12;
 const NC_UNLIMITED = 0;
-export function readNetCDFHeader(buffer, version) {
-  const recordDimensionLength = buffer.readUint32();
-  const dimList = readDimensionsList(buffer);
-  const attributes = readAttributesList(buffer);
-  const variableList = readVariablesList(buffer, dimList.recordId, version);
-  const header = {
-    version,
-    recordDimension: {
-      length: recordDimensionLength,
-      id: dimList.recordId,
-      name: dimList.recordName,
-      recordStep: variableList.recordStep
-    },
-    dimensions: dimList.dimensions,
-    variables: variableList.variables,
-    attributes
-  };
-  return header;
+/**
+ * Read the header of the file
+ * @param buffer - Buffer for the file data
+ * @param version - Version of the file
+ * @return  - Header
+ */
+function readNetCDFHeader(buffer, version) {
+    // Length of record dimension
+    // sum of the varSize's of all the record variables.
+    const recordDimensionLength = buffer.readUint32();
+    // List of dimensions
+    const dimList = readDimensionsList(buffer);
+    // List of global attributes
+    const attributes = readAttributesList(buffer);
+    // List of variables
+    const variableList = readVariablesList(buffer, dimList.recordId, version);
+    const header = {
+        version,
+        recordDimension: {
+            length: recordDimensionLength,
+            id: dimList.recordId,
+            name: dimList.recordName,
+            recordStep: variableList.recordStep
+        },
+        dimensions: dimList.dimensions,
+        variables: variableList.variables,
+        attributes
+    };
+    return header;
 }
-
+exports.readNetCDFHeader = readNetCDFHeader;
+/**
+ * Read list of dimensions
+ * @ignore
+ * @param {IOBuffer} buffer - Buffer for the file data
+ */
 function readDimensionsList(buffer) {
-  const dimList = buffer.readUint32();
-
-  if (dimList === ZERO) {
-    if (buffer.readUint32() !== ZERO) {
-      throw new Error('NetCDF: wrong empty tag for list of dimensions');
+    const dimList = buffer.readUint32();
+    if (dimList === ZERO) {
+        if (buffer.readUint32() !== ZERO) {
+            throw new Error('NetCDF: wrong empty tag for list of dimensions');
+        }
+        // TODO - is this empty dimension list supported / recoverable?
+        return {
+            recordId: 0,
+            recordName: '',
+            dimensions: []
+        };
     }
-
-    return {
-      recordId: 0,
-      recordName: '',
-      dimensions: []
-    };
-  }
-
-  if (dimList !== NC_DIMENSION) {
-    throw new Error('NetCDF: wrong tag for list of dimensions');
-  }
-
-  const dimensionSize = buffer.readUint32();
-  const dimensions = new Array(dimensionSize);
-  let recordId;
-  let recordName;
-
-  for (let dim = 0; dim < dimensionSize; dim++) {
-    const name = readName(buffer);
-    const size = buffer.readUint32();
-
-    if (size === NC_UNLIMITED) {
-      recordId = dim;
-      recordName = name;
+    if (dimList !== NC_DIMENSION) {
+        throw new Error('NetCDF: wrong tag for list of dimensions');
+    }
+    // Length of dimensions
+    const dimensionSize = buffer.readUint32();
+    const dimensions = new Array(dimensionSize);
+    let recordId;
+    let recordName;
+    for (let dim = 0; dim < dimensionSize; dim++) {
+        // Read name
+        const name = readName(buffer);
+        // Read dimension size
+        const size = buffer.readUint32();
+        if (size === NC_UNLIMITED) {
+            // in netcdf 3 one field can be of size unlimmited
+            recordId = dim;
+            recordName = name;
+        }
+        dimensions[dim] = {
+            name,
+            size
+        };
     }
-
-    dimensions[dim] = {
-      name,
-      size
+    return {
+        dimensions,
+        recordId,
+        recordName
     };
-  }
-
-  return {
-    dimensions,
-    recordId,
-    recordName
-  };
 }
-
+/**
+ * List of attributes
+ * @ignore
+ * @param buffer - Buffer for the file data
+ * @return List of attributes with:
+ */
 function readAttributesList(buffer) {
-  const gAttList = buffer.readUint32();
-
-  if (gAttList === ZERO) {
-    if (buffer.readUint32() !== ZERO) {
-      throw new Error('NetCDF: wrong empty tag for list of attributes');
+    const gAttList = buffer.readUint32();
+    if (gAttList === ZERO) {
+        if (buffer.readUint32() !== ZERO) {
+            throw new Error('NetCDF: wrong empty tag for list of attributes');
+        }
+        return [];
     }
-
-    return [];
-  }
-
-  if (gAttList !== NC_ATTRIBUTE) {
-    throw new Error('NetCDF: wrong tag for list of attributes');
-  }
-
-  const attributeSize = buffer.readUint32();
-  const attributes = new Array(attributeSize);
-
-  for (let gAtt = 0; gAtt < attributeSize; gAtt++) {
-    const name = readName(buffer);
-    const type = buffer.readUint32();
-
-    if (type < 1 || type > 6) {
-      throw new Error("NetCDF: non valid type ".concat(type));
+    if (gAttList !== NC_ATTRIBUTE) {
+        throw new Error('NetCDF: wrong tag for list of attributes');
     }
-
-    const size = buffer.readUint32();
-    const value = readType(buffer, type, size);
-    padding(buffer);
-    attributes[gAtt] = {
-      name,
-      type: num2str(type),
-      value
-    };
-  }
-
-  return attributes;
+    // Length of attributes
+    const attributeSize = buffer.readUint32();
+    const attributes = new Array(attributeSize);
+    for (let gAtt = 0; gAtt < attributeSize; gAtt++) {
+        // Read name
+        const name = readName(buffer);
+        // Read type
+        const type = buffer.readUint32();
+        if (type < 1 || type > 6) {
+            throw new Error(`NetCDF: non valid type ${type}`);
+        }
+        // Read attribute
+        const size = buffer.readUint32();
+        const value = (0, read_type_1.readType)(buffer, type, size);
+        // Apply padding
+        padding(buffer);
+        attributes[gAtt] = {
+            name,
+            type: (0, read_type_1.num2str)(type),
+            value
+        };
+    }
+    return attributes;
 }
-
+/**
+ * List of variables
+ * @param buffer - Buffer for the file data
+ * @param recordId - Id of the unlimited dimension (also called record dimension)
+ *                            This value may be undefined if there is no unlimited dimension
+ * @param {number} version - Version of the file
+ */
+// eslint-disable-next-line max-statements, complexity
 function readVariablesList(buffer, recordId, version) {
-  const varList = buffer.readUint32();
-  let recordStep = 0;
-
-  if (varList === ZERO) {
-    if (buffer.readUint32() !== ZERO) {
-      throw new Error('NetCDF: wrong empty tag for list of variables');
+    const varList = buffer.readUint32();
+    let recordStep = 0;
+    if (varList === ZERO) {
+        if (buffer.readUint32() !== ZERO) {
+            throw new Error('NetCDF: wrong empty tag for list of variables');
+        }
+        return {
+            recordStep,
+            variables: []
+        };
     }
-
-    return {
-      recordStep,
-      variables: []
-    };
-  }
-
-  if (varList !== NC_VARIABLE) {
-    throw new Error('NetCDF: wrong tag for list of variables');
-  }
-
-  const variableSize = buffer.readUint32();
-  const variables = new Array(variableSize);
-
-  for (let v = 0; v < variableSize; v++) {
-    const name = readName(buffer);
-    const dimensionality = buffer.readUint32();
-    const dimensionsIds = new Array(dimensionality);
-
-    for (let dim = 0; dim < dimensionality; dim++) {
-      dimensionsIds[dim] = buffer.readUint32();
-    }
-
-    const attributes = readAttributesList(buffer);
-    const type = buffer.readUint32();
-
-    if (type < 1 && type > 6) {
-      throw new Error("NetCDF: non valid type ".concat(type));
+    if (varList !== NC_VARIABLE) {
+        throw new Error('NetCDF: wrong tag for list of variables');
     }
-
-    const varSize = buffer.readUint32();
-    let offset = buffer.readUint32();
-
-    if (version === 2) {
-      if (offset > 0) {
-        throw new Error('NetCDF: offsets larger than 4GB not supported');
-      }
-
-      offset = buffer.readUint32();
+    // Length of variables
+    const variableSize = buffer.readUint32();
+    const variables = new Array(variableSize);
+    for (let v = 0; v < variableSize; v++) {
+        // Read name
+        const name = readName(buffer);
+        // Read dimensionality of the variable
+        const dimensionality = buffer.readUint32();
+        // Index into the list of dimensions
+        const dimensionsIds = new Array(dimensionality);
+        for (let dim = 0; dim < dimensionality; dim++) {
+            dimensionsIds[dim] = buffer.readUint32();
+        }
+        // Read variables size
+        const attributes = readAttributesList(buffer);
+        // Read type
+        const type = buffer.readUint32();
+        if (type < 1 && type > 6) {
+            throw new Error(`NetCDF: non valid type ${type}`);
+        }
+        // Read variable size
+        // The 32-bit varSize field is not large enough to contain the size of variables that require
+        // more than 2^32 - 4 bytes, so 2^32 - 1 is used in the varSize field for such variables.
+        const varSize = buffer.readUint32();
+        // Read offset
+        let offset = buffer.readUint32();
+        if (version === 2) {
+            if (offset > 0) {
+                throw new Error('NetCDF: offsets larger than 4GB not supported');
+            }
+            offset = buffer.readUint32();
+        }
+        let record = false;
+        // Count amount of record variables
+        if (typeof recordId !== 'undefined' && dimensionsIds[0] === recordId) {
+            recordStep += varSize;
+            record = true;
+        }
+        variables[v] = {
+            name,
+            dimensions: dimensionsIds,
+            attributes,
+            type: (0, read_type_1.num2str)(type),
+            size: varSize,
+            offset,
+            record
+        };
     }
-
-    let record = false;
-
-    if (typeof recordId !== 'undefined' && dimensionsIds[0] === recordId) {
-      recordStep += varSize;
-      record = true;
-    }
-
-    variables[v] = {
-      name,
-      dimensions: dimensionsIds,
-      attributes,
-      type: num2str(type),
-      size: varSize,
-      offset,
-      record
+    return {
+        variables,
+        recordStep
     };
-  }
-
-  return {
-    variables,
-    recordStep
-  };
 }
-
-export function readName(buffer) {
-  const nameLength = buffer.readUint32();
-  const name = buffer.readChars(nameLength);
-  padding(buffer);
-  return name;
+// HELPERS
+/**
+ * Reads the name
+ * @param buffer - Buffer for the file data
+ * @return Name
+ */
+function readName(buffer) {
+    // Read name
+    const nameLength = buffer.readUint32();
+    const name = buffer.readChars(nameLength);
+    // validate name
+    // TODO
+    // Apply padding
+    padding(buffer);
+    return name;
 }
-
+exports.readName = readName;
+/**
+ * Moves 1, 2, or 3 bytes to next 4-byte boundary
+ */
 function padding(buffer) {
-  if (buffer.offset % 4 !== 0) {
-    buffer.skip(4 - buffer.offset % 4);
-  }
+    if (buffer.offset % 4 !== 0) {
+        buffer.skip(4 - (buffer.offset % 4));
+    }
 }
-//# sourceMappingURL=read-header.js.map

package/dist/netcdfjs/read-type.js

@@ -1,127 +1,140 @@
-export const TYPES = {
-  BYTE: 1,
-  CHAR: 2,
-  SHORT: 3,
-  INT: 4,
-  FLOAT: 5,
-  DOUBLE: 6
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.str2num = exports.num2bytes = exports.num2str = exports.readType = exports.TYPES = void 0;
+exports.TYPES = {
+    BYTE: 1,
+    CHAR: 2,
+    SHORT: 3,
+    INT: 4,
+    FLOAT: 5,
+    DOUBLE: 6
 };
-export function readType(buffer, type, size) {
-  switch (type) {
-    case TYPES.BYTE:
-      return buffer.readBytes(size);
-
-    case TYPES.CHAR:
-      return trimNull(buffer.readChars(size));
-
-    case TYPES.SHORT:
-      return readNumber(size, buffer.readInt16.bind(buffer));
-
-    case TYPES.INT:
-      return readNumber(size, buffer.readInt32.bind(buffer));
-
-    case TYPES.FLOAT:
-      return readNumber(size, buffer.readFloat32.bind(buffer));
-
-    case TYPES.DOUBLE:
-      return readNumber(size, buffer.readFloat64.bind(buffer));
-
-    default:
-      throw new Error("NetCDF: non valid type ".concat(type));
-  }
+/**
+ * Given a type and a size reads the next element
+ * @param buffer - Buffer for the file data
+ * @param type - Type of the data to read
+ * @param size - Size of the element to read
+ * @return
+ */
+function readType(buffer, type, size) {
+    switch (type) {
+        case exports.TYPES.BYTE:
+            return buffer.readBytes(size);
+        case exports.TYPES.CHAR:
+            return trimNull(buffer.readChars(size));
+        case exports.TYPES.SHORT:
+            return readNumber(size, buffer.readInt16.bind(buffer));
+        case exports.TYPES.INT:
+            return readNumber(size, buffer.readInt32.bind(buffer));
+        case exports.TYPES.FLOAT:
+            return readNumber(size, buffer.readFloat32.bind(buffer));
+        case exports.TYPES.DOUBLE:
+            return readNumber(size, buffer.readFloat64.bind(buffer));
+        /* istanbul ignore next */
+        default:
+            throw new Error(`NetCDF: non valid type ${type}`);
+    }
 }
-export function num2str(type) {
-  switch (Number(type)) {
-    case TYPES.BYTE:
-      return 'byte';
-
-    case TYPES.CHAR:
-      return 'char';
-
-    case TYPES.SHORT:
-      return 'short';
-
-    case TYPES.INT:
-      return 'int';
-
-    case TYPES.FLOAT:
-      return 'float';
-
-    case TYPES.DOUBLE:
-      return 'double';
-
-    default:
-      return 'undefined';
-  }
+exports.readType = readType;
+/**
+ * Parse a number into their respective type
+ * @param type - integer that represents the type
+ * @return parsed value of the type
+ */
+function num2str(type) {
+    switch (Number(type)) {
+        case exports.TYPES.BYTE:
+            return 'byte';
+        case exports.TYPES.CHAR:
+            return 'char';
+        case exports.TYPES.SHORT:
+            return 'short';
+        case exports.TYPES.INT:
+            return 'int';
+        case exports.TYPES.FLOAT:
+            return 'float';
+        case exports.TYPES.DOUBLE:
+            return 'double';
+        /* istanbul ignore next */
+        default:
+            return 'undefined';
+    }
 }
-export function num2bytes(type) {
-  switch (Number(type)) {
-    case TYPES.BYTE:
-      return 1;
-
-    case TYPES.CHAR:
-      return 1;
-
-    case TYPES.SHORT:
-      return 2;
-
-    case TYPES.INT:
-      return 4;
-
-    case TYPES.FLOAT:
-      return 4;
-
-    case TYPES.DOUBLE:
-      return 8;
-
-    default:
-      return -1;
-  }
+exports.num2str = num2str;
+/**
+ * Parse a number type identifier to his size in bytes
+ * @param type - integer that represents the type
+ * @return size of the type
+ */
+function num2bytes(type) {
+    switch (Number(type)) {
+        case exports.TYPES.BYTE:
+            return 1;
+        case exports.TYPES.CHAR:
+            return 1;
+        case exports.TYPES.SHORT:
+            return 2;
+        case exports.TYPES.INT:
+            return 4;
+        case exports.TYPES.FLOAT:
+            return 4;
+        case exports.TYPES.DOUBLE:
+            return 8;
+        /* istanbul ignore next */
+        default:
+            return -1;
+    }
 }
-export function str2num(type) {
-  switch (String(type)) {
-    case 'byte':
-      return TYPES.BYTE;
-
-    case 'char':
-      return TYPES.CHAR;
-
-    case 'short':
-      return TYPES.SHORT;
-
-    case 'int':
-      return TYPES.INT;
-
-    case 'float':
-      return TYPES.FLOAT;
-
-    case 'double':
-      return TYPES.DOUBLE;
-
-    default:
-      return -1;
-  }
+exports.num2bytes = num2bytes;
+/**
+ * Reverse search of num2str
+ * @param type string that represents the type
+ * @return parsed value of the type
+ */
+function str2num(type) {
+    switch (String(type)) {
+        case 'byte':
+            return exports.TYPES.BYTE;
+        case 'char':
+            return exports.TYPES.CHAR;
+        case 'short':
+            return exports.TYPES.SHORT;
+        case 'int':
+            return exports.TYPES.INT;
+        case 'float':
+            return exports.TYPES.FLOAT;
+        case 'double':
+            return exports.TYPES.DOUBLE;
+        /* istanbul ignore next */
+        default:
+            return -1;
+    }
 }
-
+exports.str2num = str2num;
+/**
+ * Auxiliary function to read numeric data
+ * @param size - Size of the element to read
+ * @param bufferReader - Function to read next value
+ * @return
+ */
 function readNumber(size, bufferReader) {
-  if (size !== 1) {
-    const numbers = new Array(size);
-
-    for (let i = 0; i < size; i++) {
-      numbers[i] = bufferReader();
+    if (size !== 1) {
+        const numbers = new Array(size);
+        for (let i = 0; i < size; i++) {
+            numbers[i] = bufferReader();
+        }
+        return numbers;
     }
-
-    return numbers;
-  }
-
-  return bufferReader();
+    return bufferReader();
 }
-
+/**
+ * Removes null terminate value
+ * @param value - String to trim
+ * @return - Trimmed string
+ */
 function trimNull(value) {
-  if (value.charCodeAt(value.length - 1) === 0) {
-    return value.substring(0, value.length - 1);
-  }
-
-  return value;
+    if (value.charCodeAt(value.length - 1) === 0) {
+        return value.substring(0, value.length - 1);
+    }
+    return value;
 }
-//# sourceMappingURL=read-type.js.map