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

package/dist/es5/lib/streaming/binary-reader.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 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 BinaryReader = function () {
+  function BinaryReader(arrayBuffer) {
+    (0, _classCallCheck2.default)(this, BinaryReader);
+    (0, _defineProperty2.default)(this, "offset", void 0);
+    (0, _defineProperty2.default)(this, "arrayBuffer", void 0);
+    this.offset = 0;
+    this.arrayBuffer = arrayBuffer;
+  }
+  (0, _createClass2.default)(BinaryReader, [{
+    key: "hasAvailableBytes",
+    value: function hasAvailableBytes(bytes) {
+      return this.arrayBuffer.byteLength - this.offset >= bytes;
+    }
+  }, {
+    key: "getDataView",
+    value: function getDataView(bytes) {
+      if (bytes && !this.hasAvailableBytes(bytes)) {
+        throw new Error('binary data exhausted');
+      }
+      var dataView = bytes ? new DataView(this.arrayBuffer, this.offset, bytes) : new DataView(this.arrayBuffer, this.offset);
+      this.offset += bytes;
+      return dataView;
+    }
+  }, {
+    key: "skip",
+    value: function skip(bytes) {
+      this.offset += bytes;
+    }
+  }, {
+    key: "rewind",
+    value: function rewind(bytes) {
+      this.offset -= bytes;
+    }
+  }]);
+  return BinaryReader;
+}();
+exports.default = BinaryReader;
+//# sourceMappingURL=binary-reader.js.map

package/dist/es5/lib/streaming/binary-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-reader.js","names":["BinaryReader","arrayBuffer","_classCallCheck2","default","_defineProperty2","offset","_createClass2","key","value","hasAvailableBytes","bytes","byteLength","getDataView","Error","dataView","DataView","skip","rewind","exports"],"sources":["../../../../src/lib/streaming/binary-reader.ts"],"sourcesContent":["export default class BinaryReader {\n  offset: number;\n  arrayBuffer: ArrayBuffer;\n\n  constructor(arrayBuffer: ArrayBuffer) {\n    /** current global (stream) offset */\n    this.offset = 0;\n    /** current buffer from iterator */\n    this.arrayBuffer = arrayBuffer;\n  }\n  /**\n   * Checks if there are available bytes in data\n   *\n   * @param bytes\n   * @returns boolean\n   */\n  hasAvailableBytes(bytes: number): boolean {\n    return this.arrayBuffer.byteLength - this.offset >= bytes;\n  }\n\n  /**\n   * Get the required number of bytes from the iterator\n   *\n   * @param bytes\n   * @returns Dataview\n   */\n  getDataView(bytes: number): DataView {\n    if (bytes && !this.hasAvailableBytes(bytes)) {\n      throw new Error('binary data exhausted');\n    }\n\n    const dataView = bytes\n      ? new DataView(this.arrayBuffer, this.offset, bytes)\n      : new DataView(this.arrayBuffer, this.offset);\n    this.offset += bytes;\n    return dataView;\n  }\n\n  /**\n   * Skipping\n   *\n   * @param bytes\n   */\n  skip(bytes: number): void {\n    this.offset += bytes;\n  }\n\n  /**\n   * Rewinding\n   *\n   * @param bytes\n   */\n  rewind(bytes: number): void {\n    this.offset -= bytes;\n  }\n}\n"],"mappings":";;;;;;;;;;IAAqBA,YAAY;EAI/B,SAAAA,aAAYC,WAAwB,EAAE;IAAA,IAAAC,gBAAA,CAAAC,OAAA,QAAAH,YAAA;IAAA,IAAAI,gBAAA,CAAAD,OAAA;IAAA,IAAAC,gBAAA,CAAAD,OAAA;IAEpC,IAAI,CAACE,MAAM,GAAG,CAAC;IAEf,IAAI,CAACJ,WAAW,GAAGA,WAAW;EAChC;EAAC,IAAAK,aAAA,CAAAH,OAAA,EAAAH,YAAA;IAAAO,GAAA;IAAAC,KAAA,EAOD,SAAAC,kBAAkBC,KAAa,EAAW;MACxC,OAAO,IAAI,CAACT,WAAW,CAACU,UAAU,GAAG,IAAI,CAACN,MAAM,IAAIK,KAAK;IAC3D;EAAC;IAAAH,GAAA;IAAAC,KAAA,EAQD,SAAAI,YAAYF,KAAa,EAAY;MACnC,IAAIA,KAAK,IAAI,CAAC,IAAI,CAACD,iBAAiB,CAACC,KAAK,CAAC,EAAE;QAC3C,MAAM,IAAIG,KAAK,CAAC,uBAAuB,CAAC;MAC1C;MAEA,IAAMC,QAAQ,GAAGJ,KAAK,GAClB,IAAIK,QAAQ,CAAC,IAAI,CAACd,WAAW,EAAE,IAAI,CAACI,MAAM,EAAEK,KAAK,CAAC,GAClD,IAAIK,QAAQ,CAAC,IAAI,CAACd,WAAW,EAAE,IAAI,CAACI,MAAM,CAAC;MAC/C,IAAI,CAACA,MAAM,IAAIK,KAAK;MACpB,OAAOI,QAAQ;IACjB;EAAC;IAAAP,GAAA;IAAAC,KAAA,EAOD,SAAAQ,KAAKN,KAAa,EAAQ;MACxB,IAAI,CAACL,MAAM,IAAIK,KAAK;IACtB;EAAC;IAAAH,GAAA;IAAAC,KAAA,EAOD,SAAAS,OAAOP,KAAa,EAAQ;MAC1B,IAAI,CAACL,MAAM,IAAIK,KAAK;IACtB;EAAC;EAAA,OAAAV,YAAA;AAAA;AAAAkB,OAAA,CAAAf,OAAA,GAAAH,YAAA"}

