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

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

@@ -1 +1 @@
-{"version":3,"file":"geojson-loader.d.ts","sourceRoot":"","sources":["../src/geojson-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,uBAAuB,EAAE,YAAY,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAC1F,OAAO,KAAK,EAAC,iBAAiB,EAAC,yBAAsB;AASrD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG;IACrD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,eAAe,CAAC;KACzB,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,MAAM,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;KAC/B,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB;uBACD,YAAY;wBACX,UAAU;;;;;;;;;;;;;;;;;;;;;;CAuBiC,CAAC;AAE5E,eAAO,MAAM,aAAa;;;;uBA1BK,YAAY;wBACX,UAAU;;;;;;;;;;;;;;;;;;;;;;CAgC2C,CAAC;AAEtF,iBAAe,KAAK,CAClB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,YAAY,GAAG,uBAAuB,CAAC,CAEjD;AAED,iBAAS,aAAa,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,oBAAoB,GAC7B,YAAY,GAAG,uBAAuB,CA2BxC;AAED,iBAAS,cAAc,CAAC,aAAa,KAAA,EAAE,OAAO,KAAA,GAAG,aAAa,CAAC,UAAU,CAAC,CAazE"}
+{"version":3,"file":"geojson-loader.d.ts","sourceRoot":"","sources":["../src/geojson-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,uBAAuB,EAAE,YAAY,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAC1F,OAAO,KAAK,EAAC,iBAAiB,EAAC,yBAAsB;AASrD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG;IACrD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,eAAe,CAAC;KACzB,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,MAAM,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;KAC/B,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB;uBACD,YAAY;wBACX,UAAU;;;;;;;;;;;;;;;;;;;;;;CAuBiC,CAAC;AAE5E,eAAO,MAAM,aAAa;;;;uBA1BK,YAAY;wBACX,UAAU;;;;;;;;;;;;;;;;;;;;;;CAgC2C,CAAC;AAEtF,iBAAe,KAAK,CAClB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,YAAY,GAAG,uBAAuB,CAAC,CAEjD;AAED,iBAAS,aAAa,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,oBAAoB,GAC7B,YAAY,GAAG,uBAAuB,CA2BxC;AAED,iBAAS,cAAc,CAAC,aAAa,KAAA,EAAE,OAAO,KAAA,GAAG,aAAa,CAAC,UAAU,CAAC,CAczE"}

package/dist/geojson-loader.js

@@ -6,7 +6,7 @@ import { geojsonToBinary } from '@loaders.gl/gis';
 import { parseJSONInBatches } from "./lib/parsers/parse-json-in-batches.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.4.0-alpha.0" !== 'undefined' ? "4.4.0-alpha.0" : 'latest';
+const VERSION = typeof "4.4.0-alpha.9" !== 'undefined' ? "4.4.0-alpha.9" : 'latest';
 /**
  * GeoJSON loader
  */
@@ -75,7 +75,8 @@ function parseTextSync(text, options) {
 function parseInBatches(asyncIterator, options) {
     // Apps can call the parse method directly, we so apply default options here
     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':
@@ -90,3 +91,4 @@ async function* makeBinaryGeometryIterator(geojsonIterator) {
         yield batch;
     }
 }
+//# sourceMappingURL=geojson-loader.js.map

package/dist/geojson-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-loader.js","sourceRoot":"","sources":["../src/geojson-loader.ts"],"names":[],"mappings":"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"}

package/dist/geojson-worker.js

@@ -205,7 +205,10 @@
     options = {
       ...options,
       modules: loader && loader.options && loader.options.modules || {},
-      worker: false
+      core: {
+        ...options.core,
+        worker: false
+      }
     };
     return await parser(data, { ...options }, context, loader);
   }
@@ -218,6 +221,29 @@
     }
   }
 
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  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;
+  }
+
   // ../gis/src/lib/geometry-api/geometry-info.ts
   function getGeometryInfo(features) {
     let pointPositionsCount = 0;
@@ -13909,27 +13935,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);
@@ -13981,6 +13993,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 {
@@ -14160,12 +14376,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);
@@ -14221,7 +14437,7 @@ Char: ${this.c}`;
   }
 
   // src/geojson-loader.ts
-  var VERSION = true ? "4.4.0-alpha.0" : "latest";
+  var VERSION = true ? "4.4.0-alpha.9" : "latest";
   var GeoJSONWorkerLoader = {
     dataType: null,
     batchType: null,
@@ -14284,7 +14500,8 @@ Char: ${this.c}`;
   }
   function parseInBatches(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":

package/dist/geojson-writer.js

@@ -25,3 +25,4 @@ export const GeoJSONWriter = {
     },
     encodeInBatches: (tableIterator, options) => encodeTableAsGeojsonInBatches(tableIterator, options)
 };
+//# sourceMappingURL=geojson-writer.js.map

package/dist/geojson-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-writer.js","sourceRoot":"","sources":["../src/geojson-writer.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AACpC,kCAAkC;AAElC,OAAO,EAGL,4BAA4B,EAC7B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAC,6BAA6B,EAAC,0CAAuC;AAU7E,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,EAAE,EAAE,SAAS;IACb,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE,SAAS;IACjB,IAAI,EAAE,SAAS;IACf,UAAU,EAAE,CAAC,SAAS,CAAC;IACvB,SAAS,EAAE,CAAC,sBAAsB,CAAC;IACnC,IAAI,EAAE,IAAI;IACV,OAAO,EAAE;QACP,OAAO,EAAE;YACP,YAAY,EAAE,KAAK;YACnB,cAAc,EAAE,IAAI;SACrB;KACF;IAED,KAAK,CAAC,MAAM,CAAC,KAAY,EAAE,OAA6B;QACtD,MAAM,aAAa,GAAG,CAAC,KAAK,CAAiB,CAAC;QAC9C,MAAM,OAAO,GAAG,6BAA6B,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QACtE,OAAO,MAAM,4BAA4B,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IAED,eAAe,EAAE,CAAC,aAA+D,EAAE,OAAO,EAAE,EAAE,CAC5F,6BAA6B,CAAC,aAAa,EAAE,OAAO,CAAC;CACsB,CAAC"}