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

package/dist/shp-worker.js

@@ -132,7 +132,7 @@
   // src/lib/parsers/parse-shp-geometry.ts
   var LITTLE_ENDIAN2 = true;
   function parseRecord(view, options) {
-    const { _maxDimensions } = options?.shp || {};
+    const { _maxDimensions = 4 } = options?.shp || {};
     let offset = 0;
     const type = view.getInt32(offset, LITTLE_ENDIAN2);
     offset += Int32Array.BYTES_PER_ELEMENT;
@@ -318,7 +318,13 @@
       this.binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
       this.state = STATE.EXPECTING_HEADER;
       this.result = {
-        geometries: []
+        geometries: [],
+        progress: {
+          bytesTotal: NaN,
+          bytesUsed: NaN,
+          rows: NaN
+        },
+        currentIndex: NaN
       };
       this.options = options;
     }
@@ -394,7 +400,7 @@
                 binaryReader.rewind(SHP_RECORD_HEADER_SIZE);
                 return state;
               }
-              const invalidRecord = recordHeader.byteLength < 4 || recordHeader.type !== result.header.type || recordHeader.recordNumber !== result.currentIndex;
+              const invalidRecord = recordHeader.byteLength < 4 || recordHeader.type !== result.header?.type || recordHeader.recordNumber !== result.currentIndex;
               if (invalidRecord) {
                 binaryReader.rewind(SHP_RECORD_HEADER_SIZE - 4);
               } else {
@@ -424,7 +430,7 @@
   }
 
   // src/shp-loader.ts
-  var VERSION = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION = true ? "4.0.0-alpha.6" : "latest";
   var SHP_MAGIC_NUMBER2 = [0, 0, 39, 10];
   var SHPWorkerLoader = {
     name: "SHP",
@@ -485,16 +491,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);
@@ -503,22 +526,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);
       }
     }
   };
@@ -530,19 +567,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
               }
             });

package/dist/workers/dbf-worker.js

@@ -1,4 +1,5 @@
-import { DBFLoader } from '../dbf-loader';
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-createLoaderWorker(DBFLoader);
-//# sourceMappingURL=dbf-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbf_loader_1 = require("../dbf-loader");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+(0, loader_utils_1.createLoaderWorker)(dbf_loader_1.DBFLoader);

package/dist/workers/shp-worker.js

