@loaders.gl/json 3.1.7 → 3.2.0-alpha.2

package/dist/dist.min.js

@@ -1405,15 +1405,6 @@ Char: ${this.c}`;
   });
 
   // src/ndjson-loader.ts
-  async function parse2(arrayBuffer) {
-    return parseTextSync2(new TextDecoder().decode(arrayBuffer));
-  }
-  function parseTextSync2(text) {
-    return parseNDJSONSync(text);
-  }
-  function parseInBatches2(asyncIterator, options) {
-    return parseNDJSONInBatches(asyncIterator, options);
-  }
   var VERSION2, NDJSONLoader;
   var init_ndjson_loader = __esm({
     "src/ndjson-loader.ts"() {
@@ -1425,13 +1416,17 @@ Char: ${this.c}`;
         id: "ndjson",
         module: "json",
         version: VERSION2,
-        extensions: ["ndjson"],
-        mimeTypes: ["application/x-ndjson"],
+        extensions: ["ndjson", "jsonl"],
+        mimeTypes: [
+          "application/x-ndjson",
+          "application/jsonlines",
+          "application/json-seq"
+        ],
         category: "table",
         text: true,
-        parse: parse2,
-        parseTextSync: parseTextSync2,
-        parseInBatches: parseInBatches2,
+        parse: async (arrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+        parseTextSync: parseNDJSONSync,
+        parseInBatches: parseNDJSONInBatches,
         options: {}
       };
     }
@@ -2438,10 +2433,10 @@ Char: ${this.c}`;
   });
 
   // src/geojson-loader.ts
-  async function parse3(arrayBuffer, options) {
-    return parseTextSync3(new TextDecoder().decode(arrayBuffer), options);
+  async function parse2(arrayBuffer, options) {
+    return parseTextSync2(new TextDecoder().decode(arrayBuffer), options);
   }
-  function parseTextSync3(text, options) {
+  function parseTextSync2(text, options) {
     options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options };
     options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson };
     options.gis = options.gis || {};
@@ -2453,7 +2448,7 @@ Char: ${this.c}`;
         return json;
     }
   }
-  function parseInBatches3(asyncIterator, options) {
+  function parseInBatches2(asyncIterator, options) {
     options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options };
     options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson };
     const geojsonIterator = parseJSONInBatches(asyncIterator, options);
