@loaders.gl/shapefile 4.0.0-alpha.23 → 4.0.0-alpha.25

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

@@ -1,6 +1,7 @@
 // import type {Feature} from '@loaders.gl/gis';
 import {LoaderContext, parseInBatchesFromContext, parseFromContext} from '@loaders.gl/loader-utils';
 import {binaryToGeometry, transformGeoJsonCoords} from '@loaders.gl/gis';
+import type {BinaryGeometry, Geometry, ObjectRowTableBatch} from '@loaders.gl/schema';
 import {Proj4Projection} from '@math.gl/proj4';
 
 import type {SHXOutput} from './parse-shx';
@@ -32,19 +33,22 @@ export async function* parseShapefileInBatches(
   const {shx, cpg, prj} = await loadShapefileSidecarFiles(options, context);
 
   // parse geometries
-  const shapeIterable: any = await parseInBatchesFromContext(
+  const shapeIterable = await parseInBatchesFromContext(
     asyncIterator,
     SHPLoader,
     options,
     context!
   );
 
+  const shapeIterator: AsyncIterator<any> =
+    shapeIterable[Symbol.asyncIterator]?.() || shapeIterable[Symbol.iterator]?.();
+
   // parse properties
-  let propertyIterable: any;
+  let propertyIterator: AsyncIterator<any> | null = null;
   const dbfResponse = await context?.fetch(replaceExtension(context?.url || '', 'dbf'));
   if (dbfResponse?.ok) {
-    propertyIterable = await parseInBatchesFromContext(
-      dbfResponse as any,
+    const propertyIterable = await parseInBatchesFromContext(
+      dbfResponse,
       DBFLoader,
       {
         ...options,
@@ -52,39 +56,44 @@ export async function* parseShapefileInBatches(
       },
       context!
     );
+    propertyIterator =
+      propertyIterable[Symbol.asyncIterator]?.() || propertyIterable[Symbol.iterator]();
   }
 
   // When `options.metadata` is `true`, there's an extra initial `metadata`
   // object before the iterator starts. zipBatchIterators expects to receive
   // batches of Array objects, and will fail with non-iterable batches, so it's
   // important to skip over the first batch.
-  let shapeHeader = (await shapeIterable.next()).value;
+  let shapeHeader = (await shapeIterator.next()).value;
   if (shapeHeader && shapeHeader.batchType === 'metadata') {
-    shapeHeader = (await shapeIterable.next()).value;
+    shapeHeader = (await shapeIterator.next()).value;
   }
 
   let dbfHeader: {batchType?: string} = {};
-  if (propertyIterable) {
-    dbfHeader = (await propertyIterable.next()).value;
+  if (propertyIterator) {
+    dbfHeader = (await propertyIterator.next()).value;
     if (dbfHeader && dbfHeader.batchType === 'metadata') {
-      dbfHeader = (await propertyIterable.next()).value;
+      dbfHeader = (await propertyIterator.next()).value;
     }
   }
 
-  let iterator: any;
-  if (propertyIterable) {
-    iterator = zipBatchIterators(shapeIterable, propertyIterable);
-  } else {
-    iterator = shapeIterable;
-  }
+  const zippedIterator: AsyncIterator<ObjectRowTableBatch> = propertyIterator
+    ? zipBatchIterators(shapeIterator, propertyIterator, 'object-row-table')
+    : shapeIterator;
 
-  for await (const item of iterator) {
+  const zippedBatchIterable: AsyncIterable<ObjectRowTableBatch> = {
+    [Symbol.asyncIterator]() {
+      return zippedIterator;
+    }
+  };
+
+  for await (const batch of zippedBatchIterable) {
     let geometries: any;
     let properties: any;
-    if (!propertyIterable) {
-      geometries = item;
+    if (!propertyIterator) {
+      geometries = batch;
     } else {
-      [geometries, properties] = item;
+      [geometries, properties] = batch.data;
     }
 
     const geojsonGeometries = parseGeometries(geometries);
@@ -157,7 +166,7 @@ export async function parseShapefile(
  * @param geometries
  * @returns geometries as an array
  */
-function parseGeometries(geometries: any[]): any[] {
+function parseGeometries(geometries: BinaryGeometry[]): Geometry[] {
   const geojsonGeometries: any[] = [];
   for (const geom of geometries) {
     geojsonGeometries.push(binaryToGeometry(geom));
@@ -172,7 +181,7 @@ function parseGeometries(geometries: any[]): any[] {
  * @param  properties [description]
  * @return [description]
  */
-function joinProperties(geometries: object[], properties: object[]): Feature[] {
+function joinProperties(geometries: Geometry[], properties: object[]): Feature[] {
   const features: Feature[] = [];
   for (let i = 0; i < geometries.length; i++) {
     const geometry = geometries[i];
@@ -213,7 +222,7 @@ function reprojectFeatures(features: Feature[], sourceCrs?: string, targetCrs?:
  */
 // eslint-disable-next-line max-statements
 export async function loadShapefileSidecarFiles(
-  options?: object,
+  options?: ShapefileLoaderOptions,
   context?: LoaderContext
 ): Promise<{
   shx?: SHXOutput;

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

@@ -1,5 +1,5 @@
 import type {BinaryGeometry} from '@loaders.gl/schema';
-import BinaryChunkReader from '../streaming/binary-chunk-reader';
+import {BinaryChunkReader} from '../streaming/binary-chunk-reader';
 import {parseSHPHeader, SHPHeader} from './parse-shp-header';
 import {parseRecord} from './parse-shp-geometry';
 import {SHPLoaderOptions} from './types';
@@ -84,7 +84,7 @@ export function parseSHP(arrayBuffer: ArrayBuffer, options?: SHPLoaderOptions):
 export async function* parseSHPInBatches(
   asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
   options?: SHPLoaderOptions
-): AsyncIterable<BinaryGeometry | object> {
+): AsyncGenerator<BinaryGeometry | object> {
   const parser = new SHPParser(options);
   let headerReturned = false;
   for await (const arrayBuffer of asyncIterator) {

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

@@ -1,8 +1,10 @@
-type BinaryChunkReaderOptions = {
+// loaders.gl, MIT license
+
+export type BinaryChunkReaderOptions = {
   maxRewindBytes: number;
 };
 
-export default class BinaryChunkReader {
+export class BinaryChunkReader {
   offset: number;
   arrayBuffers: ArrayBuffer[];
   ended: boolean;
@@ -110,7 +112,6 @@ export default class BinaryChunkReader {
     }
 
     if (!bufferOffsets) {
-      // @ts-ignore
       return null;
     }
 

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

@@ -1,4 +1,6 @@
-export default class BinaryReader {
+// loaders.gl, MIT license
+
+export class BinaryReader {
   offset: number;
   arrayBuffer: ArrayBuffer;
 

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

@@ -1,3 +1,9 @@
+// loaders.gl, MIT license
+
+import type {ObjectRowTableBatch, ArrayRowTableBatch} from '@loaders.gl/schema';
+
+type RowTableBatch = ObjectRowTableBatch | ArrayRowTableBatch;
+
 /**
  * Zip two iterators together
  *
@@ -5,36 +11,44 @@
  * @param iterator2
  */
 export async function* zipBatchIterators(
-  iterator1: AsyncIterator<any[]>,
-  iterator2: AsyncIterator<any[]>
-): AsyncGenerator<number[][], void, unknown> {
-  let batch1: number[] = [];
-  let batch2: number[] = [];
+  iterator1: AsyncIterator<RowTableBatch> | Iterator<RowTableBatch>,
+  iterator2: AsyncIterator<RowTableBatch> | Iterator<RowTableBatch>,
+  shape: 'object-row-table' | 'array-row-table'
+): AsyncGenerator<RowTableBatch, void, unknown> {
+  const batch1Data: unknown[] = [];
+  const batch2Data: unknown[] = [];
   let iterator1Done: boolean = false;
   let iterator2Done: boolean = 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 (batch1.length === 0 && !iterator1Done) {
+    if (batch1Data.length === 0 && !iterator1Done) {
       const {value, done} = await iterator1.next();
       if (done) {
         iterator1Done = true;
       } else {
-        batch1 = value;
+        // @ts-expect-error
+        batch1Data.push(...value);
       }
-    } else if (batch2.length === 0 && !iterator2Done) {
+    }
+    if (batch2Data.length === 0 && !iterator2Done) {
       const {value, done} = await iterator2.next();
       if (done) {
         iterator2Done = true;
       } else {
-        batch2 = value;
+        batch2Data.push(...value);
       }
     }
 
-    const batch = extractBatch(batch1, batch2);
-    if (batch) {
-      yield batch;
+    const batchData = extractBatchData(batch1Data, batch2Data);
+    if (batchData) {
+      yield {
+        batchType: 'data',
+        shape,
+        length: batchData.length,
+        data: batchData
+      };
     }
   }
 }
@@ -46,14 +60,14 @@ export async function* zipBatchIterators(
  * @param batch2
  * @return array | null
  */
-function extractBatch(batch1: number[], batch2: number[]): number[][] | null {
+function extractBatchData(batch1: any[], batch2: any[]): any[] | null {
   const batchLength: number = Math.min(batch1.length, batch2.length);
   if (batchLength === 0) {
     return null;
   }
 
   // Non interleaved arrays
-  const batch: number[][] = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
+  const batch: any[] = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
 
   // Modify the 2 batches
   batch1.splice(0, batchLength);

package/src/shp-loader.ts

@@ -33,5 +33,8 @@ export const SHPLoader: LoaderWithParser = {
   ...SHPWorkerLoader,
   parse: async (arrayBuffer, options?) => parseSHP(arrayBuffer, options),
   parseSync: parseSHP,
-  parseInBatches: parseSHPInBatches
+  parseInBatches: (
+    arrayBufferIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
+    options
+  ) => parseSHPInBatches(arrayBufferIterator, options)
 };

package/dist/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

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

package/dist/dbf-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dbf-loader.d.ts","sourceRoot":"","sources":["../src/dbf-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAOvE;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAc7B,CAAC;AAEF,sBAAsB;AACtB,eAAO,MAAM,SAAS,EAAE,gBAKvB,CAAC"}

package/dist/dbf-loader.js

@@ -1,32 +0,0 @@
-"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'
-        }
-    }
-};
-/** 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
-};

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { ShapefileLoader } from './shapefile-loader';
-export { DBFLoader, DBFWorkerLoader } from './dbf-loader';
-export { SHPLoader, SHPWorkerLoader } from './shp-loader';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AACxD,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHPWorkerLoader = exports.SHPLoader = exports.DBFWorkerLoader = exports.DBFLoader = exports.ShapefileLoader = void 0;
-var shapefile_loader_1 = require("./shapefile-loader");
-Object.defineProperty(exports, "ShapefileLoader", { enumerable: true, get: function () { return shapefile_loader_1.ShapefileLoader; } });
-var dbf_loader_1 = require("./dbf-loader");
-Object.defineProperty(exports, "DBFLoader", { enumerable: true, get: function () { return dbf_loader_1.DBFLoader; } });
-Object.defineProperty(exports, "DBFWorkerLoader", { enumerable: true, get: function () { return dbf_loader_1.DBFWorkerLoader; } });
-var shp_loader_1 = require("./shp-loader");
-Object.defineProperty(exports, "SHPLoader", { enumerable: true, get: function () { return shp_loader_1.SHPLoader; } });
-Object.defineProperty(exports, "SHPWorkerLoader", { enumerable: true, get: function () { return shp_loader_1.SHPWorkerLoader; } });

package/dist/lib/parsers/parse-dbf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-dbf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-dbf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EACL,gBAAgB,EAEhB,cAAc,EACd,SAAS,EACT,aAAa,EAEd,MAAM,SAAS,CAAC;AAkDjB;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,gBAAqB,GAC7B,aAAa,GAAG,cAAc,GAAG,cAAc,CAwBjD;AACD;;;GAGG;AACH,wBAAuB,iBAAiB,CACtC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,GAAE,gBAAqB,GAC7B,aAAa,CAAC,SAAS,GAAG,aAAa,GAAG,cAAc,CAAC,CAqB3D"}

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

@@ -1,344 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDBFInBatches = exports.parseDBF = void 0;
-const binary_chunk_reader_1 = __importDefault(require("../streaming/binary-chunk-reader"));
-const LITTLE_ENDIAN = true;
-const DBF_HEADER_SIZE = 32;
-var STATE;
-(function (STATE) {
-    STATE[STATE["START"] = 0] = "START";
-    STATE[STATE["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
-    STATE[STATE["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
-    STATE[STATE["END"] = 3] = "END";
-    STATE[STATE["ERROR"] = 4] = "ERROR";
-})(STATE || (STATE = {}));
-class DBFParser {
-    constructor(options) {
-        this.binaryReader = new binary_chunk_reader_1.default();
-        this.state = STATE.START;
-        this.result = {
-            data: []
-        };
-        this.textDecoder = new TextDecoder(options.encoding);
-    }
-    /**
-     * @param arrayBuffer
-     */
-    write(arrayBuffer) {
-        this.binaryReader.write(arrayBuffer);
-        this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
-        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();
-        // important events:
-        // - schema available
-        // - first rows available
-        // - all rows available
-    }
-    end() {
-        this.binaryReader.end();
-        this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
-        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();
-        if (this.state !== STATE.END) {
-            this.state = STATE.ERROR;
-            this.result.error = 'DBF incomplete file';
-        }
-    }
-}
-/**
- * @param arrayBuffer
- * @param options
- * @returns DBFTable or rows
- */
-function parseDBF(arrayBuffer, options = {}) {
-    const { encoding = 'latin1' } = options.dbf || {};
-    const dbfParser = new DBFParser({ encoding });
-    dbfParser.write(arrayBuffer);
-    dbfParser.end();
-    const { data, schema } = dbfParser.result;
-    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':
-        default:
-            return data;
-    }
-}
-exports.parseDBF = parseDBF;
-/**
- * @param asyncIterator
- * @param options
- */
-async function* parseDBFInBatches(asyncIterator, options = {}) {
-    const { encoding = 'latin1' } = options.dbf || {};
-    const parser = new DBFParser({ encoding });
-    let headerReturned = false;
-    for await (const arrayBuffer of asyncIterator) {
-        parser.write(arrayBuffer);
-        if (!headerReturned && parser.result.dbfHeader) {
-            headerReturned = true;
-            yield parser.result.dbfHeader;
-        }
-        if (parser.result.data.length > 0) {
-            yield parser.result.data;
-            parser.result.data = [];
-        }
-    }
-    parser.end();
-    if (parser.result.data.length > 0) {
-        yield parser.result.data;
-    }
-}
-exports.parseDBFInBatches = parseDBFInBatches;
-/**
- * https://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm
- * @param state
- * @param result
- * @param binaryReader
- * @param textDecoder
- * @returns
- */
-/* eslint-disable complexity, max-depth */
-function parseState(state, result, binaryReader, textDecoder) {
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        try {
-            switch (state) {
-                case STATE.ERROR:
-                case STATE.END:
-                    return state;
-                case STATE.START:
-                    // Parse initial file header
-                    // DBF Header
-                    const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
-                    if (!dataView) {
-                        return state;
-                    }
-                    result.dbfHeader = parseDBFHeader(dataView);
-                    result.progress = {
-                        bytesUsed: 0,
-                        rowsTotal: result.dbfHeader.nRecords,
-                        rows: 0
-                    };
-                    state = STATE.FIELD_DESCRIPTORS;
-                    break;
-                case STATE.FIELD_DESCRIPTORS:
-                    // Parse DBF field descriptors (schema)
-                    const fieldDescriptorView = binaryReader.getDataView(
-                    // @ts-ignore
-                    result.dbfHeader.headerLength - DBF_HEADER_SIZE);
-                    if (!fieldDescriptorView) {
-                        return state;
-                    }
-                    result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
-                    result.schema = {
-                        fields: result.dbfFields.map((dbfField) => makeField(dbfField)),
-                        metadata: {}
-                    };
-                    state = STATE.FIELD_PROPERTIES;
-                    // TODO(kyle) Not exactly sure why start offset needs to be headerLength + 1?
-                    // parsedbf uses ((fields.length + 1) << 5) + 2;
-                    binaryReader.skip(1);
-                    break;
-                case STATE.FIELD_PROPERTIES:
-                    const { recordLength = 0, nRecords = 0 } = result?.dbfHeader || {};
-                    while (result.data.length < nRecords) {
-                        const recordView = binaryReader.getDataView(recordLength - 1);
-                        if (!recordView) {
-                            return state;
-                        }
-                        // Note: Avoid actually reading the last byte, which may not be present
-                        binaryReader.skip(1);
-                        // @ts-ignore
-                        const row = parseRow(recordView, result.dbfFields, textDecoder);
-                        result.data.push(row);
-                        // @ts-ignore
-                        result.progress.rows = result.data.length;
-                    }
-                    state = STATE.END;
-                    break;
-                default:
-                    state = STATE.ERROR;
-                    result.error = `illegal parser state ${state}`;
-                    return state;
-            }
-        }
-        catch (error) {
-            state = STATE.ERROR;
-            result.error = `DBF parsing failed: ${error.message}`;
-            return state;
-        }
-    }
-}
-/**
- * @param headerView
- */
-function parseDBFHeader(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_ENDIAN),
-        // Length of header in bytes
-        headerLength: headerView.getUint16(8, LITTLE_ENDIAN),
-        // Length of each record
-        recordLength: headerView.getUint16(10, LITTLE_ENDIAN),
-        // Not sure if this is usually set
-        languageDriver: headerView.getUint8(29)
-    };
-}
-/**
- * @param view
- */
-function parseFieldDescriptors(view, textDecoder) {
-    // NOTE: this might overestimate the number of fields if the "Database
-    // Container" container exists and is included in the headerLength
-    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))
-            // eslint-disable-next-line no-control-regex
-            .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;
-}
-/*
- * @param {BinaryChunkReader} binaryReader
-function parseRows(binaryReader, fields, nRecords, recordLength, textDecoder) {
-  const rows = [];
-  for (let i = 0; i < nRecords; i++) {
-    const recordView = binaryReader.getDataView(recordLength - 1);
-    binaryReader.skip(1);
-    // @ts-ignore
-    rows.push(parseRow(recordView, fields, textDecoder));
-  }
-  return rows;
-}
- */
-/**
- *
- * @param view
- * @param fields
- * @param textDecoder
- * @returns
- */
-function parseRow(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] = parseField(text, field.dataType);
-        offset += field.fieldLength;
-    }
-    return out;
-}
-/**
- * Should NaN be coerced to null?
- * @param text
- * @param dataType
- * @returns Field depends on a type of the data
- */
-function parseField(text, dataType) {
-    switch (dataType) {
-        case 'B':
-            return parseNumber(text);
-        case 'C':
-            return parseCharacter(text);
-        case 'F':
-            return parseNumber(text);
-        case 'N':
-            return parseNumber(text);
-        case 'O':
-            return parseNumber(text);
-        case 'D':
-            return parseDate(text);
-        case 'L':
-            return parseBoolean(text);
-        default:
-            throw new Error('Unsupported data type');
-    }
-}
-/**
- * Parse YYYYMMDD to date in milliseconds
- * @param str YYYYMMDD
- * @returns new Date as a number
- */
-function parseDate(str) {
-    return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));
-}
-/**
- * Read boolean value
- * any of Y, y, T, t coerce to true
- * any of N, n, F, f coerce to false
- * otherwise null
- * @param value
- * @returns boolean | null
- */
-function parseBoolean(value) {
-    return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;
-}
-/**
- * Return null instead of NaN
- * @param text
- * @returns number | null
- */
-function parseNumber(text) {
-    const number = parseFloat(text);
-    return isNaN(number) ? null : number;
-}
-/**
- *
- * @param text
- * @returns string | null
- */
-function parseCharacter(text) {
-    return text.trim() || null;
-}
-/**
- * Create a standard Arrow-style `Field` from field descriptor.
- * TODO - use `fieldLength` and `decimal` to generate smaller types?
- * @param param0
- * @returns Field
- */
-// eslint-disable
-function makeField({ 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');
-    }
-}