@loaders.gl/shapefile 4.2.0-alpha.4 → 4.2.0-alpha.6

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

@@ -1,50 +1,66 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Zip two iterators together
+ *
+ * @param iterator1
+ * @param iterator2
+ */
 export async function* zipBatchIterators(iterator1, iterator2, shape) {
-  const batch1Data = [];
-  const batch2Data = [];
-  let iterator1Done = false;
-  let iterator2Done = false;
-  while (!iterator1Done && !iterator2Done) {
-    if (batch1Data.length === 0 && !iterator1Done) {
-      const {
-        value,
-        done
-      } = await iterator1.next();
-      if (done) {
-        iterator1Done = true;
-      } else {
-        batch1Data.push(...value);
-      }
+    const batch1Data = [];
+    const batch2Data = [];
+    let iterator1Done = false;
+    let iterator2Done = false;
+    // TODO - one could let all iterators flow at full speed using `Promise.race`
+    // however we might end up with a big temporary buffer
+    while (!iterator1Done && !iterator2Done) {
+        if (batch1Data.length === 0 && !iterator1Done) {
+            const { value, done } = await iterator1.next();
+            if (done) {
+                iterator1Done = true;
+            }
+            else {
+                // @ts-expect-error
+                batch1Data.push(...value);
+            }
+        }
+        if (batch2Data.length === 0 && !iterator2Done) {
+            const { value, done } = await iterator2.next();
+            if (done) {
+                iterator2Done = true;
+            }
+            else {
+                batch2Data.push(...value);
+            }
+        }
+        const batchData = extractBatchData(batch1Data, batch2Data);
+        if (batchData) {
+            yield {
+                batchType: 'data',
+                shape,
+                length: batchData.length,
+                data: batchData
+            };
+        }
     }
-    if (batch2Data.length === 0 && !iterator2Done) {
-      const {
-        value,
-        done
-      } = await iterator2.next();
-      if (done) {
-        iterator2Done = true;
-      } else {
-        batch2Data.push(...value);
-      }
-    }
-    const batchData = extractBatchData(batch1Data, batch2Data);
-    if (batchData) {
-      yield {
-        batchType: 'data',
-        shape,
-        length: batchData.length,
-        data: batchData
-      };
-    }
-  }
 }
+/**
+ * Extract batch of same length from two batches
+ *
+ * @param batch1
+ * @param batch2
+ * @return array | null
+ */
 function extractBatchData(batch1, batch2) {
-  const batchLength = Math.min(batch1.length, batch2.length);
-  if (batchLength === 0) {
-    return null;
-  }
-  const batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
-  batch1.splice(0, batchLength);
-  batch2.splice(0, batchLength);
-  return batch;
+    const batchLength = Math.min(batch1.length, batch2.length);
+    if (batchLength === 0) {
+        return null;
+    }
+    // Non interleaved arrays
+    const batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
+    // Modify the 2 batches
+    batch1.splice(0, batchLength);
+    batch2.splice(0, batchLength);
+    return batch;
 }
-//# sourceMappingURL=zip-batch-iterators.js.map

package/dist/shapefile-loader.js

@@ -1,24 +1,31 @@
 import { SHP_MAGIC_NUMBER } from "./shp-loader.js";
 import { parseShapefile, parseShapefileInBatches } from "./lib/parsers/parse-shapefile.js";
-const VERSION = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : 'latest';
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof "4.2.0-alpha.5" !== 'undefined' ? "4.2.0-alpha.5" : 'latest';
+/**
+ * Shapefile loader
+ * @note Shapefile is multifile format and requires providing additional files
+ */
 export const ShapefileLoader = {
-  name: 'Shapefile',
-  id: 'shapefile',
-  module: 'shapefile',
-  version: VERSION,
-  category: 'geometry',
-  extensions: ['shp'],
-  mimeTypes: ['application/octet-stream'],
-  tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],
-  options: {
-    shapefile: {
-      shape: 'v3'
+    name: 'Shapefile',
+    id: 'shapefile',
+    module: 'shapefile',
+    version: VERSION,
+    category: 'geometry',
+    extensions: ['shp'],
+    mimeTypes: ['application/octet-stream'],
+    tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],
+    options: {
+        shapefile: {
+            shape: 'v3'
+        },
+        shp: {
+            _maxDimensions: 4
+        }
     },
-    shp: {
-      _maxDimensions: 4
-    }
-  },
-  parse: parseShapefile,
-  parseInBatches: parseShapefileInBatches
+    // @ts-expect-error
+    parse: parseShapefile,
+    // @ts-expect-error
+    parseInBatches: parseShapefileInBatches
 };
-//# sourceMappingURL=shapefile-loader.js.map

package/dist/shp-loader.js

@@ -1,26 +1,32 @@
 import { parseSHP, parseSHPInBatches } from "./lib/parsers/parse-shp.js";
-const VERSION = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : 'latest';
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof "4.2.0-alpha.5" !== 'undefined' ? "4.2.0-alpha.5" : 'latest';
 export const SHP_MAGIC_NUMBER = [0x00, 0x00, 0x27, 0x0a];
+/**
+ * SHP file loader
+ */
 export const 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
+    name: 'SHP',
+    id: 'shp',
+    module: 'shapefile',
+    version: VERSION,
+    worker: true,
+    category: 'geometry',
+    extensions: ['shp'],
+    mimeTypes: ['application/octet-stream'],
+    // ISSUE: This also identifies SHX files, which are identical to SHP for the first 100 bytes...
+    tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],
+    options: {
+        shp: {
+            _maxDimensions: 4
+        }
     }
-  }
 };
+/** SHP file loader */
 export const SHPLoader = {
-  ...SHPWorkerLoader,
-  parse: async (arrayBuffer, options) => parseSHP(arrayBuffer, options),
-  parseSync: parseSHP,
-  parseInBatches: (arrayBufferIterator, options) => parseSHPInBatches(arrayBufferIterator, options)
+    ...SHPWorkerLoader,
+    parse: async (arrayBuffer, options) => parseSHP(arrayBuffer, options),
+    parseSync: parseSHP,
+    parseInBatches: (arrayBufferIterator, options) => parseSHPInBatches(arrayBufferIterator, options)
 };
-//# sourceMappingURL=shp-loader.js.map

package/dist/shp-worker.js

