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

package/dist/esm/ndjson-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ndjson-loader.js","names":["parseNDJSONSync","parseNDJSONInBatches","VERSION","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","arrayBuffer","TextDecoder","decode","parseTextSync","parseInBatches","options"],"sources":["../../src/ndjson-loader.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {ObjectRowTable, ArrayRowTable, TableBatch} from '@loaders.gl/schema';\nimport {parseNDJSONSync} from './lib/parsers/parse-ndjson';\nimport {parseNDJSONInBatches} from './lib/parsers/parse-ndjson-in-batches';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const NDJSONLoader: LoaderWithParser<\n  ObjectRowTable | ArrayRowTable,\n  TableBatch,\n  LoaderOptions\n> = {\n  name: 'NDJSON',\n  id: 'ndjson',\n  module: 'json',\n  version: VERSION,\n  extensions: ['ndjson', 'jsonl'],\n  mimeTypes: [\n    'application/x-ndjson',\n    'application/jsonlines', // https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-batch\n    'application/json-seq'\n  ],\n  category: 'table',\n  text: true,\n  parse: async (arrayBuffer: ArrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),\n  parseTextSync: parseNDJSONSync,\n  parseInBatches: parseNDJSONInBatches,\n  options: {}\n};\n"],"mappings":"AAIA,SAAQA,eAAe,QAAO,4BAA4B;AAC1D,SAAQC,oBAAoB,QAAO,uCAAuC;AAI1E,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAE3E,OAAO,MAAMC,YAIZ,GAAG;EACFC,IAAI,EAAE,QAAQ;EACdC,EAAE,EAAE,QAAQ;EACZC,MAAM,EAAE,MAAM;EACdC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;EAC/BC,SAAS,EAAE,CACT,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,CACvB;EACDC,QAAQ,EAAE,OAAO;EACjBC,IAAI,EAAE,IAAI;EACVC,KAAK,EAAE,MAAOC,WAAwB,IAAKb,eAAe,CAAC,IAAIc,WAAW,CAAC,CAAC,CAACC,MAAM,CAACF,WAAW,CAAC,CAAC;EACjGG,aAAa,EAAEhB,eAAe;EAC9BiB,cAAc,EAAEhB,oBAAoB;EACpCiB,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/esm/workers/geojson-worker.js

@@ -0,0 +1,4 @@
+import { createLoaderWorker } from '@loaders.gl/loader-utils';
+import { GeoJSONLoader } from '../geojson-loader';
+createLoaderWorker(GeoJSONLoader);
+//# sourceMappingURL=geojson-worker.js.map

package/dist/esm/workers/geojson-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-worker.js","names":["createLoaderWorker","GeoJSONLoader"],"sources":["../../../src/workers/geojson-worker.ts"],"sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {GeoJSONLoader} from '../geojson-loader';\n\ncreateLoaderWorker(GeoJSONLoader);\n"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,0BAA0B;AAC3D,SAAQC,aAAa,QAAO,mBAAmB;AAE/CD,kBAAkB,CAACC,aAAa,CAAC"}

package/dist/geojson-loader.d.ts

@@ -1,11 +1,11 @@
 import type { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
 import type { JSONLoaderOptions } from './json-loader';
-export declare type GeoJSONLoaderOptions = JSONLoaderOptions & {
+export type GeoJSONLoaderOptions = JSONLoaderOptions & {
     geojson?: {
         shape?: 'object-row-table';
     };
     gis?: {
-        format: 'geojson';
+        format?: 'geojson' | 'binary';
     };
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"geojson-loader.d.ts","sourceRoot":"","sources":["../src/geojson-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AASrD,oBAAY,oBAAoB,GAAG,iBAAiB,GAAG;IACrD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,CAAC;KAC5B,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,MAAM,EAAE,SAAS,CAAC;KACnB,CAAC;CACH,CAAC;AAcF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAWjC,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,gBAK3B,CAAC"}
+{"version":3,"file":"geojson-loader.d.ts","sourceRoot":"","sources":["../src/geojson-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAUrD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG;IACrD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,CAAC;KAC5B,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,MAAM,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;KAC/B,CAAC;CACH,CAAC;AAcF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAWjC,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,gBAK3B,CAAC"}

package/dist/geojson-loader.js

@@ -1,81 +1,77 @@
-import { geojsonToBinary } from '@loaders.gl/gis';
-import parseJSONSync from './lib/parse-json';
-import parseJSONInBatches from './lib/parse-json-in-batches';
-const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : 'latest';
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoJSONLoader = exports.GeoJSONWorkerLoader = void 0;
+const gis_1 = require("@loaders.gl/gis");
+const parse_json_1 = require("./lib/parsers/parse-json");
+const parse_json_in_batches_1 = require("./lib/parsers/parse-json-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_GEOJSON_LOADER_OPTIONS = {
-  geojson: {
-    shape: 'object-row-table'
-  },
-  json: {
-    jsonpaths: ['$', '$.features']
-  },
-  gis: {
-    format: 'geojson'
-  }
+    geojson: {
+        shape: 'object-row-table'
+    },
+    json: {
+        jsonpaths: ['$', '$.features']
+    },
+    gis: {
+        format: 'geojson'
+    }
 };
-export const GeoJSONWorkerLoader = {
-  name: 'GeoJSON',
-  id: 'geojson',
-  module: 'geojson',
-  version: VERSION,
-  worker: true,
-  extensions: ['geojson'],
-  mimeTypes: ['application/geo+json'],
-  category: 'geometry',
-  text: true,
-  options: DEFAULT_GEOJSON_LOADER_OPTIONS
+/**
+ * GeoJSON loader
+ */
+exports.GeoJSONWorkerLoader = {
+    name: 'GeoJSON',
+    id: 'geojson',
+    module: 'geojson',
+    version: VERSION,
+    worker: true,
+    extensions: ['geojson'],
+    mimeTypes: ['application/geo+json'],
+    category: 'geometry',
+    text: true,
+    options: DEFAULT_GEOJSON_LOADER_OPTIONS
 };
-export const GeoJSONLoader = { ...GeoJSONWorkerLoader,
-  parse,
-  parseTextSync,
-  parseInBatches
+exports.GeoJSONLoader = {
+    ...exports.GeoJSONWorkerLoader,
+    parse,
+    parseTextSync,
+    parseInBatches
 };
-
 async function parse(arrayBuffer, options) {
-  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);
+    return parseTextSync(new TextDecoder().decode(arrayBuffer), options);
 }
-
 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);
-
-  switch (options.gis.format) {
-    case 'binary':
-      return geojsonToBinary(json);
-
-    default:
-      return json;
-  }
+    // Apps can call the parse method directly, we so apply default options here
+    options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options };
+    options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson };
+    options.gis = options.gis || {};
+    const table = (0, parse_json_1.parseJSONSync)(text, options);
+    table.shape = 'geojson-row-table';
+    switch (options.gis.format) {
+        case 'binary':
+            return (0, gis_1.geojsonToBinary)(table.data);
+        default:
+            return table;
+    }
 }
-
 function parseInBatches(asyncIterator, options) {
-  options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS,
-    ...options
-  };
-  options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson,
-    ...options.geojson
-  };
-  const geojsonIterator = parseJSONInBatches(asyncIterator, options);
-
-  switch (options.gis.format) {
-    case 'binary':
-      return makeBinaryGeometryIterator(geojsonIterator);
-
-    default:
-      return geojsonIterator;
-  }
+    // Apps can call the parse method directly, we so apply default options here
+    options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options };
+    options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson };
+    const geojsonIterator = (0, parse_json_in_batches_1.parseJSONInBatches)(asyncIterator, options);
+    switch (options.gis.format) {
+        case 'binary':
+            return makeBinaryGeometryIterator(geojsonIterator);
+        default:
+            return geojsonIterator;
+    }
 }
