@loaders.gl/json 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/encoders/encode-utils.d.ts

@@ -0,0 +1,19 @@
+import { Table } from '@loaders.gl/schema';
+type Row = {
+    [key: string]: unknown;
+};
+/**
+ * Attempts to identify which column contains geometry
+ * Currently just returns name (key) of first object-valued column
+ * @todo look for hints in schema metadata
+ * @todo look for WKB
+ */
+export declare function detectGeometryColumnIndex(table: Table): number;
+/**
+ * Return a row as a property (key/value) object, excluding selected columns
+ */
+export declare function getRowPropertyObject(table: Table, row: Row, excludeColumnIndices?: number[]): {
+    [columnName: string]: unknown;
+};
+export {};
+//# sourceMappingURL=encode-utils.d.ts.map

package/dist/lib/encoders/encode-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,KAAK,EAAsD,MAAM,oBAAoB,CAAC;AAE9F,KAAK,GAAG,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CAAC;AAEpC;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAsB9D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,GAAG,EACR,oBAAoB,GAAE,MAAM,EAAO,GAClC;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CASjC"}

package/dist/lib/encoders/encode-utils.js

@@ -0,0 +1,47 @@
+"use strict";
+// loaders.gl, MIT license
+// Copyright 2022 Foursquare Labs, Inc.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRowPropertyObject = exports.detectGeometryColumnIndex = void 0;
+const schema_1 = require("@loaders.gl/schema");
+/**
+ * Attempts to identify which column contains geometry
+ * Currently just returns name (key) of first object-valued column
+ * @todo look for hints in schema metadata
+ * @todo look for WKB
+ */
+function detectGeometryColumnIndex(table) {
+    // TODO - look for hints in schema metadata
+    // look for a column named geometry
+    const geometryIndex = table.schema?.fields.findIndex((field) => field.name === 'geometry') ?? -1;
+    if (geometryIndex > -1) {
+        return geometryIndex;
+    }
+    // look at the data
+    // TODO - this drags in the indices
+    if ((0, schema_1.getTableLength)(table) > 0) {
+        const row = (0, schema_1.getTableRowAsArray)(table, 0);
+        for (let columnIndex = 0; columnIndex < (0, schema_1.getTableNumCols)(table); columnIndex++) {
+            const value = row?.[columnIndex];
+            if (value && typeof value === 'object') {
+                return columnIndex;
+            }
+        }
+    }
+    throw new Error('Failed to detect geometry column');
+}
+exports.detectGeometryColumnIndex = detectGeometryColumnIndex;
+/**
+ * Return a row as a property (key/value) object, excluding selected columns
+ */
+function getRowPropertyObject(table, row, excludeColumnIndices = []) {
+    const properties = {};
+    for (let columnIndex = 0; columnIndex < (0, schema_1.getTableNumCols)(table); ++columnIndex) {
+        const columnName = table.schema?.fields[columnIndex].name;
+        if (columnName && !excludeColumnIndices.includes(columnIndex)) {
+            properties[columnName] = row[columnName];
+        }
+    }
+    return properties;
+}
+exports.getRowPropertyObject = getRowPropertyObject;

package/dist/lib/encoders/geojson-encoder.d.ts

@@ -0,0 +1,14 @@
+import { TableBatch } from '@loaders.gl/schema';
+export type GeoJSONWriterOptions = {
+    geojson?: {
+        featureArray?: boolean;
+        geometryColumn?: number | null;
+    };
+    chunkSize?: number;
+};
+/**
+ * Encode a table as GeoJSON
+ */
+export declare function encodeTableAsGeojsonInBatches(batchIterator: AsyncIterable<TableBatch>, // | Iterable<TableBatch>,
+inputOpts?: GeoJSONWriterOptions): AsyncIterable<ArrayBuffer>;
+//# sourceMappingURL=geojson-encoder.d.ts.map

package/dist/lib/encoders/geojson-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-encoder.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/geojson-encoder.ts"],"names":[],"mappings":"AAIA,OAAO,EAAQ,UAAU,EAAsB,MAAM,oBAAoB,CAAC;AAM1E,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE;QACR,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC,CAAC;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AAEH,wBAAuB,6BAA6B,CAClD,aAAa,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,0BAA0B;AACpE,SAAS,GAAE,oBAAyB,GACnC,aAAa,CAAC,WAAW,CAAC,CAqD5B"}

