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

package/dist/bundle.js

@@ -1,5 +1,5 @@
+"use strict";
+// @ts-nocheck
 const moduleExports = require('./index');
-
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/dbf-loader.js

@@ -1,23 +1,32 @@
-import { parseDBF, parseDBFInBatches } from './lib/parsers/parse-dbf';
-const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : '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'
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBFLoader = exports.DBFWorkerLoader = void 0;
+const parse_dbf_1 = require("./lib/parsers/parse-dbf");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * DBFLoader - DBF files are used to contain non-geometry columns in Shapefiles
+ */
+exports.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
+/** DBF file loader */
+exports.DBFLoader = {
+    ...exports.DBFWorkerLoader,
+    parse: async (arrayBuffer, options) => (0, parse_dbf_1.parseDBF)(arrayBuffer, options),
+    parseSync: parse_dbf_1.parseDBF,
+    parseInBatches: parse_dbf_1.parseDBFInBatches
 };
-//# sourceMappingURL=dbf-loader.js.map

package/dist/dbf-worker.js

@@ -1,420 +1,4 @@
 (() => {
-  // ../schema/src/lib/utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../schema/src/lib/schema/impl/schema.ts
-  var Schema = class {
-    constructor(fields, metadata) {
-      assert(Array.isArray(fields));
-      checkNames(fields);
-      this.fields = fields;
-      this.metadata = metadata || new Map();
-    }
-    compareTo(other) {
-      if (this.metadata !== other.metadata) {
-        return false;
-      }
-      if (this.fields.length !== other.fields.length) {
-        return false;
-      }
-      for (let i = 0; i < this.fields.length; ++i) {
-        if (!this.fields[i].compareTo(other.fields[i])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    select(...columnNames) {
-      const nameMap = Object.create(null);
-      for (const name of columnNames) {
-        nameMap[name] = true;
-      }
-      const selectedFields = this.fields.filter((field) => nameMap[field.name]);
-      return new Schema(selectedFields, this.metadata);
-    }
-    selectAt(...columnIndices) {
-      const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
-      return new Schema(selectedFields, this.metadata);
-    }
-    assign(schemaOrFields) {
-      let fields;
-      let metadata = this.metadata;
-      if (schemaOrFields instanceof Schema) {
-        const otherSchema = schemaOrFields;
-        fields = otherSchema.fields;
-        metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);
-      } else {
-        fields = schemaOrFields;
-      }
-      const fieldMap = Object.create(null);
-      for (const field of this.fields) {
-        fieldMap[field.name] = field;
-      }
-      for (const field of fields) {
-        fieldMap[field.name] = field;
-      }
-      const mergedFields = Object.values(fieldMap);
-      return new Schema(mergedFields, metadata);
-    }
-  };
-  function checkNames(fields) {
-    const usedNames = {};
-    for (const field of fields) {
-      if (usedNames[field.name]) {
-        console.warn("Schema: duplicated field name", field.name, field);
-      }
-      usedNames[field.name] = true;
-    }
-  }
-  function mergeMaps(m1, m2) {
-    return new Map([...m1 || new Map(), ...m2 || new Map()]);
-  }
-
-  // ../schema/src/lib/schema/impl/field.ts
-  var Field = class {
-    constructor(name, type, nullable = false, metadata = new Map()) {
-      this.name = name;
-      this.type = type;
-      this.nullable = nullable;
-      this.metadata = metadata;
-    }
-    get typeId() {
-      return this.type && this.type.typeId;
-    }
-    clone() {
-      return new Field(this.name, this.type, this.nullable, this.metadata);
-    }
-    compareTo(other) {
-      return this.name === other.name && this.type === other.type && this.nullable === other.nullable && this.metadata === other.metadata;
-    }
-    toString() {
-      return `${this.type}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${this.metadata}` : ""}`;
-    }
-  };
-
-  // ../schema/src/lib/schema/impl/enum.ts
-  var Type;
-  (function(Type2) {
-    Type2[Type2["NONE"] = 0] = "NONE";
-    Type2[Type2["Null"] = 1] = "Null";
-    Type2[Type2["Int"] = 2] = "Int";
-    Type2[Type2["Float"] = 3] = "Float";
-    Type2[Type2["Binary"] = 4] = "Binary";
-    Type2[Type2["Utf8"] = 5] = "Utf8";
-    Type2[Type2["Bool"] = 6] = "Bool";
-    Type2[Type2["Decimal"] = 7] = "Decimal";
-    Type2[Type2["Date"] = 8] = "Date";
-    Type2[Type2["Time"] = 9] = "Time";
-    Type2[Type2["Timestamp"] = 10] = "Timestamp";
-    Type2[Type2["Interval"] = 11] = "Interval";
-    Type2[Type2["List"] = 12] = "List";
-    Type2[Type2["Struct"] = 13] = "Struct";
-    Type2[Type2["Union"] = 14] = "Union";
-    Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
-    Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
-    Type2[Type2["Map"] = 17] = "Map";
-    Type2[Type2["Dictionary"] = -1] = "Dictionary";
-    Type2[Type2["Int8"] = -2] = "Int8";
-    Type2[Type2["Int16"] = -3] = "Int16";
-    Type2[Type2["Int32"] = -4] = "Int32";
-    Type2[Type2["Int64"] = -5] = "Int64";
-    Type2[Type2["Uint8"] = -6] = "Uint8";
-    Type2[Type2["Uint16"] = -7] = "Uint16";
-    Type2[Type2["Uint32"] = -8] = "Uint32";
-    Type2[Type2["Uint64"] = -9] = "Uint64";
-    Type2[Type2["Float16"] = -10] = "Float16";
-    Type2[Type2["Float32"] = -11] = "Float32";
-    Type2[Type2["Float64"] = -12] = "Float64";
-    Type2[Type2["DateDay"] = -13] = "DateDay";
-    Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
-    Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
-    Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
-    Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
-    Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
-    Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
-    Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
-    Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
-    Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
-    Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
-    Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
-    Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
-    Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
-  })(Type || (Type = {}));
-
-  // ../schema/src/lib/schema/impl/type.ts
-  var DataType = class {
-    static isNull(x) {
-      return x && x.typeId === Type.Null;
-    }
-    static isInt(x) {
-      return x && x.typeId === Type.Int;
-    }
-    static isFloat(x) {
-      return x && x.typeId === Type.Float;
-    }
-    static isBinary(x) {
-      return x && x.typeId === Type.Binary;
-    }
-    static isUtf8(x) {
-      return x && x.typeId === Type.Utf8;
-    }
-    static isBool(x) {
-      return x && x.typeId === Type.Bool;
-    }
-    static isDecimal(x) {
-      return x && x.typeId === Type.Decimal;
-    }
-    static isDate(x) {
-      return x && x.typeId === Type.Date;
-    }
-    static isTime(x) {
-      return x && x.typeId === Type.Time;
-    }
-    static isTimestamp(x) {
-      return x && x.typeId === Type.Timestamp;
-    }
-    static isInterval(x) {
-      return x && x.typeId === Type.Interval;
-    }
-    static isList(x) {
-      return x && x.typeId === Type.List;
-    }
-    static isStruct(x) {
-      return x && x.typeId === Type.Struct;
-    }
-    static isUnion(x) {
-      return x && x.typeId === Type.Union;
-    }
-    static isFixedSizeBinary(x) {
-      return x && x.typeId === Type.FixedSizeBinary;
-    }
-    static isFixedSizeList(x) {
-      return x && x.typeId === Type.FixedSizeList;
-    }
-    static isMap(x) {
-      return x && x.typeId === Type.Map;
-    }
-    static isDictionary(x) {
-      return x && x.typeId === Type.Dictionary;
-    }
-    get typeId() {
-      return Type.NONE;
-    }
-    compareTo(other) {
-      return this === other;
-    }
-  };
-  var Null = class extends DataType {
-    get typeId() {
-      return Type.Null;
-    }
-    get [Symbol.toStringTag]() {
-      return "Null";
-    }
-    toString() {
-      return "Null";
-    }
-  };
-  var Bool = class extends DataType {
-    get typeId() {
-      return Type.Bool;
-    }
-    get [Symbol.toStringTag]() {
-      return "Bool";
-    }
-    toString() {
-      return "Bool";
-    }
-  };
-  var Int = class extends DataType {
-    constructor(isSigned, bitWidth) {
-      super();
-      this.isSigned = isSigned;
-      this.bitWidth = bitWidth;
-    }
-    get typeId() {
-      return Type.Int;
-    }
-    get [Symbol.toStringTag]() {
-      return "Int";
-    }
-    toString() {
-      return `${this.isSigned ? "I" : "Ui"}nt${this.bitWidth}`;
-    }
-  };
-  var Precision = {
-    HALF: 16,
-    SINGLE: 32,
-    DOUBLE: 64
-  };
-  var Float = class extends DataType {
-    constructor(precision) {
-      super();
-      this.precision = precision;
-    }
-    get typeId() {
-      return Type.Float;
-    }
-    get [Symbol.toStringTag]() {
-      return "Float";
-    }
-    toString() {
-      return `Float${this.precision}`;
-    }
-  };
-  var Float64 = class extends Float {
-    constructor() {
-      super(Precision.DOUBLE);
-    }
-  };
-  var Binary = class extends DataType {
-    constructor() {
-      super();
-    }
-    get typeId() {
-      return Type.Binary;
-    }
-    toString() {
-      return "Binary";
-    }
-    get [Symbol.toStringTag]() {
-      return "Binary";
-    }
-  };
-  var Utf8 = class extends DataType {
-    get typeId() {
-      return Type.Utf8;
-    }
-    get [Symbol.toStringTag]() {
-      return "Utf8";
-    }
-    toString() {
-      return "Utf8";
-    }
-  };
-  var DateUnit = {
-    DAY: 0,
-    MILLISECOND: 1
-  };
-  var Date2 = class extends DataType {
-    constructor(unit) {
-      super();
-      this.unit = unit;
-    }
-    get typeId() {
-      return Type.Date;
-    }
-    get [Symbol.toStringTag]() {
-      return "Date";
-    }
-    toString() {
-      return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
-    }
-  };
-  var TimeUnit = {
-    SECOND: 1,
-    MILLISECOND: 1e3,
-    MICROSECOND: 1e6,
-    NANOSECOND: 1e9
-  };
-  var Time = class extends DataType {
-    constructor(unit, bitWidth) {
-      super();
-      this.unit = unit;
-      this.bitWidth = bitWidth;
-    }
-    get typeId() {
-      return Type.Time;
-    }
-    toString() {
-      return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
-    }
-    get [Symbol.toStringTag]() {
-      return "Time";
-    }
-  };
-  var Timestamp = class extends DataType {
-    constructor(unit, timezone = null) {
-      super();
-      this.unit = unit;
-      this.timezone = timezone;
-    }
-    get typeId() {
-      return Type.Timestamp;
-    }
-    get [Symbol.toStringTag]() {
-      return "Timestamp";
-    }
-    toString() {
-      return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ""}>`;
-    }
-  };
-  var TimestampMillisecond = class extends Timestamp {
-    constructor(timezone = null) {
-      super(TimeUnit.MILLISECOND, timezone);
-    }
-  };
-  var IntervalUnit = {
-    DAY_TIME: 0,
-    YEAR_MONTH: 1
-  };
-  var Interval = class extends DataType {
-    constructor(unit) {
-      super();
-      this.unit = unit;
-    }
-    get typeId() {
-      return Type.Interval;
-    }
-    get [Symbol.toStringTag]() {
-      return "Interval";
-    }
-    toString() {
-      return `Interval<${IntervalUnit[this.unit]}>`;
-    }
-  };
-  var FixedSizeList = class extends DataType {
-    constructor(listSize, child) {
-      super();
-      this.listSize = listSize;
-      this.children = [child];
-    }
-    get typeId() {
-      return Type.FixedSizeList;
-    }
-    get valueType() {
-      return this.children[0].type;
-    }
-    get valueField() {
-      return this.children[0];
-    }
-    get [Symbol.toStringTag]() {
-      return "FixedSizeList";
-    }
-    toString() {
-      return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
-    }
-  };
-  var Struct = class extends DataType {
-    constructor(children) {
-      super();
-      this.children = children;
-    }
-    get typeId() {
-      return Type.Struct;
-    }
-    toString() {
-      return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(", ")}}>`;
-    }
-    get [Symbol.toStringTag]() {
-      return "Struct";
-    }
-  };
-
   // src/lib/streaming/binary-chunk-reader.ts
   var BinaryChunkReader = class {
     constructor(options) {
@@ -549,13 +133,21 @@
     }
   };
   function parseDBF(arrayBuffer, options = {}) {
-    const loaderOptions = options.dbf || {};
-    const { encoding } = loaderOptions;
+    const { encoding = "latin1" } = options.dbf || {};
     const dbfParser = new DBFParser({ encoding });
     dbfParser.write(arrayBuffer);
     dbfParser.end();
     const { data, schema } = dbfParser.result;
-    switch (options.tables && options.tables.format) {
+    const shape = options?.tables?.format || 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":
@@ -564,8 +156,7 @@
     }
   }
   async function* parseDBFInBatches(asyncIterator, options = {}) {
-    const loaderOptions = options.dbf || {};
-    const { encoding } = loaderOptions;
+    const { encoding = "latin1" } = options.dbf || {};
     const parser = new DBFParser({ encoding });
     let headerReturned = false;
     for await (const arrayBuffer of asyncIterator) {
@@ -592,7 +183,7 @@
           case 3:
             return state;
           case 0:
-            const dataView = binaryReader.getDataView(DBF_HEADER_SIZE, "DBF header");
+            const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
             if (!dataView) {
               return state;
             }
@@ -605,12 +196,15 @@
             state = 1;
             break;
           case 1:
-            const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE, "DBF field descriptors");
+            const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE);
             if (!fieldDescriptorView) {
               return state;
             }
             result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
-            result.schema = new Schema(result.dbfFields.map((dbfField) => makeField(dbfField)));
+            result.schema = {
+              fields: result.dbfFields.map((dbfField) => makeField(dbfField)),
+              metadata: {}
+            };
             state = 2;
             binaryReader.skip(1);
             break;
@@ -713,26 +307,26 @@
   function makeField({ name, dataType, fieldLength, decimal }) {
     switch (dataType) {
       case "B":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "C":
-        return new Field(name, new Utf8(), true);
+        return { name, type: "utf8", nullable: true, metadata: {} };
       case "F":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "N":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "O":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "D":
-        return new Field(name, new TimestampMillisecond(), true);
+        return { name, type: "timestamp-millisecond", nullable: true, metadata: {} };
       case "L":
-        return new Field(name, new Bool(), true);
+        return { name, type: "bool", nullable: true, metadata: {} };
       default:
         throw new Error("Unsupported data type");
     }
   }
 
   // src/dbf-loader.ts
-  var VERSION = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION = true ? "4.0.0-alpha.6" : "latest";
   var DBFWorkerLoader = {
     name: "DBF",
     id: "dbf",
@@ -791,16 +385,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -809,22 +420,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -836,19 +461,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });