@loaders.gl/json 4.4.0-alpha.2 → 4.4.0-alpha.9

package/dist/dist.dev.js

@@ -12653,6 +12653,9 @@ return true;`);
     }
   }
 
+  // ../loader-utils/src/lib/javascript-utils/is-type.ts
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
   // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
   function concatenateArrayBuffers(...sources) {
     return concatenateArrayBuffersFromArray(sources);
@@ -12705,10 +12708,52 @@ return true;`);
   async function concatenateArrayBuffersAsync(asyncIterator) {
     const arrayBuffers = [];
     for await (const chunk of asyncIterator) {
-      arrayBuffers.push(chunk);
+      arrayBuffers.push(copyToArrayBuffer(chunk));
     }
     return concatenateArrayBuffers(...arrayBuffers);
   }
+  async function* toArrayBufferIterator(asyncIterator) {
+    for await (const chunk of asyncIterator) {
+      yield copyToArrayBuffer(chunk);
+    }
+  }
+  function copyToArrayBuffer(chunk) {
+    if (chunk instanceof ArrayBuffer) {
+      return chunk;
+    }
+    if (ArrayBuffer.isView(chunk)) {
+      const { buffer, byteOffset, byteLength } = chunk;
+      return copyFromBuffer(buffer, byteOffset, byteLength);
+    }
+    return copyFromBuffer(chunk);
+  }
+  function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy2 = new Uint8Array(view.length);
+    copy2.set(view);
+    return copy2.buffer;
+  }
+
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function ensureArrayBuffer(bufferSource) {
+    if (bufferSource instanceof ArrayBuffer) {
+      return bufferSource;
+    }
+    if (isSharedArrayBuffer(bufferSource)) {
+      return copyToArrayBuffer2(bufferSource);
+    }
+    const { buffer, byteOffset, byteLength } = bufferSource;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
+    }
+    return copyToArrayBuffer2(buffer, byteOffset, byteLength);
+  }
+  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy2 = new Uint8Array(view.length);
+    copy2.set(view);
+    return copy2.buffer;
+  }
 
   // src/lib/clarinet/clarinet.ts
   var MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
@@ -13213,27 +13258,13 @@ Char: ${this.c}`;
   var JSONPath = class {
     path;
     constructor(path = null) {
-      this.path = ["$"];
-      if (path instanceof JSONPath) {
-        this.path = [...path.path];
-        return;
-      }
-      if (Array.isArray(path)) {
-        this.path.push(...path);
-        return;
-      }
-      if (typeof path === "string") {
-        this.path = path.split(".");
-        if (this.path[0] !== "$") {
-          throw new Error("JSONPaths must start with $");
-        }
-      }
+      this.path = parseJsonPath(path);
     }
     clone() {
       return new JSONPath(this);
     }
     toString() {
-      return this.path.join(".");
+      return formatJsonPath(this.path);
     }
     push(name) {
       this.path.push(name);
@@ -13285,6 +13316,210 @@ Char: ${this.c}`;
       return object[field];
     }
   };