package/dist/lib/encoders/geojson-encoder.js

@@ -0,0 +1,104 @@
+"use strict";
+// loaders.gl, MIT license
+// Copyright 2022 Foursquare Labs, Inc.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeTableAsGeojsonInBatches = void 0;
+const schema_1 = require("@loaders.gl/schema");
+const schema_2 = require("@loaders.gl/schema");
+const encode_utils_1 = require("./encode-utils");
+const utf8_encoder_1 = require("./utf8-encoder");
+/**
+ * Encode a table as GeoJSON
+ */
+// eslint-disable-next-line max-statements
+async function* encodeTableAsGeojsonInBatches(batchIterator, // | Iterable<TableBatch>,
+inputOpts = {}) {
+    const options = { geojson: {}, chunkSize: 10000, ...inputOpts };
+    const utf8Encoder = new utf8_encoder_1.Utf8ArrayBufferEncoder(options.chunkSize);
+    if (!options.geojson.featureArray) {
+        utf8Encoder.push('{\n', '"type": "FeatureCollection",\n', '"features":\n');
+    }
+    utf8Encoder.push('['); // Note no newline
+    let geometryColumn = options.geojson.geometryColumn;
+    let isFirstLine = true;
+    for await (const batch of batchIterator) {
+        const { table, start, end = (0, schema_1.getTableLength)(batch.table) - start } = batch;
+        // Deduce geometry column if not already done
+        if (!geometryColumn) {
+            geometryColumn = geometryColumn || (0, encode_utils_1.detectGeometryColumnIndex)(table);
+        }
+        for (let rowIndex = start; rowIndex < end; ++rowIndex) {
+            // Add a comma except on final feature
+            if (!isFirstLine) {
+                utf8Encoder.push(',');
+            }
+            utf8Encoder.push('\n');
+            isFirstLine = false;
+            encodeRow(table, rowIndex, geometryColumn, utf8Encoder);
+            // eslint-disable-next-line max-depth
+            if (utf8Encoder.isFull()) {
+                yield utf8Encoder.getArrayBufferBatch();
+            }
+        }
+        const arrayBufferBatch = utf8Encoder.getArrayBufferBatch();
+        if (arrayBufferBatch.byteLength > 0) {
+            yield arrayBufferBatch;
+        }
+    }
+    utf8Encoder.push('\n');
+    // Add completing rows and emit final batch
+    utf8Encoder.push(']\n');
+    if (!options.geojson.featureArray) {
+        utf8Encoder.push('}');
+    }
+    // Note: Since we pushed a few final lines, the last batch will always exist, no need to check first
+    yield utf8Encoder.getArrayBufferBatch();
+}
+exports.encodeTableAsGeojsonInBatches = encodeTableAsGeojsonInBatches;
+// Helpers
+/**
+ * Encode a row. Currently this ignores properties in the geometry column.
+ */
+function encodeRow(table, rowIndex, geometryColumnIndex, utf8Encoder) {
+    const row = (0, schema_2.getTableRowAsObject)(table, rowIndex);
+    if (!row)
+        return;
+    const featureWithProperties = getFeatureFromRow(table, row, geometryColumnIndex);
+    const featureString = JSON.stringify(featureWithProperties);
+    utf8Encoder.push(featureString);
+}
+/**
+ * Encode a row as a Feature. Currently this ignores properties objects in the geometry column.
+ */
+function getFeatureFromRow(table, row, geometryColumnIndex) {
+    // Extract non-feature/geometry properties
+    const properties = (0, encode_utils_1.getRowPropertyObject)(table, row, [geometryColumnIndex]);
+    // Extract geometry feature
+    const columnName = table.schema?.fields[geometryColumnIndex].name;
+    let featureOrGeometry = columnName && row[columnName];
+    // GeoJSON support null geometries
+    if (!featureOrGeometry) {
+        // @ts-ignore Feature type does not support null geometries
+        return { type: 'Feature', geometry: null, properties };
+    }
+    // Support string geometries?
+    // TODO: This assumes GeoJSON strings, which may not be the correct format
+    // (could be WKT, encoded WKB...)
+    if (typeof featureOrGeometry === 'string') {
+        try {
+            featureOrGeometry = JSON.parse(featureOrGeometry);
+        }
+        catch (err) {
+            throw new Error('Invalid string geometry');
+        }
+    }
+    if (typeof featureOrGeometry !== 'object' || typeof featureOrGeometry?.type !== 'string') {
+        throw new Error('invalid geometry column value');
+    }
+    if (featureOrGeometry?.type === 'Feature') {
+        // @ts-ignore Feature type does not support null geometries
+        return { ...featureOrGeometry, properties };
+    }
+    // @ts-ignore Feature type does not support null geometries
+    return { type: 'Feature', geometry: featureOrGeometry, properties };
+}

