@loaders.gl/shapefile 4.3.2 → 4.4.0-alpha.1

package/dist/index.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  DBFArrowLoader: () => DBFArrowLoader,
+  DBFArrowWorkerLoader: () => DBFArrowWorkerLoader,
   DBFLoader: () => DBFLoader,
   DBFWorkerLoader: () => DBFWorkerLoader,
   SHPLoader: () => SHPLoader,
@@ -516,7 +518,7 @@ function parseState(state, result, binaryReader, options) {
 }
 
 // dist/shp-loader.js
-var VERSION = true ? "4.3.1" : "latest";
+var VERSION = true ? "4.4.0-alpha.0" : "latest";
 var SHP_MAGIC_NUMBER2 = [0, 0, 39, 10];
 var SHPWorkerLoader = {
   dataType: null,
@@ -618,12 +620,12 @@ function extractBatchData(batch1, batch2) {
 var LITTLE_ENDIAN4 = true;
 var DBF_HEADER_SIZE = 32;
 var STATE2;
-(function(STATE3) {
-  STATE3[STATE3["START"] = 0] = "START";
-  STATE3[STATE3["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
-  STATE3[STATE3["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
-  STATE3[STATE3["END"] = 3] = "END";
-  STATE3[STATE3["ERROR"] = 4] = "ERROR";
+(function(STATE4) {
+  STATE4[STATE4["START"] = 0] = "START";
+  STATE4[STATE4["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
+  STATE4[STATE4["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
+  STATE4[STATE4["END"] = 3] = "END";
+  STATE4[STATE4["ERROR"] = 4] = "ERROR";
 })(STATE2 || (STATE2 = {}));
 var DBFParser = class {
   binaryReader = new BinaryChunkReader();
@@ -854,7 +856,7 @@ function makeField({ name, dataType, fieldLength, decimal }) {
 }
 
 // dist/dbf-loader.js
-var VERSION2 = true ? "4.3.1" : "latest";
+var VERSION2 = true ? "4.4.0-alpha.0" : "latest";
 var DBFWorkerLoader = {
   name: "DBF",
   dataType: null,
@@ -977,7 +979,7 @@ async function parseShapefile(arrayBuffer, options, context) {
 function parseGeometries(geometries) {
   const geojsonGeometries = [];
   for (const geom of geometries) {
-    geojsonGeometries.push((0, import_gis.binaryToGeometry)(geom));
+    geojsonGeometries.push((0, import_gis.convertBinaryGeometryToGeometry)(geom));
   }
   return geojsonGeometries;
 }
@@ -1055,7 +1057,7 @@ function extname(url) {
 }
 
 // dist/shapefile-loader.js
-var VERSION3 = true ? "4.3.1" : "latest";
+var VERSION3 = true ? "4.4.0-alpha.0" : "latest";
 var ShapefileLoader = {
   name: "Shapefile",
   id: "shapefile",
@@ -1079,6 +1081,271 @@ var ShapefileLoader = {
   parseInBatches: parseShapefileInBatches
 };
 
+// dist/lib/parsers/parse-dbf-to-arrow.js
+var import_schema_utils = require("@loaders.gl/schema-utils");
+var LITTLE_ENDIAN5 = true;
+var DBF_HEADER_SIZE2 = 32;
+var STATE3;
+(function(STATE4) {
+  STATE4[STATE4["START"] = 0] = "START";
+  STATE4[STATE4["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
+  STATE4[STATE4["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
+  STATE4[STATE4["END"] = 3] = "END";
+  STATE4[STATE4["ERROR"] = 4] = "ERROR";
+})(STATE3 || (STATE3 = {}));
+var DBFParser2 = class {
+  binaryReader = new BinaryChunkReader();
+  textDecoder;
+  state = STATE3.START;
+  result = {};
+  constructor(options) {
+    this.textDecoder = new TextDecoder(options.encoding);
+  }
+  /**
+   * @param arrayBuffer
+   */
+  write(arrayBuffer) {
+    this.binaryReader.write(arrayBuffer);
+    this.state = parseState3(this.state, this.result, this.binaryReader, this.textDecoder);
+  }
+  end() {
+    this.binaryReader.end();
+    this.state = parseState3(this.state, this.result, this.binaryReader, this.textDecoder);
+    if (this.state !== STATE3.END) {
+      this.state = STATE3.ERROR;
+      this.result.error = "DBF incomplete file";
+    }
+  }
+};
+function parseDBF2(arrayBuffer, options = {}) {
+  const { encoding = "latin1" } = options.dbf || {};
+  const dbfParser = new DBFParser2({ encoding });
+  dbfParser.write(arrayBuffer);
+  dbfParser.end();
+  const tableBuilder = dbfParser.result.tableBuilder;
+  const arrowTable = tableBuilder.finishTable();
+  return arrowTable;
+}
+async function* parseDBFInBatches2(asyncIterator, options = {}) {
+  const { encoding = "latin1" } = options.dbf || {};
+  const parser = new DBFParser2({ encoding });
+  let headerReturned = false;
+  for await (const arrayBuffer of asyncIterator) {
+    parser.write(arrayBuffer);
+    if (!headerReturned && parser.result.dbfHeader) {
+      headerReturned = true;
+      const tableBuilder3 = parser.result.tableBuilder;
+      const tableBatch3 = tableBuilder3.firstBatch();
+      if (tableBatch3) {
+        yield tableBatch3;
+      }
+    }
+    const tableBuilder2 = parser.result.tableBuilder;
+    const tableBatch2 = tableBuilder2.flushBatch();
+    if (tableBatch2) {
+      yield tableBatch2;
+    }
+  }
+  parser.end();
+  const tableBuilder = parser.result.tableBuilder;
+  const tableBatch = tableBuilder.finishBatch();
+  if (tableBatch) {
+    yield tableBatch;
+  }
+}
+function parseState3(state, result, binaryReader, textDecoder) {
+  while (true) {
+    try {
+      switch (state) {
+        case STATE3.ERROR:
+        case STATE3.END:
+          return state;
+        case STATE3.START:
+          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE2);
+          if (!dataView) {
+            return state;
+          }
+          result.dbfHeader = parseDBFHeader2(dataView);
+          result.progress = {
+            bytesUsed: 0,
+            rowsTotal: result.dbfHeader.nRecords,
+            rows: 0
+          };
+          state = STATE3.FIELD_DESCRIPTORS;
+          break;
+        case STATE3.FIELD_DESCRIPTORS:
+          const fieldDescriptorView = binaryReader.getDataView(
+            // @ts-ignore
+            result.dbfHeader.headerLength - DBF_HEADER_SIZE2
+          );
+          if (!fieldDescriptorView) {
+            return state;
+          }
+          result.dbfFields = parseFieldDescriptors2(fieldDescriptorView, textDecoder);
+          const schema = {
+            fields: result.dbfFields.map((dbfField) => makeField2(dbfField)),
+            metadata: {}
+          };
+          result.tableBuilder = new import_schema_utils.ArrowTableBuilder(schema);
+          state = STATE3.FIELD_PROPERTIES;
+          binaryReader.skip(1);
+          break;
+        case STATE3.FIELD_PROPERTIES:
+          const { recordLength = 0, nRecords = 0 } = (result == null ? void 0 : result.dbfHeader) || {};
+          let rowCount = 0;
+          while (rowCount < nRecords) {
+            rowCount++;
+            const recordView = binaryReader.getDataView(recordLength - 1);
+            if (!recordView) {
+              return state;
+            }
+            binaryReader.skip(1);
+            const row = parseRow2(recordView, result.dbfFields, textDecoder);
+            result.tableBuilder.addObjectRow(row);
+          }
+          state = STATE3.END;
+          break;
+        default:
+          state = STATE3.ERROR;
+          result.error = `illegal parser state ${state}`;
+          return state;
+      }
+    } catch (error) {
+      state = STATE3.ERROR;
+      result.error = `DBF parsing failed: ${error.message}`;
+      return state;
+    }
+  }
+}
+function parseDBFHeader2(headerView) {
+  return {
+    // Last updated date
+    year: headerView.getUint8(1) + 1900,
+    month: headerView.getUint8(2),
+    day: headerView.getUint8(3),
+    // Number of records in data file
+    nRecords: headerView.getUint32(4, LITTLE_ENDIAN5),
+    // Length of header in bytes
+    headerLength: headerView.getUint16(8, LITTLE_ENDIAN5),
+    // Length of each record
+    recordLength: headerView.getUint16(10, LITTLE_ENDIAN5),
+    // Not sure if this is usually set
+    languageDriver: headerView.getUint8(29)
+  };
+}
+function parseFieldDescriptors2(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 parseRow2(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] = parseField2(text, field.dataType);
+    offset += field.fieldLength;
+  }
+  return out;
+}
+function parseField2(text, dataType) {
+  switch (dataType) {
+    case "B":
+      return parseNumber2(text);
+    case "C":
+      return parseCharacter2(text);
+    case "F":
+      return parseNumber2(text);
+    case "N":
+      return parseNumber2(text);
+    case "O":
+      return parseNumber2(text);
+    case "D":
+      return parseDate2(text);
+    case "L":
+      return parseBoolean2(text);
+    default:
+      throw new Error("Unsupported data type");
+  }
+}
+function parseDate2(str) {
+  return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));
+}
+function parseBoolean2(value) {
+  return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;
+}
+function parseNumber2(text) {
+  const number = parseFloat(text);
+  return isNaN(number) ? null : number;
+}
+function parseCharacter2(text) {
+  return text.trim() || null;
+}
+function makeField2({ name, dataType, fieldLength, decimal }) {
+  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");
+  }
+}
+
+// dist/dbf-format.js
+var DBFFormat = {
+  name: "DBF",
+  id: "dbf",
+  module: "shapefile",
+  category: "table",
+  extensions: ["dbf"],
+  mimeTypes: ["application/x-dbf"]
+};
+
+// dist/dbf-arrow-loader.js
+var VERSION4 = true ? "4.4.0-alpha.0" : "latest";
+var DBFArrowWorkerLoader = {
+  ...DBFFormat,
+  dataType: null,
+  batchType: null,
+  version: VERSION4,
+  worker: true,
+  options: {
+    dbf: {
+      encoding: "latin1"
+    }
+  }
+};
+var DBFArrowLoader = {
+  ...DBFArrowWorkerLoader,
+  parse: async (arrayBuffer, options) => parseDBF2(arrayBuffer, options),
+  parseSync: parseDBF2,
+  parseInBatches(arrayBufferIterator, options) {
+    return parseDBFInBatches2(arrayBufferIterator, options);
+  }
+};
+
 // dist/lib/streaming/binary-reader.js
 var BinaryReader = class {
   offset;