-
 async function* makeBinaryGeometryIterator(geojsonIterator) {
-  for await (const batch of geojsonIterator) {
-    batch.data = geojsonToBinary(batch.data);
-    yield batch;
-  }
+    for await (const batch of geojsonIterator) {
+        batch.data = (0, gis_1.geojsonToBinary)(batch.data);
+        yield batch;
+    }
 }
-//# sourceMappingURL=geojson-loader.js.map

package/dist/geojson-worker.js

@@ -35,16 +35,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -53,22 +70,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -80,19 +111,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -175,11 +207,10 @@
   }
 
   // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
-  function earcut(data, holeIndices, dim, areas) {
-    dim = dim || 2;
+  function earcut(positions, holeIndices, dim = 2, areas) {
     const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-    let outerNode = linkedList(data, 0, outerLen, dim, true, areas && areas[0]);
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
     const triangles = [];
     if (!outerNode || outerNode.next === outerNode.prev)
       return triangles;
@@ -191,13 +222,13 @@
     let x;
     let y;
     if (hasHoles)
-      outerNode = eliminateHoles(data, holeIndices, outerNode, dim, areas);
-    if (data.length > 80 * dim) {
-      minX = maxX = data[0];
-      minY = maxY = data[1];
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
       for (let i = dim; i < outerLen; i += dim) {
-        x = data[i];
-        y = data[i + 1];
+        x = positions[i];
+        y = positions[i + 1];
         if (x < minX)
           minX = x;
         if (y < minY)
@@ -1073,36 +1104,9 @@
     });
   }
 
-  // src/lib/parse-json.ts
-  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");
-    }
-  }
-  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;
-  }
-
-  // ../schema/src/lib/batches/base-table-batch-aggregator.ts
+  // ../schema/src/lib/table/batches/base-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT = 100;
-  var RowTableBatchAggregator = class {
+  var BaseTableBatchAggregator = class {
     constructor(schema, options) {
       this.length = 0;
       this.rows = null;
@@ -1155,7 +1159,7 @@
     }
   };
 
-  // ../schema/src/lib/utils/row-utils.ts
+  // ../schema/src/lib/table/simple-table/row-utils.ts
   function convertToObjectRow(arrayRow, headers) {
     if (!arrayRow) {
       throw new Error("null row");
@@ -1183,9 +1187,9 @@
     return arrayRow;
   }
 
-  // ../schema/src/lib/batches/row-table-batch-aggregator.ts
+  // ../schema/src/lib/table/batches/row-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT2 = 100;
-  var RowTableBatchAggregator2 = class {
+  var RowTableBatchAggregator = class {
     constructor(schema, options) {
       this.length = 0;
       this.objectRows = null;
@@ -1255,7 +1259,7 @@
     }
   };
 
-  // ../schema/src/lib/batches/columnar-table-batch-aggregator.ts
+  // ../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT3 = 100;
   var ColumnarTableBatchAggregator = class {
     constructor(schema, options) {
@@ -1331,7 +1335,7 @@
     }
   };
 
-  // ../schema/src/lib/batches/table-batch-builder.ts
+  // ../schema/src/lib/table/batches/table-batch-builder.ts
   var DEFAULT_OPTIONS = {
     shape: "array-row-table",
     batchSize: "auto",
@@ -1443,10 +1447,10 @@
     _getTableBatchType() {
       switch (this.options.shape) {
         case "row-table":
-          return RowTableBatchAggregator;
+          return BaseTableBatchAggregator;
         case "array-row-table":
         case "object-row-table":
-          return RowTableBatchAggregator2;
+          return RowTableBatchAggregator;
         case "columnar-table":
           return ColumnarTableBatchAggregator;
         case "arrow-table":
@@ -1460,6 +1464,184 @@
     }
   };
 
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromValue(value, defaultNumberType = "float32") {
+    if (value instanceof Date) {
+      return "date-millisecond";
+    }
+    if (value instanceof Number) {
+      return defaultNumberType;
+    }
+    if (typeof value === "string") {
+      return "utf8";
+    }
+    if (value === null || value === "undefined") {
+      return "null";
+    }
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
+    }
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
+    }
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+
+  // ../schema/src/lib/table/simple-table/table-schema.ts
+  function deduceTableSchema(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return deduceSchemaFromRows(table.data);
+      case "columnar-table":
+        return deduceSchemaFromColumns(table.data);
+      case "arrow-table":
+      default:
+        throw new Error("Deduce schema");
+    }
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+      const type = getDataTypeFromArray(column);
+      return {
+        name,
+        type: type.type || "null",
+        nullable: type.nullable
+      };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+      };
+    }
+    throw new Error("empty table");
+  }
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+    };
+  }
+
+  // ../schema/src/lib/table/simple-table/make-table.ts
+  function makeTableFromData(data) {
+    let table;
+    switch (getTableShapeFromData(data)) {
+      case "array-row-table":
+        table = { shape: "array-row-table", data };
+        break;
+      case "object-row-table":
+        table = { shape: "object-row-table", data };
+        break;
+      case "columnar-table":
+        table = { shape: "columnar-table", data };
+        break;
+      default:
+        throw new Error("table");
+    }
+    const schema = deduceTableSchema(table);
+    return { ...table, schema };
+  }
+  function getTableShapeFromData(data) {
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        throw new Error("cannot deduce type of empty table");
+      }
+      const firstRow = data[0];
+      if (Array.isArray(firstRow)) {
+        return "array-row-table";
+      }
+      if (firstRow && typeof firstRow === "object") {
+        return "object-row-table";
+      }
+    }
+    if (data && typeof data === "object") {
+      return "columnar-table";
+    }
+    throw new Error("invalid table");
+  }
+
+  // src/lib/parsers/parse-json.ts
+  function parseJSONSync(jsonText, options) {
+    try {
+      const json = JSON.parse(jsonText);
+      if (options.json?.table) {
+        const data = getFirstArray(json) || json;
+        return makeTableFromData(data);
+      }
+      return json;
+    } catch (error) {
+      throw new Error("JSONLoader: failed to parse JSON");
+    }
+  }
+  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;
+  }
+
   // src/lib/clarinet/clarinet.ts
   var MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
   var STATE;
