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

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"}

package/dist/lib/parsers/parse-json-in-batches.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 });
+exports.rebuildJsonObject = exports.parseJSONInBatches = void 0;
+const schema_1 = require("@loaders.gl/schema");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const streaming_json_parser_1 = __importDefault(require("../json-parser/streaming-json-parser"));
+const jsonpath_1 = __importDefault(require("../jsonpath/jsonpath"));
+// TODO - support batch size 0 = no batching/single batch?
+// eslint-disable-next-line max-statements, complexity
+async function* parseJSONInBatches(binaryAsyncIterator, options) {
+    const asyncIterator = (0, loader_utils_1.makeTextDecoderIterator)(binaryAsyncIterator);
+    const { metadata } = options;
+    const { jsonpaths } = options.json || {};
+    let isFirstChunk = true;
+    // TODO fix Schema deduction
+    const schema = null; // new Schema([]);
+    const shape = options?.json?.shape || 'row-table';
+    // @ts-ignore
+    const tableBatchBuilder = new schema_1.TableBatchBuilder(schema, {
+        ...options,
+        shape
+    });
+    const parser = new streaming_json_parser_1.default({ jsonpaths });
+    for await (const chunk of asyncIterator) {
+        const rows = parser.write(chunk);
+        const jsonpath = rows.length > 0 && parser.getStreamingJsonPathAsString();
+        if (rows.length > 0 && isFirstChunk) {
+            if (metadata) {
+                const initialBatch = {
+                    // Common fields
+                    shape,
+                    batchType: 'partial-result',
+                    data: [],
+                    length: 0,
+                    bytesUsed: 0,
+                    // JSON additions
+                    container: parser.getPartialResult(),
+                    jsonpath
+                };
+                yield initialBatch;
+            }
+            isFirstChunk = false;
+            // schema = deduceSchema(rows);
+        }
+        // Add the row
+        for (const row of rows) {
+            tableBatchBuilder.addRow(row);
+            // If a batch has been completed, emit it
+            const batch = tableBatchBuilder.getFullBatch({ jsonpath });
+            if (batch) {
+                yield batch;
+            }
+        }
+        tableBatchBuilder.chunkComplete(chunk);
+        const batch = tableBatchBuilder.getFullBatch({ jsonpath });
+        if (batch) {
+            yield batch;
+        }
+    }
+    // yield final batch
+    const jsonpath = parser.getStreamingJsonPathAsString();
+    const batch = tableBatchBuilder.getFinalBatch({ jsonpath });
+    if (batch) {
+        yield batch;
+    }
+    if (metadata) {
+        const finalBatch = {
+            shape,
+            batchType: 'final-result',
+            container: parser.getPartialResult(),
+            jsonpath: parser.getStreamingJsonPathAsString(),
+            data: [],
+            length: 0
+            // schema: null
+        };
+        yield finalBatch;
+    }
+}
+exports.parseJSONInBatches = parseJSONInBatches;
+function rebuildJsonObject(batch, data) {
+    // Last batch will have this special type and will provide all the root object of the parsed file
+    (0, loader_utils_1.assert)(batch.batchType === 'final-result');
+    // The streamed JSON data is a top level array (jsonpath = '$'), just return the array of row objects
+    if (batch.jsonpath === '$') {
+        return data;
+    }
+    // (jsonpath !== '$') The streamed data is not a top level array, so stitch it back in to the top-level object
+    if (batch.jsonpath && batch.jsonpath.length > 1) {
+        const topLevelObject = batch.container;
+        const streamingPath = new jsonpath_1.default(batch.jsonpath);
+        streamingPath.setFieldAtPath(topLevelObject, data);
+        return topLevelObject;
+    }
+    // No jsonpath, in this case nothing was streamed.
+    return batch.container;
+}
+exports.rebuildJsonObject = rebuildJsonObject;

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

@@ -0,0 +1,4 @@
+import type { RowTable } from '@loaders.gl/schema';
+import type { JSONLoaderOptions } from '../../json-loader';
+export declare function parseJSONSync(jsonText: string, options: JSONLoaderOptions): RowTable;
+//# sourceMappingURL=parse-json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-json.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-json.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAEjD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,QAAQ,CAWpF"}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJSONSync = void 0;
+const schema_1 = require("@loaders.gl/schema");
+function parseJSONSync(jsonText, options) {
+    try {
+        const json = JSON.parse(jsonText);
+        if (options.json?.table) {
+            const data = getFirstArray(json) || json;
+            return (0, schema_1.makeTableFromData)(data);
+        }
+        return json;
+    }
+    catch (error) {
+        throw new Error('JSONLoader: failed to parse JSON');
+    }
+}
+exports.parseJSONSync = parseJSONSync;
+function getFirstArray(json) {
+    if (Array.isArray(json)) {
+        return json;
+    }
+    if (json && typeof json === 'object') {
+        for (const value of Object.values(json)) {
+            const array = getFirstArray(value);
+            if (array) {
+                return array;
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,4 @@
+import type { Batch } from '@loaders.gl/schema';
+import { LoaderOptions } from '@loaders.gl/loader-utils';
+export declare function parseNDJSONInBatches(binaryAsyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: LoaderOptions): AsyncIterable<Batch>;
+//# sourceMappingURL=parse-ndjson-in-batches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ndjson-in-batches.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-ndjson-in-batches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAE9C,OAAO,EACL,aAAa,EAId,MAAM,0BAA0B,CAAC;AAElC,wBAAuB,oBAAoB,CACzC,mBAAmB,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACvE,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,KAAK,CAAC,CA+BtB"}

package/dist/lib/parsers/parse-ndjson-in-batches.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNDJSONInBatches = void 0;
+const schema_1 = require("@loaders.gl/schema");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
+    const textIterator = (0, loader_utils_1.makeTextDecoderIterator)(binaryAsyncIterator);
+    const lineIterator = (0, loader_utils_1.makeLineIterator)(textIterator);
+    const numberedLineIterator = (0, loader_utils_1.makeNumberedLineIterator)(lineIterator);
+    const schema = null;
+    const shape = 'row-table';
+    // @ts-ignore
+    const tableBatchBuilder = new schema_1.TableBatchBuilder(schema, {
+        ...options,
+        shape
+    });
+    for await (const { counter, line } of numberedLineIterator) {
+        try {
+            const row = JSON.parse(line);
+            tableBatchBuilder.addRow(row);
+            tableBatchBuilder.chunkComplete(line);
+            const batch = tableBatchBuilder.getFullBatch();
+            if (batch) {
+                yield batch;
+            }
+        }
+        catch (error) {
+            throw new Error(`NDJSONLoader: failed to parse JSON on line ${counter}`);
+        }
+    }
+    const batch = tableBatchBuilder.getFinalBatch();
+    if (batch) {
+        yield batch;
+    }
+}
+exports.parseNDJSONInBatches = parseNDJSONInBatches;

package/dist/lib/parsers/parse-ndjson.d.ts

@@ -0,0 +1,3 @@
+import type { ArrayRowTable, ObjectRowTable } from '@loaders.gl/schema';
+export declare function parseNDJSONSync(ndjsonText: string): ArrayRowTable | ObjectRowTable;
+//# sourceMappingURL=parse-ndjson.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ndjson.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-ndjson.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAGtE,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,cAAc,CAWlF"}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNDJSONSync = void 0;
+const schema_1 = require("@loaders.gl/schema");
+function parseNDJSONSync(ndjsonText) {
+    const lines = ndjsonText.trim().split('\n');
+    const parsedLines = lines.map((line, counter) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`NDJSONLoader: failed to parse JSON on line ${counter + 1}`);
+        }
+    });
+    return (0, schema_1.makeTableFromData)(parsedLines);
+}
+exports.parseNDJSONSync = parseNDJSONSync;

package/dist/ndgeoson-loader.d.ts

@@ -0,0 +1,34 @@
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import { parseNDJSONSync } from './lib/parsers/parse-ndjson';
+import { parseNDJSONInBatches } from './lib/parsers/parse-ndjson-in-batches';
+export type NDGeoJSONLoaderOptions = LoaderOptions & {
+    geojson?: {
+        shape?: 'object-row-table';
+    };
+    gis?: {
+        format: 'geojson';
+    };
+};
+export declare const NDJSONLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    text: boolean;
+    parse: (arrayBuffer: ArrayBuffer) => Promise<import("@loaders.gl/schema").ArrayRowTable | import("@loaders.gl/schema").ObjectRowTable>;
+    parseTextSync: typeof parseNDJSONSync;
+    parseInBatches: typeof parseNDJSONInBatches;
+    options: {
+        geojson: {
+            shape: string;
+        };
+        gis: {
+            format: string;
+        };
+    };
+};
+export declare const _typecheckNDJSONLoader: LoaderWithParser;
+//# sourceMappingURL=ndgeoson-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ndgeoson-loader.d.ts","sourceRoot":"","sources":["../src/ndgeoson-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAC,oBAAoB,EAAC,MAAM,uCAAuC,CAAC;AAM3E,MAAM,MAAM,sBAAsB,GAAG,aAAa,GAAG;IACnD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,CAAC;KAC5B,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,MAAM,EAAE,SAAS,CAAC;KACnB,CAAC;CACH,CAAC;AAWF,eAAO,MAAM,YAAY;;;;;;;;;yBAeI,WAAW;;;;;;;;;;;CAIvC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,gBAA+B,CAAC"}

package/dist/ndgeoson-loader.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckNDJSONLoader = exports.NDJSONLoader = void 0;
+const parse_ndjson_1 = require("./lib/parsers/parse-ndjson");
+const parse_ndjson_in_batches_1 = require("./lib/parsers/parse-ndjson-in-batches");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+const DEFAULT_NDGEOJSON_LOADER_OPTIONS = {
+    geojson: {
+        shape: 'object-row-table'
+    },
+    gis: {
+        format: 'geojson'
+    }
+};
+exports.NDJSONLoader = {
+    name: 'NDJSON',
+    id: 'ndjson',
+    module: 'json',
+    version: VERSION,
+    extensions: ['ndjson', 'ndgeojson'],
+    mimeTypes: [
+        'application/geo+x-ndjson',
+        'application/geo+x-ldjson',
+        'application/jsonlines',
+        'application/geo+json-seq',
+        'application/x-ndjson'
+    ],
+    category: 'table',
+    text: true,
+    parse: async (arrayBuffer) => (0, parse_ndjson_1.parseNDJSONSync)(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parse_ndjson_1.parseNDJSONSync,
+    parseInBatches: parse_ndjson_in_batches_1.parseNDJSONInBatches,
+    options: DEFAULT_NDGEOJSON_LOADER_OPTIONS
+};
+exports._typecheckNDJSONLoader = exports.NDJSONLoader;

package/dist/ndjson-loader.d.ts

@@ -0,0 +1,4 @@
+import { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import { ObjectRowTable, ArrayRowTable, TableBatch } from '@loaders.gl/schema';
+export declare const NDJSONLoader: LoaderWithParser<ObjectRowTable | ArrayRowTable, TableBatch, LoaderOptions>;
+//# sourceMappingURL=ndjson-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ndjson-loader.d.ts","sourceRoot":"","sources":["../src/ndjson-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAC,cAAc,EAAE,aAAa,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAQ7E,eAAO,MAAM,YAAY,EAAE,gBAAgB,CACzC,cAAc,GAAG,aAAa,EAC9B,UAAU,EACV,aAAa,CAkBd,CAAC"}

package/dist/ndjson-loader.js

@@ -1,32 +1,27 @@
-import parseNDJSONSync from './lib/parse-ndjson';
-import parseNDJSONInBatches from './lib/parse-ndjson-in-batches';
-const VERSION = typeof "4.0.0-alpha.4" !== 'undefined' ? "4.0.0-alpha.4" : 'latest';
-export const NDJSONLoader = {
-  name: 'NDJSON',
-  id: 'ndjson',
-  module: 'json',
-  version: VERSION,
-  extensions: ['ndjson'],
-  mimeTypes: ['application/x-ndjson'],
-  category: 'table',
-  text: true,
-  parse,
-  parseTextSync,
-  parseInBatches,
-  options: {}
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NDJSONLoader = void 0;
+const parse_ndjson_1 = require("./lib/parsers/parse-ndjson");
+const parse_ndjson_in_batches_1 = require("./lib/parsers/parse-ndjson-in-batches");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+exports.NDJSONLoader = {
+    name: 'NDJSON',
+    id: 'ndjson',
+    module: 'json',
+    version: VERSION,
+    extensions: ['ndjson', 'jsonl'],
+    mimeTypes: [
+        'application/x-ndjson',
+        'application/jsonlines',
+        'application/json-seq'
+    ],
+    category: 'table',
+    text: true,
+    parse: async (arrayBuffer) => (0, parse_ndjson_1.parseNDJSONSync)(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parse_ndjson_1.parseNDJSONSync,
+    parseInBatches: parse_ndjson_in_batches_1.parseNDJSONInBatches,
+    options: {}
 };
-
-async function parse(arrayBuffer) {
-  return parseTextSync(new TextDecoder().decode(arrayBuffer));
-}
-
-function parseTextSync(text) {
-  return parseNDJSONSync(text);
-}
-
-function parseInBatches(asyncIterator, options) {
-  return parseNDJSONInBatches(asyncIterator, options);
-}
-
-export const _typecheckNDJSONLoader = NDJSONLoader;
-//# sourceMappingURL=ndjson-loader.js.map

package/dist/workers/geojson-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geojson-worker.d.ts.map

package/dist/workers/geojson-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-worker.d.ts","sourceRoot":"","sources":["../../src/workers/geojson-worker.ts"],"names":[],"mappings":""}

package/dist/workers/geojson-worker.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/json",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "description": "Framework-independent loader for JSON and streaming JSON formats",
   "license": "MIT",
   "publishConfig": {
@@ -20,9 +20,9 @@
     "JSON stream",
     "JSON async iterator"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -31,13 +31,13 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle && npm run build-worker",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/geojson-worker.ts --bundle --outfile=dist/geojson-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/geojson-worker.ts --bundle --outfile=dist/geojson-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.0.0-alpha.4",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
-    "@loaders.gl/schema": "4.0.0-alpha.4"
+    "@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"
   },
-  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/geojson-loader.ts

@@ -1,8 +1,11 @@
+// loaders.gl, MIT license
+
 import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';
 import type {JSONLoaderOptions} from './json-loader';
 import {geojsonToBinary} from '@loaders.gl/gis';
-import parseJSONSync from './lib/parse-json';
-import parseJSONInBatches from './lib/parse-json-in-batches';
+import {parseJSONSync} from './lib/parsers/parse-json';
+import {parseJSONInBatches} from './lib/parsers/parse-json-in-batches';
+import {GeoJSONRowTable} from '@loaders.gl/schema';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -13,7 +16,7 @@ export type GeoJSONLoaderOptions = JSONLoaderOptions & {
     shape?: 'object-row-table';
   };
   gis?: {
-    format: 'geojson';
+    format?: 'geojson' | 'binary';
   };
 };
 
@@ -61,12 +64,13 @@ function parseTextSync(text, options) {
   options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};
   options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};
   options.gis = options.gis || {};
-  const json = parseJSONSync(text, options);
+  const table = parseJSONSync(text, options) as GeoJSONRowTable;
+  table.shape = 'geojson-row-table';
   switch (options.gis.format) {
     case 'binary':
-      return geojsonToBinary(json);
+      return geojsonToBinary(table.data);
     default:
-      return json;
+      return table;
   }
 }