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

package/dist/index.cjs

@@ -597,27 +597,13 @@ function checkBufferLength(parser) {
 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);
@@ -669,6 +655,210 @@ var JSONPath = class {
     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("");
+}
 
 // dist/lib/json-parser/json-parser.js
 var JSONParser = class {
@@ -848,13 +1038,13 @@ var StreamingJSONParser = class extends JSONParser {
 
 // dist/lib/parsers/parse-json-in-batches.js
 async function* parseJSONInBatches(binaryAsyncIterator, options) {
-  var _a;
-  const asyncIterator = (0, import_loader_utils.makeTextDecoderIterator)(binaryAsyncIterator);
-  const { metadata } = options;
+  var _a, _b;
+  const asyncIterator = (0, import_loader_utils.makeTextDecoderIterator)((0, import_loader_utils.toArrayBufferIterator)(binaryAsyncIterator));
+  const metadata = Boolean(((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.metadata) || (options == null ? void 0 : options.metadata));
   const { jsonpaths } = options.json || {};
   let isFirstChunk = true;
   const schema = null;
-  const tableBatchBuilder = new import_schema_utils2.TableBatchBuilder(schema, options);
+  const tableBatchBuilder = new import_schema_utils2.TableBatchBuilder(schema, options == null ? void 0 : options.core);
   const parser = new StreamingJSONParser({ jsonpaths });
   for await (const chunk of asyncIterator) {
     const rows = parser.write(chunk);
@@ -863,7 +1053,7 @@ async function* parseJSONInBatches(binaryAsyncIterator, options) {
       if (metadata) {
         const initialBatch = {
           // Common fields
-          shape: ((_a = options == null ? void 0 : options.json) == null ? void 0 : _a.shape) || "array-row-table",
+          shape: ((_b = options == null ? void 0 : options.json) == null ? void 0 : _b.shape) || "array-row-table",
           batchType: "partial-result",
           data: [],
           length: 0,
@@ -923,7 +1113,7 @@ function rebuildJsonObject(batch, data) {
 }
 
 // dist/json-loader.js
-var VERSION = true ? "4.4.0-alpha.0" : "latest";
+var VERSION = true ? "4.4.0-alpha.9" : "latest";
 var JSONLoader = {
   dataType: null,
   batchType: null,
@@ -977,13 +1167,13 @@ function parseNDJSONSync(ndjsonText) {
 var import_schema_utils4 = require("@loaders.gl/schema-utils");
 var import_loader_utils2 = require("@loaders.gl/loader-utils");
 async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
-  const textIterator = (0, import_loader_utils2.makeTextDecoderIterator)(binaryAsyncIterator);
+  const textIterator = (0, import_loader_utils2.makeTextDecoderIterator)((0, import_loader_utils2.toArrayBufferIterator)(binaryAsyncIterator));
   const lineIterator = (0, import_loader_utils2.makeLineIterator)(textIterator);
   const numberedLineIterator = (0, import_loader_utils2.makeNumberedLineIterator)(lineIterator);
   const schema = null;
   const shape = "row-table";
   const tableBatchBuilder = new import_schema_utils4.TableBatchBuilder(schema, {
-    ...options,
+    ...(options == null ? void 0 : options.core) || options,
     shape
   });
   for await (const { counter, line } of numberedLineIterator) {
@@ -1006,7 +1196,7 @@ async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
 }
 
 // dist/ndjson-loader.js
-var VERSION2 = true ? "4.4.0-alpha.0" : "latest";
+var VERSION2 = true ? "4.4.0-alpha.9" : "latest";
 var NDJSONLoader = {
   dataType: null,
   batchType: null,
@@ -1058,7 +1248,7 @@ var JSONWriter = {
 
 // dist/geojson-loader.js
 var import_gis = require("@loaders.gl/gis");
-var VERSION3 = true ? "4.4.0-alpha.0" : "latest";
+var VERSION3 = true ? "4.4.0-alpha.9" : "latest";
 var GeoJSONWorkerLoader = {
   dataType: null,
   batchType: null,
@@ -1121,7 +1311,8 @@ function parseTextSync2(text, options) {
 }
 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":
@@ -1138,7 +1329,7 @@ async function* makeBinaryGeometryIterator(geojsonIterator) {
 }
 
 // dist/geojson-writer.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 
 // dist/lib/encoders/geojson-encoder.js
 var import_schema_utils8 = require("@loaders.gl/schema-utils");
@@ -1209,6 +1400,7 @@ function getFeatureFromRow(table, row, geometryColumnIndex) {
 }
 
 // dist/lib/encoder-utils/utf8-encoder.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
 var Utf8ArrayBufferEncoder = class {
   chunkSize;
   strings = [];
@@ -1227,7 +1419,7 @@ var Utf8ArrayBufferEncoder = class {
     return this.totalLength >= this.chunkSize;
   }
   getArrayBufferBatch() {
-    return this.textEncoder.encode(this.getStringBatch()).buffer;
+    return (0, import_loader_utils3.ensureArrayBuffer)(this.textEncoder.encode(this.getStringBatch()).buffer);
   }
   getStringBatch() {
     const stringChunk = this.strings.join("");
@@ -1296,7 +1488,7 @@ var GeoJSONWriter = {
   async encode(table, options) {
     const tableIterator = [table];
     const batches = encodeTableAsGeojsonInBatches(tableIterator, options);
-    return await (0, import_loader_utils3.concatenateArrayBuffersAsync)(batches);
+    return await (0, import_loader_utils4.concatenateArrayBuffersAsync)(batches);
   },
   encodeInBatches: (tableIterator, options) => encodeTableAsGeojsonInBatches(tableIterator, options)
 };