@@ -2502,9 +2497,9 @@ Char: ${this.c}`;
       };
       GeoJSONLoader = {
         ...GeoJSONWorkerLoader,
-        parse: parse3,
-        parseTextSync: parseTextSync3,
-        parseInBatches: parseInBatches3
+        parse: parse2,
+        parseTextSync: parseTextSync2,
+        parseInBatches: parseInBatches2
       };
     }
   });

package/dist/es5/geojson-loader.js

@@ -29,7 +29,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-var VERSION = typeof "3.1.7" !== 'undefined' ? "3.1.7" : 'latest';
+var VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
 var DEFAULT_GEOJSON_LOADER_OPTIONS = {
   geojson: {
     shape: 'object-row-table'

package/dist/es5/geojson-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/geojson-loader.ts"],"names":["VERSION","DEFAULT_GEOJSON_LOADER_OPTIONS","geojson","shape","json","jsonpaths","gis","format","GeoJSONWorkerLoader","name","id","module","version","worker","extensions","mimeTypes","category","text","options","GeoJSONLoader","parse","parseTextSync","parseInBatches","arrayBuffer","TextDecoder","decode","asyncIterator","geojsonIterator","makeBinaryGeometryIterator","batch","data"],"mappings":"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","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {JSONLoaderOptions} from './json-loader';\nimport {geojsonToBinary} from '@loaders.gl/gis';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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 type GeoJSONLoaderOptions = JSONLoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format: 'geojson';\n  };\n};\n\nconst DEFAULT_GEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  json: {\n    jsonpaths: ['$', '$.features']\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\n/**\n * GeoJSON loader\n */\nexport const GeoJSONWorkerLoader: Loader = {\n  name: 'GeoJSON',\n  id: 'geojson',\n  module: 'geojson',\n  version: VERSION,\n  worker: true,\n  extensions: ['geojson'],\n  mimeTypes: ['application/geo+json'],\n  category: 'geometry',\n  text: true,\n  options: DEFAULT_GEOJSON_LOADER_OPTIONS\n};\n\nexport const GeoJSONLoader: LoaderWithParser = {\n  ...GeoJSONWorkerLoader,\n  parse,\n  parseTextSync,\n  parseInBatches\n};\n\nasync function parse(arrayBuffer, options) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text, options) {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n  options.gis = options.gis || {};\n  const json = parseJSONSync(text, options);\n  switch (options.gis.format) {\n    case 'binary':\n      return geojsonToBinary(json);\n    default:\n      return json;\n  }\n}\n\nfunction parseInBatches(asyncIterator, options): AsyncIterable<any> {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n\n  const geojsonIterator = parseJSONInBatches(asyncIterator, options);\n\n  switch (options.gis.format) {\n    case 'binary':\n      return makeBinaryGeometryIterator(geojsonIterator);\n    default:\n      return geojsonIterator;\n  }\n}\n\nasync function* makeBinaryGeometryIterator(geojsonIterator) {\n  for await (const batch of geojsonIterator) {\n    batch.data = geojsonToBinary(batch.data);\n    yield batch;\n  }\n}\n"],"file":"geojson-loader.js"}
+{"version":3,"sources":["../../src/geojson-loader.ts"],"names":["VERSION","DEFAULT_GEOJSON_LOADER_OPTIONS","geojson","shape","json","jsonpaths","gis","format","GeoJSONWorkerLoader","name","id","module","version","worker","extensions","mimeTypes","category","text","options","GeoJSONLoader","parse","parseTextSync","parseInBatches","arrayBuffer","TextDecoder","decode","asyncIterator","geojsonIterator","makeBinaryGeometryIterator","batch","data"],"mappings":"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","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {JSONLoaderOptions} from './json-loader';\nimport {geojsonToBinary} from '@loaders.gl/gis';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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 type GeoJSONLoaderOptions = JSONLoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format?: 'geojson' | 'binary';\n  };\n};\n\nconst DEFAULT_GEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  json: {\n    jsonpaths: ['$', '$.features']\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\n/**\n * GeoJSON loader\n */\nexport const GeoJSONWorkerLoader: Loader = {\n  name: 'GeoJSON',\n  id: 'geojson',\n  module: 'geojson',\n  version: VERSION,\n  worker: true,\n  extensions: ['geojson'],\n  mimeTypes: ['application/geo+json'],\n  category: 'geometry',\n  text: true,\n  options: DEFAULT_GEOJSON_LOADER_OPTIONS\n};\n\nexport const GeoJSONLoader: LoaderWithParser = {\n  ...GeoJSONWorkerLoader,\n  parse,\n  parseTextSync,\n  parseInBatches\n};\n\nasync function parse(arrayBuffer, options) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text, options) {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n  options.gis = options.gis || {};\n  const json = parseJSONSync(text, options);\n  switch (options.gis.format) {\n    case 'binary':\n      return geojsonToBinary(json);\n    default:\n      return json;\n  }\n}\n\nfunction parseInBatches(asyncIterator, options): AsyncIterable<any> {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n\n  const geojsonIterator = parseJSONInBatches(asyncIterator, options);\n\n  switch (options.gis.format) {\n    case 'binary':\n      return makeBinaryGeometryIterator(geojsonIterator);\n    default:\n      return geojsonIterator;\n  }\n}\n\nasync function* makeBinaryGeometryIterator(geojsonIterator) {\n  for await (const batch of geojsonIterator) {\n    batch.data = geojsonToBinary(batch.data);\n    yield batch;\n  }\n}\n"],"file":"geojson-loader.js"}

package/dist/es5/json-loader.js

@@ -21,7 +21,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-var VERSION = typeof "3.1.7" !== 'undefined' ? "3.1.7" : 'latest';
+var VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
 var DEFAULT_JSON_LOADER_OPTIONS = {
   json: {
     shape: 'row-table',

package/dist/es5/json-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/json-loader.ts"],"names":["VERSION","DEFAULT_JSON_LOADER_OPTIONS","json","shape","table","jsonpaths","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","jsonOptions","asyncIterator"],"mappings":";;;;;;;;;;;;;;;AAEA;;AACA;;;;;;AAIA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAcA,IAAMC,2BAA2B,GAAG;AAClCC,EAAAA,IAAI,EAAE;AACJC,IAAAA,KAAK,EAAE,WADH;AAEJC,IAAAA,KAAK,EAAE,KAFH;AAGJC,IAAAA,SAAS,EAAE;AAHP;AAD4B,CAApC;AASO,IAAMC,UAA4B,GAAG;AAC1CC,EAAAA,IAAI,EAAE,MADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEV,OAJiC;AAK1CW,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CAL8B;AAM1CC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CAN+B;AAoB1CC,EAAAA,QAAQ,EAAE,OApBgC;AAqB1CC,EAAAA,IAAI,EAAE,IArBoC;AAsB1CC,EAAAA,KAAK,EAALA,KAtB0C;AAuB1CC,EAAAA,aAAa,EAAbA,aAvB0C;AAwB1CC,EAAAA,cAAc,EAAdA,cAxB0C;AAyB1CC,EAAAA,OAAO,EAAEjB;AAzBiC,CAArC;;;SA4BQc,K;;;;;qEAAf,iBAAqBI,WAArB,EAA+CD,OAA/C;AAAA;AAAA;AAAA;AAAA;AAAA,6CACSF,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,EAAwCD,OAAxC,CADtB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAIA,SAASF,aAAT,CAAuBF,IAAvB,EAAqCI,OAArC,EAAkE;AAChE,MAAMI,WAAW,mCAAOJ,OAAP;AAAgBhB,IAAAA,IAAI,kCAAMD,2BAA2B,CAACC,IAAlC,GAA2CgB,OAA3C,aAA2CA,OAA3C,uBAA2CA,OAAO,CAAEhB,IAApD;AAApB,IAAjB;;AACA,SAAO,wBAAcY,IAAd,EAAoBQ,WAApB,CAAP;AACD;;AAED,SAASL,cAAT,CACEM,aADF,EAEEL,OAFF,EAGwB;AACtB,MAAMI,WAAW,mCAAOJ,OAAP;AAAgBhB,IAAAA,IAAI,kCAAMD,2BAA2B,CAACC,IAAlC,GAA2CgB,OAA3C,aAA2CA,OAA3C,uBAA2CA,OAAO,CAAEhB,IAApD;AAApB,IAAjB;;AACA,SAAO,iCAAmBqB,aAAnB,EAAkCD,WAAlC,CAAP;AACD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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\n/**\n * @param table -\n * @param jsonpaths -\n */\nexport type JSONLoaderOptions = LoaderOptions & {\n  json?: {\n    shape?: 'row-table';\n    table?: false;\n    jsonpaths?: string[];\n  };\n};\n\nconst DEFAULT_JSON_LOADER_OPTIONS = {\n  json: {\n    shape: 'row-table',\n    table: false,\n    jsonpaths: []\n    // batchSize: 'auto'\n  }\n};\n\nexport const JSONLoader: LoaderWithParser = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  // TODO - support various line based JSON formats\n  /*\n  extensions: {\n    json: null,\n    jsonl: {stream: true},\n    ndjson: {stream: true}\n  },\n  mimeTypes: {\n    'application/json': null,\n    'application/json-seq': {stream: true},\n    'application/x-ndjson': {stream: true}\n  },\n  */\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: DEFAULT_JSON_LOADER_OPTIONS\n};\n\nasync function parse(arrayBuffer: ArrayBuffer, options?: JSONLoaderOptions) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text: string, options?: JSONLoaderOptions) {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONSync(text, jsonOptions as JSONLoaderOptions);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: JSONLoaderOptions\n): AsyncIterable<Batch> {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONInBatches(asyncIterator, jsonOptions as JSONLoaderOptions);\n}\n"],"file":"json-loader.js"}
+{"version":3,"sources":["../../src/json-loader.ts"],"names":["VERSION","DEFAULT_JSON_LOADER_OPTIONS","json","shape","table","jsonpaths","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","jsonOptions","asyncIterator"],"mappings":";;;;;;;;;;;;;;;AAEA;;AACA;;;;;;AAIA,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAcA,IAAMC,2BAA2B,GAAG;AAClCC,EAAAA,IAAI,EAAE;AACJC,IAAAA,KAAK,EAAE,WADH;AAEJC,IAAAA,KAAK,EAAE,KAFH;AAGJC,IAAAA,SAAS,EAAE;AAHP;AAD4B,CAApC;AASO,IAAMC,UAA4B,GAAG;AAC1CC,EAAAA,IAAI,EAAE,MADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEV,OAJiC;AAK1CW,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CAL8B;AAM1CC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CAN+B;AAO1CC,EAAAA,QAAQ,EAAE,OAPgC;AAQ1CC,EAAAA,IAAI,EAAE,IARoC;AAS1CC,EAAAA,KAAK,EAALA,KAT0C;AAU1CC,EAAAA,aAAa,EAAbA,aAV0C;AAW1CC,EAAAA,cAAc,EAAdA,cAX0C;AAY1CC,EAAAA,OAAO,EAAEjB;AAZiC,CAArC;;;SAeQc,K;;;;;qEAAf,iBAAqBI,WAArB,EAA+CD,OAA/C;AAAA;AAAA;AAAA;AAAA;AAAA,6CACSF,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,EAAwCD,OAAxC,CADtB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAIA,SAASF,aAAT,CAAuBF,IAAvB,EAAqCI,OAArC,EAAkE;AAChE,MAAMI,WAAW,mCAAOJ,OAAP;AAAgBhB,IAAAA,IAAI,kCAAMD,2BAA2B,CAACC,IAAlC,GAA2CgB,OAA3C,aAA2CA,OAA3C,uBAA2CA,OAAO,CAAEhB,IAApD;AAApB,IAAjB;;AACA,SAAO,wBAAcY,IAAd,EAAoBQ,WAApB,CAAP;AACD;;AAED,SAASL,cAAT,CACEM,aADF,EAEEL,OAFF,EAGwB;AACtB,MAAMI,WAAW,mCAAOJ,OAAP;AAAgBhB,IAAAA,IAAI,kCAAMD,2BAA2B,CAACC,IAAlC,GAA2CgB,OAA3C,aAA2CA,OAA3C,uBAA2CA,OAAO,CAAEhB,IAApD;AAApB,IAAjB;;AACA,SAAO,iCAAmBqB,aAAnB,EAAkCD,WAAlC,CAAP;AACD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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\n/**\n * @param table -\n * @param jsonpaths -\n */\nexport type JSONLoaderOptions = LoaderOptions & {\n  json?: {\n    shape?: 'row-table';\n    table?: false;\n    jsonpaths?: string[];\n  };\n};\n\nconst DEFAULT_JSON_LOADER_OPTIONS = {\n  json: {\n    shape: 'row-table',\n    table: false,\n    jsonpaths: []\n    // batchSize: 'auto'\n  }\n};\n\nexport const JSONLoader: LoaderWithParser = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: DEFAULT_JSON_LOADER_OPTIONS\n};\n\nasync function parse(arrayBuffer: ArrayBuffer, options?: JSONLoaderOptions) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text: string, options?: JSONLoaderOptions) {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONSync(text, jsonOptions as JSONLoaderOptions);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: JSONLoaderOptions\n): AsyncIterable<Batch> {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONInBatches(asyncIterator, jsonOptions as JSONLoaderOptions);\n}\n"],"file":"json-loader.js"}

package/dist/es5/ndjgeoson-loader.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._typecheckNDJSONLoader = exports.NDJSONLoader = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _parseNdjson = _interopRequireDefault(require("./lib/parse-ndjson"));
+
+var _parseNdjsonInBatches = _interopRequireDefault(require("./lib/parse-ndjson-in-batches"));
+
+var VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
+var DEFAULT_NDGEOJSON_LOADER_OPTIONS = {
+  geojson: {
+    shape: 'object-row-table'
+  },
+  gis: {
+    format: 'geojson'
+  }
+};
+var NDJSONLoader = {
+  name: 'NDJSON',
+  id: 'ndjson',
+  module: 'json',
+  version: VERSION,
+  extensions: ['ndjson', 'ndgeojson'],
+  mimeTypes: ['application/geo+x-ndjson', 'application/geo+x-ldjson', 'application/jsonlines', 'application/geo+json-seq', 'application/x-ndjson'],
+  category: 'table',
+  text: true,
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", (0, _parseNdjson.default)(new TextDecoder().decode(arrayBuffer)));
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function parse(_x) {
+      return _parse.apply(this, arguments);
+    }
+
+    return parse;
+  }(),
+  parseTextSync: _parseNdjson.default,
+  parseInBatches: _parseNdjsonInBatches.default,
+  options: DEFAULT_NDGEOJSON_LOADER_OPTIONS
+};
+exports.NDJSONLoader = NDJSONLoader;
+var _typecheckNDJSONLoader = NDJSONLoader;
+exports._typecheckNDJSONLoader = _typecheckNDJSONLoader;
+//# sourceMappingURL=ndjgeoson-loader.js.map

package/dist/es5/ndjgeoson-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ndjgeoson-loader.ts"],"names":["VERSION","DEFAULT_NDGEOJSON_LOADER_OPTIONS","geojson","shape","gis","format","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","arrayBuffer","TextDecoder","decode","parseTextSync","parseNDJSONSync","parseInBatches","parseNDJSONInBatches","options","_typecheckNDJSONLoader"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;AAIA,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAWA,IAAMC,gCAAgC,GAAG;AACvCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,KAAK,EAAE;AADA,GAD8B;AAIvCC,EAAAA,GAAG,EAAE;AACHC,IAAAA,MAAM,EAAE;AADL;AAJkC,CAAzC;AASO,IAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEV,OAJiB;AAK1BW,EAAAA,UAAU,EAAE,CAAC,QAAD,EAAW,WAAX,CALc;AAM1BC,EAAAA,SAAS,EAAE,CACT,0BADS,EAET,0BAFS,EAGT,uBAHS,EAIT,0BAJS,EAKT,sBALS,CANe;AAa1BC,EAAAA,QAAQ,EAAE,OAbgB;AAc1BC,EAAAA,IAAI,EAAE,IAdoB;AAe1BC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAoC,0BAAgB,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAhB,CAApC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAfqB;AAgB1BG,EAAAA,aAAa,EAAEC,oBAhBW;AAiB1BC,EAAAA,cAAc,EAAEC,6BAjBU;AAkB1BC,EAAAA,OAAO,EAAEtB;AAlBiB,CAArB;;AAqBA,IAAMuB,sBAAwC,GAAGlB,YAAjD","sourcesContent":["import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/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 type NDGeoJSONLoaderOptions = LoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format: 'geojson';\n  };\n};\n\nconst DEFAULT_NDGEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\nexport const NDJSONLoader = {\n  name: 'NDJSON',\n  id: 'ndjson',\n  module: 'json',\n  version: VERSION,\n  extensions: ['ndjson', 'ndgeojson'],\n  mimeTypes: [\n    'application/geo+x-ndjson',\n    'application/geo+x-ldjson',\n    'application/jsonlines', // https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-batch\n    'application/geo+json-seq',\n    'application/x-ndjson'\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: DEFAULT_NDGEOJSON_LOADER_OPTIONS\n};\n\nexport const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;\n"],"file":"ndjgeoson-loader.js"}

package/dist/es5/ndjson-loader.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._typecheckNDJSONLoader = exports.NDJSONLoader = void 0;
+exports.NDJSONLoader = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -15,53 +15,41 @@ var _parseNdjson = _interopRequireDefault(require("./lib/parse-ndjson"));
 
 var _parseNdjsonInBatches = _interopRequireDefault(require("./lib/parse-ndjson-in-batches"));
 
-var VERSION = typeof "3.1.7" !== 'undefined' ? "3.1.7" : 'latest';
+var VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
 var NDJSONLoader = {
   name: 'NDJSON',
   id: 'ndjson',
   module: 'json',
   version: VERSION,
-  extensions: ['ndjson'],
-  mimeTypes: ['application/x-ndjson'],
+  extensions: ['ndjson', 'jsonl'],
+  mimeTypes: ['application/x-ndjson', 'application/jsonlines', 'application/json-seq'],
   category: 'table',
   text: true,
-  parse: parse,
-  parseTextSync: parseTextSync,
-  parseInBatches: parseInBatches,
-  options: {}
-};
-exports.NDJSONLoader = NDJSONLoader;
-
-function parse(_x) {
-  return _parse.apply(this, arguments);
-}
-
-function _parse() {
-  _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            return _context.abrupt("return", parseTextSync(new TextDecoder().decode(arrayBuffer)));
-
-          case 1:
-          case "end":
-            return _context.stop();
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", (0, _parseNdjson.default)(new TextDecoder().decode(arrayBuffer)));
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
         }
-      }
-    }, _callee);
-  }));
-  return _parse.apply(this, arguments);
-}
-
-function parseTextSync(text) {
-  return (0, _parseNdjson.default)(text);
-}
+      }, _callee);
+    }));
 
-function parseInBatches(asyncIterator, options) {
-  return (0, _parseNdjsonInBatches.default)(asyncIterator, options);
-}
+    function parse(_x) {
+      return _parse.apply(this, arguments);
+    }
 
-var _typecheckNDJSONLoader = NDJSONLoader;
-exports._typecheckNDJSONLoader = _typecheckNDJSONLoader;
+    return parse;
+  }(),
+  parseTextSync: _parseNdjson.default,
+  parseInBatches: _parseNdjsonInBatches.default,
+  options: {}
+};
+exports.NDJSONLoader = NDJSONLoader;
 //# sourceMappingURL=ndjson-loader.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/ndjson-loader.ts"],"names":["VERSION","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","asyncIterator","_typecheckNDJSONLoader"],"mappings":";;;;;;;;;;;;;AAEA;;AACA;;AAIA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAEO,IAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEL,OAJiB;AAK1BM,EAAAA,UAAU,EAAE,CAAC,QAAD,CALc;AAM1BC,EAAAA,SAAS,EAAE,CAAC,sBAAD,CANe;AAO1BC,EAAAA,QAAQ,EAAE,OAPgB;AAQ1BC,EAAAA,IAAI,EAAE,IARoB;AAS1BC,EAAAA,KAAK,EAALA,KAT0B;AAU1BC,EAAAA,aAAa,EAAbA,aAV0B;AAW1BC,EAAAA,cAAc,EAAdA,cAX0B;AAY1BC,EAAAA,OAAO,EAAE;AAZiB,CAArB;;;SAeQH,K;;;;;qEAAf,iBAAqBI,WAArB;AAAA;AAAA;AAAA;AAAA;AAAA,6CACSH,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CADtB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAIA,SAASH,aAAT,CAAuBF,IAAvB,EAAqC;AACnC,SAAO,0BAAgBA,IAAhB,CAAP;AACD;;AAED,SAASG,cAAT,CACEK,aADF,EAEEJ,OAFF,EAGwB;AACtB,SAAO,mCAAqBI,aAArB,EAAoCJ,OAApC,CAAP;AACD;;AAEM,IAAMK,sBAAwC,GAAGjB,YAAjD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/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 = {\n  name: 'NDJSON',\n  id: 'ndjson',\n  module: 'json',\n  version: VERSION,\n  extensions: ['ndjson'],\n  mimeTypes: ['application/x-ndjson'],\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: {}\n};\n\nasync function parse(arrayBuffer: ArrayBuffer) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer));\n}\n\nfunction parseTextSync(text: string) {\n  return parseNDJSONSync(text);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: LoaderOptions\n): AsyncIterable<Batch> {\n  return parseNDJSONInBatches(asyncIterator, options);\n}\n\nexport const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;\n"],"file":"ndjson-loader.js"}
+{"version":3,"sources":["../../src/ndjson-loader.ts"],"names":["VERSION","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","arrayBuffer","TextDecoder","decode","parseTextSync","parseNDJSONSync","parseInBatches","parseNDJSONInBatches","options"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AAIA,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAEO,IAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEL,OAJiB;AAK1BM,EAAAA,UAAU,EAAE,CAAC,QAAD,EAAW,OAAX,CALc;AAM1BC,EAAAA,SAAS,EAAE,CACT,sBADS,EAET,uBAFS,EAGT,sBAHS,CANe;AAW1BC,EAAAA,QAAQ,EAAE,OAXgB;AAY1BC,EAAAA,IAAI,EAAE,IAZoB;AAa1BC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAoC,0BAAgB,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAhB,CAApC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAbqB;AAc1BG,EAAAA,aAAa,EAAEC,oBAdW;AAe1BC,EAAAA,cAAc,EAAEC,6BAfU;AAgB1BC,EAAAA,OAAO,EAAE;AAhBiB,CAArB","sourcesContent":["import parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/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 = {\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"],"file":"ndjson-loader.js"}

package/dist/esm/geojson-loader.js

@@ -1,7 +1,7 @@
 import { geojsonToBinary } from '@loaders.gl/gis';
 import parseJSONSync from './lib/parse-json';
 import parseJSONInBatches from './lib/parse-json-in-batches';
-const VERSION = typeof "3.1.7" !== 'undefined' ? "3.1.7" : 'latest';
+const VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
 const DEFAULT_GEOJSON_LOADER_OPTIONS = {
   geojson: {
     shape: 'object-row-table'

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/geojson-loader.ts"],"names":["geojsonToBinary","parseJSONSync","parseJSONInBatches","VERSION","DEFAULT_GEOJSON_LOADER_OPTIONS","geojson","shape","json","jsonpaths","gis","format","GeoJSONWorkerLoader","name","id","module","version","worker","extensions","mimeTypes","category","text","options","GeoJSONLoader","parse","parseTextSync","parseInBatches","arrayBuffer","TextDecoder","decode","asyncIterator","geojsonIterator","makeBinaryGeometryIterator","batch","data"],"mappings":"AAEA,SAAQA,eAAR,QAA8B,iBAA9B;AACA,OAAOC,aAAP,MAA0B,kBAA1B;AACA,OAAOC,kBAAP,MAA+B,6BAA/B;AAIA,MAAMC,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAWA,MAAMC,8BAA8B,GAAG;AACrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,KAAK,EAAE;AADA,GAD4B;AAIrCC,EAAAA,IAAI,EAAE;AACJC,IAAAA,SAAS,EAAE,CAAC,GAAD,EAAM,YAAN;AADP,GAJ+B;AAOrCC,EAAAA,GAAG,EAAE;AACHC,IAAAA,MAAM,EAAE;AADL;AAPgC,CAAvC;AAeA,OAAO,MAAMC,mBAA2B,GAAG;AACzCC,EAAAA,IAAI,EAAE,SADmC;AAEzCC,EAAAA,EAAE,EAAE,SAFqC;AAGzCC,EAAAA,MAAM,EAAE,SAHiC;AAIzCC,EAAAA,OAAO,EAAEZ,OAJgC;AAKzCa,EAAAA,MAAM,EAAE,IALiC;AAMzCC,EAAAA,UAAU,EAAE,CAAC,SAAD,CAN6B;AAOzCC,EAAAA,SAAS,EAAE,CAAC,sBAAD,CAP8B;AAQzCC,EAAAA,QAAQ,EAAE,UAR+B;AASzCC,EAAAA,IAAI,EAAE,IATmC;AAUzCC,EAAAA,OAAO,EAAEjB;AAVgC,CAApC;AAaP,OAAO,MAAMkB,aAA+B,GAAG,EAC7C,GAAGX,mBAD0C;AAE7CY,EAAAA,KAF6C;AAG7CC,EAAAA,aAH6C;AAI7CC,EAAAA;AAJ6C,CAAxC;;AAOP,eAAeF,KAAf,CAAqBG,WAArB,EAAkCL,OAAlC,EAA2C;AACzC,SAAOG,aAAa,CAAC,IAAIG,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,EAAwCL,OAAxC,CAApB;AACD;;AAED,SAASG,aAAT,CAAuBJ,IAAvB,EAA6BC,OAA7B,EAAsC;AAEpCA,EAAAA,OAAO,GAAG,EAAC,GAAGjB,8BAAJ;AAAoC,OAAGiB;AAAvC,GAAV;AACAA,EAAAA,OAAO,CAACd,IAAR,GAAe,EAAC,GAAGH,8BAA8B,CAACC,OAAnC;AAA4C,OAAGgB,OAAO,CAAChB;AAAvD,GAAf;AACAgB,EAAAA,OAAO,CAACZ,GAAR,GAAcY,OAAO,CAACZ,GAAR,IAAe,EAA7B;AACA,QAAMF,IAAI,GAAGN,aAAa,CAACmB,IAAD,EAAOC,OAAP,CAA1B;;AACA,UAAQA,OAAO,CAACZ,GAAR,CAAYC,MAApB;AACE,SAAK,QAAL;AACE,aAAOV,eAAe,CAACO,IAAD,CAAtB;;AACF;AACE,aAAOA,IAAP;AAJJ;AAMD;;AAED,SAASkB,cAAT,CAAwBI,aAAxB,EAAuCR,OAAvC,EAAoE;AAElEA,EAAAA,OAAO,GAAG,EAAC,GAAGjB,8BAAJ;AAAoC,OAAGiB;AAAvC,GAAV;AACAA,EAAAA,OAAO,CAACd,IAAR,GAAe,EAAC,GAAGH,8BAA8B,CAACC,OAAnC;AAA4C,OAAGgB,OAAO,CAAChB;AAAvD,GAAf;AAEA,QAAMyB,eAAe,GAAG5B,kBAAkB,CAAC2B,aAAD,EAAgBR,OAAhB,CAA1C;;AAEA,UAAQA,OAAO,CAACZ,GAAR,CAAYC,MAApB;AACE,SAAK,QAAL;AACE,aAAOqB,0BAA0B,CAACD,eAAD,CAAjC;;AACF;AACE,aAAOA,eAAP;AAJJ;AAMD;;AAED,gBAAgBC,0BAAhB,CAA2CD,eAA3C,EAA4D;AAC1D,aAAW,MAAME,KAAjB,IAA0BF,eAA1B,EAA2C;AACzCE,IAAAA,KAAK,CAACC,IAAN,GAAajC,eAAe,CAACgC,KAAK,CAACC,IAAP,CAA5B;AACA,UAAMD,KAAN;AACD;AACF","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {JSONLoaderOptions} from './json-loader';\nimport {geojsonToBinary} from '@loaders.gl/gis';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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 type GeoJSONLoaderOptions = JSONLoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format: 'geojson';\n  };\n};\n\nconst DEFAULT_GEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  json: {\n    jsonpaths: ['$', '$.features']\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\n/**\n * GeoJSON loader\n */\nexport const GeoJSONWorkerLoader: Loader = {\n  name: 'GeoJSON',\n  id: 'geojson',\n  module: 'geojson',\n  version: VERSION,\n  worker: true,\n  extensions: ['geojson'],\n  mimeTypes: ['application/geo+json'],\n  category: 'geometry',\n  text: true,\n  options: DEFAULT_GEOJSON_LOADER_OPTIONS\n};\n\nexport const GeoJSONLoader: LoaderWithParser = {\n  ...GeoJSONWorkerLoader,\n  parse,\n  parseTextSync,\n  parseInBatches\n};\n\nasync function parse(arrayBuffer, options) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text, options) {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n  options.gis = options.gis || {};\n  const json = parseJSONSync(text, options);\n  switch (options.gis.format) {\n    case 'binary':\n      return geojsonToBinary(json);\n    default:\n      return json;\n  }\n}\n\nfunction parseInBatches(asyncIterator, options): AsyncIterable<any> {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n\n  const geojsonIterator = parseJSONInBatches(asyncIterator, options);\n\n  switch (options.gis.format) {\n    case 'binary':\n      return makeBinaryGeometryIterator(geojsonIterator);\n    default:\n      return geojsonIterator;\n  }\n}\n\nasync function* makeBinaryGeometryIterator(geojsonIterator) {\n  for await (const batch of geojsonIterator) {\n    batch.data = geojsonToBinary(batch.data);\n    yield batch;\n  }\n}\n"],"file":"geojson-loader.js"}
+{"version":3,"sources":["../../src/geojson-loader.ts"],"names":["geojsonToBinary","parseJSONSync","parseJSONInBatches","VERSION","DEFAULT_GEOJSON_LOADER_OPTIONS","geojson","shape","json","jsonpaths","gis","format","GeoJSONWorkerLoader","name","id","module","version","worker","extensions","mimeTypes","category","text","options","GeoJSONLoader","parse","parseTextSync","parseInBatches","arrayBuffer","TextDecoder","decode","asyncIterator","geojsonIterator","makeBinaryGeometryIterator","batch","data"],"mappings":"AAEA,SAAQA,eAAR,QAA8B,iBAA9B;AACA,OAAOC,aAAP,MAA0B,kBAA1B;AACA,OAAOC,kBAAP,MAA+B,6BAA/B;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAWA,MAAMC,8BAA8B,GAAG;AACrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,KAAK,EAAE;AADA,GAD4B;AAIrCC,EAAAA,IAAI,EAAE;AACJC,IAAAA,SAAS,EAAE,CAAC,GAAD,EAAM,YAAN;AADP,GAJ+B;AAOrCC,EAAAA,GAAG,EAAE;AACHC,IAAAA,MAAM,EAAE;AADL;AAPgC,CAAvC;AAeA,OAAO,MAAMC,mBAA2B,GAAG;AACzCC,EAAAA,IAAI,EAAE,SADmC;AAEzCC,EAAAA,EAAE,EAAE,SAFqC;AAGzCC,EAAAA,MAAM,EAAE,SAHiC;AAIzCC,EAAAA,OAAO,EAAEZ,OAJgC;AAKzCa,EAAAA,MAAM,EAAE,IALiC;AAMzCC,EAAAA,UAAU,EAAE,CAAC,SAAD,CAN6B;AAOzCC,EAAAA,SAAS,EAAE,CAAC,sBAAD,CAP8B;AAQzCC,EAAAA,QAAQ,EAAE,UAR+B;AASzCC,EAAAA,IAAI,EAAE,IATmC;AAUzCC,EAAAA,OAAO,EAAEjB;AAVgC,CAApC;AAaP,OAAO,MAAMkB,aAA+B,GAAG,EAC7C,GAAGX,mBAD0C;AAE7CY,EAAAA,KAF6C;AAG7CC,EAAAA,aAH6C;AAI7CC,EAAAA;AAJ6C,CAAxC;;AAOP,eAAeF,KAAf,CAAqBG,WAArB,EAAkCL,OAAlC,EAA2C;AACzC,SAAOG,aAAa,CAAC,IAAIG,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,EAAwCL,OAAxC,CAApB;AACD;;AAED,SAASG,aAAT,CAAuBJ,IAAvB,EAA6BC,OAA7B,EAAsC;AAEpCA,EAAAA,OAAO,GAAG,EAAC,GAAGjB,8BAAJ;AAAoC,OAAGiB;AAAvC,GAAV;AACAA,EAAAA,OAAO,CAACd,IAAR,GAAe,EAAC,GAAGH,8BAA8B,CAACC,OAAnC;AAA4C,OAAGgB,OAAO,CAAChB;AAAvD,GAAf;AACAgB,EAAAA,OAAO,CAACZ,GAAR,GAAcY,OAAO,CAACZ,GAAR,IAAe,EAA7B;AACA,QAAMF,IAAI,GAAGN,aAAa,CAACmB,IAAD,EAAOC,OAAP,CAA1B;;AACA,UAAQA,OAAO,CAACZ,GAAR,CAAYC,MAApB;AACE,SAAK,QAAL;AACE,aAAOV,eAAe,CAACO,IAAD,CAAtB;;AACF;AACE,aAAOA,IAAP;AAJJ;AAMD;;AAED,SAASkB,cAAT,CAAwBI,aAAxB,EAAuCR,OAAvC,EAAoE;AAElEA,EAAAA,OAAO,GAAG,EAAC,GAAGjB,8BAAJ;AAAoC,OAAGiB;AAAvC,GAAV;AACAA,EAAAA,OAAO,CAACd,IAAR,GAAe,EAAC,GAAGH,8BAA8B,CAACC,OAAnC;AAA4C,OAAGgB,OAAO,CAAChB;AAAvD,GAAf;AAEA,QAAMyB,eAAe,GAAG5B,kBAAkB,CAAC2B,aAAD,EAAgBR,OAAhB,CAA1C;;AAEA,UAAQA,OAAO,CAACZ,GAAR,CAAYC,MAApB;AACE,SAAK,QAAL;AACE,aAAOqB,0BAA0B,CAACD,eAAD,CAAjC;;AACF;AACE,aAAOA,eAAP;AAJJ;AAMD;;AAED,gBAAgBC,0BAAhB,CAA2CD,eAA3C,EAA4D;AAC1D,aAAW,MAAME,KAAjB,IAA0BF,eAA1B,EAA2C;AACzCE,IAAAA,KAAK,CAACC,IAAN,GAAajC,eAAe,CAACgC,KAAK,CAACC,IAAP,CAA5B;AACA,UAAMD,KAAN;AACD;AACF","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {JSONLoaderOptions} from './json-loader';\nimport {geojsonToBinary} from '@loaders.gl/gis';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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 type GeoJSONLoaderOptions = JSONLoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format?: 'geojson' | 'binary';\n  };\n};\n\nconst DEFAULT_GEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  json: {\n    jsonpaths: ['$', '$.features']\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\n/**\n * GeoJSON loader\n */\nexport const GeoJSONWorkerLoader: Loader = {\n  name: 'GeoJSON',\n  id: 'geojson',\n  module: 'geojson',\n  version: VERSION,\n  worker: true,\n  extensions: ['geojson'],\n  mimeTypes: ['application/geo+json'],\n  category: 'geometry',\n  text: true,\n  options: DEFAULT_GEOJSON_LOADER_OPTIONS\n};\n\nexport const GeoJSONLoader: LoaderWithParser = {\n  ...GeoJSONWorkerLoader,\n  parse,\n  parseTextSync,\n  parseInBatches\n};\n\nasync function parse(arrayBuffer, options) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text, options) {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n  options.gis = options.gis || {};\n  const json = parseJSONSync(text, options);\n  switch (options.gis.format) {\n    case 'binary':\n      return geojsonToBinary(json);\n    default:\n      return json;\n  }\n}\n\nfunction parseInBatches(asyncIterator, options): AsyncIterable<any> {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n\n  const geojsonIterator = parseJSONInBatches(asyncIterator, options);\n\n  switch (options.gis.format) {\n    case 'binary':\n      return makeBinaryGeometryIterator(geojsonIterator);\n    default:\n      return geojsonIterator;\n  }\n}\n\nasync function* makeBinaryGeometryIterator(geojsonIterator) {\n  for await (const batch of geojsonIterator) {\n    batch.data = geojsonToBinary(batch.data);\n    yield batch;\n  }\n}\n"],"file":"geojson-loader.js"}

package/dist/esm/json-loader.js

@@ -1,6 +1,6 @@
 import parseJSONSync from './lib/parse-json';
 import parseJSONInBatches from './lib/parse-json-in-batches';
-const VERSION = typeof "3.1.7" !== 'undefined' ? "3.1.7" : 'latest';
+const VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
 const DEFAULT_JSON_LOADER_OPTIONS = {
   json: {
     shape: 'row-table',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/json-loader.ts"],"names":["parseJSONSync","parseJSONInBatches","VERSION","DEFAULT_JSON_LOADER_OPTIONS","json","shape","table","jsonpaths","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","jsonOptions","asyncIterator"],"mappings":"AAEA,OAAOA,aAAP,MAA0B,kBAA1B;AACA,OAAOC,kBAAP,MAA+B,6BAA/B;AAIA,MAAMC,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAcA,MAAMC,2BAA2B,GAAG;AAClCC,EAAAA,IAAI,EAAE;AACJC,IAAAA,KAAK,EAAE,WADH;AAEJC,IAAAA,KAAK,EAAE,KAFH;AAGJC,IAAAA,SAAS,EAAE;AAHP;AAD4B,CAApC;AASA,OAAO,MAAMC,UAA4B,GAAG;AAC1CC,EAAAA,IAAI,EAAE,MADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEV,OAJiC;AAK1CW,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CAL8B;AAM1CC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CAN+B;AAoB1CC,EAAAA,QAAQ,EAAE,OApBgC;AAqB1CC,EAAAA,IAAI,EAAE,IArBoC;AAsB1CC,EAAAA,KAtB0C;AAuB1CC,EAAAA,aAvB0C;AAwB1CC,EAAAA,cAxB0C;AAyB1CC,EAAAA,OAAO,EAAEjB;AAzBiC,CAArC;;AA4BP,eAAec,KAAf,CAAqBI,WAArB,EAA+CD,OAA/C,EAA4E;AAC1E,SAAOF,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,EAAwCD,OAAxC,CAApB;AACD;;AAED,SAASF,aAAT,CAAuBF,IAAvB,EAAqCI,OAArC,EAAkE;AAChE,QAAMI,WAAW,GAAG,EAAC,GAAGJ,OAAJ;AAAahB,IAAAA,IAAI,EAAE,EAAC,GAAGD,2BAA2B,CAACC,IAAhC;AAAsC,UAAGgB,OAAH,aAAGA,OAAH,uBAAGA,OAAO,CAAEhB,IAAZ;AAAtC;AAAnB,GAApB;AACA,SAAOJ,aAAa,CAACgB,IAAD,EAAOQ,WAAP,CAApB;AACD;;AAED,SAASL,cAAT,CACEM,aADF,EAEEL,OAFF,EAGwB;AACtB,QAAMI,WAAW,GAAG,EAAC,GAAGJ,OAAJ;AAAahB,IAAAA,IAAI,EAAE,EAAC,GAAGD,2BAA2B,CAACC,IAAhC;AAAsC,UAAGgB,OAAH,aAAGA,OAAH,uBAAGA,OAAO,CAAEhB,IAAZ;AAAtC;AAAnB,GAApB;AACA,SAAOH,kBAAkB,CAACwB,aAAD,EAAgBD,WAAhB,CAAzB;AACD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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\n/**\n * @param table -\n * @param jsonpaths -\n */\nexport type JSONLoaderOptions = LoaderOptions & {\n  json?: {\n    shape?: 'row-table';\n    table?: false;\n    jsonpaths?: string[];\n  };\n};\n\nconst DEFAULT_JSON_LOADER_OPTIONS = {\n  json: {\n    shape: 'row-table',\n    table: false,\n    jsonpaths: []\n    // batchSize: 'auto'\n  }\n};\n\nexport const JSONLoader: LoaderWithParser = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  // TODO - support various line based JSON formats\n  /*\n  extensions: {\n    json: null,\n    jsonl: {stream: true},\n    ndjson: {stream: true}\n  },\n  mimeTypes: {\n    'application/json': null,\n    'application/json-seq': {stream: true},\n    'application/x-ndjson': {stream: true}\n  },\n  */\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: DEFAULT_JSON_LOADER_OPTIONS\n};\n\nasync function parse(arrayBuffer: ArrayBuffer, options?: JSONLoaderOptions) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text: string, options?: JSONLoaderOptions) {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONSync(text, jsonOptions as JSONLoaderOptions);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: JSONLoaderOptions\n): AsyncIterable<Batch> {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONInBatches(asyncIterator, jsonOptions as JSONLoaderOptions);\n}\n"],"file":"json-loader.js"}
+{"version":3,"sources":["../../src/json-loader.ts"],"names":["parseJSONSync","parseJSONInBatches","VERSION","DEFAULT_JSON_LOADER_OPTIONS","json","shape","table","jsonpaths","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","jsonOptions","asyncIterator"],"mappings":"AAEA,OAAOA,aAAP,MAA0B,kBAA1B;AACA,OAAOC,kBAAP,MAA+B,6BAA/B;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAcA,MAAMC,2BAA2B,GAAG;AAClCC,EAAAA,IAAI,EAAE;AACJC,IAAAA,KAAK,EAAE,WADH;AAEJC,IAAAA,KAAK,EAAE,KAFH;AAGJC,IAAAA,SAAS,EAAE;AAHP;AAD4B,CAApC;AASA,OAAO,MAAMC,UAA4B,GAAG;AAC1CC,EAAAA,IAAI,EAAE,MADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEV,OAJiC;AAK1CW,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CAL8B;AAM1CC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CAN+B;AAO1CC,EAAAA,QAAQ,EAAE,OAPgC;AAQ1CC,EAAAA,IAAI,EAAE,IARoC;AAS1CC,EAAAA,KAT0C;AAU1CC,EAAAA,aAV0C;AAW1CC,EAAAA,cAX0C;AAY1CC,EAAAA,OAAO,EAAEjB;AAZiC,CAArC;;AAeP,eAAec,KAAf,CAAqBI,WAArB,EAA+CD,OAA/C,EAA4E;AAC1E,SAAOF,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,EAAwCD,OAAxC,CAApB;AACD;;AAED,SAASF,aAAT,CAAuBF,IAAvB,EAAqCI,OAArC,EAAkE;AAChE,QAAMI,WAAW,GAAG,EAAC,GAAGJ,OAAJ;AAAahB,IAAAA,IAAI,EAAE,EAAC,GAAGD,2BAA2B,CAACC,IAAhC;AAAsC,UAAGgB,OAAH,aAAGA,OAAH,uBAAGA,OAAO,CAAEhB,IAAZ;AAAtC;AAAnB,GAApB;AACA,SAAOJ,aAAa,CAACgB,IAAD,EAAOQ,WAAP,CAApB;AACD;;AAED,SAASL,cAAT,CACEM,aADF,EAEEL,OAFF,EAGwB;AACtB,QAAMI,WAAW,GAAG,EAAC,GAAGJ,OAAJ;AAAahB,IAAAA,IAAI,EAAE,EAAC,GAAGD,2BAA2B,CAACC,IAAhC;AAAsC,UAAGgB,OAAH,aAAGA,OAAH,uBAAGA,OAAO,CAAEhB,IAAZ;AAAtC;AAAnB,GAApB;AACA,SAAOH,kBAAkB,CAACwB,aAAD,EAAgBD,WAAhB,CAAzB;AACD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-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\n/**\n * @param table -\n * @param jsonpaths -\n */\nexport type JSONLoaderOptions = LoaderOptions & {\n  json?: {\n    shape?: 'row-table';\n    table?: false;\n    jsonpaths?: string[];\n  };\n};\n\nconst DEFAULT_JSON_LOADER_OPTIONS = {\n  json: {\n    shape: 'row-table',\n    table: false,\n    jsonpaths: []\n    // batchSize: 'auto'\n  }\n};\n\nexport const JSONLoader: LoaderWithParser = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: DEFAULT_JSON_LOADER_OPTIONS\n};\n\nasync function parse(arrayBuffer: ArrayBuffer, options?: JSONLoaderOptions) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text: string, options?: JSONLoaderOptions) {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONSync(text, jsonOptions as JSONLoaderOptions);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: JSONLoaderOptions\n): AsyncIterable<Batch> {\n  const jsonOptions = {...options, json: {...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json}};\n  return parseJSONInBatches(asyncIterator, jsonOptions as JSONLoaderOptions);\n}\n"],"file":"json-loader.js"}

package/dist/esm/ndjgeoson-loader.js

@@ -0,0 +1,27 @@
+import parseNDJSONSync from './lib/parse-ndjson';
+import parseNDJSONInBatches from './lib/parse-ndjson-in-batches';
+const VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
+const DEFAULT_NDGEOJSON_LOADER_OPTIONS = {
+  geojson: {
+    shape: 'object-row-table'
+  },
+  gis: {
+    format: 'geojson'
+  }
+};
+export const NDJSONLoader = {
+  name: 'NDJSON',
+  id: 'ndjson',
+  module: 'json',
+  version: VERSION,
+  extensions: ['ndjson', 'ndgeojson'],
+  mimeTypes: ['application/geo+x-ndjson', 'application/geo+x-ldjson', 'application/jsonlines', 'application/geo+json-seq', 'application/x-ndjson'],
+  category: 'table',
+  text: true,
+  parse: async arrayBuffer => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+  parseTextSync: parseNDJSONSync,
+  parseInBatches: parseNDJSONInBatches,
+  options: DEFAULT_NDGEOJSON_LOADER_OPTIONS
+};
+export const _typecheckNDJSONLoader = NDJSONLoader;
+//# sourceMappingURL=ndjgeoson-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ndjgeoson-loader.ts"],"names":["parseNDJSONSync","parseNDJSONInBatches","VERSION","DEFAULT_NDGEOJSON_LOADER_OPTIONS","geojson","shape","gis","format","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","arrayBuffer","TextDecoder","decode","parseTextSync","parseInBatches","options","_typecheckNDJSONLoader"],"mappings":"AACA,OAAOA,eAAP,MAA4B,oBAA5B;AACA,OAAOC,oBAAP,MAAiC,+BAAjC;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAWA,MAAMC,gCAAgC,GAAG;AACvCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,KAAK,EAAE;AADA,GAD8B;AAIvCC,EAAAA,GAAG,EAAE;AACHC,IAAAA,MAAM,EAAE;AADL;AAJkC,CAAzC;AASA,OAAO,MAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEV,OAJiB;AAK1BW,EAAAA,UAAU,EAAE,CAAC,QAAD,EAAW,WAAX,CALc;AAM1BC,EAAAA,SAAS,EAAE,CACT,0BADS,EAET,0BAFS,EAGT,uBAHS,EAIT,0BAJS,EAKT,sBALS,CANe;AAa1BC,EAAAA,QAAQ,EAAE,OAbgB;AAc1BC,EAAAA,IAAI,EAAE,IAdoB;AAe1BC,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAoClB,eAAe,CAAC,IAAImB,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAfhC;AAgB1BG,EAAAA,aAAa,EAAErB,eAhBW;AAiB1BsB,EAAAA,cAAc,EAAErB,oBAjBU;AAkB1BsB,EAAAA,OAAO,EAAEpB;AAlBiB,CAArB;AAqBP,OAAO,MAAMqB,sBAAwC,GAAGhB,YAAjD","sourcesContent":["import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/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 type NDGeoJSONLoaderOptions = LoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format: 'geojson';\n  };\n};\n\nconst DEFAULT_NDGEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\nexport const NDJSONLoader = {\n  name: 'NDJSON',\n  id: 'ndjson',\n  module: 'json',\n  version: VERSION,\n  extensions: ['ndjson', 'ndgeojson'],\n  mimeTypes: [\n    'application/geo+x-ndjson',\n    'application/geo+x-ldjson',\n    'application/jsonlines', // https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-batch\n    'application/geo+json-seq',\n    'application/x-ndjson'\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: DEFAULT_NDGEOJSON_LOADER_OPTIONS\n};\n\nexport const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;\n"],"file":"ndjgeoson-loader.js"}

package/dist/esm/ndjson-loader.js

@@ -1,32 +1,18 @@
 import parseNDJSONSync from './lib/parse-ndjson';
 import parseNDJSONInBatches from './lib/parse-ndjson-in-batches';
-const VERSION = typeof "3.1.7" !== 'undefined' ? "3.1.7" : 'latest';
+const VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
 export const NDJSONLoader = {
   name: 'NDJSON',
   id: 'ndjson',
   module: 'json',
   version: VERSION,
-  extensions: ['ndjson'],
-  mimeTypes: ['application/x-ndjson'],
+  extensions: ['ndjson', 'jsonl'],
+  mimeTypes: ['application/x-ndjson', 'application/jsonlines', 'application/json-seq'],
   category: 'table',
   text: true,
-  parse,
-  parseTextSync,
-  parseInBatches,
+  parse: async arrayBuffer => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+  parseTextSync: parseNDJSONSync,
+  parseInBatches: parseNDJSONInBatches,
   options: {}
 };
-
-async function parse(arrayBuffer) {
-  return parseTextSync(new TextDecoder().decode(arrayBuffer));
-}
-
-function parseTextSync(text) {
-  return parseNDJSONSync(text);
-}
-
-function parseInBatches(asyncIterator, options) {
-  return parseNDJSONInBatches(asyncIterator, options);
-}
-
-export const _typecheckNDJSONLoader = NDJSONLoader;
 //# sourceMappingURL=ndjson-loader.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/ndjson-loader.ts"],"names":["parseNDJSONSync","parseNDJSONInBatches","VERSION","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","asyncIterator","_typecheckNDJSONLoader"],"mappings":"AAEA,OAAOA,eAAP,MAA4B,oBAA5B;AACA,OAAOC,oBAAP,MAAiC,+BAAjC;AAIA,MAAMC,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAEA,OAAO,MAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEL,OAJiB;AAK1BM,EAAAA,UAAU,EAAE,CAAC,QAAD,CALc;AAM1BC,EAAAA,SAAS,EAAE,CAAC,sBAAD,CANe;AAO1BC,EAAAA,QAAQ,EAAE,OAPgB;AAQ1BC,EAAAA,IAAI,EAAE,IARoB;AAS1BC,EAAAA,KAT0B;AAU1BC,EAAAA,aAV0B;AAW1BC,EAAAA,cAX0B;AAY1BC,EAAAA,OAAO,EAAE;AAZiB,CAArB;;AAeP,eAAeH,KAAf,CAAqBI,WAArB,EAA+C;AAC7C,SAAOH,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAApB;AACD;;AAED,SAASH,aAAT,CAAuBF,IAAvB,EAAqC;AACnC,SAAOX,eAAe,CAACW,IAAD,CAAtB;AACD;;AAED,SAASG,cAAT,CACEK,aADF,EAEEJ,OAFF,EAGwB;AACtB,SAAOd,oBAAoB,CAACkB,aAAD,EAAgBJ,OAAhB,CAA3B;AACD;;AAED,OAAO,MAAMK,sBAAwC,GAAGjB,YAAjD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/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 = {\n  name: 'NDJSON',\n  id: 'ndjson',\n  module: 'json',\n  version: VERSION,\n  extensions: ['ndjson'],\n  mimeTypes: ['application/x-ndjson'],\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: {}\n};\n\nasync function parse(arrayBuffer: ArrayBuffer) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer));\n}\n\nfunction parseTextSync(text: string) {\n  return parseNDJSONSync(text);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: LoaderOptions\n): AsyncIterable<Batch> {\n  return parseNDJSONInBatches(asyncIterator, options);\n}\n\nexport const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;\n"],"file":"ndjson-loader.js"}
+{"version":3,"sources":["../../src/ndjson-loader.ts"],"names":["parseNDJSONSync","parseNDJSONInBatches","VERSION","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","arrayBuffer","TextDecoder","decode","parseTextSync","parseInBatches","options"],"mappings":"AAAA,OAAOA,eAAP,MAA4B,oBAA5B;AACA,OAAOC,oBAAP,MAAiC,+BAAjC;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAEA,OAAO,MAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEL,OAJiB;AAK1BM,EAAAA,UAAU,EAAE,CAAC,QAAD,EAAW,OAAX,CALc;AAM1BC,EAAAA,SAAS,EAAE,CACT,sBADS,EAET,uBAFS,EAGT,sBAHS,CANe;AAW1BC,EAAAA,QAAQ,EAAE,OAXgB;AAY1BC,EAAAA,IAAI,EAAE,IAZoB;AAa1BC,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAoCb,eAAe,CAAC,IAAIc,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAbhC;AAc1BG,EAAAA,aAAa,EAAEhB,eAdW;AAe1BiB,EAAAA,cAAc,EAAEhB,oBAfU;AAgB1BiB,EAAAA,OAAO,EAAE;AAhBiB,CAArB","sourcesContent":["import parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/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 = {\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"],"file":"ndjson-loader.js"}

package/dist/geojson-loader.d.ts

@@ -5,7 +5,7 @@ export declare type GeoJSONLoaderOptions = JSONLoaderOptions & {
         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":"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,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-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,7 +111,7 @@
   // ../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) => {
@@ -2235,7 +2266,7 @@ Char: ${this.c}`;
   }
 
   // src/geojson-loader.ts