package/dist/lib/encoders/json-encoder.d.ts

@@ -0,0 +1,16 @@
+import { Table } from '@loaders.gl/schema';
+type RowArray = unknown[];
+type RowObject = {
+    [key: string]: unknown;
+};
+type TableJSON = RowArray[] | RowObject[];
+export type JSONWriterOptions = {
+    shape?: 'object-row-table' | 'array-row-table';
+    wrapper?: (table: TableJSON) => unknown;
+};
+/**
+ * Encode a table as a JSON string
+ */
+export declare function encodeTableAsJSON(table: Table, options?: JSONWriterOptions): string;
+export {};
+//# sourceMappingURL=json-encoder.d.ts.map

package/dist/lib/encoders/json-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-encoder.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/json-encoder.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,KAAK,EAAkB,MAAM,oBAAoB,CAAC;AAE1D,KAAK,QAAQ,GAAG,OAAO,EAAE,CAAC;AAC1B,KAAK,SAAS,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CAAC;AAC1C,KAAK,SAAS,GAAG,QAAQ,EAAE,GAAG,SAAS,EAAE,CAAC;AAE1C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,CAAC;IAC/C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC;CACzC,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAYvF"}

package/dist/lib/encoders/json-encoder.js

@@ -0,0 +1,22 @@
+"use strict";
+// loaders.gl, MIT license
+// Copyright 2022 Foursquare Labs, Inc.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeTableAsJSON = void 0;
+const schema_1 = require("@loaders.gl/schema");
+/**
+ * Encode a table as a JSON string
+ */
+function encodeTableAsJSON(table, options = {}) {
+    const shape = options.shape || 'object-row-table';
+    const strings = [];
+    const rowIterator = (0, schema_1.makeRowIterator)(table, shape);
+    for (const row of rowIterator) {
+        // Round elements etc
+        // processRow(wrappedRow, table.schema);
+        // const wrappedRow = options.wrapper ? options.wrapper(row) : row;
+        strings.push(JSON.stringify(row));
+    }
+    return `[${strings.join(',')}]`;
+}
+exports.encodeTableAsJSON = encodeTableAsJSON;

package/dist/lib/encoders/utf8-encoder.d.ts

@@ -0,0 +1,12 @@
+export declare class Utf8ArrayBufferEncoder {
+    private readonly chunkSize;
+    private strings;
+    private totalLength;
+    private textEncoder;
+    constructor(chunkSize: number);
+    push(...strings: string[]): void;
+    isFull(): boolean;
+    getArrayBufferBatch(): ArrayBufferLike;
+    getStringBatch(): string;
+}
+//# sourceMappingURL=utf8-encoder.d.ts.map

package/dist/lib/encoders/utf8-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8-encoder.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/utf8-encoder.ts"],"names":[],"mappings":"AAGA,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,WAAW,CAAkC;gBAEzC,SAAS,EAAE,MAAM;IAI7B,IAAI,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAOhC,MAAM,IAAI,OAAO;IAIjB,mBAAmB,IAAI,eAAe;IAItC,cAAc,IAAI,MAAM;CAMzB"}

package/dist/lib/encoders/utf8-encoder.js