@@ -2,6 +2,10 @@
 (() => {
   // src/lib/streaming/binary-chunk-reader.ts
   var BinaryChunkReader = class {
+    offset;
+    arrayBuffers;
+    ended;
+    maxRewindBytes;
     constructor(options) {
       const { maxRewindBytes = 0 } = options || {};
       this.offset = 0;
@@ -359,21 +363,21 @@
     ERROR: 3
   };
   var SHPParser = class {
+    options = {};
+    binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
+    state = STATE.EXPECTING_HEADER;
+    result = {
+      geometries: [],
+      // Initialize with number values to make TS happy
+      // These are initialized for real in STATE.EXPECTING_HEADER
+      progress: {
+        bytesTotal: NaN,
+        bytesUsed: NaN,
+        rows: NaN
+      },
+      currentIndex: NaN
+    };
     constructor(options) {
-      this.options = {};
-      this.binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
-      this.state = STATE.EXPECTING_HEADER;
-      this.result = {
-        geometries: [],
-        // Initialize with number values to make TS happy
-        // These are initialized for real in STATE.EXPECTING_HEADER
-        progress: {
-          bytesTotal: NaN,
-          bytesUsed: NaN,
-          rows: NaN
-        },
-        currentIndex: NaN
-      };
       this.options = options;
     }
     write(arrayBuffer) {
@@ -480,7 +484,7 @@
   }
 
   // src/shp-loader.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = true ? "4.2.0-alpha.5" : "latest";
   var SHP_MAGIC_NUMBER2 = [0, 0, 39, 10];
   var SHPWorkerLoader = {
     name: "SHP",
@@ -565,7 +569,9 @@
       }
       getParentPort().then((parentPort2) => {
         if (parentPort2) {
-          parentPort2.on("message", handleMessage);
+          parentPort2.on("message", (message) => {
+            handleMessage(message);
+          });
           parentPort2.on("exit", () => console.debug("Node worker closing"));
         } else {
           globalThis.onmessage = handleMessage;

package/dist/workers/dbf-worker.js

@@ -1,4 +1,3 @@
 import { DBFLoader } from "../dbf-loader.js";
 import { createLoaderWorker } from '@loaders.gl/loader-utils';
 createLoaderWorker(DBFLoader);
-//# sourceMappingURL=dbf-worker.js.map

package/dist/workers/shp-worker.js

@@ -1,4 +1,3 @@
 import { SHPLoader } from "../shp-loader.js";
 import { createLoaderWorker } from '@loaders.gl/loader-utils';
 createLoaderWorker(SHPLoader);
-//# sourceMappingURL=shp-worker.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/shapefile",
   "description": "Loader for the Shapefile Format",
-  "version": "4.2.0-alpha.4",
+  "version": "4.2.0-alpha.6",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -38,16 +38,20 @@
     "README.md"
   ],
   "scripts": {
-    "pre-build": "npm run build-worker-shp && npm run build-worker-dbf && npm run build-bundle && npm run build-bundle -- --env=dev",
-    "build-bundle": "ocular-bundle ./src/index.ts",
+    "pre-build": "npm run build-worker-shp && npm run build-worker-dbf && 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",
     "build-worker-shp": "esbuild src/workers/shp-worker.ts --bundle --outfile=dist/shp-worker.js --define:__VERSION__=\\\"$npm_package_version\\\"",
     "build-worker-dbf": "esbuild src/workers/dbf-worker.ts --bundle --outfile=dist/dbf-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.2.0-alpha.4",
-    "@loaders.gl/loader-utils": "4.2.0-alpha.4",
-    "@loaders.gl/schema": "4.2.0-alpha.4",
+    "@loaders.gl/gis": "4.2.0-alpha.6",
+    "@loaders.gl/loader-utils": "4.2.0-alpha.6",
+    "@loaders.gl/schema": "4.2.0-alpha.6",
     "@math.gl/proj4": "^4.0.0"
   },
-  "gitHead": "6c52dee5c3f005648a394cc4aee7fc37005c8e83"
+  "peerDependencies": {
+    "@loaders.gl/core": "^4.0.0"
+  },
+  "gitHead": "37bd8ca71763529f18727ee4bf29dd176aa914ca"
 }

package/dist/dbf-loader.js.map

@@ -1 +0,0 @@
-{"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","arrayBufferIterator"],"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(arrayBufferIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options) {\n    return parseDBFInBatches(arrayBufferIterator, options);\n  }\n};\n"],"mappings":"SACQA,QAAQ,EAAEC,iBAAiB;AAInC,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,cAAcA,CAACC,mBAAuE,EAAER,OAAO,EAAE;IAC/F,OAAOX,iBAAiB,CAACmB,mBAAmB,EAAER,OAAO,CAAC;EACxD;AACF,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["ShapefileLoader","DBFLoader","DBFWorkerLoader","SHPLoader","SHPWorkerLoader","BinaryReader","_BinaryReader","BinaryChunkReader","_BinaryChunkReader","zipBatchIterators","_zipBatchIterators"],"sources":["../src/index.ts"],"sourcesContent":["export {ShapefileLoader} from './shapefile-loader';\nexport {DBFLoader, DBFWorkerLoader} from './dbf-loader';\nexport {SHPLoader, SHPWorkerLoader} from './shp-loader';\n\n// EXPERIMENTAL\nexport {BinaryReader as _BinaryReader} from './lib/streaming/binary-reader';\nexport {BinaryChunkReader as _BinaryChunkReader} from './lib/streaming/binary-chunk-reader';\nexport {zipBatchIterators as _zipBatchIterators} from './lib/streaming/zip-batch-iterators';\n"],"mappings":"SAAQA,eAAe;AAAA,SACfC,SAAS,EAAEC,eAAe;AAAA,SAC1BC,SAAS,EAAEC,eAAe;AAAA,SAG1BC,YAAY,IAAIC,aAAa;AAAA,SAC7BC,iBAAiB,IAAIC,kBAAkB;AAAA,SACvCC,iBAAiB,IAAIC,kBAAkB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"parse-dbf.js","names":["BinaryChunkReader","LITTLE_ENDIAN","DBF_HEADER_SIZE","STATE","DBFParser","constructor","options","binaryReader","textDecoder","state","START","result","data","TextDecoder","encoding","write","arrayBuffer","parseState","end","END","ERROR","error","parseDBF","_options$dbf","arguments","length","undefined","dbf","dbfParser","schema","shape","table","rows","parseDBFInBatches","asyncIterator","parser","headerReturned","dbfHeader","e","Promise","reject","dataView","getDataView","parseDBFHeader","progress","bytesUsed","rowsTotal","nRecords","FIELD_DESCRIPTORS","fieldDescriptorView","headerLength","dbfFields","parseFieldDescriptors","fields","map","dbfField","makeField","metadata","FIELD_PROPERTIES","skip","recordLength","recordView","row","parseRow","push","message","headerView","year","getUint8","month","day","getUint32","getUint16","languageDriver","view","nFields","byteLength","offset","i","name","decode","Uint8Array","buffer","byteOffset","replace","dataType","String","fromCharCode","fieldLength","decimal","out","field","text","parseField","parseNumber","parseCharacter","parseDate","parseBoolean","Error","str","Date","UTC","slice","parseInt","value","test","number","parseFloat","isNaN","trim","_ref","type","nullable"],"sources":["../../../src/lib/parsers/parse-dbf.ts"],"sourcesContent":["import {Field, ObjectRowTable} from '@loaders.gl/schema';\nimport {BinaryChunkReader} from '../streaming/binary-chunk-reader';\nimport {\n  DBFLoaderOptions,\n  DBFResult,\n  DBFTableOutput,\n  DBFHeader,\n  DBFRowsOutput,\n  DBFField\n} from './types';\n\nconst LITTLE_ENDIAN = true;\nconst DBF_HEADER_SIZE = 32;\n\nenum STATE {\n  START = 0, // Expecting header\n  FIELD_DESCRIPTORS = 1,\n  FIELD_PROPERTIES = 2,\n  END = 3,\n  ERROR = 4\n}\n\nclass DBFParser {\n  binaryReader = new BinaryChunkReader();\n  textDecoder: TextDecoder;\n  state = STATE.START;\n  result: DBFResult = {\n    data: []\n  };\n\n  constructor(options: {encoding: string}) {\n    this.textDecoder = new TextDecoder(options.encoding);\n  }\n\n  /**\n   * @param arrayBuffer\n   */\n  write(arrayBuffer: ArrayBuffer): void {\n    this.binaryReader.write(arrayBuffer);\n    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);\n    // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();\n\n    // important events:\n    // - schema available\n    // - first rows available\n    // - all rows available\n  }\n\n  end(): void {\n    this.binaryReader.end();\n    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);\n    // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();\n    if (this.state !== STATE.END) {\n      this.state = STATE.ERROR;\n      this.result.error = 'DBF incomplete file';\n    }\n  }\n}\n\n/**\n * @param arrayBuffer\n * @param options\n * @returns DBFTable or rows\n */\nexport function parseDBF(\n  arrayBuffer: ArrayBuffer,\n  options: DBFLoaderOptions = {}\n): DBFRowsOutput | DBFTableOutput | ObjectRowTable {\n  const {encoding = 'latin1'} = options.dbf || {};\n\n  const dbfParser = new DBFParser({encoding});\n  dbfParser.write(arrayBuffer);\n  dbfParser.end();\n\n  const {data, schema} = dbfParser.result;\n  const shape = options?.dbf?.shape;\n  switch (shape) {\n    case 'object-row-table': {\n      const table: ObjectRowTable = {\n        shape: 'object-row-table',\n        schema,\n        data\n      };\n      return table;\n    }\n    case 'table':\n      return {schema, rows: data};\n    case 'rows':\n    default:\n      return data;\n  }\n}\n/**\n * @param asyncIterator\n * @param options\n */\nexport async function* parseDBFInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: DBFLoaderOptions = {}\n): AsyncIterable<DBFHeader | DBFRowsOutput | DBFTableOutput> {\n  const {encoding = 'latin1'} = options.dbf || {};\n\n  const parser = new DBFParser({encoding});\n  let headerReturned = false;\n  for await (const arrayBuffer of asyncIterator) {\n    parser.write(arrayBuffer);\n    if (!headerReturned && parser.result.dbfHeader) {\n      headerReturned = true;\n      yield parser.result.dbfHeader;\n    }\n\n    if (parser.result.data.length > 0) {\n      yield parser.result.data;\n      parser.result.data = [];\n    }\n  }\n  parser.end();\n  if (parser.result.data.length > 0) {\n    yield parser.result.data;\n  }\n}\n/**\n * https://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm\n * @param state\n * @param result\n * @param binaryReader\n * @param textDecoder\n * @returns\n */\n/* eslint-disable complexity, max-depth */\nfunction parseState(\n  state: STATE,\n  result: DBFResult,\n  binaryReader: BinaryChunkReader,\n  textDecoder: TextDecoder\n): STATE {\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    try {\n      switch (state) {\n        case STATE.ERROR:\n        case STATE.END:\n          return state;\n\n        case STATE.START:\n          // Parse initial file header\n          // DBF Header\n          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);\n          if (!dataView) {\n            return state;\n          }\n          result.dbfHeader = parseDBFHeader(dataView);\n          result.progress = {\n            bytesUsed: 0,\n            rowsTotal: result.dbfHeader.nRecords,\n            rows: 0\n          };\n          state = STATE.FIELD_DESCRIPTORS;\n          break;\n\n        case STATE.FIELD_DESCRIPTORS:\n          // Parse DBF field descriptors (schema)\n          const fieldDescriptorView = binaryReader.getDataView(\n            // @ts-ignore\n            result.dbfHeader.headerLength - DBF_HEADER_SIZE\n          );\n          if (!fieldDescriptorView) {\n            return state;\n          }\n\n          result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);\n          result.schema = {\n            fields: result.dbfFields.map((dbfField) => makeField(dbfField)),\n            metadata: {}\n          };\n\n          state = STATE.FIELD_PROPERTIES;\n\n          // TODO(kyle) Not exactly sure why start offset needs to be headerLength + 1?\n          // parsedbf uses ((fields.length + 1) << 5) + 2;\n          binaryReader.skip(1);\n          break;\n\n        case STATE.FIELD_PROPERTIES:\n          const {recordLength = 0, nRecords = 0} = result?.dbfHeader || {};\n          while (result.data.length < nRecords) {\n            const recordView = binaryReader.getDataView(recordLength - 1);\n            if (!recordView) {\n              return state;\n            }\n            // Note: Avoid actually reading the last byte, which may not be present\n            binaryReader.skip(1);\n\n            // @ts-ignore\n            const row = parseRow(recordView, result.dbfFields, textDecoder);\n            result.data.push(row);\n            // @ts-ignore\n            result.progress.rows = result.data.length;\n          }\n          state = STATE.END;\n          break;\n\n        default:\n          state = STATE.ERROR;\n          result.error = `illegal parser state ${state}`;\n          return state;\n      }\n    } catch (error) {\n      state = STATE.ERROR;\n      result.error = `DBF parsing failed: ${(error as Error).message}`;\n      return state;\n    }\n  }\n}\n\n/**\n * @param headerView\n */\nfunction parseDBFHeader(headerView: DataView): DBFHeader {\n  return {\n    // Last updated date\n    year: headerView.getUint8(1) + 1900,\n    month: headerView.getUint8(2),\n    day: headerView.getUint8(3),\n    // Number of records in data file\n    nRecords: headerView.getUint32(4, LITTLE_ENDIAN),\n    // Length of header in bytes\n    headerLength: headerView.getUint16(8, LITTLE_ENDIAN),\n    // Length of each record\n    recordLength: headerView.getUint16(10, LITTLE_ENDIAN),\n    // Not sure if this is usually set\n    languageDriver: headerView.getUint8(29)\n  };\n}\n\n/**\n * @param view\n */\nfunction parseFieldDescriptors(view: DataView, textDecoder: TextDecoder): DBFField[] {\n  // NOTE: this might overestimate the number of fields if the \"Database\n  // Container\" container exists and is included in the headerLength\n  const nFields = (view.byteLength - 1) / 32;\n  const fields: DBFField[] = [];\n  let offset = 0;\n  for (let i = 0; i < nFields; i++) {\n    const name = textDecoder\n      .decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11))\n      // eslint-disable-next-line no-control-regex\n      .replace(/\\u0000/g, '');\n\n    fields.push({\n      name,\n      dataType: String.fromCharCode(view.getUint8(offset + 11)),\n      fieldLength: view.getUint8(offset + 16),\n      decimal: view.getUint8(offset + 17)\n    });\n    offset += 32;\n  }\n  return fields;\n}\n\n/*\n * @param {BinaryChunkReader} binaryReader\nfunction parseRows(binaryReader, fields, nRecords, recordLength, textDecoder) {\n  const rows = [];\n  for (let i = 0; i < nRecords; i++) {\n    const recordView = binaryReader.getDataView(recordLength - 1);\n    binaryReader.skip(1);\n    // @ts-ignore\n    rows.push(parseRow(recordView, fields, textDecoder));\n  }\n  return rows;\n}\n */\n\n/**\n *\n * @param view\n * @param fields\n * @param textDecoder\n * @returns\n */\nfunction parseRow(\n  view: DataView,\n  fields: DBFField[],\n  textDecoder: TextDecoder\n): {[key: string]: any} {\n  const out: {[key: string]: string | number | boolean | null} = {};\n  let offset = 0;\n  for (const field of fields) {\n    const text = textDecoder.decode(\n      new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength)\n    );\n    out[field.name] = parseField(text, field.dataType);\n    offset += field.fieldLength;\n  }\n\n  return out;\n}\n\n/**\n * Should NaN be coerced to null?\n * @param text\n * @param dataType\n * @returns Field depends on a type of the data\n */\nfunction parseField(text: string, dataType: string): string | number | boolean | null {\n  switch (dataType) {\n    case 'B':\n      return parseNumber(text);\n    case 'C':\n      return parseCharacter(text);\n    case 'F':\n      return parseNumber(text);\n    case 'N':\n      return parseNumber(text);\n    case 'O':\n      return parseNumber(text);\n    case 'D':\n      return parseDate(text);\n    case 'L':\n      return parseBoolean(text);\n    default:\n      throw new Error('Unsupported data type');\n  }\n}\n\n/**\n * Parse YYYYMMDD to date in milliseconds\n * @param str YYYYMMDD\n * @returns new Date as a number\n */\nfunction parseDate(str: any): number {\n  return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));\n}\n\n/**\n * Read boolean value\n * any of Y, y, T, t coerce to true\n * any of N, n, F, f coerce to false\n * otherwise null\n * @param value\n * @returns boolean | null\n */\nfunction parseBoolean(value: string): boolean | null {\n  return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;\n}\n\n/**\n * Return null instead of NaN\n * @param text\n * @returns number | null\n */\nfunction parseNumber(text: string): number | null {\n  const number = parseFloat(text);\n  return isNaN(number) ? null : number;\n}\n\n/**\n *\n * @param text\n * @returns string | null\n */\nfunction parseCharacter(text: string): string | null {\n  return text.trim() || null;\n}\n\n/**\n * Create a standard Arrow-style `Field` from field descriptor.\n * TODO - use `fieldLength` and `decimal` to generate smaller types?\n * @param param0\n * @returns Field\n */\n// eslint-disable\nfunction makeField({name, dataType, fieldLength, decimal}: DBFField): Field {\n  switch (dataType) {\n    case 'B':\n      return {name, type: 'float64', nullable: true, metadata: {}};\n    case 'C':\n      return {name, type: 'utf8', nullable: true, metadata: {}};\n    case 'F':\n      return {name, type: 'float64', nullable: true, metadata: {}};\n    case 'N':\n      return {name, type: 'float64', nullable: true, metadata: {}};\n    case 'O':\n      return {name, type: 'float64', nullable: true, metadata: {}};\n    case 'D':\n      return {name, type: 'timestamp-millisecond', nullable: true, metadata: {}};\n    case 'L':\n      return {name, type: 'bool', nullable: true, metadata: {}};\n    default:\n      throw new Error('Unsupported data type');\n  }\n}\n"],"mappings":"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"}

package/dist/lib/parsers/parse-shapefile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-shapefile.js","names":["parseInBatchesFromContext","parseFromContext","binaryToGeometry","transformGeoJsonCoords","Proj4Projection","parseShx","zipBatchIterators","SHPLoader","DBFLoader","parseShapefileInBatches","asyncIterator","options","context","_shapeIterable$Symbol","_shapeIterable$Symbol2","reproject","_targetCrs","gis","shx","cpg","prj","loadShapefileSidecarFiles","shapeIterable","shapeIterator","Symbol","call","iterator","propertyIterator","dbfResponse","fetch","replaceExtension","url","ok","_propertyIterable$Sym","propertyIterable","dbf","encoding","shapeHeader","next","value","batchType","dbfHeader","zippedIterator","zippedBatchIterable","batch","geometries","properties","data","geojsonGeometries","parseGeometries","features","joinProperties","reprojectFeatures","header","parseShapefile","arrayBuffer","_propertyTable","_options$shapefile","_propertyTable2","propertyTable","shape","shapefile","type","schema","metadata","fields","geom","push","i","length","geometry","feature","sourceCrs","targetCrs","projection","from","to","coord","project","shxPromise","cpgPromise","prjPromise","Promise","all","shxResponse","cpgResponse","text","prjResponse","newExtension","baseName","basename","extension","extname","isUpperCase","toUpperCase","extIndex","lastIndexOf","substr"],"sources":["../../../src/lib/parsers/parse-shapefile.ts"],"sourcesContent":["// import type {Feature} from '@loaders.gl/gis';\nimport {LoaderContext, parseInBatchesFromContext, parseFromContext} from '@loaders.gl/loader-utils';\nimport {binaryToGeometry, transformGeoJsonCoords} from '@loaders.gl/gis';\nimport type {\n  BinaryGeometry,\n  Geometry,\n  ObjectRowTable,\n  ObjectRowTableBatch\n} from '@loaders.gl/schema';\nimport {Proj4Projection} from '@math.gl/proj4';\n\nimport type {SHXOutput} from './parse-shx';\nimport type {SHPHeader} from './parse-shp-header';\nimport type {ShapefileLoaderOptions} from './types';\nimport {parseShx} from './parse-shx';\nimport {zipBatchIterators} from '../streaming/zip-batch-iterators';\nimport {SHPLoader} from '../../shp-loader';\nimport {DBFLoader} from '../../dbf-loader';\n\ntype Feature = any;\ninterface ShapefileOutput {\n  encoding?: string;\n  prj?: string;\n  shx?: SHXOutput;\n  header: SHPHeader;\n  data: object[];\n}\n/**\n * Parsing of file in batches\n */\n// eslint-disable-next-line max-statements, complexity\nexport async function* parseShapefileInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: ShapefileLoaderOptions,\n  context?: LoaderContext\n): AsyncIterable<ShapefileOutput> {\n  const {reproject = false, _targetCrs = 'WGS84'} = options?.gis || {};\n  const {shx, cpg, prj} = await loadShapefileSidecarFiles(options, context);\n\n  // parse geometries\n  const shapeIterable = await parseInBatchesFromContext(\n    asyncIterator,\n    SHPLoader,\n    options,\n    context!\n  );\n\n  const shapeIterator: AsyncIterator<any> =\n    shapeIterable[Symbol.asyncIterator]?.() || shapeIterable[Symbol.iterator]?.();\n\n  // parse properties\n  let propertyIterator: AsyncIterator<any> | null = null;\n  const dbfResponse = await context?.fetch(replaceExtension(context?.url || '', 'dbf'));\n  if (dbfResponse?.ok) {\n    const propertyIterable = await parseInBatchesFromContext(\n      dbfResponse,\n      DBFLoader,\n      {\n        ...options,\n        dbf: {encoding: cpg || 'latin1'}\n      },\n      context!\n    );\n    propertyIterator =\n      propertyIterable[Symbol.asyncIterator]?.() || propertyIterable[Symbol.iterator]();\n  }\n\n  // When `options.metadata` is `true`, there's an extra initial `metadata`\n  // object before the iterator starts. zipBatchIterators expects to receive\n  // batches of Array objects, and will fail with non-iterable batches, so it's\n  // important to skip over the first batch.\n  let shapeHeader = (await shapeIterator.next()).value;\n  if (shapeHeader && shapeHeader.batchType === 'metadata') {\n    shapeHeader = (await shapeIterator.next()).value;\n  }\n\n  let dbfHeader: {batchType?: string} = {};\n  if (propertyIterator) {\n    dbfHeader = (await propertyIterator.next()).value;\n    if (dbfHeader && dbfHeader.batchType === 'metadata') {\n      dbfHeader = (await propertyIterator.next()).value;\n    }\n  }\n\n  const zippedIterator: AsyncIterator<ObjectRowTableBatch> = propertyIterator\n    ? zipBatchIterators(shapeIterator, propertyIterator, 'object-row-table')\n    : shapeIterator;\n\n  const zippedBatchIterable: AsyncIterable<ObjectRowTableBatch> = {\n    [Symbol.asyncIterator]() {\n      return zippedIterator;\n    }\n  };\n\n  for await (const batch of zippedBatchIterable) {\n    let geometries: any;\n    let properties: any;\n    if (!propertyIterator) {\n      geometries = batch;\n    } else {\n      [geometries, properties] = batch.data;\n    }\n\n    const geojsonGeometries = parseGeometries(geometries);\n    let features = joinProperties(geojsonGeometries, properties);\n    if (reproject) {\n      // @ts-ignore\n      features = reprojectFeatures(features, prj, _targetCrs);\n    }\n    yield {\n      encoding: cpg,\n      prj,\n      shx,\n      header: shapeHeader,\n      data: features\n    };\n  }\n}\n\n/**\n * Parse shapefile\n *\n * @param arrayBuffer\n * @param options\n * @param context\n * @returns output of shapefile\n */\nexport async function parseShapefile(\n  arrayBuffer: ArrayBuffer,\n  options?: ShapefileLoaderOptions,\n  context?: LoaderContext\n): Promise<ShapefileOutput> {\n  const {reproject = false, _targetCrs = 'WGS84'} = options?.gis || {};\n  const {shx, cpg, prj} = await loadShapefileSidecarFiles(options, context);\n\n  // parse geometries\n  const {header, geometries} = await parseFromContext(arrayBuffer, SHPLoader, options, context!); // {shp: shx}\n\n  const geojsonGeometries = parseGeometries(geometries);\n\n  // parse properties\n  let propertyTable: ObjectRowTable | undefined;\n\n  const dbfResponse = await context?.fetch(replaceExtension(context?.url!, 'dbf'));\n  if (dbfResponse?.ok) {\n    propertyTable = await parseFromContext(\n      dbfResponse as any,\n      DBFLoader,\n      {dbf: {shape: 'object-row-table', encoding: cpg || 'latin1'}},\n      context!\n    );\n  }\n\n  let features = joinProperties(geojsonGeometries, propertyTable?.data || []);\n  if (reproject) {\n    features = reprojectFeatures(features, prj, _targetCrs);\n  }\n\n  switch (options?.shapefile?.shape) {\n    case 'geojson-table':\n      return {\n        // @ts-expect-error\n        shape: 'geojson-table',\n        type: 'FeatureCollection',\n        encoding: cpg,\n        schema: propertyTable?.schema || {metadata: {}, fields: []},\n        prj,\n        shx,\n        header,\n        features\n      };\n    default:\n      return {\n        encoding: cpg,\n        prj,\n        shx,\n        header,\n        data: features\n      };\n  }\n}\n\n/**\n * Parse geometries\n *\n * @param geometries\n * @returns geometries as an array\n */\nfunction parseGeometries(geometries: BinaryGeometry[]): Geometry[] {\n  const geojsonGeometries: any[] = [];\n  for (const geom of geometries) {\n    geojsonGeometries.push(binaryToGeometry(geom));\n  }\n  return geojsonGeometries;\n}\n\n/**\n * Join properties and geometries into features\n *\n * @param geometries [description]\n * @param  properties [description]\n * @return [description]\n */\nfunction joinProperties(geometries: Geometry[], properties: object[]): Feature[] {\n  const features: Feature[] = [];\n  for (let i = 0; i < geometries.length; i++) {\n    const geometry = geometries[i];\n    const feature: Feature = {\n      type: 'Feature',\n      geometry,\n      // properties can be undefined if dbfResponse above was empty\n      properties: (properties && properties[i]) || {}\n    };\n    features.push(feature);\n  }\n\n  return features;\n}\n\n/**\n * Reproject GeoJSON features to output CRS\n *\n * @param features parsed GeoJSON features\n * @param sourceCrs source coordinate reference system\n * @param targetCrs †arget coordinate reference system\n * @return Reprojected Features\n */\nfunction reprojectFeatures(features: Feature[], sourceCrs?: string, targetCrs?: string): Feature[] {\n  if (!sourceCrs && !targetCrs) {\n    return features;\n  }\n\n  const projection = new Proj4Projection({from: sourceCrs || 'WGS84', to: targetCrs || 'WGS84'});\n  return transformGeoJsonCoords(features, (coord) => projection.project(coord));\n}\n\n/**\n *\n * @param options\n * @param context\n * @returns Promise\n */\n// eslint-disable-next-line max-statements\nexport async function loadShapefileSidecarFiles(\n  options?: ShapefileLoaderOptions,\n  context?: LoaderContext\n): Promise<{\n  shx?: SHXOutput;\n  cpg?: string;\n  prj?: string;\n}> {\n  // Attempt a parallel load of the small sidecar files\n  // @ts-ignore context must be defined\n  const {url, fetch} = context;\n  const shxPromise = fetch(replaceExtension(url, 'shx'));\n  const cpgPromise = fetch(replaceExtension(url, 'cpg'));\n  const prjPromise = fetch(replaceExtension(url, 'prj'));\n  await Promise.all([shxPromise, cpgPromise, prjPromise]);\n\n  let shx: SHXOutput | undefined;\n  let cpg: string | undefined;\n  let prj: string | undefined;\n\n  const shxResponse = await shxPromise;\n  if (shxResponse.ok) {\n    const arrayBuffer = await shxResponse.arrayBuffer();\n    shx = parseShx(arrayBuffer);\n  }\n\n  const cpgResponse = await cpgPromise;\n  if (cpgResponse.ok) {\n    cpg = await cpgResponse.text();\n  }\n\n  const prjResponse = await prjPromise;\n  if (prjResponse.ok) {\n    prj = await prjResponse.text();\n  }\n\n  return {\n    shx,\n    cpg,\n    prj\n  };\n}\n\n/**\n * Replace the extension at the end of a path.\n *\n * Matches the case of new extension with the case of the original file extension,\n * to increase the chance of finding files without firing off a request storm looking for various case combinations\n *\n * NOTE: Extensions can be both lower and uppercase\n * per spec, extensions should be lower case, but that doesn't mean they always are. See:\n * calvinmetcalf/shapefile-js#64, mapserver/mapserver#4712\n * https://trac.osgeo.org/mapserver/ticket/166\n */\nexport function replaceExtension(url: string, newExtension: string): string {\n  const baseName = basename(url);\n  const extension = extname(url);\n  const isUpperCase = extension === extension.toUpperCase();\n  if (isUpperCase) {\n    newExtension = newExtension.toUpperCase();\n  }\n  return `${baseName}.${newExtension}`;\n}\n\n// NOTE - this gives the entire path minus extension (i.e. NOT same as path.basename)\n/**\n * @param url\n * @returns string\n */\nfunction basename(url: string): string {\n  const extIndex = url && url.lastIndexOf('.');\n  if (typeof extIndex === 'number') {\n    return extIndex >= 0 ? url.substr(0, extIndex) : '';\n  }\n  return extIndex;\n}\n/**\n * @param url\n * @returns string\n */\nfunction extname(url: string): string {\n  const extIndex = url && url.lastIndexOf('.');\n  if (typeof extIndex === 'number') {\n    return extIndex >= 0 ? url.substr(extIndex + 1) : '';\n  }\n  return extIndex;\n}\n"],"mappings":"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"}

package/dist/lib/parsers/parse-shp-geometry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-shp-geometry.js","names":["LITTLE_ENDIAN","parseRecord","view","options","_maxDimensions","shp","offset","type","getInt32","Int32Array","BYTES_PER_ELEMENT","parseNull","parsePoint","Math","min","parsePoly","parseMultiPoint","Error","dim","positions","parsePositions","value","size","Float64Array","nPoints","xyPositions","mPositions","zPositions","concatPositions","nParts","bufferOffset","byteOffset","bufferLength","ringIndices","set","buffer","slice","pathIndices","polygonIndices","i","length","startRingIndex","endRingIndex","ring","subarray","sign","getWindingDirection","push","primitivePolygonIndices","Uint32Array","arrayLength","nDim","getSignedArea","area","nCoords"],"sources":["../../../src/lib/parsers/parse-shp-geometry.ts"],"sourcesContent":["import {BinaryGeometry, BinaryGeometryType} from '@loaders.gl/schema';\nimport {SHPLoaderOptions} from './types';\n\nconst LITTLE_ENDIAN = true;\n\n/**\n * Parse individual record\n *\n * @param view Record data\n * @return Binary Geometry Object\n */\n// eslint-disable-next-line complexity\nexport function parseRecord(view: DataView, options?: SHPLoaderOptions): BinaryGeometry | null {\n  const {_maxDimensions = 4} = options?.shp || {};\n\n  let offset = 0;\n  const type: number = view.getInt32(offset, LITTLE_ENDIAN);\n  offset += Int32Array.BYTES_PER_ELEMENT;\n\n  switch (type) {\n    case 0:\n      // Null Shape\n      return parseNull();\n    case 1:\n      // Point\n      return parsePoint(view, offset, Math.min(2, _maxDimensions));\n    case 3:\n      // PolyLine\n      return parsePoly(view, offset, Math.min(2, _maxDimensions), 'LineString');\n    case 5:\n      // Polygon\n      return parsePoly(view, offset, Math.min(2, _maxDimensions), 'Polygon');\n    case 8:\n      // MultiPoint\n      return parseMultiPoint(view, offset, Math.min(2, _maxDimensions));\n    // GeometryZ can have 3 or 4 dimensions, since the M is not required to\n    // exist\n    case 11:\n      // PointZ\n      return parsePoint(view, offset, Math.min(4, _maxDimensions));\n    case 13:\n      // PolyLineZ\n      return parsePoly(view, offset, Math.min(4, _maxDimensions), 'LineString');\n    case 15:\n      // PolygonZ\n      return parsePoly(view, offset, Math.min(4, _maxDimensions), 'Polygon');\n    case 18:\n      // MultiPointZ\n      return parseMultiPoint(view, offset, Math.min(4, _maxDimensions));\n    case 21:\n      // PointM\n      return parsePoint(view, offset, Math.min(3, _maxDimensions));\n    case 23:\n      // PolyLineM\n      return parsePoly(view, offset, Math.min(3, _maxDimensions), 'LineString');\n    case 25:\n      // PolygonM\n      return parsePoly(view, offset, Math.min(3, _maxDimensions), 'Polygon');\n    case 28:\n      // MultiPointM\n      return parseMultiPoint(view, offset, Math.min(3, _maxDimensions));\n    default:\n      throw new Error(`unsupported shape type: ${type}`);\n  }\n}\n\n// TODO handle null\n/**\n * Parse Null geometry\n *\n * @return null\n */\nfunction parseNull(): null {\n  return null;\n}\n\n/**\n * Parse point geometry\n *\n * @param view Geometry data\n * @param offset Offset in view\n * @param dim Dimension size\n */\nfunction parsePoint(view: DataView, offset: number, dim: number): BinaryGeometry {\n  let positions: Float64Array;\n  [positions, offset] = parsePositions(view, offset, 1, dim);\n\n  return {\n    positions: {value: positions, size: dim},\n    type: 'Point'\n  };\n}\n\n/**\n * Parse MultiPoint geometry\n *\n * @param view Geometry data\n * @param offset Offset in view\n * @param dim Input dimension\n * @return Binary geometry object\n */\nfunction parseMultiPoint(view: DataView, offset: number, dim: number): BinaryGeometry {\n  // skip parsing box\n  offset += 4 * Float64Array.BYTES_PER_ELEMENT;\n\n  const nPoints = view.getInt32(offset, LITTLE_ENDIAN);\n  offset += Int32Array.BYTES_PER_ELEMENT;\n\n  let xyPositions: Float64Array | null = null;\n  let mPositions: Float64Array | null = null;\n  let zPositions: Float64Array | null = null;\n  [xyPositions, offset] = parsePositions(view, offset, nPoints, 2);\n\n  // Parse Z coordinates\n  if (dim === 4) {\n    // skip parsing range\n    offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n    [zPositions, offset] = parsePositions(view, offset, nPoints, 1);\n  }\n\n  // Parse M coordinates\n  if (dim >= 3) {\n    // skip parsing range\n    offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n    [mPositions, offset] = parsePositions(view, offset, nPoints, 1);\n  }\n\n  const positions = concatPositions(xyPositions, mPositions, zPositions);\n\n  return {\n    positions: {value: positions, size: dim},\n    type: 'Point'\n  };\n}\n\n/**\n * Polygon and PolyLine parsing\n *\n * @param view Geometry data\n * @param offset Offset in view\n * @param dim Input dimension\n * @param type Either 'Polygon' or 'Polyline'\n * @return Binary geometry object\n */\n// eslint-disable-next-line max-statements\nfunction parsePoly(\n  view: DataView,\n  offset: number,\n  dim: number,\n  type: BinaryGeometryType\n): BinaryGeometry {\n  // skip parsing bounding box\n  offset += 4 * Float64Array.BYTES_PER_ELEMENT;\n\n  const nParts = view.getInt32(offset, LITTLE_ENDIAN);\n  offset += Int32Array.BYTES_PER_ELEMENT;\n  const nPoints = view.getInt32(offset, LITTLE_ENDIAN);\n  offset += Int32Array.BYTES_PER_ELEMENT;\n\n  // Create longer indices array by 1 because output format is expected to\n  // include the last index as the total number of positions\n  const bufferOffset = view.byteOffset + offset;\n  const bufferLength = nParts * Int32Array.BYTES_PER_ELEMENT;\n  const ringIndices = new Int32Array(nParts + 1);\n  ringIndices.set(new Int32Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)));\n  ringIndices[nParts] = nPoints;\n  offset += nParts * Int32Array.BYTES_PER_ELEMENT;\n\n  let xyPositions: Float64Array | null = null;\n  let mPositions: Float64Array | null = null;\n  let zPositions: Float64Array | null = null;\n  [xyPositions, offset] = parsePositions(view, offset, nPoints, 2);\n\n  // Parse Z coordinates\n  if (dim === 4) {\n    // skip parsing range\n    offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n    [zPositions, offset] = parsePositions(view, offset, nPoints, 1);\n  }\n\n  // Parse M coordinates\n  if (dim >= 3) {\n    // skip parsing range\n    offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n    [mPositions, offset] = parsePositions(view, offset, nPoints, 1);\n  }\n\n  const positions = concatPositions(xyPositions, mPositions, zPositions);\n\n  // parsePoly only accepts type = LineString or Polygon\n  if (type === 'LineString') {\n    return {\n      type,\n      positions: {value: positions, size: dim},\n      pathIndices: {value: ringIndices, size: 1}\n    };\n  }\n\n  // for every ring, determine sign of polygon\n  // Use only 2D positions for ring calc\n  const polygonIndices: number[] = [];\n  for (let i = 1; i < ringIndices.length; i++) {\n    const startRingIndex = ringIndices[i - 1];\n    const endRingIndex = ringIndices[i];\n    // @ts-ignore\n    const ring = xyPositions.subarray(startRingIndex * 2, endRingIndex * 2);\n    const sign = getWindingDirection(ring);\n\n    // A positive sign implies clockwise\n    // A clockwise ring is a filled ring\n    if (sign > 0) {\n      polygonIndices.push(startRingIndex);\n    }\n  }\n\n  polygonIndices.push(nPoints);\n\n  return {\n    type,\n    positions: {value: positions, size: dim},\n    primitivePolygonIndices: {value: ringIndices, size: 1},\n    // TODO: Dynamically choose Uint32Array over Uint16Array only when\n    // necessary. I believe the implementation requires nPoints to be the\n    // largest value in the array, so you should be able to use Uint32Array only\n    // when nPoints > 65535.\n    polygonIndices: {value: new Uint32Array(polygonIndices), size: 1}\n  };\n}\n\n/**\n * Parse a contiguous block of positions into a Float64Array\n *\n * @param view  Geometry data\n * @param offset  Offset in view\n * @param nPoints Number of points\n * @param dim     Input dimension\n * @return Data and offset\n */\nfunction parsePositions(\n  view: DataView,\n  offset: number,\n  nPoints: number,\n  dim: number\n): [Float64Array, number] {\n  const bufferOffset = view.byteOffset + offset;\n  const bufferLength = nPoints * dim * Float64Array.BYTES_PER_ELEMENT;\n  return [\n    new Float64Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)),\n    offset + bufferLength\n  ];\n}\n\n/**\n * Concatenate and interleave positions arrays\n * xy positions are interleaved; mPositions, zPositions are their own arrays\n *\n * @param xyPositions 2d positions\n * @param mPositions  M positions\n * @param zPositions  Z positions\n * @return Combined interleaved positions\n */\n// eslint-disable-next-line complexity\nfunction concatPositions(\n  xyPositions: Float64Array,\n  mPositions: Float64Array | null,\n  zPositions: Float64Array | null\n): Float64Array {\n  if (!(mPositions || zPositions)) {\n    return xyPositions;\n  }\n\n  let arrayLength = xyPositions.length;\n  let nDim = 2;\n\n  if (zPositions && zPositions.length) {\n    arrayLength += zPositions.length;\n    nDim++;\n  }\n\n  if (mPositions && mPositions.length) {\n    arrayLength += mPositions.length;\n    nDim++;\n  }\n\n  const positions = new Float64Array(arrayLength);\n  for (let i = 0; i < xyPositions.length / 2; i++) {\n    positions[nDim * i] = xyPositions[i * 2];\n    positions[nDim * i + 1] = xyPositions[i * 2 + 1];\n  }\n\n  if (zPositions && zPositions.length) {\n    for (let i = 0; i < zPositions.length; i++) {\n      // If Z coordinates exist; used as third coord in positions array\n      positions[nDim * i + 2] = zPositions[i];\n    }\n  }\n\n  if (mPositions && mPositions.length) {\n    for (let i = 0; i < mPositions.length; i++) {\n      // M is always last, either 3rd or 4th depending on if Z exists\n      positions[nDim * i + (nDim - 1)] = mPositions[i];\n    }\n  }\n\n  return positions;\n}\n\n/**\n * Returns the direction of the polygon path\n * A positive number is clockwise.\n * A negative number is counter clockwise.\n *\n * @param positions\n * @return Sign of polygon ring\n */\nfunction getWindingDirection(positions: Float64Array): number {\n  return Math.sign(getSignedArea(positions));\n}\n\n/**\n * Get signed area of flat typed array of 2d positions\n *\n * @param positions\n * @return Signed area of polygon ring\n */\nfunction getSignedArea(positions: Float64Array): number {\n  let area = 0;\n\n  // Rings are closed according to shapefile spec\n  const nCoords = positions.length / 2 - 1;\n  for (let i = 0; i < nCoords; i++) {\n    area +=\n      (positions[i * 2] + positions[(i + 1) * 2]) *\n      (positions[i * 2 + 1] - positions[(i + 1) * 2 + 1]);\n  }\n\n  return area / 2;\n}\n"],"mappings":"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"}

package/dist/lib/parsers/parse-shp-header.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-shp-header.js","names":["LITTLE_ENDIAN","BIG_ENDIAN","SHP_MAGIC_NUMBER","parseSHPHeader","headerView","header","magic","getInt32","length","version","type","bbox","minX","getFloat64","minY","minZ","minM","maxX","maxY","maxZ","maxM","console","error"],"sources":["../../../src/lib/parsers/parse-shp-header.ts"],"sourcesContent":["export interface SHPHeader {\n  /** SHP Magic number */\n  magic: number;\n\n  /** Number of bytes in file */\n  length: number;\n  version: number;\n  type: number;\n  bbox: {\n    minX: number;\n    minY: number;\n    minZ: number;\n    minM: number;\n    maxX: number;\n    maxY: number;\n    maxZ: number;\n    maxM: number;\n  };\n}\n\nconst LITTLE_ENDIAN = true;\nconst BIG_ENDIAN = false;\nconst SHP_MAGIC_NUMBER = 0x0000270a;\n\n/**\n * Extract the binary header\n * Note: Also used by SHX\n * @param headerView\n * @returns SHPHeader\n */\nexport function parseSHPHeader(headerView: DataView): SHPHeader {\n  // Note: The SHP format switches endianness between fields!\n  // https://www.esri.com/library/whitepapers/pdfs/shapefile.pdf\n  const header = {\n    magic: headerView.getInt32(0, BIG_ENDIAN),\n    // Length is stored as # of 2-byte words; multiply by 2 to get # of bytes\n    length: headerView.getInt32(24, BIG_ENDIAN) * 2,\n    version: headerView.getInt32(28, LITTLE_ENDIAN),\n    type: headerView.getInt32(32, LITTLE_ENDIAN),\n    bbox: {\n      minX: headerView.getFloat64(36, LITTLE_ENDIAN),\n      minY: headerView.getFloat64(44, LITTLE_ENDIAN),\n      minZ: headerView.getFloat64(68, LITTLE_ENDIAN),\n      minM: headerView.getFloat64(84, LITTLE_ENDIAN),\n      maxX: headerView.getFloat64(52, LITTLE_ENDIAN),\n      maxY: headerView.getFloat64(60, LITTLE_ENDIAN),\n      maxZ: headerView.getFloat64(76, LITTLE_ENDIAN),\n      maxM: headerView.getFloat64(92, LITTLE_ENDIAN)\n    }\n  };\n  if (header.magic !== SHP_MAGIC_NUMBER) {\n    // eslint-disable-next-line\n    console.error(`SHP file: bad magic number ${header.magic}`);\n  }\n  if (header.version !== 1000) {\n    // eslint-disable-next-line\n    console.error(`SHP file: bad version ${header.version}`);\n  }\n  return header;\n}\n"],"mappings":"AAoBA,MAAMA,aAAa,GAAG,IAAI;AAC1B,MAAMC,UAAU,GAAG,KAAK;AACxB,MAAMC,gBAAgB,GAAG,UAAU;AAQnC,OAAO,SAASC,cAAcA,CAACC,UAAoB,EAAa;EAG9D,MAAMC,MAAM,GAAG;IACbC,KAAK,EAAEF,UAAU,CAACG,QAAQ,CAAC,CAAC,EAAEN,UAAU,CAAC;IAEzCO,MAAM,EAAEJ,UAAU,CAACG,QAAQ,CAAC,EAAE,EAAEN,UAAU,CAAC,GAAG,CAAC;IAC/CQ,OAAO,EAAEL,UAAU,CAACG,QAAQ,CAAC,EAAE,EAAEP,aAAa,CAAC;IAC/CU,IAAI,EAAEN,UAAU,CAACG,QAAQ,CAAC,EAAE,EAAEP,aAAa,CAAC;IAC5CW,IAAI,EAAE;MACJC,IAAI,EAAER,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9Cc,IAAI,EAAEV,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9Ce,IAAI,EAAEX,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9CgB,IAAI,EAAEZ,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9CiB,IAAI,EAAEb,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9CkB,IAAI,EAAEd,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9CmB,IAAI,EAAEf,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa,CAAC;MAC9CoB,IAAI,EAAEhB,UAAU,CAACS,UAAU,CAAC,EAAE,EAAEb,aAAa;IAC/C;EACF,CAAC;EACD,IAAIK,MAAM,CAACC,KAAK,KAAKJ,gBAAgB,EAAE;IAErCmB,OAAO,CAACC,KAAK,CAAE,8BAA6BjB,MAAM,CAACC,KAAM,EAAC,CAAC;EAC7D;EACA,IAAID,MAAM,CAACI,OAAO,KAAK,IAAI,EAAE;IAE3BY,OAAO,CAACC,KAAK,CAAE,yBAAwBjB,MAAM,CAACI,OAAQ,EAAC,CAAC;EAC1D;EACA,OAAOJ,MAAM;AACf"}

package/dist/lib/parsers/parse-shp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-shp.js","names":["BinaryChunkReader","parseSHPHeader","parseRecord","LITTLE_ENDIAN","BIG_ENDIAN","SHP_HEADER_SIZE","SHP_RECORD_HEADER_SIZE","STATE","EXPECTING_HEADER","EXPECTING_RECORD","END","ERROR","SHPParser","constructor","options","binaryReader","maxRewindBytes","state","result","geometries","progress","bytesTotal","NaN","bytesUsed","rows","currentIndex","write","arrayBuffer","parseState","end","error","parseSHP","shpParser","parseSHPInBatches","asyncIterator","parser","headerReturned","header","length","dataView","getDataView","hasAvailableBytes","_result$header","recordHeaderView","recordHeader","recordNumber","getInt32","byteLength","type","rewind","invalidRecord","recordView","geometry","push","ended","message"],"sources":["../../../src/lib/parsers/parse-shp.ts"],"sourcesContent":["import type {BinaryGeometry} from '@loaders.gl/schema';\nimport {BinaryChunkReader} from '../streaming/binary-chunk-reader';\nimport {parseSHPHeader, SHPHeader} from './parse-shp-header';\nimport {parseRecord} from './parse-shp-geometry';\nimport {SHPLoaderOptions} from './types';\n\nconst LITTLE_ENDIAN = true;\nconst BIG_ENDIAN = false;\n\nconst SHP_HEADER_SIZE = 100;\n// According to the spec, the record header is just 8 bytes, but here we set it\n// to 12 so that we can also access the record's type\nconst SHP_RECORD_HEADER_SIZE = 12;\n\nconst STATE = {\n  EXPECTING_HEADER: 0,\n  EXPECTING_RECORD: 1,\n  END: 2,\n  ERROR: 3\n};\n\ntype SHPResult = {\n  geometries: (BinaryGeometry | null)[];\n  header?: SHPHeader;\n  error?: string;\n  progress: {\n    bytesUsed: number;\n    bytesTotal: number;\n    rows: number;\n  };\n  currentIndex: number;\n};\n\nclass SHPParser {\n  options?: SHPLoaderOptions = {};\n  binaryReader = new BinaryChunkReader({maxRewindBytes: SHP_RECORD_HEADER_SIZE});\n  state = STATE.EXPECTING_HEADER;\n  result: SHPResult = {\n    geometries: [],\n    // Initialize with number values to make TS happy\n    // These are initialized for real in STATE.EXPECTING_HEADER\n    progress: {\n      bytesTotal: NaN,\n      bytesUsed: NaN,\n      rows: NaN\n    },\n    currentIndex: NaN\n  };\n\n  constructor(options?: SHPLoaderOptions) {\n    this.options = options;\n  }\n\n  write(arrayBuffer: ArrayBuffer) {\n    this.binaryReader.write(arrayBuffer);\n    this.state = parseState(this.state, this.result, this.binaryReader, this.options);\n  }\n\n  end() {\n    this.binaryReader.end();\n    this.state = parseState(this.state, this.result, this.binaryReader, this.options);\n    // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();\n    if (this.state !== STATE.END) {\n      this.state = STATE.ERROR;\n      this.result.error = 'SHP incomplete file';\n    }\n  }\n}\n\nexport function parseSHP(arrayBuffer: ArrayBuffer, options?: SHPLoaderOptions): BinaryGeometry[] {\n  const shpParser = new SHPParser(options);\n  shpParser.write(arrayBuffer);\n  shpParser.end();\n\n  // @ts-ignore\n  return shpParser.result;\n}\n\n/**\n * @param asyncIterator\n * @param options\n * @returns\n */\nexport async function* parseSHPInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: SHPLoaderOptions\n): AsyncGenerator<BinaryGeometry | object> {\n  const parser = new SHPParser(options);\n  let headerReturned = false;\n  for await (const arrayBuffer of asyncIterator) {\n    parser.write(arrayBuffer);\n    if (!headerReturned && parser.result.header) {\n      headerReturned = true;\n      yield parser.result.header;\n    }\n\n    if (parser.result.geometries.length > 0) {\n      yield parser.result.geometries;\n      parser.result.geometries = [];\n    }\n  }\n  parser.end();\n  if (parser.result.geometries.length > 0) {\n    yield parser.result.geometries;\n  }\n\n  return;\n}\n\n/**\n * State-machine parser for SHP data\n *\n * Note that whenever more data is needed, a `return`, not a `break`, is\n * necessary, as the `break` keeps the context within `parseState`, while\n * `return` releases context so that more data can be written into the\n * BinaryChunkReader.\n *\n * @param  state Current state\n * @param  result An object to hold result data\n * @param  binaryReader\n * @return State at end of current parsing\n */\n/* eslint-disable complexity, max-depth */\nfunction parseState(\n  state: number,\n  result: SHPResult,\n  binaryReader: BinaryChunkReader,\n  options?: SHPLoaderOptions\n): number {\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    try {\n      switch (state) {\n        case STATE.ERROR:\n        case STATE.END:\n          return state;\n\n        case STATE.EXPECTING_HEADER:\n          // Parse initial file header\n          const dataView = binaryReader.getDataView(SHP_HEADER_SIZE);\n          if (!dataView) {\n            return state;\n          }\n\n          result.header = parseSHPHeader(dataView);\n          result.progress = {\n            bytesUsed: 0,\n            bytesTotal: result.header.length,\n            rows: 0\n          };\n          // index numbering starts at 1\n          result.currentIndex = 1;\n          state = STATE.EXPECTING_RECORD;\n          break;\n\n        case STATE.EXPECTING_RECORD:\n          while (binaryReader.hasAvailableBytes(SHP_RECORD_HEADER_SIZE)) {\n            const recordHeaderView = binaryReader.getDataView(SHP_RECORD_HEADER_SIZE) as DataView;\n            const recordHeader = {\n              recordNumber: recordHeaderView.getInt32(0, BIG_ENDIAN),\n              // 2 byte words; includes the four words of record header\n              byteLength: recordHeaderView.getInt32(4, BIG_ENDIAN) * 2,\n              // This is actually part of the record, not the header...\n              type: recordHeaderView.getInt32(8, LITTLE_ENDIAN)\n            };\n\n            if (!binaryReader.hasAvailableBytes(recordHeader.byteLength - 4)) {\n              binaryReader.rewind(SHP_RECORD_HEADER_SIZE);\n              return state;\n            }\n\n            const invalidRecord =\n              recordHeader.byteLength < 4 ||\n              recordHeader.type !== result.header?.type ||\n              recordHeader.recordNumber !== result.currentIndex;\n\n            // All records must have at least four bytes (for the record shape type)\n            if (invalidRecord) {\n              // Malformed record, try again, advancing just 4 bytes\n              // Note: this is a rewind because binaryReader.getDataView above\n              // moved the pointer forward 12 bytes, so rewinding 8 bytes still\n              // leaves us 4 bytes ahead\n              binaryReader.rewind(SHP_RECORD_HEADER_SIZE - 4);\n            } else {\n              // Note: type is actually part of the record, not the header, so\n              // rewind 4 bytes before reading record\n              binaryReader.rewind(4);\n\n              const recordView = binaryReader.getDataView(recordHeader.byteLength) as DataView;\n              const geometry = parseRecord(recordView, options);\n              result.geometries.push(geometry);\n\n              result.currentIndex++;\n              result.progress.rows = result.currentIndex - 1;\n            }\n          }\n\n          if (binaryReader.ended) {\n            state = STATE.END;\n          }\n\n          return state;\n\n        default:\n          state = STATE.ERROR;\n          result.error = `illegal parser state ${state}`;\n          return state;\n      }\n    } catch (error) {\n      state = STATE.ERROR;\n      result.error = `SHP parsing failed: ${(error as Error)?.message}`;\n      return state;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/lib/parsers/parse-shx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-shx.js","names":["parseSHPHeader","SHX_HEADER_SIZE","BIG_ENDIAN","parseShx","arrayBuffer","headerView","DataView","header","contentLength","length","contentView","offsets","Int32Array","lengths","i","getInt32"],"sources":["../../../src/lib/parsers/parse-shx.ts"],"sourcesContent":["import {parseSHPHeader} from './parse-shp-header';\n\nexport interface SHXOutput {\n  offsets: Int32Array;\n  lengths: Int32Array;\n}\n\nconst SHX_HEADER_SIZE = 100;\nconst BIG_ENDIAN = false;\n\n/**\n * @param arrayBuffer\n * @returns SHXOutput\n */\nexport function parseShx(arrayBuffer: ArrayBuffer): SHXOutput {\n  // SHX header is identical to SHP Header\n  const headerView = new DataView(arrayBuffer, 0, SHX_HEADER_SIZE);\n  const header = parseSHPHeader(headerView);\n  const contentLength = header.length - SHX_HEADER_SIZE;\n\n  const contentView = new DataView(arrayBuffer, SHX_HEADER_SIZE, contentLength);\n\n  const offsets = new Int32Array(contentLength);\n  const lengths = new Int32Array(contentLength);\n\n  for (let i = 0; i < contentLength / 8; i++) {\n    offsets[i] = contentView.getInt32(i * 8, BIG_ENDIAN);\n    lengths[i] = contentView.getInt32(i * 8 + 4, BIG_ENDIAN);\n  }\n\n  return {\n    offsets,\n    lengths\n  };\n}\n"],"mappings":"SAAQA,cAAc;AAOtB,MAAMC,eAAe,GAAG,GAAG;AAC3B,MAAMC,UAAU,GAAG,KAAK;AAMxB,OAAO,SAASC,QAAQA,CAACC,WAAwB,EAAa;EAE5D,MAAMC,UAAU,GAAG,IAAIC,QAAQ,CAACF,WAAW,EAAE,CAAC,EAAEH,eAAe,CAAC;EAChE,MAAMM,MAAM,GAAGP,cAAc,CAACK,UAAU,CAAC;EACzC,MAAMG,aAAa,GAAGD,MAAM,CAACE,MAAM,GAAGR,eAAe;EAErD,MAAMS,WAAW,GAAG,IAAIJ,QAAQ,CAACF,WAAW,EAAEH,eAAe,EAAEO,aAAa,CAAC;EAE7E,MAAMG,OAAO,GAAG,IAAIC,UAAU,CAACJ,aAAa,CAAC;EAC7C,MAAMK,OAAO,GAAG,IAAID,UAAU,CAACJ,aAAa,CAAC;EAE7C,KAAK,IAAIM,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,aAAa,GAAG,CAAC,EAAEM,CAAC,EAAE,EAAE;IAC1CH,OAAO,CAACG,CAAC,CAAC,GAAGJ,WAAW,CAACK,QAAQ,CAACD,CAAC,GAAG,CAAC,EAAEZ,UAAU,CAAC;IACpDW,OAAO,CAACC,CAAC,CAAC,GAAGJ,WAAW,CAACK,QAAQ,CAACD,CAAC,GAAG,CAAC,GAAG,CAAC,EAAEZ,UAAU,CAAC;EAC1D;EAEA,OAAO;IACLS,OAAO;IACPE;EACF,CAAC;AACH"}

package/dist/lib/parsers/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../src/lib/parsers/types.ts"],"sourcesContent":["import {Schema, ObjectRowTable} from '@loaders.gl/schema';\nimport type {LoaderOptions} from '@loaders.gl/loader-utils';\n\nexport type SHPLoaderOptions = LoaderOptions & {\n  shp?: {\n    _maxDimensions?: number;\n  };\n};\n\nexport type DBFLoaderOptions = LoaderOptions & {\n  dbf?: {\n    encoding?: string;\n    shape?: 'rows' | 'table' | 'object-row-table';\n  };\n};\n\nexport type ShapefileLoaderOptions = LoaderOptions &\n  SHPLoaderOptions & {\n    shapefile?: {\n      shape?: 'geojson-table';\n    };\n    gis?: {\n      reproject?: boolean;\n      _targetCrs?: string;\n    };\n  };\n\nexport type DBFRowsOutput = ObjectRowTable['data'];\n\n/**\n * DBF Table output. Deprecated in favor of ObjectRowTable\n * @deprecated\n */\nexport interface DBFTableOutput {\n  schema?: Schema;\n  rows: DBFRowsOutput;\n}\n\nexport type DBFHeader = {\n  // Last updated date\n  year: number;\n  month: number;\n  day: number;\n  // Number of records in data file\n  nRecords: number;\n  // Length of header in bytes\n  headerLength: number;\n  // Length of each record\n  recordLength: number;\n  // Not sure if this is usually set\n  languageDriver: number;\n};\n\nexport type DBFField = {\n  name: string;\n  dataType: string;\n  fieldLength: number;\n  decimal: number;\n};\n\nexport type DBFResult = {\n  data: {[key: string]: any}[];\n  schema?: Schema;\n  error?: string;\n  dbfHeader?: DBFHeader;\n  dbfFields?: DBFField[];\n  progress?: {\n    bytesUsed: number;\n    rowsTotal: number;\n    rows: number;\n  };\n};\n"],"mappings":""}

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

@@ -1 +0,0 @@
-{"version":3,"file":"binary-chunk-reader.js","names":["BinaryChunkReader","constructor","options","offset","arrayBuffers","ended","maxRewindBytes","write","arrayBuffer","push","end","hasAvailableBytes","bytes","bytesAvailable","byteLength","findBufferOffsets","selectedBuffers","i","length","buf","start","Math","abs","getDataView","bufferOffsets","Error","bufferIndex","view","DataView","disposeBuffers","_combineArrayBuffers","shift","bufferOffset","result","Uint8Array","resultOffset","sourceArray","set","subarray","buffer","skip","rewind"],"sources":["../../../src/lib/streaming/binary-chunk-reader.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nexport type BinaryChunkReaderOptions = {\n  maxRewindBytes: number;\n};\n\nexport class BinaryChunkReader {\n  offset: number;\n  arrayBuffers: ArrayBuffer[];\n  ended: boolean;\n  maxRewindBytes: number;\n\n  constructor(options?: BinaryChunkReaderOptions) {\n    const {maxRewindBytes = 0} = options || {};\n\n    /** current global offset into current array buffer*/\n    this.offset = 0;\n    /** current buffer from iterator */\n    this.arrayBuffers = [];\n    this.ended = false;\n\n    /** bytes behind offset to hold on to */\n    this.maxRewindBytes = maxRewindBytes;\n  }\n  /**\n   * @param arrayBuffer\n   */\n  write(arrayBuffer: ArrayBuffer): void {\n    this.arrayBuffers.push(arrayBuffer);\n  }\n\n  end(): void {\n    this.arrayBuffers = [];\n    this.ended = true;\n  }\n\n  /**\n   * Has enough bytes available in array buffers\n   *\n   * @param bytes Number of bytes\n   * @return boolean\n   */\n  hasAvailableBytes(bytes: number): boolean {\n    let bytesAvailable = -this.offset;\n    for (const arrayBuffer of this.arrayBuffers) {\n      bytesAvailable += arrayBuffer.byteLength;\n      if (bytesAvailable >= bytes) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Find offsets of byte ranges within this.arrayBuffers\n   *\n   * @param  bytes Byte length to read\n   * @return Arrays with byte ranges pointing to this.arrayBuffers, Output type is nested array, e.g. [ [0, [1, 2]], ...]\n   */\n  findBufferOffsets(bytes: number): any[] | null {\n    let offset = -this.offset;\n    const selectedBuffers: any = [];\n\n    for (let i = 0; i < this.arrayBuffers.length; i++) {\n      const buf = this.arrayBuffers[i];\n\n      // Current buffer isn't long enough to reach global offset\n      if (offset + buf.byteLength <= 0) {\n        offset += buf.byteLength;\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n\n      // Find start/end offsets for this buffer\n      // When offset < 0, need to skip over Math.abs(offset) bytes\n      // When offset > 0, implies bytes in previous buffer, start at 0\n      const start = offset <= 0 ? Math.abs(offset) : 0;\n      let end: number;\n\n      // Length of requested bytes is contained in current buffer\n      if (start + bytes <= buf.byteLength) {\n        end = start + bytes;\n        selectedBuffers.push([i, [start, end]]);\n        return selectedBuffers;\n      }\n\n      // Will need to look into next buffer\n      end = buf.byteLength;\n      selectedBuffers.push([i, [start, end]]);\n\n      // Need to read fewer bytes in next iter\n      bytes -= buf.byteLength - start;\n      offset += buf.byteLength;\n    }\n\n    // Should only finish loop if exhausted all arrays\n    return null;\n  }\n\n  /**\n   * Get the required number of bytes from the iterator\n   *\n   * @param bytes Number of bytes\n   * @return DataView with data\n   */\n  getDataView(bytes: number): DataView | null {\n    const bufferOffsets = this.findBufferOffsets(bytes);\n    // return `null` if not enough data, except if end() already called, in\n    // which case throw an error.\n    if (!bufferOffsets && this.ended) {\n      throw new Error('binary data exhausted');\n    }\n\n    if (!bufferOffsets) {\n      return null;\n    }\n\n    // If only one arrayBuffer needed, return DataView directly\n    if (bufferOffsets.length === 1) {\n      const [bufferIndex, [start, end]] = bufferOffsets[0];\n      const arrayBuffer = this.arrayBuffers[bufferIndex];\n      const view = new DataView(arrayBuffer, start, end - start);\n\n      this.offset += bytes;\n      this.disposeBuffers();\n      return view;\n    }\n\n    // Concatenate portions of multiple ArrayBuffers\n    const view = new DataView(this._combineArrayBuffers(bufferOffsets));\n    this.offset += bytes;\n    this.disposeBuffers();\n    return view;\n  }\n\n  /**\n   * Dispose of old array buffers\n   */\n  disposeBuffers(): void {\n    while (\n      this.arrayBuffers.length > 0 &&\n      this.offset - this.maxRewindBytes >= this.arrayBuffers[0].byteLength\n    ) {\n      this.offset -= this.arrayBuffers[0].byteLength;\n      this.arrayBuffers.shift();\n    }\n  }\n\n  /**\n   * Copy multiple ArrayBuffers into one contiguous ArrayBuffer\n   *\n   * In contrast to concatenateArrayBuffers, this only copies the necessary\n   * portions of the source arrays, rather than first copying the entire arrays\n   * then taking a part of them.\n   *\n   * @param bufferOffsets List of internal array offsets\n   * @return New contiguous ArrayBuffer\n   */\n  _combineArrayBuffers(bufferOffsets: any[]): ArrayBufferLike {\n    let byteLength: number = 0;\n    for (const bufferOffset of bufferOffsets) {\n      const [start, end] = bufferOffset[1];\n      byteLength += end - start;\n    }\n\n    const result = new Uint8Array(byteLength);\n\n    // Copy the subarrays\n    let resultOffset: number = 0;\n    for (const bufferOffset of bufferOffsets) {\n      const [bufferIndex, [start, end]] = bufferOffset;\n      const sourceArray = new Uint8Array(this.arrayBuffers[bufferIndex]);\n      result.set(sourceArray.subarray(start, end), resultOffset);\n      resultOffset += end - start;\n    }\n\n    return result.buffer;\n  }\n  /**\n   * @param bytes\n   */\n  skip(bytes: number): void {\n    this.offset += bytes;\n  }\n  /**\n   * @param bytes\n   */\n  rewind(bytes: number): void {\n    // TODO - only works if offset is already set\n    this.offset -= bytes;\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"binary-reader.js","names":["BinaryReader","constructor","arrayBuffer","offset","hasAvailableBytes","bytes","byteLength","getDataView","Error","dataView","DataView","skip","rewind"],"sources":["../../../src/lib/streaming/binary-reader.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nexport 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":"AAIA,OAAO,MAAMA,YAAY,CAAC;EAIxBC,WAAWA,CAACC,WAAwB,EAAE;IAAA,KAHtCC,MAAM;IAAA,KACND,WAAW;IAIT,IAAI,CAACC,MAAM,GAAG,CAAC;IAEf,IAAI,CAACD,WAAW,GAAGA,WAAW;EAChC;EAOAE,iBAAiBA,CAACC,KAAa,EAAW;IACxC,OAAO,IAAI,CAACH,WAAW,CAACI,UAAU,GAAG,IAAI,CAACH,MAAM,IAAIE,KAAK;EAC3D;EAQAE,WAAWA,CAACF,KAAa,EAAY;IACnC,IAAIA,KAAK,IAAI,CAAC,IAAI,CAACD,iBAAiB,CAACC,KAAK,CAAC,EAAE;MAC3C,MAAM,IAAIG,KAAK,CAAC,uBAAuB,CAAC;IAC1C;IAEA,MAAMC,QAAQ,GAAGJ,KAAK,GAClB,IAAIK,QAAQ,CAAC,IAAI,CAACR,WAAW,EAAE,IAAI,CAACC,MAAM,EAAEE,KAAK,CAAC,GAClD,IAAIK,QAAQ,CAAC,IAAI,CAACR,WAAW,EAAE,IAAI,CAACC,MAAM,CAAC;IAC/C,IAAI,CAACA,MAAM,IAAIE,KAAK;IACpB,OAAOI,QAAQ;EACjB;EAOAE,IAAIA,CAACN,KAAa,EAAQ;IACxB,IAAI,CAACF,MAAM,IAAIE,KAAK;EACtB;EAOAO,MAAMA,CAACP,KAAa,EAAQ;IAC1B,IAAI,CAACF,MAAM,IAAIE,KAAK;EACtB;AACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"zip-batch-iterators.js","names":["zipBatchIterators","iterator1","iterator2","shape","batch1Data","batch2Data","iterator1Done","iterator2Done","length","value","done","next","push","batchData","extractBatchData","batchType","data","batch1","batch2","batchLength","Math","min","batch","slice","splice"],"sources":["../../../src/lib/streaming/zip-batch-iterators.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {ObjectRowTableBatch, ArrayRowTableBatch} from '@loaders.gl/schema';\n\ntype RowTableBatch = ObjectRowTableBatch | ArrayRowTableBatch;\n\n/**\n * Zip two iterators together\n *\n * @param iterator1\n * @param iterator2\n */\nexport async function* zipBatchIterators(\n  iterator1: AsyncIterator<RowTableBatch> | Iterator<RowTableBatch>,\n  iterator2: AsyncIterator<RowTableBatch> | Iterator<RowTableBatch>,\n  shape: 'object-row-table' | 'array-row-table'\n): AsyncGenerator<RowTableBatch, void, unknown> {\n  const batch1Data: unknown[] = [];\n  const batch2Data: unknown[] = [];\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 (batch1Data.length === 0 && !iterator1Done) {\n      const {value, done} = await iterator1.next();\n      if (done) {\n        iterator1Done = true;\n      } else {\n        // @ts-expect-error\n        batch1Data.push(...value);\n      }\n    }\n    if (batch2Data.length === 0 && !iterator2Done) {\n      const {value, done} = await iterator2.next();\n      if (done) {\n        iterator2Done = true;\n      } else {\n        batch2Data.push(...value);\n      }\n    }\n\n    const batchData = extractBatchData(batch1Data, batch2Data);\n    if (batchData) {\n      yield {\n        batchType: 'data',\n        shape,\n        length: batchData.length,\n        data: batchData\n      };\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 extractBatchData(batch1: any[], batch2: any[]): any[] | 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: any[] = [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":"AAcA,OAAO,gBAAgBA,iBAAiBA,CACtCC,SAAiE,EACjEC,SAAiE,EACjEC,KAA6C,EACC;EAC9C,MAAMC,UAAqB,GAAG,EAAE;EAChC,MAAMC,UAAqB,GAAG,EAAE;EAChC,IAAIC,aAAsB,GAAG,KAAK;EAClC,IAAIC,aAAsB,GAAG,KAAK;EAIlC,OAAO,CAACD,aAAa,IAAI,CAACC,aAAa,EAAE;IACvC,IAAIH,UAAU,CAACI,MAAM,KAAK,CAAC,IAAI,CAACF,aAAa,EAAE;MAC7C,MAAM;QAACG,KAAK;QAAEC;MAAI,CAAC,GAAG,MAAMT,SAAS,CAACU,IAAI,CAAC,CAAC;MAC5C,IAAID,IAAI,EAAE;QACRJ,aAAa,GAAG,IAAI;MACtB,CAAC,MAAM;QAELF,UAAU,CAACQ,IAAI,CAAC,GAAGH,KAAK,CAAC;MAC3B;IACF;IACA,IAAIJ,UAAU,CAACG,MAAM,KAAK,CAAC,IAAI,CAACD,aAAa,EAAE;MAC7C,MAAM;QAACE,KAAK;QAAEC;MAAI,CAAC,GAAG,MAAMR,SAAS,CAACS,IAAI,CAAC,CAAC;MAC5C,IAAID,IAAI,EAAE;QACRH,aAAa,GAAG,IAAI;MACtB,CAAC,MAAM;QACLF,UAAU,CAACO,IAAI,CAAC,GAAGH,KAAK,CAAC;MAC3B;IACF;IAEA,MAAMI,SAAS,GAAGC,gBAAgB,CAACV,UAAU,EAAEC,UAAU,CAAC;IAC1D,IAAIQ,SAAS,EAAE;MACb,MAAM;QACJE,SAAS,EAAE,MAAM;QACjBZ,KAAK;QACLK,MAAM,EAAEK,SAAS,CAACL,MAAM;QACxBQ,IAAI,EAAEH;MACR,CAAC;IACH;EACF;AACF;AASA,SAASC,gBAAgBA,CAACG,MAAa,EAAEC,MAAa,EAAgB;EACpE,MAAMC,WAAmB,GAAGC,IAAI,CAACC,GAAG,CAACJ,MAAM,CAACT,MAAM,EAAEU,MAAM,CAACV,MAAM,CAAC;EAClE,IAAIW,WAAW,KAAK,CAAC,EAAE;IACrB,OAAO,IAAI;EACb;EAGA,MAAMG,KAAY,GAAG,CAACL,MAAM,CAACM,KAAK,CAAC,CAAC,EAAEJ,WAAW,CAAC,EAAED,MAAM,CAACK,KAAK,CAAC,CAAC,EAAEJ,WAAW,CAAC,CAAC;EAGjFF,MAAM,CAACO,MAAM,CAAC,CAAC,EAAEL,WAAW,CAAC;EAC7BD,MAAM,CAACM,MAAM,CAAC,CAAC,EAAEL,WAAW,CAAC;EAC7B,OAAOG,KAAK;AACd"}

package/dist/shapefile-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shapefile-loader.js","names":["SHP_MAGIC_NUMBER","parseShapefile","parseShapefileInBatches","VERSION","ShapefileLoader","name","id","module","version","category","extensions","mimeTypes","tests","Uint8Array","buffer","options","shapefile","shape","shp","_maxDimensions","parse","parseInBatches"],"sources":["../src/shapefile-loader.ts"],"sourcesContent":["import type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {SHP_MAGIC_NUMBER} from './shp-loader';\nimport {parseShapefile, parseShapefileInBatches} from './lib/parsers/parse-shapefile';\nimport {Batch, GeoJSONTable} from '@loaders.gl/schema';\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 type ShapefileLoaderOptions = LoaderOptions & {\n  shapefile?: {\n    shape?: 'geojson-table' | 'v3';\n  };\n};\n\n/**\n * Shapefile loader\n * @note Shapefile is multifile format and requires providing additional files\n */\nexport const ShapefileLoader: LoaderWithParser<GeoJSONTable, Batch, ShapefileLoaderOptions> = {\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      shape: 'v3'\n    },\n    shp: {\n      _maxDimensions: 4\n    }\n  },\n  // @ts-expect-error\n  parse: parseShapefile,\n  // @ts-expect-error\n  parseInBatches: parseShapefileInBatches\n};\n"],"mappings":"SACQA,gBAAgB;AAAA,SAChBC,cAAc,EAAEC,uBAAuB;AAK/C,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAY3E,OAAO,MAAMC,eAA8E,GAAG;EAC5FC,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,CAACb,gBAAgB,CAAC,CAACc,MAAM,CAAC;EAChDC,OAAO,EAAE;IACPC,SAAS,EAAE;MACTC,KAAK,EAAE;IACT,CAAC;IACDC,GAAG,EAAE;MACHC,cAAc,EAAE;IAClB;EACF,CAAC;EAEDC,KAAK,EAAEnB,cAAc;EAErBoB,cAAc,EAAEnB;AAClB,CAAC"}

package/dist/shp-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shp-loader.js","names":["parseSHP","parseSHPInBatches","VERSION","SHP_MAGIC_NUMBER","SHPWorkerLoader","name","id","module","version","worker","category","extensions","mimeTypes","tests","Uint8Array","buffer","options","shp","_maxDimensions","SHPLoader","parse","arrayBuffer","parseSync","parseInBatches","arrayBufferIterator"],"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: (\n    arrayBufferIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n    options\n  ) => parseSHPInBatches(arrayBufferIterator, options)\n};\n"],"mappings":"SACQA,QAAQ,EAAEC,iBAAiB;AAInC,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAE3E,OAAO,MAAMC,gBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;AAKxD,OAAO,MAAMC,eAAuB,GAAG;EACrCC,IAAI,EAAE,KAAK;EACXC,EAAE,EAAE,KAAK;EACTC,MAAM,EAAE,WAAW;EACnBC,OAAO,EAAEN,OAAO;EAChBO,MAAM,EAAE,IAAI;EACZC,QAAQ,EAAE,UAAU;EACpBC,UAAU,EAAE,CAAC,KAAK,CAAC;EACnBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EAEvCC,KAAK,EAAE,CAAC,IAAIC,UAAU,CAACX,gBAAgB,CAAC,CAACY,MAAM,CAAC;EAChDC,OAAO,EAAE;IACPC,GAAG,EAAE;MACHC,cAAc,EAAE;IAClB;EACF;AACF,CAAC;AAGD,OAAO,MAAMC,SAA2B,GAAG;EACzC,GAAGf,eAAe;EAClBgB,KAAK,EAAE,MAAAA,CAAOC,WAAW,EAAEL,OAAQ,KAAKhB,QAAQ,CAACqB,WAAW,EAAEL,OAAO,CAAC;EACtEM,SAAS,EAAEtB,QAAQ;EACnBuB,cAAc,EAAEA,CACdC,mBAAuE,EACvER,OAAO,KACJf,iBAAiB,CAACuB,mBAAmB,EAAER,OAAO;AACrD,CAAC"}