@@ -2016,7 +2198,7 @@ Char: ${this.c}`;
     }
   };
 
-  // src/lib/parser/json-parser.ts
+  // src/lib/json-parser/json-parser.ts
   var JSONParser = class {
     constructor(options) {
       this.result = void 0;
@@ -2104,7 +2286,7 @@ Char: ${this.c}`;
     }
   };
 
-  // src/lib/parser/streaming-json-parser.ts
+  // src/lib/json-parser/streaming-json-parser.ts
   var StreamingJSONParser = class extends JSONParser {
     constructor(options = {}) {
       super({
@@ -2172,7 +2354,7 @@ Char: ${this.c}`;
     }
   };
 
-  // src/lib/parse-json-in-batches.ts
+  // src/lib/parsers/parse-json-in-batches.ts
   async function* parseJSONInBatches(binaryAsyncIterator, options) {
     const asyncIterator = makeTextDecoderIterator(binaryAsyncIterator);
     const { metadata } = options;
@@ -2235,7 +2417,7 @@ Char: ${this.c}`;
   }
 
   // src/geojson-loader.ts
-  var VERSION = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION = true ? "4.0.0-alpha.6" : "latest";
   var DEFAULT_GEOJSON_LOADER_OPTIONS = {
     geojson: {
       shape: "object-row-table"
@@ -2272,12 +2454,13 @@ Char: ${this.c}`;
     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);
+    table.shape = "geojson-row-table";
     switch (options.gis.format) {
       case "binary":
-        return geojsonToBinary(json);
+        return geojsonToBinary(table.data);
       default:
-        return json;
+        return table;
     }
   }
   function parseInBatches(asyncIterator, options) {

package/dist/geojson-writer.d.ts

@@ -0,0 +1,6 @@
+import type { Writer } from '@loaders.gl/loader-utils';
+import type { Table, TableBatch } from '@loaders.gl/schema';
+import type { GeoJSONWriterOptions } from './lib/encoders/geojson-encoder';
+export type { GeoJSONWriterOptions };
+export declare const GeoJSONWriter: Writer<Table, TableBatch, GeoJSONWriterOptions>;
+//# sourceMappingURL=geojson-writer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-writer.d.ts","sourceRoot":"","sources":["../src/geojson-writer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,EAAC,KAAK,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,gCAAgC,CAAC;AAGzE,YAAY,EAAC,oBAAoB,EAAC,CAAC;AAEnC,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,oBAAoB,CAgBzE,CAAC"}