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

package/dist/es5/index.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "NetCDFReader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _netcdfReader.NetCDFReader;
   }
 });
 Object.defineProperty(exports, "NetCDFLoader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _netcdfLoader.NetCDFLoader;
   }
 });

package/dist/es5/iobuffer/iobuffer.js

@@ -7,19 +7,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.IOBuffer = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var DEFAULT_BYTE_LENGTH = 1024 * 8;
+const DEFAULT_BYTE_LENGTH = 1024 * 8;
 
-var IOBuffer = function () {
-  function IOBuffer() {
-    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_BYTE_LENGTH;
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    (0, _classCallCheck2.default)(this, IOBuffer);
+class IOBuffer {
+  constructor(data = DEFAULT_BYTE_LENGTH, options = {}) {
     (0, _defineProperty2.default)(this, "buffer", void 0);
     (0, _defineProperty2.default)(this, "byteLength", void 0);
     (0, _defineProperty2.default)(this, "byteOffset", void 0);
@@ -32,7 +25,7 @@ var IOBuffer = function () {
     (0, _defineProperty2.default)(this, "_marks", void 0);
     (0, _defineProperty2.default)(this, "textDecoder", new TextDecoder());
     (0, _defineProperty2.default)(this, "textEncoder", new TextEncoder());
-    var dataIsGiven = false;
+    let dataIsGiven = false;
 
     if (typeof data === 'number') {
       data = new ArrayBuffer(data);
@@ -41,9 +34,9 @@ var IOBuffer = function () {
       this.lastWrittenByte = data.byteLength;
     }
 
-    var offset = options.offset ? options.offset >>> 0 : 0;
-    var byteLength = data.byteLength - offset;
-    var dvOffset = offset;
+    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) {
@@ -70,363 +63,311 @@ var IOBuffer = function () {
     this._marks = [];
   }
 
-  (0, _createClass2.default)(IOBuffer, [{
-    key: "available",
-    value: function available() {
-      var byteLength = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-      return this.offset + byteLength <= this.length;
-    }
-  }, {
-    key: "isLittleEndian",
-    value: function isLittleEndian() {
-      return this.littleEndian;
-    }
-  }, {
-    key: "setLittleEndian",
-    value: function setLittleEndian() {
-      this.littleEndian = true;
-      return this;
-    }
-  }, {
-    key: "isBigEndian",
-    value: function isBigEndian() {
-      return !this.littleEndian;
-    }
-  }, {
-    key: "setBigEndian",
-    value: function setBigEndian() {
-      this.littleEndian = false;
-      return this;
-    }
-  }, {
-    key: "skip",
-    value: function skip() {
-      var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-      this.offset += n;
-      return this;
-    }
-  }, {
-    key: "seek",
-    value: function seek(offset) {
-      this.offset = offset;
-      return this;
-    }
-  }, {
-    key: "mark",
-    value: function mark() {
-      this._mark = this.offset;
-      return this;
-    }
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.offset = this._mark;
-      return this;
-    }
-  }, {
-    key: "pushMark",
-    value: function pushMark() {
-      this._marks.push(this.offset);
+  available(byteLength = 1) {
+    return this.offset + byteLength <= this.length;
+  }
 
-      return this;
-    }
-  }, {
-    key: "popMark",
-    value: function popMark() {
-      var offset = this._marks.pop();
+  isLittleEndian() {
+    return this.littleEndian;
+  }
 
-      if (offset === undefined) {
-        throw new Error('Mark stack empty');
-      }
+  setLittleEndian() {
+    this.littleEndian = true;
+    return this;
+  }
 
-      this.seek(offset);
-      return this;
-    }
-  }, {
-    key: "rewind",
-    value: function rewind() {
-      this.offset = 0;
-      return this;
-    }
-  }, {
-    key: "ensureAvailable",
-    value: function ensureAvailable() {
-      var byteLength = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-
-      if (!this.available(byteLength)) {
-        var lengthNeeded = this.offset + byteLength;
-        var newLength = lengthNeeded * 2;
-        var 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);
-      }
+  isBigEndian() {
+    return !this.littleEndian;
+  }
 
-      return this;
-    }
-  }, {
-    key: "readBoolean",
-    value: function readBoolean() {
-      return this.readUint8() !== 0;
-    }
-  }, {
-    key: "readInt8",
-    value: function readInt8() {
-      return this._data.getInt8(this.offset++);
-    }
-  }, {
-    key: "readUint8",
-    value: function readUint8() {
-      return this._data.getUint8(this.offset++);
-    }
-  }, {
-    key: "readByte",
-    value: function readByte() {
-      return this.readUint8();
-    }
-  }, {
-    key: "readBytes",
-    value: function readBytes() {
-      var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-      var bytes = new Uint8Array(n);
-
-      for (var i = 0; i < n; i++) {
-        bytes[i] = this.readByte();
-      }
+  setBigEndian() {
+    this.littleEndian = false;
+    return this;
+  }
 
-      return bytes;
-    }
-  }, {
-    key: "readInt16",
-    value: function readInt16() {
-      var value = this._data.getInt16(this.offset, this.littleEndian);
+  skip(n = 1) {
+    this.offset += n;
+    return this;
+  }
 
-      this.offset += 2;
-      return value;
-    }
-  }, {
-    key: "readUint16",
-    value: function readUint16() {
-      var value = this._data.getUint16(this.offset, this.littleEndian);
+  seek(offset) {
+    this.offset = offset;
+    return this;
+  }
 
-      this.offset += 2;
-      return value;
-    }
-  }, {
-    key: "readInt32",
-    value: function readInt32() {
-      var value = this._data.getInt32(this.offset, this.littleEndian);
+  mark() {
+    this._mark = this.offset;
+    return this;
+  }
 
-      this.offset += 4;
-      return value;
-    }
-  }, {
-    key: "readUint32",
-    value: function readUint32() {
-      var value = this._data.getUint32(this.offset, this.littleEndian);
+  reset() {
+    this.offset = this._mark;
+    return this;
+  }
 
-      this.offset += 4;
-      return value;
-    }
-  }, {
-    key: "readFloat32",
-    value: function readFloat32() {
-      var value = this._data.getFloat32(this.offset, this.littleEndian);
+  pushMark() {
+    this._marks.push(this.offset);
 
-      this.offset += 4;
-      return value;
-    }
-  }, {
-    key: "readFloat64",
-    value: function readFloat64() {
-      var value = this._data.getFloat64(this.offset, this.littleEndian);
+    return this;
+  }
 
-      this.offset += 8;
-      return value;
-    }
-  }, {
-    key: "readChar",
-    value: function readChar() {
-      return String.fromCharCode(this.readInt8());
-    }
-  }, {
-    key: "readChars",
-    value: function readChars() {
-      var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-      var result = '';
-
-      for (var i = 0; i < n; i++) {
-        result += this.readChar();
-      }
+  popMark() {
+    const offset = this._marks.pop();
 
-      return result;
-    }
-  }, {
-    key: "readUtf8",
-    value: function readUtf8() {
-      var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-      return this.textDecoder.decode(this.readBytes(n));
+    if (offset === undefined) {
+      throw new Error('Mark stack empty');
     }
-  }, {
-    key: "writeBoolean",
-    value: function writeBoolean(value) {
-      this.writeUint8(value ? 0xff : 0x00);
-      return this;
-    }
-  }, {
-    key: "writeInt8",
-    value: function writeInt8(value) {
-      this.ensureAvailable(1);
 
-      this._data.setInt8(this.offset++, value);
+    this.seek(offset);
+    return this;
+  }
 
-      this._updateLastWrittenByte();
+  rewind() {
+    this.offset = 0;
+    return this;
+  }
 
-      return this;
+  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);
     }
-  }, {
-    key: "writeUint8",
-    value: function writeUint8(value) {
-      this.ensureAvailable(1);
 
-      this._data.setUint8(this.offset++, value);
+    return this;
+  }
 
-      this._updateLastWrittenByte();
+  readBoolean() {
+    return this.readUint8() !== 0;
+  }
 
-      return this;
-    }
-  }, {
-    key: "writeByte",
-    value: function writeByte(value) {
-      return this.writeUint8(value);
-    }
-  }, {
-    key: "writeBytes",
-    value: function writeBytes(bytes) {
-      this.ensureAvailable(bytes.length);
+  readInt8() {
+    return this._data.getInt8(this.offset++);
+  }
 
-      for (var i = 0; i < bytes.length; i++) {
-        this._data.setUint8(this.offset++, bytes[i]);
-      }
+  readUint8() {
+    return this._data.getUint8(this.offset++);
+  }
+
+  readByte() {
+    return this.readUint8();
+  }
 
-      this._updateLastWrittenByte();
+  readBytes(n = 1) {
+    const bytes = new Uint8Array(n);
 
-      return this;
+    for (let i = 0; i < n; i++) {
+      bytes[i] = this.readByte();
     }
-  }, {
-    key: "writeInt16",
-    value: function writeInt16(value) {
-      this.ensureAvailable(2);
 
-      this._data.setInt16(this.offset, value, this.littleEndian);
+    return bytes;
+  }
 
-      this.offset += 2;
+  readInt16() {
+    const value = this._data.getInt16(this.offset, this.littleEndian);
 
-      this._updateLastWrittenByte();
+    this.offset += 2;
+    return value;
+  }
 
-      return this;
-    }
-  }, {
-    key: "writeUint16",
-    value: function writeUint16(value) {
-      this.ensureAvailable(2);
+  readUint16() {
+    const value = this._data.getUint16(this.offset, this.littleEndian);
 
-      this._data.setUint16(this.offset, value, this.littleEndian);
+    this.offset += 2;
+    return value;
+  }
 
-      this.offset += 2;
+  readInt32() {
+    const value = this._data.getInt32(this.offset, this.littleEndian);
 
-      this._updateLastWrittenByte();
+    this.offset += 4;
+    return value;
+  }
 
-      return this;
-    }
-  }, {
-    key: "writeInt32",
-    value: function writeInt32(value) {
-      this.ensureAvailable(4);
+  readUint32() {
+    const value = this._data.getUint32(this.offset, this.littleEndian);
 
-      this._data.setInt32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
 
-      this.offset += 4;
+  readFloat32() {
+    const value = this._data.getFloat32(this.offset, this.littleEndian);
 
-      this._updateLastWrittenByte();
+    this.offset += 4;
+    return value;
+  }
 
-      return this;
-    }
-  }, {
-    key: "writeUint32",
-    value: function writeUint32(value) {
-      this.ensureAvailable(4);
+  readFloat64() {
+    const value = this._data.getFloat64(this.offset, this.littleEndian);
 
-      this._data.setUint32(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
 
-      this.offset += 4;
+  readChar() {
+    return String.fromCharCode(this.readInt8());
+  }
 
-      this._updateLastWrittenByte();
+  readChars(n = 1) {
+    let result = '';
 
-      return this;
+    for (let i = 0; i < n; i++) {
+      result += this.readChar();
     }
-  }, {
-    key: "writeFloat32",
-    value: function writeFloat32(value) {
-      this.ensureAvailable(4);
 
-      this._data.setFloat32(this.offset, value, this.littleEndian);
+    return result;
+  }
 
-      this.offset += 4;
+  readUtf8(n = 1) {
+    return this.textDecoder.decode(this.readBytes(n));
+  }
 
-      this._updateLastWrittenByte();
+  writeBoolean(value) {
+    this.writeUint8(value ? 0xff : 0x00);
+    return this;
+  }
 
-      return this;
-    }
-  }, {
-    key: "writeFloat64",
-    value: function writeFloat64(value) {
-      this.ensureAvailable(8);
+  writeInt8(value) {
+    this.ensureAvailable(1);
 
-      this._data.setFloat64(this.offset, value, this.littleEndian);
+    this._data.setInt8(this.offset++, value);
 
-      this.offset += 8;
+    this._updateLastWrittenByte();
 
-      this._updateLastWrittenByte();
+    return this;
+  }
 
-      return this;
-    }
-  }, {
-    key: "writeChar",
-    value: function writeChar(str) {
-      return this.writeUint8(str.charCodeAt(0));
-    }
-  }, {
-    key: "writeChars",
-    value: function writeChars(str) {
-      for (var i = 0; i < str.length; i++) {
-        this.writeUint8(str.charCodeAt(i));
-      }
+  writeUint8(value) {
+    this.ensureAvailable(1);
 
-      return this;
-    }
-  }, {
-    key: "writeUtf8",
-    value: function writeUtf8(str) {
-      var bytes = this.textEncoder.encode(str);
-      return this.writeBytes(bytes);
+    this._data.setUint8(this.offset++, value);
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeByte(value) {
+    return this.writeUint8(value);
+  }
+
+  writeBytes(bytes) {
+    this.ensureAvailable(bytes.length);
+
+    for (let i = 0; i < bytes.length; i++) {
+      this._data.setUint8(this.offset++, bytes[i]);
     }
-  }, {
-    key: "toArray",
-    value: function toArray() {
-      return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeInt16(value) {
+    this.ensureAvailable(2);
+
+    this._data.setInt16(this.offset, value, this.littleEndian);
+
+    this.offset += 2;
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeUint16(value) {
+    this.ensureAvailable(2);
+
+    this._data.setUint16(this.offset, value, this.littleEndian);
+
+    this.offset += 2;
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeInt32(value) {
+    this.ensureAvailable(4);
+
+    this._data.setInt32(this.offset, value, this.littleEndian);
+
+    this.offset += 4;
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeUint32(value) {
+    this.ensureAvailable(4);
+
+    this._data.setUint32(this.offset, value, this.littleEndian);
+
+    this.offset += 4;
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeFloat32(value) {
+    this.ensureAvailable(4);
+
+    this._data.setFloat32(this.offset, value, this.littleEndian);
+
+    this.offset += 4;
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeFloat64(value) {
+    this.ensureAvailable(8);
+
+    this._data.setFloat64(this.offset, value, this.littleEndian);
+
+    this.offset += 8;
+
+    this._updateLastWrittenByte();
+
+    return this;
+  }
+
+  writeChar(str) {
+    return this.writeUint8(str.charCodeAt(0));
+  }
+
+  writeChars(str) {
+    for (let i = 0; i < str.length; i++) {
+      this.writeUint8(str.charCodeAt(i));
     }
-  }, {
-    key: "_updateLastWrittenByte",
-    value: function _updateLastWrittenByte() {
-      if (this.offset > this.lastWrittenByte) {
-        this.lastWrittenByte = this.offset;
-      }
+
+    return this;
+  }
+
+  writeUtf8(str) {
+    const bytes = this.textEncoder.encode(str);
+    return this.writeBytes(bytes);
+  }
+
+  toArray() {
+    return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
+  }
+
+  _updateLastWrittenByte() {
+    if (this.offset > this.lastWrittenByte) {
+      this.lastWrittenByte = this.offset;
     }
-  }]);
-  return IOBuffer;
-}();
+  }
+
+}
 
 exports.IOBuffer = IOBuffer;
 //# sourceMappingURL=iobuffer.js.map