@loaders.gl/shapefile 3.1.8 → 3.2.0-alpha.3

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;
   }
 
@@ -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,74 @@
+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';
+  };
+};
+
+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;