+  function parseJsonPath(path) {
+    if (path instanceof JSONPath) {
+      return [...path.path];
+    }
+    if (Array.isArray(path)) {
+      return ["$"].concat(path);
+    }
+    if (typeof path === "string") {
+      return parseJsonPathString(path);
+    }
+    return ["$"];
+  }
+  function parseJsonPathString(pathString) {
+    const trimmedPath = pathString.trim();
+    if (!trimmedPath.startsWith("$")) {
+      throw new Error("JSONPath must start with $");
+    }
+    const segments = ["$"];
+    let index = 1;
+    let arrayElementSelectorEncountered = false;
+    while (index < trimmedPath.length) {
+      const character = trimmedPath[index];
+      if (character === ".") {
+        if (arrayElementSelectorEncountered) {
+          throw new Error("JSONPath cannot select fields after array element selectors");
+        }
+        index += 1;
+        if (trimmedPath[index] === ".") {
+          throw new Error("JSONPath descendant selectors (..) are not supported");
+        }
+        const { value, nextIndex, isWildcard } = parseDotSegment(trimmedPath, index);
+        if (isWildcard) {
+          if (nextIndex < trimmedPath.length) {
+            throw new Error("JSONPath wildcard selectors must terminate the path");
+          }
+          arrayElementSelectorEncountered = true;
+          index = nextIndex;
+          continue;
+        }
+        segments.push(value);
+        index = nextIndex;
+        continue;
+      }
+      if (character === "[") {
+        const parsedSegment = parseBracketSegment(trimmedPath, index);
+        if (parsedSegment.type === "property") {
+          if (arrayElementSelectorEncountered) {
+            throw new Error("JSONPath cannot select fields after array element selectors");
+          }
+          segments.push(parsedSegment.value);
+        } else {
+          arrayElementSelectorEncountered = true;
+        }
+        index = parsedSegment.nextIndex;
+        continue;
+      }
+      if (character === "@") {
+        throw new Error("JSONPath current node selector (@) is not supported");
+      }
+      if (character.trim() === "") {
+        index += 1;
+        continue;
+      }
+      throw new Error(`Unexpected character "${character}" in JSONPath`);
+    }
+    return segments;
+  }
+  function parseDotSegment(pathString, startIndex) {
+    if (startIndex >= pathString.length) {
+      throw new Error("JSONPath cannot end with a period");
+    }
+    if (pathString[startIndex] === "*") {
+      return { value: "*", nextIndex: startIndex + 1, isWildcard: true };
+    }
+    const firstCharacter = pathString[startIndex];
+    if (firstCharacter === "@") {
+      throw new Error("JSONPath current node selector (@) is not supported");
+    }
+    if (!isIdentifierStartCharacter(firstCharacter)) {
+      throw new Error("JSONPath property names after period must start with a letter, $ or _");
+    }
+    let endIndex = startIndex + 1;
+    while (endIndex < pathString.length && isIdentifierCharacter(pathString[endIndex])) {
+      endIndex++;
+    }
+    if (endIndex === startIndex) {
+      throw new Error("JSONPath is missing a property name after period");
+    }
+    return {
+      value: pathString.slice(startIndex, endIndex),
+      nextIndex: endIndex,
+      isWildcard: false
+    };
+  }
+  function parseBracketSegment(pathString, startIndex) {
+    const contentStartIndex = startIndex + 1;
+    if (contentStartIndex >= pathString.length) {
+      throw new Error("JSONPath has unterminated bracket");
+    }
+    const firstCharacter = pathString[contentStartIndex];
+    if (firstCharacter === "'" || firstCharacter === '"') {
+      const { value, nextIndex } = parseBracketProperty(pathString, contentStartIndex);
+      return { type: "property", value, nextIndex };
+    }
+    const closingBracketIndex = pathString.indexOf("]", contentStartIndex);
+    if (closingBracketIndex === -1) {
+      throw new Error("JSONPath has unterminated bracket");
+    }
+    const content = pathString.slice(contentStartIndex, closingBracketIndex).trim();
+    const unsupportedSelectorMessage = getUnsupportedBracketSelectorMessage(content);
+    if (unsupportedSelectorMessage) {
+      throw new Error(unsupportedSelectorMessage);
+    }
+    if (content === "*") {
+      return { type: "array-selector", nextIndex: closingBracketIndex + 1 };
+    }
+    if (/^\d+$/.test(content)) {
+      throw new Error("JSONPath array index selectors are not supported");
+    }
+    if (/^\d*\s*:\s*\d*(\s*:\s*\d*)?$/.test(content)) {
+      return { type: "array-selector", nextIndex: closingBracketIndex + 1 };
+    }
+    throw new Error(`Unsupported bracket selector "[${content}]" in JSONPath`);
+  }
+  function getUnsupportedBracketSelectorMessage(content) {
+    if (!content.length) {
+      return "JSONPath bracket selectors cannot be empty";
+    }
+    if (content.startsWith("(")) {
+      return "JSONPath script selectors are not supported";
+    }
+    if (content.startsWith("?")) {
+      return "JSONPath filter selectors are not supported";
+    }
+    if (content.includes(",")) {
+      return "JSONPath union selectors are not supported";
+    }
+    if (content.startsWith("@") || content.includes("@.")) {
+      return "JSONPath current node selector (@) is not supported";
+    }
+    return null;
+  }
+  function parseBracketProperty(pathString, startIndex) {
+    const quoteCharacter = pathString[startIndex];
+    let index = startIndex + 1;
+    let value = "";
+    let terminated = false;
+    while (index < pathString.length) {
+      const character = pathString[index];
+      if (character === "\\") {
+        index += 1;
+        if (index >= pathString.length) {
+          break;
+        }
+        value += pathString[index];
+        index += 1;
+        continue;
+      }
+      if (character === quoteCharacter) {
+        terminated = true;
+        index += 1;
+        break;
+      }
+      value += character;
+      index += 1;
+    }
+    if (!terminated) {
+      throw new Error("JSONPath string in bracket property selector is unterminated");
+    }
+    while (index < pathString.length && pathString[index].trim() === "") {
+      index += 1;
+    }
+    if (pathString[index] !== "]") {
+      throw new Error("JSONPath property selectors must end with ]");
+    }
+    if (!value.length) {
+      throw new Error("JSONPath property selectors cannot be empty");
+    }
+    return { value, nextIndex: index + 1 };
+  }
+  function isIdentifierCharacter(character) {
+    return /[a-zA-Z0-9$_]/.test(character);
+  }
+  function isIdentifierStartCharacter(character) {
+    return /[a-zA-Z_$]/.test(character);
+  }
+  function isIdentifierSegment(segment) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(segment);
+  }
+  function formatJsonPath(path) {
+    return path.map((segment, index) => {
+      if (index === 0) {
+        return segment;
+      }
+      if (segment === "*") {
+        return ".*";
+      }
+      if (isIdentifierSegment(segment)) {
+        return `.${segment}`;
+      }
+      const escapedSegment = segment.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+      return `['${escapedSegment}']`;
+    }).join("");
+  }
 
   // src/lib/json-parser/json-parser.ts
   var JSONParser = class {
@@ -13464,12 +13699,12 @@ Char: ${this.c}`;
 
   // src/lib/parsers/parse-json-in-batches.ts
   async function* parseJSONInBatches(binaryAsyncIterator, options) {
-    const asyncIterator = makeTextDecoderIterator(binaryAsyncIterator);
-    const { metadata } = options;
+    const asyncIterator = makeTextDecoderIterator(toArrayBufferIterator(binaryAsyncIterator));
+    const metadata = Boolean(options?.core?.metadata || options?.metadata);
     const { jsonpaths } = options.json || {};
     let isFirstChunk = true;
     const schema = null;
-    const tableBatchBuilder = new TableBatchBuilder(schema, options);
+    const tableBatchBuilder = new TableBatchBuilder(schema, options?.core);
     const parser = new StreamingJSONParser({ jsonpaths });
     for await (const chunk of asyncIterator) {
       const rows = parser.write(chunk);
@@ -13589,13 +13824,13 @@ Char: ${this.c}`;
 
   // src/lib/parsers/parse-ndjson-in-batches.ts
   async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
-    const textIterator = makeTextDecoderIterator(binaryAsyncIterator);
+    const textIterator = makeTextDecoderIterator(toArrayBufferIterator(binaryAsyncIterator));
     const lineIterator = makeLineIterator(textIterator);
     const numberedLineIterator = makeNumberedLineIterator(lineIterator);
     const schema = null;
     const shape = "row-table";
     const tableBatchBuilder = new TableBatchBuilder(schema, {
-      ...options,
+      ...options?.core || options,
       shape
     });
     for await (const { counter, line } of numberedLineIterator) {
@@ -14703,7 +14938,8 @@ Char: ${this.c}`;
   }
   function parseInBatches2(asyncIterator, options) {
     options = { ...GeoJSONLoader.options, ...options };
-    options.json = { ...GeoJSONLoader.options.geojson, ...options.geojson };
+    options.json = { ...GeoJSONLoader.options.json, ...options.json };
+    options.geojson = { ...GeoJSONLoader.options.geojson, ...options.geojson };
     const geojsonIterator = parseJSONInBatches(asyncIterator, options);
     switch (options.gis.format) {
       case "binary":
@@ -14798,7 +15034,7 @@ Char: ${this.c}`;
       return this.totalLength >= this.chunkSize;
     }
     getArrayBufferBatch() {
-      return this.textEncoder.encode(this.getStringBatch()).buffer;
+      return ensureArrayBuffer(this.textEncoder.encode(this.getStringBatch()).buffer);
     }
     getStringBatch() {
       const stringChunk = this.strings.join("");