@@ -1,4 +1,5 @@
-import { SHPLoader } from '../shp-loader';
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-createLoaderWorker(SHPLoader);
-//# sourceMappingURL=shp-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shp_loader_1 = require("../shp-loader");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+(0, loader_utils_1.createLoaderWorker)(shp_loader_1.SHPLoader);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/shapefile",
   "description": "Loader for the Shapefile Format",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.6",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -18,8 +18,8 @@
     "shp"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "browser": {
     "./src/lib/filesystems/node-filesystem.js": false,
@@ -37,10 +37,10 @@
     "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.0.0-alpha.5",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
-    "@loaders.gl/schema": "4.0.0-alpha.5",
+    "@loaders.gl/gis": "4.0.0-alpha.6",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/schema": "4.0.0-alpha.6",
     "@math.gl/proj4": "^3.5.1"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/lib/parsers/parse-dbf.ts

@@ -1,47 +1,13 @@
-import {Schema, Field, Bool, Utf8, Float64, TimestampMillisecond} from '@loaders.gl/schema';
+import {Field, ObjectRowTable} from '@loaders.gl/schema';
 import BinaryChunkReader from '../streaming/binary-chunk-reader';
-
-type DBFRowsOutput = object[];
-
-interface DBFTableOutput {
-  schema?: Schema;
-  rows: DBFRowsOutput;
-}
-
-type DBFHeader = {
-  // Last updated date
-  year: number;
-  month: number;
-  day: number;
-  // Number of records in data file
-  nRecords: number;
-  // Length of header in bytes
-  headerLength: number;
-  // Length of each record
-  recordLength: number;
-  // Not sure if this is usually set
-  languageDriver: number;
-};
-
-type DBFField = {
-  name: string;
-  dataType: string;
-  fieldLength: number;
-  decimal: number;
-};
-
-type DBFResult = {
-  data: {[key: string]: any}[];
-  schema?: Schema;
-  error?: string;
-  dbfHeader?: DBFHeader;
-  dbfFields?: DBFField[];
-  progress?: {
-    bytesUsed: number;
-    rowsTotal: number;
-    rows: number;
-  };
-};
+import {
+  DBFLoaderOptions,
+  DBFResult,
+  DBFTableOutput,
+  DBFHeader,
+  DBFRowsOutput,
+  DBFField
+} from './types';
 
 const LITTLE_ENDIAN = true;
 const DBF_HEADER_SIZE = 32;
@@ -98,21 +64,27 @@ class DBFParser {
  */
 export function parseDBF(
   arrayBuffer: ArrayBuffer,
-  options: any = {}
-): DBFRowsOutput | DBFTableOutput {
-  const loaderOptions = options.dbf || {};
-  const {encoding} = loaderOptions;
+  options: DBFLoaderOptions = {}
+): DBFRowsOutput | DBFTableOutput | ObjectRowTable {
+  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: ObjectRowTable = {
+        shape: 'object-row-table',
+        schema,
+        data
+      };
+      return table;
+    }
     case 'table':
-      // TODO - parse columns
       return {schema, rows: data};
-
     case 'rows':
     default:
       return data;
@@ -124,10 +96,9 @@ export function parseDBF(
  */
 export async function* parseDBFInBatches(
   asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
-  options: any = {}
+  options: DBFLoaderOptions = {}
 ): AsyncIterable<DBFHeader | DBFRowsOutput | DBFTableOutput> {
-  const loaderOptions = options.dbf || {};
-  const {encoding} = loaderOptions;
+  const {encoding = 'latin1'} = options.dbf || {};
 
   const parser = new DBFParser({encoding});
   let headerReturned = false;
@@ -160,7 +131,7 @@ export async function* parseDBFInBatches(
 function parseState(
   state: STATE,
   result: DBFResult,
-  binaryReader: {[key: string]: any},
+  binaryReader: BinaryChunkReader,
   textDecoder: TextDecoder
 ): STATE {
   // eslint-disable-next-line no-constant-condition
@@ -173,7 +144,8 @@ function parseState(
 
         case STATE.START:
           // Parse initial file header
-          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE, 'DBF header');
+          // DBF Header
+          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
           if (!dataView) {
             return state;
           }
@@ -190,15 +162,17 @@ function parseState(
           // Parse DBF field descriptors (schema)
           const fieldDescriptorView = binaryReader.getDataView(
             // @ts-ignore
-            result.dbfHeader.headerLength - DBF_HEADER_SIZE,
-            'DBF field descriptors'
+            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 = STATE.FIELD_PROPERTIES;
 
@@ -311,7 +285,7 @@ function parseRow(
   fields: DBFField[],
   textDecoder: TextDecoder
 ): {[key: string]: any} {
-  const out = {};
+  const out: {[key: string]: string | number | boolean | null} = {};
   let offset = 0;
   for (const field of fields) {
     const text = textDecoder.decode(
@@ -398,22 +372,22 @@ function parseCharacter(text: string): string | null {
  * @returns Field
  */
 // eslint-disable
-function makeField({name, dataType, fieldLength, decimal}): Field {
+function makeField({name, dataType, fieldLength, decimal}: DBFField): Field {
   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');
   }

package/src/lib/parsers/parse-shapefile.ts

@@ -2,6 +2,7 @@
 import type {SHXOutput} from './parse-shx';
 import type {SHPHeader} from './parse-shp-header';
 import type {LoaderContext} from '@loaders.gl/loader-utils';
+import type {ShapefileLoaderOptions} from './types';
 
 import {binaryToGeometry, transformGeoJsonCoords} from '@loaders.gl/gis';
 import {Proj4Projection} from '@math.gl/proj4';
@@ -20,15 +21,11 @@ interface ShapefileOutput {
 }
 /**
  * Parsing of file in batches
- *
- * @param asyncIterator
- * @param options
- * @param context
  */
 // eslint-disable-next-line max-statements, complexity
 export async function* parseShapefileInBatches(
   asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
-  options?: any,
+  options?: ShapefileLoaderOptions,
   context?: LoaderContext
 ): AsyncIterable<ShapefileOutput> {
   const {reproject = false, _targetCrs = 'WGS84'} = options?.gis || {};
@@ -109,7 +106,7 @@ export async function* parseShapefileInBatches(
  */
 export async function parseShapefile(
   arrayBuffer: ArrayBuffer,
-  options?: {[key: string]: any},
+  options?: ShapefileLoaderOptions,
   context?: LoaderContext
 ): Promise<ShapefileOutput> {
   const {reproject = false, _targetCrs = 'WGS84'} = options?.gis || {};

package/src/lib/parsers/parse-shp-geometry.ts

@@ -1,4 +1,5 @@
 import {BinaryGeometry, BinaryGeometryType} from '@loaders.gl/schema';
+import {SHPLoaderOptions} from './types';
 
 const LITTLE_ENDIAN = true;
 
@@ -9,8 +10,8 @@ const LITTLE_ENDIAN = true;
  * @return Binary Geometry Object
  */
 // eslint-disable-next-line complexity
-export function parseRecord(view: DataView, options?: {shp?: any}): BinaryGeometry | null {
-  const {_maxDimensions} = options?.shp || {};
+export function parseRecord(view: DataView, options?: SHPLoaderOptions): BinaryGeometry | null {
+  const {_maxDimensions = 4} = options?.shp || {};
 
   let offset = 0;
   const type: number = view.getInt32(offset, LITTLE_ENDIAN);

package/src/lib/parsers/parse-shp.ts

@@ -1,8 +1,8 @@
-import type {LoaderOptions} from '@loaders.gl/loader-utils';
 import type {BinaryGeometry} from '@loaders.gl/schema';
 import BinaryChunkReader from '../streaming/binary-chunk-reader';
-import {parseSHPHeader} from './parse-shp-header';
+import {parseSHPHeader, SHPHeader} from './parse-shp-header';
 import {parseRecord} from './parse-shp-geometry';
+import {SHPLoaderOptions} from './types';
 
 const LITTLE_ENDIAN = true;
 const BIG_ENDIAN = false;
@@ -20,20 +20,34 @@ const STATE = {
 };
 
 type SHPResult = {
-  geometries: [];
-  header?: {};
+  geometries: (BinaryGeometry | null)[];
+  header?: SHPHeader;
   error?: string;
+  progress: {
+    bytesUsed: number;
+    bytesTotal: number;
+    rows: number;
+  };
+  currentIndex: number;
 };
 
 class SHPParser {
-  options?: any = {};
+  options?: SHPLoaderOptions = {};
   binaryReader = new BinaryChunkReader({maxRewindBytes: SHP_RECORD_HEADER_SIZE});
   state = STATE.EXPECTING_HEADER;
   result: SHPResult = {
-    geometries: []
+    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?: LoaderOptions) {
+  constructor(options?: SHPLoaderOptions) {
     this.options = options;
   }
 
@@ -53,7 +67,7 @@ class SHPParser {
   }
 }
 
-export function parseSHP(arrayBuffer: ArrayBuffer, options?: object): BinaryGeometry[] {
+export function parseSHP(arrayBuffer: ArrayBuffer, options?: SHPLoaderOptions): BinaryGeometry[] {
   const shpParser = new SHPParser(options);
   shpParser.write(arrayBuffer);
   shpParser.end();
@@ -69,7 +83,7 @@ export function parseSHP(arrayBuffer: ArrayBuffer, options?: object): BinaryGeom
  */
 export async function* parseSHPInBatches(
   asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
-  options?: object
+  options?: SHPLoaderOptions
 ): AsyncIterable<BinaryGeometry | object> {
   const parser = new SHPParser(options);
   let headerReturned = false;
@@ -109,9 +123,9 @@ export async function* parseSHPInBatches(
 /* eslint-disable complexity, max-depth */
 function parseState(
   state: number,
-  result: {[key: string]: any},
+  result: SHPResult,
   binaryReader: BinaryChunkReader,
-  options: {shp?: any}
+  options?: SHPLoaderOptions
 ): number {
   // eslint-disable-next-line no-constant-condition
   while (true) {
@@ -157,7 +171,7 @@ function parseState(
 
             const invalidRecord =
               recordHeader.byteLength < 4 ||
-              recordHeader.type !== result.header.type ||
+              recordHeader.type !== result.header?.type ||
               recordHeader.recordNumber !== result.currentIndex;
 
             // All records must have at least four bytes (for the record shape type)

package/src/lib/parsers/types.ts

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

package/src/lib/streaming/binary-chunk-reader.ts

@@ -1,10 +1,14 @@
+type BinaryChunkReaderOptions = {
+  maxRewindBytes: number;
+};
+
 export default class BinaryChunkReader {
   offset: number;
   arrayBuffers: ArrayBuffer[];
   ended: boolean;
   maxRewindBytes: number;
 
-  constructor(options?: {[key: string]: any}) {
+  constructor(options?: BinaryChunkReaderOptions) {
     const {maxRewindBytes = 0} = options || {};
 
     /** current global offset into current array buffer*/

package/src/lib/streaming/zip-batch-iterators.ts

@@ -8,8 +8,8 @@ export async function* zipBatchIterators(
   iterator1: AsyncIterator<any[]>,
   iterator2: AsyncIterator<any[]>
 ): AsyncGenerator<number[][], void, unknown> {
-  let batch1 = [];
-  let batch2 = [];
+  let batch1: number[] = [];
+  let batch2: number[] = [];
   let iterator1Done: boolean = false;
   let iterator2Done: boolean = false;
 

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/dbf-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/dbf-loader.ts"],"names":["parseDBF","parseDBFInBatches","VERSION","DBFWorkerLoader","name","id","module","version","worker","category","extensions","mimeTypes","options","dbf","encoding","DBFLoader","parse","arrayBuffer","parseSync","parseInBatches"],"mappings":"AACA,SAAQA,QAAR,EAAkBC,iBAAlB,QAA0C,yBAA1C;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAKA,OAAO,MAAMC,eAAuB,GAAG;AACrCC,EAAAA,IAAI,EAAE,KAD+B;AAErCC,EAAAA,EAAE,EAAE,KAFiC;AAGrCC,EAAAA,MAAM,EAAE,WAH6B;AAIrCC,EAAAA,OAAO,EAAEL,OAJ4B;AAKrCM,EAAAA,MAAM,EAAE,IAL6B;AAMrCC,EAAAA,QAAQ,EAAE,OAN2B;AAOrCC,EAAAA,UAAU,EAAE,CAAC,KAAD,CAPyB;AAQrCC,EAAAA,SAAS,EAAE,CAAC,mBAAD,CAR0B;AASrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AACHC,MAAAA,QAAQ,EAAE;AADP;AADE;AAT4B,CAAhC;AAiBP,OAAO,MAAMC,SAA2B,GAAG,EACzC,GAAGZ,eADsC;AAEzCa,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBL,OAApB,KAAgCZ,QAAQ,CAACiB,WAAD,EAAcL,OAAd,CAFN;AAGzCM,EAAAA,SAAS,EAAElB,QAH8B;AAIzCmB,EAAAA,cAAc,EAAElB;AAJyB,CAApC","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseDBF, parseDBFInBatches} from './lib/parsers/parse-dbf';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * DBFLoader - DBF files are used to contain non-geometry columns in Shapefiles\n */\nexport const DBFWorkerLoader: Loader = {\n  name: 'DBF',\n  id: 'dbf',\n  module: 'shapefile',\n  version: VERSION,\n  worker: true,\n  category: 'table',\n  extensions: ['dbf'],\n  mimeTypes: ['application/x-dbf'],\n  options: {\n    dbf: {\n      encoding: 'latin1'\n    }\n  }\n};\n\n/** DBF file loader */\nexport const DBFLoader: LoaderWithParser = {\n  ...DBFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseDBF(arrayBuffer, options),\n  parseSync: parseDBF,\n  parseInBatches: parseDBFInBatches\n};\n"],"file":"dbf-loader.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["ShapefileLoader","DBFLoader","DBFWorkerLoader","SHPLoader","SHPWorkerLoader"],"mappings":"AAAA,SAAQA,eAAR,QAA8B,oBAA9B;AACA,SAAQC,SAAR,EAAmBC,eAAnB,QAAyC,cAAzC;AACA,SAAQC,SAAR,EAAmBC,eAAnB,QAAyC,cAAzC","sourcesContent":["export {ShapefileLoader} from './shapefile-loader';\nexport {DBFLoader, DBFWorkerLoader} from './dbf-loader';\nexport {SHPLoader, SHPWorkerLoader} from './shp-loader';\n"],"file":"index.js"}