package/dist/es5/lib/streaming/zip-batch-iterators.js

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zipBatchIterators = zipBatchIterators;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+function zipBatchIterators(_x, _x2) {
+  return _zipBatchIterators.apply(this, arguments);
+}
+function _zipBatchIterators() {
+  _zipBatchIterators = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(iterator1, iterator2) {
+    var batch1, batch2, iterator1Done, iterator2Done, _yield$_awaitAsyncGen, value, done, _yield$_awaitAsyncGen2, _value, _done, batch;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          batch1 = [];
+          batch2 = [];
+          iterator1Done = false;
+          iterator2Done = false;
+        case 4:
+          if (!(!iterator1Done && !iterator2Done)) {
+            _context.next = 27;
+            break;
+          }
+          if (!(batch1.length === 0 && !iterator1Done)) {
+            _context.next = 14;
+            break;
+          }
+          _context.next = 8;
+          return (0, _awaitAsyncGenerator2.default)(iterator1.next());
+        case 8:
+          _yield$_awaitAsyncGen = _context.sent;
+          value = _yield$_awaitAsyncGen.value;
+          done = _yield$_awaitAsyncGen.done;
+          if (done) {
+            iterator1Done = true;
+          } else {
+            batch1 = value;
+          }
+          _context.next = 21;
+          break;
+        case 14:
+          if (!(batch2.length === 0 && !iterator2Done)) {
+            _context.next = 21;
+            break;
+          }
+          _context.next = 17;
+          return (0, _awaitAsyncGenerator2.default)(iterator2.next());
+        case 17:
+          _yield$_awaitAsyncGen2 = _context.sent;
+          _value = _yield$_awaitAsyncGen2.value;
+          _done = _yield$_awaitAsyncGen2.done;
+          if (_done) {
+            iterator2Done = true;
+          } else {
+            batch2 = _value;
+          }
+        case 21:
+          batch = extractBatch(batch1, batch2);
+          if (!batch) {
+            _context.next = 25;
+            break;
+          }
+          _context.next = 25;
+          return batch;
+        case 25:
+          _context.next = 4;
+          break;
+        case 27:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _zipBatchIterators.apply(this, arguments);
+}
+function extractBatch(batch1, batch2) {
+  var batchLength = Math.min(batch1.length, batch2.length);
+  if (batchLength === 0) {
+    return null;
+  }
+  var batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
+  batch1.splice(0, batchLength);
+  batch2.splice(0, batchLength);
+  return batch;
+}
+//# sourceMappingURL=zip-batch-iterators.js.map

package/dist/es5/lib/streaming/zip-batch-iterators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-batch-iterators.js","names":["zipBatchIterators","_x","_x2","_zipBatchIterators","apply","arguments","_wrapAsyncGenerator2","default","_regenerator","mark","_callee","iterator1","iterator2","batch1","batch2","iterator1Done","iterator2Done","_yield$_awaitAsyncGen","value","done","_yield$_awaitAsyncGen2","_value","_done","batch","wrap","_callee$","_context","prev","next","length","_awaitAsyncGenerator2","sent","extractBatch","stop","batchLength","Math","min","slice","splice"],"sources":["../../../../src/lib/streaming/zip-batch-iterators.ts"],"sourcesContent":["/**\n * Zip two iterators together\n *\n * @param iterator1\n * @param iterator2\n */\nexport async function* zipBatchIterators(\n  iterator1: AsyncIterator<any[]>,\n  iterator2: AsyncIterator<any[]>\n): AsyncGenerator<number[][], void, unknown> {\n  let batch1: number[] = [];\n  let batch2: number[] = [];\n  let iterator1Done: boolean = false;\n  let iterator2Done: boolean = false;\n\n  // TODO - one could let all iterators flow at full speed using `Promise.race`\n  // however we might end up with a big temporary buffer\n  while (!iterator1Done && !iterator2Done) {\n    if (batch1.length === 0 && !iterator1Done) {\n      const {value, done} = await iterator1.next();\n      if (done) {\n        iterator1Done = true;\n      } else {\n        batch1 = value;\n      }\n    } else if (batch2.length === 0 && !iterator2Done) {\n      const {value, done} = await iterator2.next();\n      if (done) {\n        iterator2Done = true;\n      } else {\n        batch2 = value;\n      }\n    }\n\n    const batch = extractBatch(batch1, batch2);\n    if (batch) {\n      yield batch;\n    }\n  }\n}\n\n/**\n * Extract batch of same length from two batches\n *\n * @param batch1\n * @param batch2\n * @return array | null\n */\nfunction extractBatch(batch1: number[], batch2: number[]): number[][] | null {\n  const batchLength: number = Math.min(batch1.length, batch2.length);\n  if (batchLength === 0) {\n    return null;\n  }\n\n  // Non interleaved arrays\n  const batch: number[][] = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];\n\n  // Modify the 2 batches\n  batch1.splice(0, batchLength);\n  batch2.splice(0, batchLength);\n  return batch;\n}\n"],"mappings":"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"}

package/dist/es5/shapefile-loader.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._typecheckShapefileLoader = exports.ShapefileLoader = void 0;
+var _shpLoader = require("./shp-loader");
+var _parseShapefile = require("./lib/parsers/parse-shapefile");
+var VERSION = typeof "4.0.0-alpha.7" !== 'undefined' ? "4.0.0-alpha.7" : 'latest';
+var ShapefileLoader = {
+  name: 'Shapefile',
+  id: 'shapefile',
+  module: 'shapefile',
+  version: VERSION,
+  category: 'geometry',
+  extensions: ['shp'],
+  mimeTypes: ['application/octet-stream'],
+  tests: [new Uint8Array(_shpLoader.SHP_MAGIC_NUMBER).buffer],
+  options: {
+    shapefile: {},
+    shp: {
+      _maxDimensions: 4
+    }
+  },
+  parse: _parseShapefile.parseShapefile,
+  parseInBatches: _parseShapefile.parseShapefileInBatches
+};
+exports.ShapefileLoader = ShapefileLoader;
+var _typecheckShapefileLoader = ShapefileLoader;
+exports._typecheckShapefileLoader = _typecheckShapefileLoader;
+//# sourceMappingURL=shapefile-loader.js.map

package/dist/es5/shapefile-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapefile-loader.js","names":["_shpLoader","require","_parseShapefile","VERSION","ShapefileLoader","name","id","module","version","category","extensions","mimeTypes","tests","Uint8Array","SHP_MAGIC_NUMBER","buffer","options","shapefile","shp","_maxDimensions","parse","parseShapefile","parseInBatches","parseShapefileInBatches","exports","_typecheckShapefileLoader"],"sources":["../../src/shapefile-loader.ts"],"sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {SHP_MAGIC_NUMBER} from './shp-loader';\nimport {parseShapefile, parseShapefileInBatches} from './lib/parsers/parse-shapefile';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * Shapefile loader\n * @note Shapefile is multifile format and requires providing additional files\n */\nexport const ShapefileLoader = {\n  name: 'Shapefile',\n  id: 'shapefile',\n  module: 'shapefile',\n  version: VERSION,\n  category: 'geometry',\n  extensions: ['shp'],\n  mimeTypes: ['application/octet-stream'],\n  tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],\n  options: {\n    shapefile: {},\n    shp: {\n      _maxDimensions: 4\n    }\n  },\n  parse: parseShapefile,\n  parseInBatches: parseShapefileInBatches\n};\n\nexport const _typecheckShapefileLoader: LoaderWithParser = ShapefileLoader;\n"],"mappings":";;;;;;AACA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,eAAA,GAAAD,OAAA;AAIA,IAAME,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAMpE,IAAMC,eAAe,GAAG;EAC7BC,IAAI,EAAE,WAAW;EACjBC,EAAE,EAAE,WAAW;EACfC,MAAM,EAAE,WAAW;EACnBC,OAAO,EAAEL,OAAO;EAChBM,QAAQ,EAAE,UAAU;EACpBC,UAAU,EAAE,CAAC,KAAK,CAAC;EACnBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,KAAK,EAAE,CAAC,IAAIC,UAAU,CAACC,2BAAgB,CAAC,CAACC,MAAM,CAAC;EAChDC,OAAO,EAAE;IACPC,SAAS,EAAE,CAAC,CAAC;IACbC,GAAG,EAAE;MACHC,cAAc,EAAE;IAClB;EACF,CAAC;EACDC,KAAK,EAAEC,8BAAc;EACrBC,cAAc,EAAEC;AAClB,CAAC;AAACC,OAAA,CAAApB,eAAA,GAAAA,eAAA;AAEK,IAAMqB,yBAA2C,GAAGrB,eAAe;AAACoB,OAAA,CAAAC,yBAAA,GAAAA,yBAAA"}

package/dist/es5/shp-loader.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SHP_MAGIC_NUMBER = exports.SHPWorkerLoader = exports.SHPLoader = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _parseShp = require("./lib/parsers/parse-shp");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var VERSION = typeof "4.0.0-alpha.7" !== 'undefined' ? "4.0.0-alpha.7" : 'latest';
+var SHP_MAGIC_NUMBER = [0x00, 0x00, 0x27, 0x0a];
+exports.SHP_MAGIC_NUMBER = SHP_MAGIC_NUMBER;
+var SHPWorkerLoader = {
+  name: 'SHP',
+  id: 'shp',
+  module: 'shapefile',
+  version: VERSION,
+  worker: true,
+  category: 'geometry',
+  extensions: ['shp'],
+  mimeTypes: ['application/octet-stream'],
+  tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],
+  options: {
+    shp: {
+      _maxDimensions: 4
+    }
+  }
+};
+exports.SHPWorkerLoader = SHPWorkerLoader;
+var SHPLoader = _objectSpread(_objectSpread({}, SHPWorkerLoader), {}, {
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", (0, _parseShp.parseSHP)(arrayBuffer, options));
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function parse(_x, _x2) {
+      return _parse.apply(this, arguments);
+    }
+    return parse;
+  }(),
+  parseSync: _parseShp.parseSHP,
+  parseInBatches: _parseShp.parseSHPInBatches
+});
+exports.SHPLoader = SHPLoader;
+//# sourceMappingURL=shp-loader.js.map