@@ -0,0 +1,32 @@
+"use strict";
+// loaders.gl, MIT License
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utf8ArrayBufferEncoder = void 0;
+/* global TextEncoder */
+class Utf8ArrayBufferEncoder {
+    constructor(chunkSize) {
+        this.strings = [];
+        this.totalLength = 0;
+        this.textEncoder = new TextEncoder();
+        this.chunkSize = chunkSize;
+    }
+    push(...strings) {
+        for (const string of strings) {
+            this.strings.push(string);
+            this.totalLength += string.length;
+        }
+    }
+    isFull() {
+        return this.totalLength >= this.chunkSize;
+    }
+    getArrayBufferBatch() {
+        return this.textEncoder.encode(this.getStringBatch()).buffer;
+    }
+    getStringBatch() {
+        const stringChunk = this.strings.join('');
+        this.strings = [];
+        this.totalLength = 0;
+        return stringChunk;
+    }
+}
+exports.Utf8ArrayBufferEncoder = Utf8ArrayBufferEncoder;

package/dist/lib/json-parser/json-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/json-parser/json-parser.ts"],"names":[],"mappings":"AAEA,OAAO,cAAc,EAAE,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAC3E,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAI5C,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,MAAM,YAAa;IACnB,cAAc,UAAM;IACpB,YAAY;;;OAA6C;IACzD,QAAQ,EAAE,QAAQ,CAAkB;gBAExB,OAAO,EAAE,qBAAqB;IAiD1C,KAAK,IAAI,IAAI;IAOb,KAAK,CAAC,KAAK,KAAA,GAAG,IAAI;IAIlB,KAAK,IAAI,IAAI;IAMb,UAAU,CAAC,KAAK,KAAA,GAAG,IAAI;IAUvB,UAAU,CAAC,YAAY,UAAK,GAAG,IAAI;IAOnC,WAAW,IAAI,IAAI;IAKnB,WAAW,CAAC,YAAY,KAAK,GAAG,IAAI;IAOpC,YAAY,IAAI,IAAI;CAIrB"}

package/dist/lib/json-parser/json-parser.js

@@ -0,0 +1,98 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const clarinet_1 = __importDefault(require("../clarinet/clarinet"));
+const jsonpath_1 = __importDefault(require("../jsonpath/jsonpath"));
+// JSONParser builds a JSON object using the events emitted by the Clarinet parser
+class JSONParser {
+    constructor(options) {
+        this.result = undefined;
+        this.previousStates = [];
+        this.currentState = Object.freeze({ container: [], key: null });
+        this.jsonpath = new jsonpath_1.default();
+        this.reset();
+        this.parser = new clarinet_1.default({
+            onready: () => {
+                this.jsonpath = new jsonpath_1.default();
+                this.previousStates.length = 0;
+                this.currentState.container.length = 0;
+            },
+            onopenobject: (name) => {
+                this._openObject({});
+                if (typeof name !== 'undefined') {
+                    this.parser.emit('onkey', name);
+                }
+            },
+            onkey: (name) => {
+                this.jsonpath.set(name);
+                this.currentState.key = name;
+            },
+            oncloseobject: () => {
+                this._closeObject();
+            },
+            onopenarray: () => {
+                this._openArray();
+            },
+            onclosearray: () => {
+                this._closeArray();
+            },
+            onvalue: (value) => {
+                this._pushOrSet(value);
+            },
+            onerror: (error) => {
+                throw error;
+            },
+            onend: () => {
+                this.result = this.currentState.container.pop();
+            },
+            ...options
+        });
+    }
+    reset() {
+        this.result = undefined;
+        this.previousStates = [];
+        this.currentState = Object.freeze({ container: [], key: null });
+        this.jsonpath = new jsonpath_1.default();
+    }
+    write(chunk) {
+        this.parser.write(chunk);
+    }
+    close() {
+        this.parser.close();
+    }
+    // PRIVATE METHODS
+    _pushOrSet(value) {
+        const { container, key } = this.currentState;
+        if (key !== null) {
+            container[key] = value;
+            this.currentState.key = null;
+        }
+        else {
+            container.push(value);
+        }
+    }
+    _openArray(newContainer = []) {
+        this.jsonpath.push(null);
+        this._pushOrSet(newContainer);
+        this.previousStates.push(this.currentState);
+        this.currentState = { container: newContainer, isArray: true, key: null };
+    }
+    _closeArray() {
+        this.jsonpath.pop();
+        this.currentState = this.previousStates.pop();
+    }
+    _openObject(newContainer = {}) {
+        this.jsonpath.push(null);
+        this._pushOrSet(newContainer);
+        this.previousStates.push(this.currentState);
+        this.currentState = { container: newContainer, isArray: false, key: null };
+    }
+    _closeObject() {
+        this.jsonpath.pop();
+        this.currentState = this.previousStates.pop();
+    }
+}
+exports.default = JSONParser;