-  var VERSION = true ? "3.1.7" : "latest";
+  var VERSION = true ? "3.2.0-alpha.2" : "latest";
   var DEFAULT_GEOJSON_LOADER_OPTIONS = {
     geojson: {
       shape: "object-row-table"

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

@@ -1 +1 @@
-{"version":3,"file":"json-loader.d.ts","sourceRoot":"","sources":["../src/json-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAQ9E;;;GAGG;AACH,oBAAY,iBAAiB,GAAG,aAAa,GAAG;IAC9C,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,WAAW,CAAC;QACpB,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC;CACH,CAAC;AAWF,eAAO,MAAM,UAAU,EAAE,gBA0BxB,CAAC"}
+{"version":3,"file":"json-loader.d.ts","sourceRoot":"","sources":["../src/json-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAQ9E;;;GAGG;AACH,oBAAY,iBAAiB,GAAG,aAAa,GAAG;IAC9C,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,WAAW,CAAC;QACpB,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC;CACH,CAAC;AAWF,eAAO,MAAM,UAAU,EAAE,gBAaxB,CAAC"}

package/dist/json-loader.js

@@ -24,19 +24,6 @@ exports.JSONLoader = {
     version: VERSION,
     extensions: ['json', 'geojson'],
     mimeTypes: ['application/json'],
-    // TODO - support various line based JSON formats
-    /*
-    extensions: {
-      json: null,
-      jsonl: {stream: true},
-      ndjson: {stream: true}
-    },
-    mimeTypes: {
-      'application/json': null,
-      'application/json-seq': {stream: true},
-      'application/x-ndjson': {stream: true}
-    },
-    */
     category: 'table',
     text: true,
     parse,

package/dist/ndjgeoson-loader.d.ts

@@ -0,0 +1,34 @@
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import parseNDJSONSync from './lib/parse-ndjson';
+import parseNDJSONInBatches from './lib/parse-ndjson-in-batches';
+export declare type NDGeoJSONLoaderOptions = LoaderOptions & {
+    geojson?: {
+        shape?: 'object-row-table';
+    };
+    gis?: {
+        format: 'geojson';
+    };
+};
+export declare const NDJSONLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    text: boolean;
+    parse: (arrayBuffer: ArrayBuffer) => Promise<any[]>;
+    parseTextSync: typeof parseNDJSONSync;
+    parseInBatches: typeof parseNDJSONInBatches;
+    options: {
+        geojson: {
+            shape: string;
+        };
+        gis: {
+            format: string;
+        };
+    };
+};
+export declare const _typecheckNDJSONLoader: LoaderWithParser;
+//# sourceMappingURL=ndjgeoson-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ndjgeoson-loader.d.ts","sourceRoot":"","sources":["../src/ndjgeoson-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,eAAe,MAAM,oBAAoB,CAAC;AACjD,OAAO,oBAAoB,MAAM,+BAA+B,CAAC;AAMjE,oBAAY,sBAAsB,GAAG,aAAa,GAAG;IACnD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,CAAC;KAC5B,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,MAAM,EAAE,SAAS,CAAC;KACnB,CAAC;CACH,CAAC;AAWF,eAAO,MAAM,YAAY;;;;;;;;;yBAeI,WAAW;;;;;;;;;;;CAIvC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,gBAA+B,CAAC"}

package/dist/ndjgeoson-loader.js

@@ -0,0 +1,40 @@
+"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';
+const DEFAULT_NDGEOJSON_LOADER_OPTIONS = {
+    geojson: {
+        shape: 'object-row-table'
+    },
+    gis: {
+        format: 'geojson'
+    }
+};
+exports.NDJSONLoader = {
+    name: 'NDJSON',
+    id: 'ndjson',
+    module: 'json',
+    version: VERSION,
+    extensions: ['ndjson', 'ndgeojson'],
+    mimeTypes: [
+        'application/geo+x-ndjson',
+        'application/geo+x-ldjson',
+        'application/jsonlines',
+        'application/geo+json-seq',
+        'application/x-ndjson'
+    ],
+    category: 'table',
+    text: true,
+    parse: async (arrayBuffer) => (0, parse_ndjson_1.default)(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parse_ndjson_1.default,
+    parseInBatches: parse_ndjson_in_batches_1.default,
+    options: DEFAULT_NDGEOJSON_LOADER_OPTIONS
+};
+exports._typecheckNDJSONLoader = exports.NDJSONLoader;

package/dist/ndjson-loader.d.ts

@@ -1,5 +1,5 @@
-import type { Batch } from '@loaders.gl/schema';
-import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import parseNDJSONSync from './lib/parse-ndjson';
+import parseNDJSONInBatches from './lib/parse-ndjson-in-batches';
 export declare const NDJSONLoader: {
     name: string;
     id: string;
@@ -9,14 +9,9 @@ export declare const NDJSONLoader: {
     mimeTypes: string[];
     category: string;
     text: boolean;
-    parse: typeof parse;
-    parseTextSync: typeof parseTextSync;
-    parseInBatches: typeof parseInBatches;
+    parse: (arrayBuffer: ArrayBuffer) => Promise<any[]>;
+    parseTextSync: typeof parseNDJSONSync;
+    parseInBatches: typeof parseNDJSONInBatches;
     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

@@ -1 +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"}
+{"version":3,"file":"ndjson-loader.d.ts","sourceRoot":"","sources":["../src/ndjson-loader.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,oBAAoB,CAAC;AACjD,OAAO,oBAAoB,MAAM,+BAA+B,CAAC;AAMjE,eAAO,MAAM,YAAY;;;;;;;;;yBAaI,WAAW;;;;CAIvC,CAAC"}

package/dist/ndjson-loader.js

@@ -3,7 +3,7 @@ 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;
+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
@@ -14,22 +14,16 @@ exports.NDJSONLoader = {
     id: 'ndjson',
     module: 'json',
     version: VERSION,
-    extensions: ['ndjson'],
-    mimeTypes: ['application/x-ndjson'],
+    extensions: ['ndjson', 'jsonl'],
+    mimeTypes: [
+        'application/x-ndjson',
+        'application/jsonlines',
+        'application/json-seq'
+    ],
     category: 'table',
     text: true,
-    parse,
-    parseTextSync,
-    parseInBatches,
+    parse: async (arrayBuffer) => (0, parse_ndjson_1.default)(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parse_ndjson_1.default,
+    parseInBatches: parse_ndjson_in_batches_1.default,
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/json",
-  "version": "3.1.7",
+  "version": "3.2.0-alpha.2",
   "description": "Framework-independent loader for JSON and streaming JSON formats",
   "license": "MIT",
   "publishConfig": {
@@ -35,9 +35,9 @@
     "build-worker": "esbuild src/workers/geojson-worker.ts --bundle --outfile=dist/geojson-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "3.1.7",
-    "@loaders.gl/loader-utils": "3.1.7",
-    "@loaders.gl/schema": "3.1.7"
+    "@loaders.gl/gis": "3.2.0-alpha.2",
+    "@loaders.gl/loader-utils": "3.2.0-alpha.2",
+    "@loaders.gl/schema": "3.2.0-alpha.2"
   },
-  "gitHead": "e48d29e426e9f23879875763e73efc5c58345be1"
+  "gitHead": "52a602739cbfce60fc314f474efc984d199dff78"
 }

package/src/geojson-loader.ts

@@ -13,7 +13,7 @@ export type GeoJSONLoaderOptions = JSONLoaderOptions & {
     shape?: 'object-row-table';
   };
   gis?: {
-    format: 'geojson';
+    format?: 'geojson' | 'binary';
   };
 };
 

package/src/json-loader.ts

@@ -35,19 +35,6 @@ export const JSONLoader: LoaderWithParser = {
   version: VERSION,
   extensions: ['json', 'geojson'],
   mimeTypes: ['application/json'],
-  // TODO - support various line based JSON formats
-  /*
-  extensions: {
-    json: null,
-    jsonl: {stream: true},
-    ndjson: {stream: true}
-  },
-  mimeTypes: {
-    'application/json': null,
-    'application/json-seq': {stream: true},
-    'application/x-ndjson': {stream: true}
-  },
-  */
   category: 'table',
   text: true,
   parse,

package/src/ndjgeoson-loader.ts

@@ -0,0 +1,48 @@
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import parseNDJSONSync from './lib/parse-ndjson';
+import parseNDJSONInBatches from './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';
+
+export type NDGeoJSONLoaderOptions = LoaderOptions & {
+  geojson?: {
+    shape?: 'object-row-table';
+  };
+  gis?: {
+    format: 'geojson';
+  };
+};
+
+const DEFAULT_NDGEOJSON_LOADER_OPTIONS = {
+  geojson: {
+    shape: 'object-row-table'
+  },
+  gis: {
+    format: 'geojson'
+  }
+};
+
+export const NDJSONLoader = {
+  name: 'NDJSON',
+  id: 'ndjson',
+  module: 'json',
+  version: VERSION,
+  extensions: ['ndjson', 'ndgeojson'],
+  mimeTypes: [
+    'application/geo+x-ndjson',
+    'application/geo+x-ldjson',
+    'application/jsonlines', // https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-batch
+    'application/geo+json-seq',
+    'application/x-ndjson'
+  ],
+  category: 'table',
+  text: true,
+  parse: async (arrayBuffer: ArrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+  parseTextSync: parseNDJSONSync,
+  parseInBatches: parseNDJSONInBatches,
+  options: DEFAULT_NDGEOJSON_LOADER_OPTIONS
+};
+
+export const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;

package/src/ndjson-loader.ts

@@ -1,5 +1,3 @@
-import type {Batch} from '@loaders.gl/schema';
-import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
 import parseNDJSONSync from './lib/parse-ndjson';
 import parseNDJSONInBatches from './lib/parse-ndjson-in-batches';
 
@@ -12,29 +10,16 @@ export const NDJSONLoader = {
   id: 'ndjson',
   module: 'json',
   version: VERSION,
-  extensions: ['ndjson'],
-  mimeTypes: ['application/x-ndjson'],
+  extensions: ['ndjson', 'jsonl'],
+  mimeTypes: [
+    'application/x-ndjson',
+    'application/jsonlines', // https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-batch
+    'application/json-seq'
+  ],
   category: 'table',
   text: true,
-  parse,
-  parseTextSync,
-  parseInBatches,
+  parse: async (arrayBuffer: ArrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+  parseTextSync: parseNDJSONSync,
+  parseInBatches: parseNDJSONInBatches,
   options: {}
 };
-
-async function parse(arrayBuffer: ArrayBuffer) {
-  return parseTextSync(new TextDecoder().decode(arrayBuffer));
-}
-
-function parseTextSync(text: string) {
-  return parseNDJSONSync(text);
-}
-
-function parseInBatches(
-  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
-  options?: LoaderOptions
-): AsyncIterable<Batch> {
-  return parseNDJSONInBatches(asyncIterator, options);
-}
-
-export const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;

package/dist/es5/jsonl-loader.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=jsonl-loader.js.map

package/dist/es5/jsonl-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"jsonl-loader.js"}

package/dist/esm/jsonl-loader.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=jsonl-loader.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"jsonl-loader.js"}

package/dist/jsonl-loader.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=jsonl-loader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"jsonl-loader.d.ts","sourceRoot":"","sources":["../src/jsonl-loader.ts"],"names":[],"mappings":""}

package/dist/jsonl-loader.js

@@ -1,54 +0,0 @@
-"use strict";
-/* TODO JSONL loader
-export const JSONLoader: LoaderWithParser = {
-  name: 'JSON',
-  id: 'json',
-  module: 'json',
-  version: VERSION,
-  extensions: ['json', 'geojson'],
-  mimeTypes: ['application/json'],
-  // TODO - support various line based JSON formats
-  /*
-  extensions: {
-    json: null,
-    jsonl: {stream: true},
-    ndjson: {stream: true}
-  },
-  mimeTypes: {
-    'application/json': null,
-    'application/json-seq': {stream: true},
-    'application/x-ndjson': {stream: true}
-  },
-  *
-  category: 'table',
-  text: true,
-  parse,
-  parseTextSync,
-  parseInBatches,
-  options: DEFAULT_JSON_LOADER_OPTIONS
-};
-{
-  name: 'TEST-JSONL_LOADER',
-  extensions: ['jsonl'],
-  parse: async (arrayBuffer, options, context) => {
-    const characters = new Uint8Array(arrayBuffer);
-    const result = [];
-
-    const len = characters.length;
-    let startIndex = 0;
-    for (let i = 0; i <= len; i++) {
-      if (characters[i] === 10 || i === len) {
-        // Note: we need to make a copy of the buffer here because we cannot
-        // handover the ownership of arrayBuffer to the child process
-        const json = characters.slice(startIndex, i);
-        if (json.length > 1) {
-          result.push(await context.parse(json.buffer, {}, 'line.json'));
-        }
-        startIndex = i + 1;
-      }
-    }
-
-    return result;
-  }
-};
-*/

package/src/jsonl-loader.ts

@@ -1,53 +0,0 @@
-/* TODO JSONL loader
-export const JSONLoader: LoaderWithParser = {
-  name: 'JSON',
-  id: 'json',
-  module: 'json',
-  version: VERSION,
-  extensions: ['json', 'geojson'],
-  mimeTypes: ['application/json'],
-  // TODO - support various line based JSON formats
-  /*
-  extensions: {
-    json: null,
-    jsonl: {stream: true},
-    ndjson: {stream: true}
-  },
-  mimeTypes: {
-    'application/json': null,
-    'application/json-seq': {stream: true},
-    'application/x-ndjson': {stream: true}
-  },
-  *
-  category: 'table',
-  text: true,
-  parse,
-  parseTextSync,
-  parseInBatches,
-  options: DEFAULT_JSON_LOADER_OPTIONS
-};
-{
-  name: 'TEST-JSONL_LOADER',
-  extensions: ['jsonl'],
-  parse: async (arrayBuffer, options, context) => {
-    const characters = new Uint8Array(arrayBuffer);
-    const result = [];
-
-    const len = characters.length;
-    let startIndex = 0;
-    for (let i = 0; i <= len; i++) {
-      if (characters[i] === 10 || i === len) {
-        // Note: we need to make a copy of the buffer here because we cannot
-        // handover the ownership of arrayBuffer to the child process
-        const json = characters.slice(startIndex, i);
-        if (json.length > 1) {
-          result.push(await context.parse(json.buffer, {}, 'line.json'));
-        }
-        startIndex = i + 1;
-      }
-    }
-
-    return result;
-  }
-};
-*/