@loaders.gl/netcdf 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/netcdfjs/read-header.js

@@ -1,161 +1,225 @@
 import { readType, num2str } from "./read-type.js";
+// Grammar constants
 const ZERO = 0;
 const NC_DIMENSION = 10;
 const NC_VARIABLE = 11;
 const NC_ATTRIBUTE = 12;
 const NC_UNLIMITED = 0;
+/**
+ * Read the header of the file
+ * @param buffer - Buffer for the file data
+ * @param version - Version of the file
+ * @return  - Header
+ */
 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;
+    // 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, // id of the unlimited dimension
+            name: dimList.recordName, // name of the unlimited dimension
+            recordStep: variableList.recordStep
+        },
+        dimensions: dimList.dimensions,
+        variables: variableList.variables,
+        attributes
+    };
+    return header;
 }
+/**
+ * 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 ${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 = readType(buffer, type, size);
+        // Apply padding
+        padding(buffer);
+        attributes[gAtt] = {
+            name,
+            type: 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 ${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: 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
-  };
 }
+// HELPERS
+/**
+ * Reads the name
+ * @param buffer - Buffer for the file data
+ * @return Name
+ */
 export function readName(buffer) {
-  const nameLength = buffer.readUint32();
-  const name = buffer.readChars(nameLength);
-  padding(buffer);
-  return name;
+    // Read name
+    const nameLength = buffer.readUint32();
+    const name = buffer.readChars(nameLength);
+    // validate name
+    // TODO
+    // Apply padding
+    padding(buffer);
+    return name;
 }
+/**
+ * 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.d.ts

@@ -1,4 +1,4 @@
-import { IOBuffer } from '../iobuffer/iobuffer';
+import { IOBuffer } from "../iobuffer/iobuffer.js";
 export declare const TYPES: {
     BYTE: number;
     CHAR: number;

package/dist/netcdfjs/read-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-type.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/read-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAE9C,eAAO,MAAM,KAAK;;;;;;;CAOjB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,CAkBzC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB5C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB9C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB5C"}
+{"version":3,"file":"read-type.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/read-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,gCAA6B;AAE9C,eAAO,MAAM,KAAK;;;;;;;CAOjB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,CAkBzC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB5C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB9C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB5C"}

package/dist/netcdfjs/read-type.js

@@ -1,97 +1,133 @@
 export const TYPES = {
-  BYTE: 1,
-  CHAR: 2,
-  SHORT: 3,
-  INT: 4,
-  FLOAT: 5,
-  DOUBLE: 6
+    BYTE: 1,
+    CHAR: 2,
+    SHORT: 3,
+    INT: 4,
+    FLOAT: 5,
+    DOUBLE: 6
 };
+/**
+ * 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
+ */
 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 ${type}`);
-  }
+    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));
+        /* istanbul ignore next */
+        default:
+            throw new Error(`NetCDF: non valid type ${type}`);
+    }
 }
+/**
+ * Parse a number into their respective type
+ * @param type - integer that represents the type
+ * @return parsed value of the 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';
-  }
+    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';
+        /* istanbul ignore next */
+        default:
+            return 'undefined';
+    }
 }
+/**
+ * Parse a number type identifier to his size in bytes
+ * @param type - integer that represents the type
+ * @return size of the type
+ */
 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;
-  }
+    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;
+        /* istanbul ignore next */
+        default:
+            return -1;
+    }
 }
+/**
+ * Reverse search of num2str
+ * @param type string that represents the type
+ * @return parsed value of the type
+ */
 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;
-  }
+    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;
+        /* istanbul ignore next */
+        default:
+            return -1;
+    }
 }
+/**
+ * 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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/netcdf",
   "description": "Loader for NetCDF",
-  "version": "4.2.0-alpha.4",
+  "version": "4.2.0-alpha.5",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -34,11 +34,15 @@
     "README.md"
   ],
   "scripts": {
-    "pre-build": "npm run build-bundle && npm run build-bundle -- --env=dev",
-    "build-bundle": "ocular-bundle ./src/index.ts"
+    "pre-build": "npm run build-bundle && npm run build-bundle-dev",
+    "build-bundle": "ocular-bundle ./bundle.ts --output=dist/dist.min.js",
+    "build-bundle-dev": "ocular-bundle ./bundle.ts --env=dev --output=dist/dist.dev.js"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.2.0-alpha.4"
+    "@loaders.gl/loader-utils": "4.2.0-alpha.5"
   },
-  "gitHead": "6c52dee5c3f005648a394cc4aee7fc37005c8e83"
+  "peerDependencies": {
+    "@loaders.gl/core": "^4.0.0"
+  },
+  "gitHead": "32d95a81971f104e4dfeb88ab57065f05321a76a"
 }

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["NetCDFReader","NetCDFLoader"],"sources":["../src/index.ts"],"sourcesContent":["export {NetCDFReader} from './netcdfjs/netcdf-reader';\n\nexport {NetCDFLoader} from './netcdf-loader';\n"],"mappings":"SAAQA,YAAY;AAAA,SAEZC,YAAY"}