@loaders.gl/json 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -0,0 +1,22 @@
+import ClarinetParser, { ClarinetParserOptions } from '../clarinet/clarinet';
+import JSONPath from '../jsonpath/jsonpath';
+export default class JSONParser {
+    readonly parser: ClarinetParser;
+    result: undefined;
+    previousStates: never[];
+    currentState: Readonly<{
+        container: never[];
+        key: null;
+    }>;
+    jsonpath: JSONPath;
+    constructor(options: ClarinetParserOptions);
+    reset(): void;
+    write(chunk: any): void;
+    close(): void;
+    _pushOrSet(value: any): void;
+    _openArray(newContainer?: never[]): void;
+    _closeArray(): void;
+    _openObject(newContainer?: {}): void;
+    _closeObject(): void;
+}
+//# sourceMappingURL=json-parser.d.ts.map

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

@@ -0,0 +1,37 @@
+import { default as JSONParser } from './json-parser';
+import JSONPath from '../jsonpath/jsonpath';
+/**
+ * The `StreamingJSONParser` looks for the first array in the JSON structure.
+ * and emits an array of chunks
+ */
+export default class StreamingJSONParser extends JSONParser {
+    private jsonPaths;
+    private streamingJsonPath;
+    private streamingArray;
+    private topLevelObject;
+    constructor(options?: {
+        [key: string]: any;
+    });
+    /**
+     * 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: any): any[];
+    /**
+     * Returns a partially formed result object
+     * Useful for returning the "wrapper" object when array is not top level
+     * e.g. GeoJSON
+     */
+    getPartialResult(): object | null;
+    getStreamingJsonPath(): JSONPath | null;
+    getStreamingJsonPathAsString(): string | null;
+    getJsonPath(): JSONPath;
+    /**
+     * Checks is this.getJsonPath matches the jsonpaths provided in options
+     */
+    _matchJSONPath(): boolean;
+}
+//# sourceMappingURL=streaming-json-parser.d.ts.map

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.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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`
+ */
+export default class JSONPath {
+    path: string[];
+    constructor(path?: JSONPath | string[] | string | null);
+    clone(): JSONPath;
+    toString(): string;
+    push(name: string): void;
+    pop(): string | undefined;
+    set(name: string): void;
+    equals(other: JSONPath): boolean;
+    /**
+     * Sets the value pointed at by path
+     * TODO - handle root path
+     * @param object
+     * @param value
+     */
+    setFieldAtPath(object: any, value: any): void;
+    /**
+     * Gets the value pointed at by path
+     * TODO - handle root path
+     * @param object
+     */
+    getFieldAtPath(object: any): any;
+}
+//# sourceMappingURL=jsonpath.d.ts.map

package/dist/lib/jsonpath/jsonpath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonpath.d.ts","sourceRoot":"","sources":["../../../src/lib/jsonpath/jsonpath.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,IAAI,EAAE,MAAM,EAAE,CAAC;gBAEH,IAAI,GAAE,QAAQ,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,IAAW;IAuB5D,KAAK,IAAI,QAAQ;IAIjB,QAAQ,IAAI,MAAM;IAIlB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIxB,GAAG;IAIH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIvB,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAchC;;;;;OAKG;IACH,cAAc,CAAC,MAAM,KAAA,EAAE,KAAK,KAAA;IAW5B;;;;OAIG;IACH,cAAc,CAAC,MAAM,KAAA;CAUtB"}