package/dist/es5/shp-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shp-loader.js","names":["_parseShp","require","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","VERSION","SHP_MAGIC_NUMBER","exports","SHPWorkerLoader","name","id","module","version","worker","category","extensions","mimeTypes","tests","Uint8Array","buffer","options","shp","_maxDimensions","SHPLoader","parse","_parse","_asyncToGenerator2","_regenerator","mark","_callee","arrayBuffer","wrap","_callee$","_context","prev","next","abrupt","parseSHP","stop","_x","_x2","parseSync","parseInBatches","parseSHPInBatches"],"sources":["../../src/shp-loader.ts"],"sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseSHP, parseSHPInBatches} from './lib/parsers/parse-shp';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const SHP_MAGIC_NUMBER = [0x00, 0x00, 0x27, 0x0a];\n\n/**\n * SHP file loader\n */\nexport const SHPWorkerLoader: Loader = {\n  name: 'SHP',\n  id: 'shp',\n  module: 'shapefile',\n  version: VERSION,\n  worker: true,\n  category: 'geometry',\n  extensions: ['shp'],\n  mimeTypes: ['application/octet-stream'],\n  // ISSUE: This also identifies SHX files, which are identical to SHP for the first 100 bytes...\n  tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],\n  options: {\n    shp: {\n      _maxDimensions: 4\n    }\n  }\n};\n\n/** SHP file loader */\nexport const SHPLoader: LoaderWithParser = {\n  ...SHPWorkerLoader,\n  parse: async (arrayBuffer, options?) => parseSHP(arrayBuffer, options),\n  parseSync: parseSHP,\n  parseInBatches: parseSHPInBatches\n};\n"],"mappings":"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"}

package/dist/es5/workers/dbf-worker.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _dbfLoader = require("../dbf-loader");
+var _loaderUtils = require("@loaders.gl/loader-utils");
+(0, _loaderUtils.createLoaderWorker)(_dbfLoader.DBFLoader);
+//# sourceMappingURL=dbf-worker.js.map

package/dist/es5/workers/dbf-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbf-worker.js","names":["_dbfLoader","require","_loaderUtils","createLoaderWorker","DBFLoader"],"sources":["../../../src/workers/dbf-worker.ts"],"sourcesContent":["import {DBFLoader} from '../dbf-loader';\nimport {createLoaderWorker} from '@loaders.gl/loader-utils';\n\ncreateLoaderWorker(DBFLoader);\n"],"mappings":";;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,IAAAE,+BAAkB,EAACC,oBAAS,CAAC"}

package/dist/es5/workers/shp-worker.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _shpLoader = require("../shp-loader");
+var _loaderUtils = require("@loaders.gl/loader-utils");
+(0, _loaderUtils.createLoaderWorker)(_shpLoader.SHPLoader);
+//# sourceMappingURL=shp-worker.js.map

package/dist/es5/workers/shp-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shp-worker.js","names":["_shpLoader","require","_loaderUtils","createLoaderWorker","SHPLoader"],"sources":["../../../src/workers/shp-worker.ts"],"sourcesContent":["import {SHPLoader} from '../shp-loader';\nimport {createLoaderWorker} from '@loaders.gl/loader-utils';\n\ncreateLoaderWorker(SHPLoader);\n"],"mappings":";;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,IAAAE,+BAAkB,EAACC,oBAAS,CAAC"}

package/dist/esm/bundle.js

@@ -0,0 +1,4 @@
+const moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/esm/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

package/dist/esm/dbf-loader.js

@@ -0,0 +1,24 @@
+import { parseDBF, parseDBFInBatches } from './lib/parsers/parse-dbf';
+const VERSION = typeof "4.0.0-alpha.7" !== 'undefined' ? "4.0.0-alpha.7" : 'latest';
+export const DBFWorkerLoader = {
+  name: 'DBF',
+  id: 'dbf',
+  module: 'shapefile',
+  version: VERSION,
+  worker: true,
+  category: 'table',
+  extensions: ['dbf'],
+  mimeTypes: ['application/x-dbf'],
+  options: {
+    dbf: {
+      encoding: 'latin1'
+    }
+  }
+};
+export const DBFLoader = {
+  ...DBFWorkerLoader,
+  parse: async (arrayBuffer, options) => parseDBF(arrayBuffer, options),
+  parseSync: parseDBF,
+  parseInBatches: parseDBFInBatches
+};
+//# sourceMappingURL=dbf-loader.js.map

package/dist/esm/dbf-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbf-loader.js","names":["parseDBF","parseDBFInBatches","VERSION","DBFWorkerLoader","name","id","module","version","worker","category","extensions","mimeTypes","options","dbf","encoding","DBFLoader","parse","arrayBuffer","parseSync","parseInBatches"],"sources":["../../src/dbf-loader.ts"],"sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseDBF, parseDBFInBatches} from './lib/parsers/parse-dbf';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * DBFLoader - DBF files are used to contain non-geometry columns in Shapefiles\n */\nexport const DBFWorkerLoader: Loader = {\n  name: 'DBF',\n  id: 'dbf',\n  module: 'shapefile',\n  version: VERSION,\n  worker: true,\n  category: 'table',\n  extensions: ['dbf'],\n  mimeTypes: ['application/x-dbf'],\n  options: {\n    dbf: {\n      encoding: 'latin1'\n    }\n  }\n};\n\n/** DBF file loader */\nexport const DBFLoader: LoaderWithParser = {\n  ...DBFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseDBF(arrayBuffer, options),\n  parseSync: parseDBF,\n  parseInBatches: parseDBFInBatches\n};\n"],"mappings":"AACA,SAAQA,QAAQ,EAAEC,iBAAiB,QAAO,yBAAyB;AAInE,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAK3E,OAAO,MAAMC,eAAuB,GAAG;EACrCC,IAAI,EAAE,KAAK;EACXC,EAAE,EAAE,KAAK;EACTC,MAAM,EAAE,WAAW;EACnBC,OAAO,EAAEL,OAAO;EAChBM,MAAM,EAAE,IAAI;EACZC,QAAQ,EAAE,OAAO;EACjBC,UAAU,EAAE,CAAC,KAAK,CAAC;EACnBC,SAAS,EAAE,CAAC,mBAAmB,CAAC;EAChCC,OAAO,EAAE;IACPC,GAAG,EAAE;MACHC,QAAQ,EAAE;IACZ;EACF;AACF,CAAC;AAGD,OAAO,MAAMC,SAA2B,GAAG;EACzC,GAAGZ,eAAe;EAClBa,KAAK,EAAE,MAAAA,CAAOC,WAAW,EAAEL,OAAO,KAAKZ,QAAQ,CAACiB,WAAW,EAAEL,OAAO,CAAC;EACrEM,SAAS,EAAElB,QAAQ;EACnBmB,cAAc,EAAElB;AAClB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { ShapefileLoader } from './shapefile-loader';
+export { DBFLoader, DBFWorkerLoader } from './dbf-loader';
+export { SHPLoader, SHPWorkerLoader } from './shp-loader';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["ShapefileLoader","DBFLoader","DBFWorkerLoader","SHPLoader","SHPWorkerLoader"],"sources":["../../src/index.ts"],"sourcesContent":["export {ShapefileLoader} from './shapefile-loader';\nexport {DBFLoader, DBFWorkerLoader} from './dbf-loader';\nexport {SHPLoader, SHPWorkerLoader} from './shp-loader';\n"],"mappings":"AAAA,SAAQA,eAAe,QAAO,oBAAoB;AAClD,SAAQC,SAAS,EAAEC,eAAe,QAAO,cAAc;AACvD,SAAQC,SAAS,EAAEC,eAAe,QAAO,cAAc"}