package/dist/lib/json-parser/streaming-json-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/json-parser/streaming-json-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAE5C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,UAAU;IACzD,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,cAAc,CAAuB;gBAEjC,OAAO,GAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAM;IAiC9C;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,KAAA;IAUX;;;;OAIG;IACH,gBAAgB;IAIhB,oBAAoB;IAIpB,4BAA4B;IAI5B,WAAW;IAMX;;OAEG;IACH,cAAc;CAkBf"}

package/dist/lib/json-parser/streaming-json-parser.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_parser_1 = __importDefault(require("./json-parser"));
+const jsonpath_1 = __importDefault(require("../jsonpath/jsonpath"));
+/**
+ * The `StreamingJSONParser` looks for the first array in the JSON structure.
+ * and emits an array of chunks
+ */
+class StreamingJSONParser extends json_parser_1.default {
+    constructor(options = {}) {
+        super({
+            onopenarray: () => {
+                if (!this.streamingArray) {
+                    if (this._matchJSONPath()) {
+                        // @ts-ignore
+                        this.streamingJsonPath = this.getJsonPath().clone();
+                        this.streamingArray = [];
+                        this._openArray(this.streamingArray);
+                        return;
+                    }
+                }
+                this._openArray();
+            },
+            // Redefine onopenarray to inject value for top-level object
+            onopenobject: (name) => {
+                if (!this.topLevelObject) {
+                    this.topLevelObject = {};
+                    this._openObject(this.topLevelObject);
+                }
+                else {
+                    this._openObject({});
+                }
+                if (typeof name !== 'undefined') {
+                    this.parser.emit('onkey', name);
+                }
+            }
+        });
+        this.streamingJsonPath = null;
+        this.streamingArray = null;
+        this.topLevelObject = null;
+        const jsonpaths = options.jsonpaths || [];
+        this.jsonPaths = jsonpaths.map((jsonpath) => new jsonpath_1.default(jsonpath));
+    }
+    /**
+     * write REDEFINITION
+     * - super.write() chunk to parser
+     * - get the contents (so far) of "topmost-level" array as batch of rows
+     * - clear top-level array
+     * - return the batch of rows\
+     */
+    write(chunk) {
+        super.write(chunk);
+        let array = [];
+        if (this.streamingArray) {
+            array = [...this.streamingArray];
+            this.streamingArray.length = 0;
+        }
+        return array;
+    }
+    /**
+     * Returns a partially formed result object
+     * Useful for returning the "wrapper" object when array is not top level
+     * e.g. GeoJSON
+     */
+    getPartialResult() {
+        return this.topLevelObject;
+    }
+    getStreamingJsonPath() {
+        return this.streamingJsonPath;
+    }
+    getStreamingJsonPathAsString() {
+        return this.streamingJsonPath && this.streamingJsonPath.toString();
+    }
+    getJsonPath() {
+        return this.jsonpath;
+    }
+    // PRIVATE METHODS
+    /**
+     * Checks is this.getJsonPath matches the jsonpaths provided in options
+     */
+    _matchJSONPath() {
+        const currentPath = this.getJsonPath();
+        // console.debug(`Testing JSONPath`, currentPath);
+        // Backwards compatibility, match any array
+        // TODO implement using wildcard once that is supported
+        if (this.jsonPaths.length === 0) {
+            return true;
+        }
+        for (const jsonPath of this.jsonPaths) {
+            if (jsonPath.equals(currentPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.default = StreamingJSONParser;

package/dist/lib/jsonpath/jsonpath.js

@@ -1,86 +1,89 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-export default class JSONPath {
-  constructor(path = null) {
-    _defineProperty(this, "path", void 0);
-
-    this.path = ['$'];
-
-    if (path instanceof JSONPath) {
-      this.path = [...path.path];
-      return;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A parser for a minimal subset of the jsonpath standard
+ * Full JSON path parsers for JS exist but are quite large (bundle size)
+ *
+ * Supports
+ *
+ *   `$.component.component.component`
+ */
+class JSONPath {
+    constructor(path = null) {
+        this.path = ['$'];
+        if (path instanceof JSONPath) {
+            // @ts-ignore
+            this.path = [...path.path];
+            return;
+        }
+        if (Array.isArray(path)) {
+            this.path.push(...path);
+            return;
+        }
+        // Parse a string as a JSONPath
+        if (typeof path === 'string') {
+            this.path = path.split('.');
+            if (this.path[0] !== '$') {
+                throw new Error('JSONPaths must start with $');
+            }
+        }
     }
-
-    if (Array.isArray(path)) {
-      this.path.push(...path);
-      return;
+    clone() {
+        return new JSONPath(this);
     }
-
-    if (typeof path === 'string') {
-      this.path = path.split('.');
-
-      if (this.path[0] !== '$') {
-        throw new Error('JSONPaths must start with $');
-      }
+    toString() {
+        return this.path.join('.');
     }
-  }
-
-  clone() {
-    return new JSONPath(this);
-  }
-
-  toString() {
-    return this.path.join('.');
-  }
-
-  push(name) {
-    this.path.push(name);
-  }
-
-  pop() {
-    return this.path.pop();
-  }
-
-  set(name) {
-    this.path[this.path.length - 1] = name;
-  }
-
-  equals(other) {
-    if (!this || !other || this.path.length !== other.path.length) {
-      return false;
+    push(name) {
+        this.path.push(name);
     }
-
-    for (let i = 0; i < this.path.length; ++i) {
-      if (this.path[i] !== other.path[i]) {
-        return false;
-      }
+    pop() {
+        return this.path.pop();
     }
-
-    return true;
-  }
-
-  setFieldAtPath(object, value) {
-    const path = [...this.path];
-    path.shift();
-    const field = path.pop();
-
-    for (const component of path) {
-      object = object[component];
+    set(name) {
+        this.path[this.path.length - 1] = name;
     }
-
-    object[field] = value;
-  }
-
-  getFieldAtPath(object) {
-    const path = [...this.path];
-    path.shift();
-    const field = path.pop();
-
-    for (const component of path) {
-      object = object[component];
+    equals(other) {
+        if (!this || !other || this.path.length !== other.path.length) {
+            return false;
+        }
+        for (let i = 0; i < this.path.length; ++i) {
+            if (this.path[i] !== other.path[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Sets the value pointed at by path
+     * TODO - handle root path
+     * @param object
+     * @param value
+     */
+    setFieldAtPath(object, value) {
+        const path = [...this.path];
+        path.shift();
+        const field = path.pop();
+        for (const component of path) {
+            object = object[component];
+        }
+        // @ts-ignore
+        object[field] = value;
+    }
+    /**
+     * Gets the value pointed at by path
+     * TODO - handle root path
+     * @param object
+     */
+    getFieldAtPath(object) {
+        const path = [...this.path];
+        path.shift();
+        const field = path.pop();
+        for (const component of path) {
+            object = object[component];
+        }
+        // @ts-ignore
+        return object[field];
     }
-
-    return object[field];
-  }
-
 }
-//# sourceMappingURL=jsonpath.js.map
+exports.default = JSONPath;

package/dist/lib/parsers/parse-json-in-batches.d.ts

@@ -0,0 +1,5 @@
+import type { TableBatch } from '@loaders.gl/schema';
+import type { JSONLoaderOptions } from '../../json-loader';
+export declare function parseJSONInBatches(binaryAsyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options: JSONLoaderOptions): AsyncIterable<TableBatch>;
+export declare function rebuildJsonObject(batch: any, data: any): any;
+//# sourceMappingURL=parse-json-in-batches.d.ts.map

package/dist/lib/parsers/parse-json-in-batches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-json-in-batches.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-json-in-batches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAQzD,wBAAuB,kBAAkB,CACvC,mBAAmB,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACvE,OAAO,EAAE,iBAAiB,GACzB,aAAa,CAAC,UAAU,CAAC,CA+E3B;AAED,wBAAgB,iBAAiB,CAAC,KAAK,KAAA,EAAE,IAAI,KAAA,OAmB5C"}