@loaders.gl/json 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/lib/parse-json-in-batches.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@loaders.gl/schema");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const streaming_json_parser_1 = __importDefault(require("./parser/streaming-json-parser"));
+// 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.default = parseJSONInBatches;

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

@@ -1,2 +1,3 @@
 import type { JSONLoaderOptions } from '../json-loader';
 export default function parseJSONSync(jsonText: string, options: JSONLoaderOptions): any;
+//# sourceMappingURL=parse-json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-json.d.ts","sourceRoot":"","sources":["../../src/lib/parse-json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAEtD,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,OAUjF"}

package/dist/lib/parse-json.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseJSONSync(jsonText, options) {
+    try {
+        const json = JSON.parse(jsonText);
+        if (options.json?.table) {
+            return getFirstArray(json) || json;
+        }
+        return json;
+    }
+    catch (error) {
+        throw new Error('JSONLoader: failed to parse JSON');
+    }
+}
+exports.default = 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/parse-ndjson-in-batches.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ndjson-in-batches.d.ts","sourceRoot":"","sources":["../../src/lib/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,wBAA+B,oBAAoB,CACjD,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/parse-ndjson-in-batches.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.default = parseNDJSONInBatches;

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

@@ -1 +1,2 @@
 export default function parseNDJSONSync(ndjsonText: string): any[];
+//# sourceMappingURL=parse-ndjson.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ndjson.d.ts","sourceRoot":"","sources":["../../src/lib/parse-ndjson.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,UAAU,EAAE,MAAM,SASzD"}

package/dist/lib/parse-ndjson.js

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

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

@@ -1,9 +1,15 @@
-import ClarinetParser from '../clarinet/clarinet';
+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;
-    _parser?: ClarinetParser;
-    constructor();
+    constructor(options: ClarinetParserOptions);
     reset(): void;
     write(chunk: any): void;
     close(): void;
@@ -12,6 +18,5 @@ export default class JSONParser {
     _closeArray(): void;
     _openObject(newContainer?: {}): void;
     _closeObject(): void;
-    _initializeParser(): void;
-    protected get parser(): ClarinetParser;
 }
+//# sourceMappingURL=json-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/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/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/parser/streaming-json-parser.d.ts

@@ -33,5 +33,5 @@ export default class StreamingJSONParser extends JSONParser {
      * Checks is this.getJsonPath matches the jsonpaths provided in options
      */
     _matchJSONPath(): boolean;
-    _extendParser(): void;
 }
+//# sourceMappingURL=streaming-json-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/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/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/ndjson-loader.d.ts

@@ -1,2 +1,22 @@
-import type { LoaderWithParser } from '@loaders.gl/loader-utils';
-export declare const NDJSONLoader: LoaderWithParser;
+import type { Batch } from '@loaders.gl/schema';
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+export declare const NDJSONLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    text: boolean;
+    parse: typeof parse;
+    parseTextSync: typeof parseTextSync;
+    parseInBatches: typeof parseInBatches;
+    options: {};
+};
+declare function parse(arrayBuffer: ArrayBuffer): Promise<any[]>;
+declare function parseTextSync(text: string): any[];
+declare function parseInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: LoaderOptions): AsyncIterable<Batch>;
+export declare const _typecheckNDJSONLoader: LoaderWithParser;
+export {};
+//# 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":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAQ9E,eAAO,MAAM,YAAY;;;;;;;;;;;;;CAaxB,CAAC;AAEF,iBAAe,KAAK,CAAC,WAAW,EAAE,WAAW,kBAE5C;AAED,iBAAS,aAAa,CAAC,IAAI,EAAE,MAAM,SAElC;AAED,iBAAS,cAAc,CACrB,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,KAAK,CAAC,CAEtB;AAED,eAAO,MAAM,sBAAsB,EAAE,gBAA+B,CAAC"}

package/dist/ndjson-loader.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckNDJSONLoader = exports.NDJSONLoader = void 0;
+const parse_ndjson_1 = __importDefault(require("./lib/parse-ndjson"));
+const parse_ndjson_in_batches_1 = __importDefault(require("./lib/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'],
+    mimeTypes: ['application/x-ndjson'],
+    category: 'table',
+    text: true,
+    parse,
+    parseTextSync,
+    parseInBatches,
+    options: {}
+};
+async function parse(arrayBuffer) {
+    return parseTextSync(new TextDecoder().decode(arrayBuffer));
+}
+function parseTextSync(text) {
+    return (0, parse_ndjson_1.default)(text);
+}
+function parseInBatches(asyncIterator, options) {
+    return (0, parse_ndjson_in_batches_1.default)(asyncIterator, options);
+}
+exports._typecheckNDJSONLoader = exports.NDJSONLoader;

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

@@ -1 +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

@@ -0,0 +1,5 @@
+"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": "3.1.0-alpha.5",
+  "version": "3.1.0-beta.5",
   "description": "Framework-independent loader for JSON and streaming JSON formats",
   "license": "MIT",
   "publishConfig": {
@@ -31,14 +31,13 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle && npm run build-worker",
-    "post-build": "tsc",
-    "build-bundle": "webpack --config ../../scripts/webpack/bundle.js",
-    "build-worker": "webpack --entry ./src/workers/geojson-worker.ts --output ./dist/geojson-worker.js --config ../../scripts/webpack/worker.js"
+    "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"
   },
   "dependencies": {
-    "@loaders.gl/gis": "3.1.0-alpha.5",
-    "@loaders.gl/loader-utils": "3.1.0-alpha.5",
-    "@loaders.gl/schema": "3.1.0-alpha.5"
+    "@loaders.gl/gis": "3.1.0-beta.5",
+    "@loaders.gl/loader-utils": "3.1.0-beta.5",
+    "@loaders.gl/schema": "3.1.0-beta.5"
   },
-  "gitHead": "352241dd910a8c6307a235dadbe154ca915b885b"
+  "gitHead": "5d66468457cc878d2dbff3d7807d737ceb181c9a"
 }