package/dist/esm/lib/parsers/parse-dbf.js

@@ -0,0 +1,296 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import BinaryChunkReader from '../streaming/binary-chunk-reader';
+const LITTLE_ENDIAN = true;
+const DBF_HEADER_SIZE = 32;
+var STATE = function (STATE) {
+  STATE[STATE["START"] = 0] = "START";
+  STATE[STATE["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
+  STATE[STATE["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
+  STATE[STATE["END"] = 3] = "END";
+  STATE[STATE["ERROR"] = 4] = "ERROR";
+  return STATE;
+}(STATE || {});
+class DBFParser {
+  constructor(options) {
+    _defineProperty(this, "binaryReader", new BinaryChunkReader());
+    _defineProperty(this, "textDecoder", void 0);
+    _defineProperty(this, "state", STATE.START);
+    _defineProperty(this, "result", {
+      data: []
+    });
+    this.textDecoder = new TextDecoder(options.encoding);
+  }
+  write(arrayBuffer) {
+    this.binaryReader.write(arrayBuffer);
+    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
+  }
+  end() {
+    this.binaryReader.end();
+    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
+    if (this.state !== STATE.END) {
+      this.state = STATE.ERROR;
+      this.result.error = 'DBF incomplete file';
+    }
+  }
+}
+export function parseDBF(arrayBuffer) {
+  var _options$tables, _options$dbf;
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    encoding = 'latin1'
+  } = options.dbf || {};
+  const dbfParser = new DBFParser({
+    encoding
+  });
+  dbfParser.write(arrayBuffer);
+  dbfParser.end();
+  const {
+    data,
+    schema
+  } = dbfParser.result;
+  const shape = (options === null || options === void 0 ? void 0 : (_options$tables = options.tables) === null || _options$tables === void 0 ? void 0 : _options$tables.format) || (options === null || options === void 0 ? void 0 : (_options$dbf = options.dbf) === null || _options$dbf === void 0 ? void 0 : _options$dbf.shape);
+  switch (shape) {
+    case 'object-row-table':
+      {
+        const table = {
+          shape: 'object-row-table',
+          schema,
+          data
+        };
+        return table;
+      }
+    case 'table':
+      return {
+        schema,
+        rows: data
+      };
+    case 'rows':
+    default:
+      return data;
+  }
+}
+export function parseDBFInBatches(asyncIterator) {
+  try {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return async function* () {
+      const {
+        encoding = 'latin1'
+      } = options.dbf || {};
+      const parser = new DBFParser({
+        encoding
+      });
+      let headerReturned = false;
+      for await (const arrayBuffer of asyncIterator) {
+        parser.write(arrayBuffer);
+        if (!headerReturned && parser.result.dbfHeader) {
+          headerReturned = true;
+          yield parser.result.dbfHeader;
+        }
+        if (parser.result.data.length > 0) {
+          yield parser.result.data;
+          parser.result.data = [];
+        }
+      }
+      parser.end();
+      if (parser.result.data.length > 0) {
+        yield parser.result.data;
+      }
+    }();
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+function parseState(state, result, binaryReader, textDecoder) {
+  while (true) {
+    try {
+      switch (state) {
+        case STATE.ERROR:
+        case STATE.END:
+          return state;
+        case STATE.START:
+          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
+          if (!dataView) {
+            return state;
+          }
+          result.dbfHeader = parseDBFHeader(dataView);
+          result.progress = {
+            bytesUsed: 0,
+            rowsTotal: result.dbfHeader.nRecords,
+            rows: 0
+          };
+          state = STATE.FIELD_DESCRIPTORS;
+          break;
+        case STATE.FIELD_DESCRIPTORS:
+          const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE);
+          if (!fieldDescriptorView) {
+            return state;
+          }
+          result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
+          result.schema = {
+            fields: result.dbfFields.map(dbfField => makeField(dbfField)),
+            metadata: {}
+          };
+          state = STATE.FIELD_PROPERTIES;
+          binaryReader.skip(1);
+          break;
+        case STATE.FIELD_PROPERTIES:
+          const {
+            recordLength = 0,
+            nRecords = 0
+          } = (result === null || result === void 0 ? void 0 : result.dbfHeader) || {};
+          while (result.data.length < nRecords) {
+            const recordView = binaryReader.getDataView(recordLength - 1);
+            if (!recordView) {
+              return state;
+            }
+            binaryReader.skip(1);
+            const row = parseRow(recordView, result.dbfFields, textDecoder);
+            result.data.push(row);
+            result.progress.rows = result.data.length;
+          }
+          state = STATE.END;
+          break;
+        default:
+          state = STATE.ERROR;
+          result.error = "illegal parser state ".concat(state);
+          return state;
+      }
+    } catch (error) {
+      state = STATE.ERROR;
+      result.error = "DBF parsing failed: ".concat(error.message);
+      return state;
+    }
+  }
+}
+function parseDBFHeader(headerView) {
+  return {
+    year: headerView.getUint8(1) + 1900,
+    month: headerView.getUint8(2),
+    day: headerView.getUint8(3),
+    nRecords: headerView.getUint32(4, LITTLE_ENDIAN),
+    headerLength: headerView.getUint16(8, LITTLE_ENDIAN),
+    recordLength: headerView.getUint16(10, LITTLE_ENDIAN),
+    languageDriver: headerView.getUint8(29)
+  };
+}
+function parseFieldDescriptors(view, textDecoder) {
+  const nFields = (view.byteLength - 1) / 32;
+  const fields = [];
+  let offset = 0;
+  for (let i = 0; i < nFields; i++) {
+    const name = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11)).replace(/\u0000/g, '');
+    fields.push({
+      name,
+      dataType: String.fromCharCode(view.getUint8(offset + 11)),
+      fieldLength: view.getUint8(offset + 16),
+      decimal: view.getUint8(offset + 17)
+    });
+    offset += 32;
+  }
+  return fields;
+}
+function parseRow(view, fields, textDecoder) {
+  const out = {};
+  let offset = 0;
+  for (const field of fields) {
+    const text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));
+    out[field.name] = parseField(text, field.dataType);
+    offset += field.fieldLength;
+  }
+  return out;
+}
+function parseField(text, dataType) {
+  switch (dataType) {
+    case 'B':
+      return parseNumber(text);
+    case 'C':
+      return parseCharacter(text);
+    case 'F':
+      return parseNumber(text);
+    case 'N':
+      return parseNumber(text);
+    case 'O':
+      return parseNumber(text);
+    case 'D':
+      return parseDate(text);
+    case 'L':
+      return parseBoolean(text);
+    default:
+      throw new Error('Unsupported data type');
+  }
+}
+function parseDate(str) {
+  return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));
+}
+function parseBoolean(value) {
+  return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;
+}
+function parseNumber(text) {
+  const number = parseFloat(text);
+  return isNaN(number) ? null : number;
+}
+function parseCharacter(text) {
+  return text.trim() || null;
+}
+function makeField(_ref) {
+  let {
+    name,
+    dataType,
+    fieldLength,
+    decimal
+  } = _ref;
+  switch (dataType) {
+    case 'B':
+      return {
+        name,
+        type: 'float64',
+        nullable: true,
+        metadata: {}
+      };
+    case 'C':
+      return {
+        name,
+        type: 'utf8',
+        nullable: true,
+        metadata: {}
+      };
+    case 'F':
+      return {
+        name,
+        type: 'float64',
+        nullable: true,
+        metadata: {}
+      };
+    case 'N':
+      return {
+        name,
+        type: 'float64',
+        nullable: true,
+        metadata: {}
+      };
+    case 'O':
+      return {
+        name,
+        type: 'float64',
+        nullable: true,
+        metadata: {}
+      };
+    case 'D':
+      return {
+        name,
+        type: 'timestamp-millisecond',
+        nullable: true,
+        metadata: {}
+      };
+    case 'L':
+      return {
+        name,
+        type: 'bool',
+        nullable: true,
+        metadata: {}
+      };
+    default:
+      throw new Error('Unsupported data type');
+  }
+}
+//# sourceMappingURL=parse-dbf.js.map