@deck.gl/carto 8.9.23 → 8.9.25

package/dist/dist.dev.js

@@ -3985,7 +3985,7 @@ var __exports__ = (() => {
         if (moment2.version === void 0 && moment2.default) {
           moment2 = moment2.default;
         }
-        var VERSION = "0.5.35", zones = {}, links = {}, countries = {}, names = {}, guesses = {}, cachedGuess;
+        var VERSION4 = "0.5.35", zones = {}, links = {}, countries = {}, names = {}, guesses = {}, cachedGuess;
         if (!moment2 || typeof moment2.version !== "string") {
           logError("Moment Timezone requires Moment.js. See https://momentjs.com/timezone/docs/#/use-it/browser/");
         }
@@ -4361,7 +4361,7 @@ var __exports__ = (() => {
           out.tz(name);
           return out;
         }
-        tz.version = VERSION;
+        tz.version = VERSION4;
         tz.dataVersion = "";
         tz._zones = zones;
         tz._links = links;
@@ -6330,11 +6330,11 @@ var __exports__ = (() => {
           for (var i = 0; i < tiles2.length; i++) {
             var t = tiles2[i];
             if (t[0] % 2 === 0 && t[1] % 2 === 0) {
-              var id2 = toID(t[0] + 1, t[1], z), id3 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
-              if (tileHash[id2] && tileHash[id3] && tileHash[id4]) {
+              var id22 = toID(t[0] + 1, t[1], z), id32 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
+              if (tileHash[id22] && tileHash[id32] && tileHash[id4]) {
                 tileHash[toID(t[0], t[1], t[2])] = false;
-                tileHash[id2] = false;
-                tileHash[id3] = false;
+                tileHash[id22] = false;
+                tileHash[id32] = false;
                 tileHash[id4] = false;
                 var parentTile = [t[0] / 2, t[1] / 2, z - 1];
                 if (z - 1 === limits.min_zoom)
@@ -6372,8 +6372,8 @@ var __exports__ = (() => {
         for (i = 0; i < intersections.length; i += 2) {
           y = intersections[i][1];
           for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
-            var id = toID(x, y, zoom);
-            if (!tileHash[id]) {
+            var id4 = toID(x, y, zoom);
+            if (!tileHash[id4]) {
               tileArray.push([x, y, zoom]);
             }
           }
@@ -6424,8 +6424,8 @@ var __exports__ = (() => {
         var dim = 2 * (1 << z);
         return (dim * y + x) * 32 + z;
       }
-      function fromID(id) {
-        var z = id % 32, dim = 2 * (1 << z), xy = (id - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
+      function fromID(id4) {
+        var z = id4 % 32, dim = 2 * (1 << z), xy = (id4 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
         return [x, y, z];
       }
     }
@@ -11467,7 +11467,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var import_geo_layers7 = __toESM(require_geo_layers());
 
   // src/layers/carto-tile-layer.ts
-  var import_core = __toESM(require_core2());
+  var import_core2 = __toESM(require_core2());
 
   // src/layers/schema/fast-pbf.ts
   function readPackedTypedArray(TypedArray, pbf, obj) {
@@ -11703,19 +11703,52 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return tile;
   }
 
+  // src/utils.ts
+  var import_core = __toESM(require_core());
+  function assert(condition, message) {
+    import_core.log.assert(condition, message);
+  }
+  function createBinaryProxy(data, index) {
+    const {
+      properties,
+      numericProps
+    } = data;
+    return new Proxy(properties[index] || {}, {
+      get(target, property, receiver) {
+        if (property in numericProps) {
+          return numericProps[property].value[index];
+        }
+        return target[property];
+      },
+      has(target, property) {
+        return property in numericProps || property in target;
+      }
+    });
+  }
+  function getWorkerUrl(id4, version) {
+    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id4}-worker.js`;
+  }
+
   // src/layers/schema/carto-vector-tile-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id = "cartoVectorTile";
+  var DEFAULT_OPTIONS = {
+    cartoVectorTile: {
+      workerUrl: getWorkerUrl(id, VERSION)
+    }
+  };
   var CartoVectorTileLoader = {
     name: "CARTO Vector Tile",
-    version: "1",
-    id: "cartoVectorTile",
+    version: VERSION,
+    id,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-vector-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
     parseSync: parseCartoVectorTile,
-    options: {}
+    worker: false,
+    options: DEFAULT_OPTIONS
   };
   function parseCartoVectorTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -11944,7 +11977,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/carto-tile-layer.ts
-  (0, import_core.registerLoaders)([carto_vector_tile_loader_default]);
+  (0, import_core2.registerLoaders)([carto_vector_tile_loader_default]);
   var defaultTileFormat = TILE_FORMATS.BINARY;
   var defaultProps = {
     ...import_geo_layers.MVTLayer.defaultProps,
@@ -12021,7 +12054,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   __publicField(CartoTileLayer, "defaultProps", defaultProps);
 
   // src/layers/h3-tile-layer.ts
-  var import_core3 = __toESM(require_core());
+  var import_core4 = __toESM(require_core());
   var import_geo_layers4 = __toESM(require_geo_layers());
 
   // src/layers/h3-tileset-2d.ts
@@ -12131,7 +12164,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
 
   // src/layers/spatial-index-tile-layer.ts
-  var import_core2 = __toESM(require_core2());
+  var import_core3 = __toESM(require_core2());
 
   // src/layers/schema/carto-raster-tile.ts
   var ARRAY_TYPES = {
@@ -12188,18 +12221,25 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
 
   // src/layers/schema/carto-raster-tile-loader.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id2 = "cartoRasterTile";
+  var DEFAULT_OPTIONS2 = {
+    cartoRasterTile: {
+      workerUrl: getWorkerUrl(id2, VERSION2)
+    }
+  };
   var CartoRasterTileLoader = {
     name: "CARTO Raster Tile",
-    version: "1",
-    id: "cartoRasterTile",
+    version: VERSION2,
+    id: id2,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-raster-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
     parseSync: parseCartoRasterTile,
-    options: {}
+    worker: false,
+    options: DEFAULT_OPTIONS2
   };
   function parseCartoRasterTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -12346,7 +12386,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const count = cells.indices.value.length;
     const spatial = [];
     for (let i = 0; i < count; i++) {
-      const id = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
+      const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
       const properties = {
         ...cells.properties[i]
       };
@@ -12354,7 +12394,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         properties[key] = cells.numericProps[key].value[i];
       }
       spatial.push({
-        id,
+        id: id4,
         properties
       });
     }
@@ -12362,22 +12402,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/schema/carto-spatial-tile-loader.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id3 = "cartoSpatialTile";
+  var DEFAULT_OPTIONS3 = {
+    cartoSpatialTile: {
+      scheme: "quadbin",
+      workerUrl: getWorkerUrl(id3, VERSION3)
+    }
+  };
   var CartoSpatialTileLoader = {
     name: "CARTO Spatial Tile",
-    version: "1",
-    id: "cartoSpatialTile",
+    version: VERSION3,
+    id: id3,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-spatial-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
     parseSync: parseCartoSpatialTile,
-    options: {
-      cartoSpatialTile: {
-        scheme: "quadbin"
-      }
-    }
+    worker: false,
+    options: DEFAULT_OPTIONS3
   };
   function parseCartoSpatialTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -12397,7 +12441,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/layers/spatial-index-tile-layer.ts
   var import_geo_layers3 = __toESM(require_geo_layers());
-  (0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
+  (0, import_core3.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
@@ -12496,7 +12540,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var defaultProps3 = {
     aggregationResLevel: 4
   };
-  var H3TileLayer = class extends import_core3.CompositeLayer {
+  var H3TileLayer = class extends import_core4.CompositeLayer {
     initializeState() {
       import_geo_layers4.H3HexagonLayer._checkH3Lib();
       this.setState({
@@ -12559,7 +12603,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   __publicField(H3TileLayer, "defaultProps", defaultProps3);
 
   // src/layers/quadbin-tile-layer.ts
-  var import_core4 = __toESM(require_core());
+  var import_core5 = __toESM(require_core());
 
   // src/layers/quadbin-layer.ts
   var import_geo_layers5 = __toESM(require_geo_layers());
@@ -12680,7 +12724,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var defaultProps5 = {
     aggregationResLevel: 6
   };
-  var QuadbinTileLayer = class extends import_core4.CompositeLayer {
+  var QuadbinTileLayer = class extends import_core5.CompositeLayer {
     initializeState() {
       this.setState({
         data: null,
@@ -12833,29 +12877,6 @@ void main(void) {
 }
 `;
 
-  // src/utils.ts
-  var import_core5 = __toESM(require_core());
-  function assert2(condition, message) {
-    import_core5.log.assert(condition, message);
-  }
-  function createBinaryProxy(data, index) {
-    const {
-      properties,
-      numericProps
-    } = data;
-    return new Proxy(properties[index] || {}, {
-      get(target, property, receiver) {
-        if (property in numericProps) {
-          return numericProps[property].value[index];
-        }
-        return target[property];
-      },
-      has(target, property) {
-        return property in numericProps || property in target;
-      }
-    });
-  }
-
   // src/layers/raster-layer.ts
   var defaultProps6 = {
     ...import_layers2.ColumnLayer.defaultProps,
@@ -12916,7 +12937,7 @@ void main(void) {
         blockWidth,
         blockHeight
       } = data;
-      assert2(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
+      assert(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
       const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
       const offset = [xOffset, yOffset, scale / blockWidth];
       const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
@@ -13187,7 +13208,7 @@ void main(void) {
       }
     };
     const layer = layerTypeDefs[type];
-    assert2(layer, `Unsupported layer type: ${type}`);
+    assert(layer, `Unsupported layer type: ${type}`);
     return {
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
@@ -13552,7 +13573,7 @@ void main(void) {
       }
       return backgroundPadding;
     }
-    renderTextLayer(id, {
+    renderTextLayer(id4, {
       updateTriggers: updateTriggersOverride = {},
       ...props
     }) {
@@ -13573,7 +13594,7 @@ void main(void) {
         updateTriggers
       } = this.props;
       return new EnhancedTextLayer(this.getSubLayerProps({
-        id,
+        id: id4,
         data,
         characterSet,
         fontFamily,
@@ -13649,7 +13670,7 @@ void main(void) {
       datasets,
       token
     } = json;
-    assert2(keplerMapConfig.version === "v1", "Only support Kepler v1");
+    assert(keplerMapConfig.version === "v1", "Only support Kepler v1");
     const {
       mapState,
       mapStyle
@@ -13669,7 +13690,7 @@ void main(void) {
       mapStyle,
       token,
       layers: layers.reverse().map(({
-        id,
+        id: id4,
         type,
         config,
         visualChannels
@@ -13679,11 +13700,11 @@ void main(void) {
             dataId
           } = config;
           const dataset = datasets.find((d) => d.id === dataId);
-          assert2(dataset, `No dataset matching dataId: ${dataId}`);
+          assert(dataset, `No dataset matching dataId: ${dataId}`);
           const {
             data
           } = dataset;
-          assert2(data, `No data loaded for dataId: ${dataId}`);
+          assert(data, `No data loaded for dataId: ${dataId}`);
           const {
             Layer,
             propMap,
@@ -13691,12 +13712,12 @@ void main(void) {
           } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
           return new Layer({
-            id,
+            id: id4,
             data,
             ...defaultProps10,
             ...createInteractionProps(interactionConfig),
             ...styleProps,
-            ...createChannelProps(id, type, config, visualChannels, data),
+            ...createChannelProps(id4, type, config, visualChannels, data),
             ...createParametersProp(layerBlending, styleProps.parameters || {}),
             ...createLoadOptions(token)
           });
@@ -13761,7 +13782,7 @@ void main(void) {
     result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
     return result;
   }
-  function createChannelProps(id, type, config, visualChannels, data) {
+  function createChannelProps(id4, type, config, visualChannels, data) {
     const {
       colorField,
       colorScale,
@@ -13914,7 +13935,7 @@ void main(void) {
     }
     if (textLabel && textLabel.length && textLabel[0].field) {
       const [mainLabel, secondaryLabel] = textLabel;
-      const collisionGroup = id;
+      const collisionGroup = id4;
       ({
         alignment: result.getTextAlignmentBaseline,
         anchor: result.getTextAnchor,
@@ -14174,20 +14195,20 @@ void main(void) {
     aggregationExp,
     aggregationResLevel
   }) {
-    assert2(connection, "Must define connection");
-    assert2(type, "Must define a type");
-    assert2(source, "Must define a source");
-    assert2(credentials2.apiVersion === API_VERSIONS.V3, "Method only available for v3");
-    assert2(credentials2.apiBaseUrl, "Must define apiBaseUrl");
-    assert2(credentials2.accessToken, "Must define an accessToken");
+    assert(connection, "Must define connection");
+    assert(type, "Must define a type");
+    assert(source, "Must define a source");
+    assert(credentials2.apiVersion === API_VERSIONS.V3, "Method only available for v3");
+    assert(credentials2.apiBaseUrl, "Must define apiBaseUrl");
+    assert(credentials2.accessToken, "Must define an accessToken");
     if (columns) {
-      assert2(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
+      assert(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
     }
     if (geoColumn) {
-      assert2(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
+      assert(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
     } else {
-      assert2(!aggregationExp, "Have aggregationExp, but geoColumn parameter is missing");
-      assert2(!aggregationResLevel, "Have aggregationResLevel, but geoColumn parameter is missing");
+      assert(!aggregationExp, "Have aggregationExp, but geoColumn parameter is missing");
+      assert(!aggregationResLevel, "Have aggregationResLevel, but geoColumn parameter is missing");
     }
   }
   async function fetchLayerData({
@@ -14295,7 +14316,7 @@ void main(void) {
     if (format2) {
       mapFormat = format2;
       url = getUrlFromMetadata(metadata, format2);
-      assert2(url, `Format ${format2} not available`);
+      assert(url, `Format ${format2} not available`);
     } else {
       const prioritizedFormats = [FORMATS.GEOJSON, FORMATS.JSON, FORMATS.NDJSON, FORMATS.TILEJSON];
       for (const f of prioritizedFormats) {
@@ -14305,7 +14326,7 @@ void main(void) {
           break;
         }
       }
-      assert2(url && mapFormat, "Unsupported data formats received from backend.");
+      assert(url && mapFormat, "Unsupported data formats received from backend.");
     }
     if (format2 === FORMATS.TILEJSON && formatTiles) {
       import_core10.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
@@ -14481,16 +14502,16 @@ void main(void) {
     const {
       accessToken
     } = localCreds;
-    assert2(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
-    assert2(localCreds.apiVersion === API_VERSIONS.V3, "Method only available for v3");
-    assert2(localCreds.apiBaseUrl, "Must define apiBaseUrl");
+    assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+    assert(localCreds.apiVersion === API_VERSIONS.V3, "Method only available for v3");
+    assert(localCreds.apiBaseUrl, "Must define apiBaseUrl");
     if (!localCreds.mapsUrl) {
       localCreds.mapsUrl = buildMapsUrlFromBase(localCreds.apiBaseUrl);
     }
     if (autoRefresh || onNewData) {
-      assert2(onNewData, "Must define `onNewData` when using autoRefresh");
-      assert2(typeof onNewData === "function", "`onNewData` must be a function");
-      assert2(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
+      assert(onNewData, "Must define `onNewData` when using autoRefresh");
+      assert(typeof onNewData === "function", "`onNewData` must be a function");
+      assert(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
     }
     const url = `${localCreds.mapsUrl}/public/${cartoMapId}`;
     const errorContext = {
@@ -14699,7 +14720,7 @@ void main(void) {
       }
     }
     _getSubLayerAndProps() {
-      assert2(this.state);
+      assert(this.state);
       const {
         data,
         apiVersion
@@ -14723,7 +14744,7 @@ void main(void) {
       return [layerFromTileDataset(props.formatTiles, data.scheme, props.type), props];
     }
     renderLayers() {
-      assert2(this.state);
+      assert(this.state);
       const {
         apiVersion,
         data

package/dist/es5/layers/schema/carto-raster-tile-loader.js

@@ -15,15 +15,23 @@ var _cartoRasterTile = require("./carto-raster-tile");
 
 var _tileLoaderUtils = require("./tile-loader-utils");
 
+var _utils = require("../../utils");
+
+var VERSION = typeof "8.9.24" !== 'undefined' ? "8.9.24" : 'latest';
+var id = 'cartoRasterTile';
+var DEFAULT_OPTIONS = {
+  cartoRasterTile: {
+    workerUrl: (0, _utils.getWorkerUrl)(id, VERSION)
+  }
+};
 var CartoRasterTileLoader = {
   name: 'CARTO Raster Tile',
-  version: '1',
-  id: 'cartoRasterTile',
+  version: VERSION,
+  id: id,
   module: 'carto',
   extensions: ['pbf'],
   mimeTypes: ['application/vnd.carto-raster-tile'],
   category: 'geometry',
-  worker: false,
   parse: function () {
     var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
       return _regenerator.default.wrap(function _callee$(_context) {
@@ -47,7 +55,8 @@ var CartoRasterTileLoader = {
     return parse;
   }(),
   parseSync: parseCartoRasterTile,
-  options: {}
+  worker: false,
+  options: DEFAULT_OPTIONS
 };
 
 function parseCartoRasterTile(arrayBuffer, options) {

package/dist/es5/layers/schema/carto-raster-tile-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/layers/schema/carto-raster-tile-loader.ts"],"names":["CartoRasterTileLoader","name","version","id","module","extensions","mimeTypes","category","worker","parse","arrayBuffer","options","parseCartoRasterTile","parseSync","tile","TileReader","bands","blockHeight","blockWidth","numericProps","i","length","data","cells","properties"],"mappings":";;;;;;;;;;;;;AAEA;;AACA;;AAGA,IAAMA,qBAAuC,GAAG;AAC9CC,EAAAA,IAAI,EAAE,mBADwC;AAE9CC,EAAAA,OAAO,EAAE,GAFqC;AAG9CC,EAAAA,EAAE,EAAE,iBAH0C;AAI9CC,EAAAA,MAAM,EAAE,OAJsC;AAK9CC,EAAAA,UAAU,EAAE,CAAC,KAAD,CALkC;AAM9CC,EAAAA,SAAS,EAAE,CAAC,mCAAD,CANmC;AAO9CC,EAAAA,QAAQ,EAAE,UAPoC;AAQ9CC,EAAAA,MAAM,EAAE,KARsC;AAS9CC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAgCC,oBAAoB,CAACF,WAAD,EAAcC,OAAd,CAApD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KATyC;AAU9CE,EAAAA,SAAS,EAAED,oBAVmC;AAW9CD,EAAAA,OAAO,EAAE;AAXqC,CAAhD;;AAuBA,SAASC,oBAAT,CAA8BF,WAA9B,EAAwDC,OAAxD,EAAgG;AAC9F,MAAI,CAACD,WAAL,EAAkB,OAAO,IAAP;AAClB,MAAMI,IAAI,GAAG,+BAASJ,WAAT,EAAsBK,2BAAtB,CAAb;AACA,MAAOC,KAAP,GAAyCF,IAAzC,CAAOE,KAAP;AAAA,MAAcC,WAAd,GAAyCH,IAAzC,CAAcG,WAAd;AAAA,MAA2BC,UAA3B,GAAyCJ,IAAzC,CAA2BI,UAA3B;AACA,MAAMC,YAAY,GAAG,EAArB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGJ,KAAK,CAACK,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;AACrC,mBAAqBJ,KAAK,CAACI,CAAD,CAA1B;AAAA,QAAOnB,IAAP,YAAOA,IAAP;AAAA,QAAaqB,IAAb,YAAaA,IAAb;AACAH,IAAAA,YAAY,CAAClB,IAAD,CAAZ,GAAqBqB,IAArB;AACD;;AACD,SAAO;AAACJ,IAAAA,UAAU,EAAVA,UAAD;AAAaD,IAAAA,WAAW,EAAXA,WAAb;AAA0BM,IAAAA,KAAK,EAAE;AAACJ,MAAAA,YAAY,EAAZA,YAAD;AAAeK,MAAAA,UAAU,EAAE;AAA3B;AAAjC,GAAP;AACD;;eAEcxB,qB","sourcesContent":["import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\n\nimport {TileReader} from './carto-raster-tile';\nimport {parsePbf} from './tile-loader-utils';\nimport {NumericProps, Properties} from './spatialjson-utils';\n\nconst CartoRasterTileLoader: LoaderWithParser = {\n  name: 'CARTO Raster Tile',\n  version: '1',\n  id: 'cartoRasterTile',\n  module: 'carto',\n  extensions: ['pbf'],\n  mimeTypes: ['application/vnd.carto-raster-tile'],\n  category: 'geometry',\n  worker: false,\n  parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),\n  parseSync: parseCartoRasterTile,\n  options: {}\n};\n\nexport type Raster = {\n  blockWidth: number;\n  blockHeight: number;\n  cells: {\n    numericProps: NumericProps;\n    properties: Properties[];\n  };\n};\n\nfunction parseCartoRasterTile(arrayBuffer: ArrayBuffer, options?: LoaderOptions): Raster | null {\n  if (!arrayBuffer) return null;\n  const tile = parsePbf(arrayBuffer, TileReader);\n  const {bands, blockHeight, blockWidth} = tile;\n  const numericProps = {};\n  for (let i = 0; i < bands.length; i++) {\n    const {name, data} = bands[i];\n    numericProps[name] = data;\n  }\n  return {blockWidth, blockHeight, cells: {numericProps, properties: []}};\n}\n\nexport default CartoRasterTileLoader;\n"],"file":"carto-raster-tile-loader.js"}
+{"version":3,"sources":["../../../../src/layers/schema/carto-raster-tile-loader.ts"],"names":["VERSION","id","DEFAULT_OPTIONS","cartoRasterTile","workerUrl","CartoRasterTileLoader","name","version","module","extensions","mimeTypes","category","parse","arrayBuffer","options","parseCartoRasterTile","parseSync","worker","tile","TileReader","bands","blockHeight","blockWidth","numericProps","i","length","data","cells","properties"],"mappings":";;;;;;;;;;;;;AAEA;;AACA;;AACA;;AAGA,IAAMA,OAAO,GAAG,oBAAuB,WAAvB,cAAmD,QAAnE;AACA,IAAMC,EAAE,GAAG,iBAAX;AAQA,IAAMC,eAA6C,GAAG;AACpDC,EAAAA,eAAe,EAAE;AACfC,IAAAA,SAAS,EAAE,yBAAaH,EAAb,EAAiBD,OAAjB;AADI;AADmC,CAAtD;AAMA,IAAMK,qBAAuC,GAAG;AAC9CC,EAAAA,IAAI,EAAE,mBADwC;AAE9CC,EAAAA,OAAO,EAAEP,OAFqC;AAG9CC,EAAAA,EAAE,EAAFA,EAH8C;AAI9CO,EAAAA,MAAM,EAAE,OAJsC;AAK9CC,EAAAA,UAAU,EAAE,CAAC,KAAD,CALkC;AAM9CC,EAAAA,SAAS,EAAE,CAAC,mCAAD,CANmC;AAO9CC,EAAAA,QAAQ,EAAE,UAPoC;AAQ9CC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CACLC,oBAAoB,CAACF,WAAD,EAAcC,OAAd,CADf;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KARyC;AAU9CE,EAAAA,SAAS,EAAED,oBAVmC;AAW9CE,EAAAA,MAAM,EAAE,KAXsC;AAY9CH,EAAAA,OAAO,EAAEZ;AAZqC,CAAhD;;AAwBA,SAASa,oBAAT,CACEF,WADF,EAEEC,OAFF,EAGiB;AACf,MAAI,CAACD,WAAL,EAAkB,OAAO,IAAP;AAClB,MAAMK,IAAI,GAAG,+BAASL,WAAT,EAAsBM,2BAAtB,CAAb;AACA,MAAOC,KAAP,GAAyCF,IAAzC,CAAOE,KAAP;AAAA,MAAcC,WAAd,GAAyCH,IAAzC,CAAcG,WAAd;AAAA,MAA2BC,UAA3B,GAAyCJ,IAAzC,CAA2BI,UAA3B;AACA,MAAMC,YAAY,GAAG,EAArB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGJ,KAAK,CAACK,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;AACrC,mBAAqBJ,KAAK,CAACI,CAAD,CAA1B;AAAA,QAAOlB,IAAP,YAAOA,IAAP;AAAA,QAAaoB,IAAb,YAAaA,IAAb;AACAH,IAAAA,YAAY,CAACjB,IAAD,CAAZ,GAAqBoB,IAArB;AACD;;AACD,SAAO;AAACJ,IAAAA,UAAU,EAAVA,UAAD;AAAaD,IAAAA,WAAW,EAAXA,WAAb;AAA0BM,IAAAA,KAAK,EAAE;AAACJ,MAAAA,YAAY,EAAZA,YAAD;AAAeK,MAAAA,UAAU,EAAE;AAA3B;AAAjC,GAAP;AACD;;eAEcvB,qB","sourcesContent":["import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\n\nimport {TileReader} from './carto-raster-tile';\nimport {parsePbf} from './tile-loader-utils';\nimport {getWorkerUrl} from '../../utils';\nimport {NumericProps, Properties} from './spatialjson-utils';\n\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\nconst id = 'cartoRasterTile';\n\ntype CartoRasterTileLoaderOptions = LoaderOptions & {\n  cartoRasterTile?: {\n    workerUrl: string;\n  };\n};\n\nconst DEFAULT_OPTIONS: CartoRasterTileLoaderOptions = {\n  cartoRasterTile: {\n    workerUrl: getWorkerUrl(id, VERSION)\n  }\n};\n\nconst CartoRasterTileLoader: LoaderWithParser = {\n  name: 'CARTO Raster Tile',\n  version: VERSION,\n  id,\n  module: 'carto',\n  extensions: ['pbf'],\n  mimeTypes: ['application/vnd.carto-raster-tile'],\n  category: 'geometry',\n  parse: async (arrayBuffer, options?: CartoRasterTileLoaderOptions) =>\n    parseCartoRasterTile(arrayBuffer, options),\n  parseSync: parseCartoRasterTile,\n  worker: false, // TODO set to true once workers deployed to unpkg\n  options: DEFAULT_OPTIONS\n};\n\nexport type Raster = {\n  blockWidth: number;\n  blockHeight: number;\n  cells: {\n    numericProps: NumericProps;\n    properties: Properties[];\n  };\n};\n\nfunction parseCartoRasterTile(\n  arrayBuffer: ArrayBuffer,\n  options?: CartoRasterTileLoaderOptions\n): Raster | null {\n  if (!arrayBuffer) return null;\n  const tile = parsePbf(arrayBuffer, TileReader);\n  const {bands, blockHeight, blockWidth} = tile;\n  const numericProps = {};\n  for (let i = 0; i < bands.length; i++) {\n    const {name, data} = bands[i];\n    numericProps[name] = data;\n  }\n  return {blockWidth, blockHeight, cells: {numericProps, properties: []}};\n}\n\nexport default CartoRasterTileLoader;\n"],"file":"carto-raster-tile-loader.js"}

package/dist/es5/layers/schema/carto-spatial-tile-loader.js

@@ -15,17 +15,26 @@ var _cartoSpatialTile = require("./carto-spatial-tile");
 
 var _tileLoaderUtils = require("./tile-loader-utils");
 
+var _utils = require("../../utils");
+
 var _spatialjsonUtils = require("./spatialjson-utils");
 
+var VERSION = typeof "8.9.24" !== 'undefined' ? "8.9.24" : 'latest';
+var id = 'cartoSpatialTile';
+var DEFAULT_OPTIONS = {
+  cartoSpatialTile: {
+    scheme: 'quadbin',
+    workerUrl: (0, _utils.getWorkerUrl)(id, VERSION)
+  }
+};
 var CartoSpatialTileLoader = {
   name: 'CARTO Spatial Tile',
-  version: '1',
-  id: 'cartoSpatialTile',
+  version: VERSION,
+  id: id,
   module: 'carto',
   extensions: ['pbf'],
   mimeTypes: ['application/vnd.carto-spatial-tile'],
   category: 'geometry',
-  worker: false,
   parse: function () {
     var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
       return _regenerator.default.wrap(function _callee$(_context) {
@@ -49,11 +58,8 @@ var CartoSpatialTileLoader = {
     return parse;
   }(),
   parseSync: parseCartoSpatialTile,
-  options: {
-    cartoSpatialTile: {
-      scheme: 'quadbin'
-    }
-  }
+  worker: false,
+  options: DEFAULT_OPTIONS
 };
 
 function parseCartoSpatialTile(arrayBuffer, options) {

package/dist/es5/layers/schema/carto-spatial-tile-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/layers/schema/carto-spatial-tile-loader.ts"],"names":["CartoSpatialTileLoader","name","version","id","module","extensions","mimeTypes","category","worker","parse","arrayBuffer","options","parseCartoSpatialTile","parseSync","cartoSpatialTile","scheme","tile","TileReader","cells","data"],"mappings":";;;;;;;;;;;;;AAEA;;AACA;;AACA;;AAEA,IAAMA,sBAAwC,GAAG;AAC/CC,EAAAA,IAAI,EAAE,oBADyC;AAE/CC,EAAAA,OAAO,EAAE,GAFsC;AAG/CC,EAAAA,EAAE,EAAE,kBAH2C;AAI/CC,EAAAA,MAAM,EAAE,OAJuC;AAK/CC,EAAAA,UAAU,EAAE,CAAC,KAAD,CALmC;AAM/CC,EAAAA,SAAS,EAAE,CAAC,oCAAD,CANoC;AAO/CC,EAAAA,QAAQ,EAAE,UAPqC;AAQ/CC,EAAAA,MAAM,EAAE,KARuC;AAS/CC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAgCC,qBAAqB,CAACF,WAAD,EAAcC,OAAd,CAArD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAT0C;AAU/CE,EAAAA,SAAS,EAAED,qBAVoC;AAW/CD,EAAAA,OAAO,EAAE;AACPG,IAAAA,gBAAgB,EAAE;AAChBC,MAAAA,MAAM,EAAE;AADQ;AADX;AAXsC,CAAjD;;AAkBA,SAASH,qBAAT,CACEF,WADF,EAEEC,OAFF,EAGsB;AAAA;;AACpB,MAAI,CAACD,WAAL,EAAkB,OAAO,IAAP;AAClB,MAAMM,IAAU,GAAG,+BAASN,WAAT,EAAsBO,4BAAtB,CAAnB;AAEA,MAAOC,KAAP,GAAgBF,IAAhB,CAAOE,KAAP;AAEA,MAAMH,MAAM,GAAGJ,OAAH,aAAGA,OAAH,gDAAGA,OAAO,CAAEG,gBAAZ,0DAAG,sBAA2BC,MAA1C;AACA,MAAMI,IAAI,GAAG;AAACD,IAAAA,KAAK,EAALA,KAAD;AAAQH,IAAAA,MAAM,EAANA;AAAR,GAAb;AAEA,SAAO,2CAAoBI,IAApB,CAAP;AACD;;eAEcnB,sB","sourcesContent":["import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\n\nimport {Tile, TileReader} from './carto-spatial-tile';\nimport {parsePbf} from './tile-loader-utils';\nimport {IndexScheme, binaryToSpatialjson, SpatialJson} from './spatialjson-utils';\n\nconst CartoSpatialTileLoader: LoaderWithParser = {\n  name: 'CARTO Spatial Tile',\n  version: '1',\n  id: 'cartoSpatialTile',\n  module: 'carto',\n  extensions: ['pbf'],\n  mimeTypes: ['application/vnd.carto-spatial-tile'],\n  category: 'geometry',\n  worker: false,\n  parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),\n  parseSync: parseCartoSpatialTile,\n  options: {\n    cartoSpatialTile: {\n      scheme: 'quadbin'\n    } as {scheme: IndexScheme}\n  }\n};\n\nfunction parseCartoSpatialTile(\n  arrayBuffer: ArrayBuffer,\n  options?: LoaderOptions\n): SpatialJson | null {\n  if (!arrayBuffer) return null;\n  const tile: Tile = parsePbf(arrayBuffer, TileReader);\n\n  const {cells} = tile;\n  // @ts-expect-error\n  const scheme = options?.cartoSpatialTile?.scheme;\n  const data = {cells, scheme};\n\n  return binaryToSpatialjson(data);\n}\n\nexport default CartoSpatialTileLoader;\n"],"file":"carto-spatial-tile-loader.js"}
+{"version":3,"sources":["../../../../src/layers/schema/carto-spatial-tile-loader.ts"],"names":["VERSION","id","DEFAULT_OPTIONS","cartoSpatialTile","scheme","workerUrl","CartoSpatialTileLoader","name","version","module","extensions","mimeTypes","category","parse","arrayBuffer","options","parseCartoSpatialTile","parseSync","worker","tile","TileReader","cells","data"],"mappings":";;;;;;;;;;;;;AAEA;;AACA;;AACA;;AACA;;AAEA,IAAMA,OAAO,GAAG,oBAAuB,WAAvB,cAAmD,QAAnE;AACA,IAAMC,EAAE,GAAG,kBAAX;AASA,IAAMC,eAA8C,GAAG;AACrDC,EAAAA,gBAAgB,EAAE;AAChBC,IAAAA,MAAM,EAAE,SADQ;AAEhBC,IAAAA,SAAS,EAAE,yBAAaJ,EAAb,EAAiBD,OAAjB;AAFK;AADmC,CAAvD;AAOA,IAAMM,sBAAwC,GAAG;AAC/CC,EAAAA,IAAI,EAAE,oBADyC;AAE/CC,EAAAA,OAAO,EAAER,OAFsC;AAG/CC,EAAAA,EAAE,EAAFA,EAH+C;AAI/CQ,EAAAA,MAAM,EAAE,OAJuC;AAK/CC,EAAAA,UAAU,EAAE,CAAC,KAAD,CALmC;AAM/CC,EAAAA,SAAS,EAAE,CAAC,oCAAD,CANoC;AAO/CC,EAAAA,QAAQ,EAAE,UAPqC;AAQ/CC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CACLC,qBAAqB,CAACF,WAAD,EAAcC,OAAd,CADhB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAR0C;AAU/CE,EAAAA,SAAS,EAAED,qBAVoC;AAW/CE,EAAAA,MAAM,EAAE,KAXuC;AAY/CH,EAAAA,OAAO,EAAEb;AAZsC,CAAjD;;AAeA,SAASc,qBAAT,CACEF,WADF,EAEEC,OAFF,EAGsB;AAAA;;AACpB,MAAI,CAACD,WAAL,EAAkB,OAAO,IAAP;AAClB,MAAMK,IAAU,GAAG,+BAASL,WAAT,EAAsBM,4BAAtB,CAAnB;AAEA,MAAOC,KAAP,GAAgBF,IAAhB,CAAOE,KAAP;AACA,MAAMjB,MAAM,GAAGW,OAAH,aAAGA,OAAH,gDAAGA,OAAO,CAAEZ,gBAAZ,0DAAG,sBAA2BC,MAA1C;AACA,MAAMkB,IAAI,GAAG;AAACD,IAAAA,KAAK,EAALA,KAAD;AAAQjB,IAAAA,MAAM,EAANA;AAAR,GAAb;AAEA,SAAO,2CAAoBkB,IAApB,CAAP;AACD;;eAEchB,sB","sourcesContent":["import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\n\nimport {Tile, TileReader} from './carto-spatial-tile';\nimport {parsePbf} from './tile-loader-utils';\nimport {getWorkerUrl} from '../../utils';\nimport {IndexScheme, binaryToSpatialjson, SpatialJson} from './spatialjson-utils';\n\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\nconst id = 'cartoSpatialTile';\n\ntype CartoSpatialTileLoaderOptions = LoaderOptions & {\n  cartoSpatialTile?: {\n    scheme: IndexScheme;\n    workerUrl: string;\n  };\n};\n\nconst DEFAULT_OPTIONS: CartoSpatialTileLoaderOptions = {\n  cartoSpatialTile: {\n    scheme: 'quadbin',\n    workerUrl: getWorkerUrl(id, VERSION)\n  }\n};\n\nconst CartoSpatialTileLoader: LoaderWithParser = {\n  name: 'CARTO Spatial Tile',\n  version: VERSION,\n  id,\n  module: 'carto',\n  extensions: ['pbf'],\n  mimeTypes: ['application/vnd.carto-spatial-tile'],\n  category: 'geometry',\n  parse: async (arrayBuffer, options?: CartoSpatialTileLoaderOptions) =>\n    parseCartoSpatialTile(arrayBuffer, options),\n  parseSync: parseCartoSpatialTile,\n  worker: false, // TODO set to true once workers deployed to unpkg\n  options: DEFAULT_OPTIONS\n};\n\nfunction parseCartoSpatialTile(\n  arrayBuffer: ArrayBuffer,\n  options?: CartoSpatialTileLoaderOptions\n): SpatialJson | null {\n  if (!arrayBuffer) return null;\n  const tile: Tile = parsePbf(arrayBuffer, TileReader);\n\n  const {cells} = tile;\n  const scheme = options?.cartoSpatialTile?.scheme;\n  const data = {cells, scheme};\n\n  return binaryToSpatialjson(data);\n}\n\nexport default CartoSpatialTileLoader;\n"],"file":"carto-spatial-tile-loader.js"}

package/dist/es5/layers/schema/carto-vector-tile-loader.js

@@ -15,15 +15,23 @@ var _cartoTile = require("./carto-tile");
 
 var _tileLoaderUtils = require("./tile-loader-utils");
 
+var _utils = require("../../utils");
+
+var VERSION = typeof "8.9.24" !== 'undefined' ? "8.9.24" : 'latest';
+var id = 'cartoVectorTile';
+var DEFAULT_OPTIONS = {
+  cartoVectorTile: {
+    workerUrl: (0, _utils.getWorkerUrl)(id, VERSION)
+  }
+};
 var CartoVectorTileLoader = {
   name: 'CARTO Vector Tile',
-  version: '1',
-  id: 'cartoVectorTile',
+  version: VERSION,
+  id: id,
   module: 'carto',
   extensions: ['pbf'],
   mimeTypes: ['application/vnd.carto-vector-tile'],
   category: 'geometry',
-  worker: false,
   parse: function () {
     var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
       return _regenerator.default.wrap(function _callee$(_context) {
@@ -47,7 +55,8 @@ var CartoVectorTileLoader = {
     return parse;
   }(),
   parseSync: parseCartoVectorTile,
-  options: {}
+  worker: false,
+  options: DEFAULT_OPTIONS
 };
 
 function parseCartoVectorTile(arrayBuffer, options) {

package/dist/es5/layers/schema/carto-vector-tile-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/layers/schema/carto-vector-tile-loader.ts"],"names":["CartoVectorTileLoader","name","version","id","module","extensions","mimeTypes","category","worker","parse","arrayBuffer","options","parseCartoVectorTile","parseSync","tile","TileReader"],"mappings":";;;;;;;;;;;;;AAGA;;AACA;;AAEA,IAAMA,qBAAuC,GAAG;AAC9CC,EAAAA,IAAI,EAAE,mBADwC;AAE9CC,EAAAA,OAAO,EAAE,GAFqC;AAG9CC,EAAAA,EAAE,EAAE,iBAH0C;AAI9CC,EAAAA,MAAM,EAAE,OAJsC;AAK9CC,EAAAA,UAAU,EAAE,CAAC,KAAD,CALkC;AAM9CC,EAAAA,SAAS,EAAE,CAAC,mCAAD,CANmC;AAO9CC,EAAAA,QAAQ,EAAE,UAPoC;AAQ9CC,EAAAA,MAAM,EAAE,KARsC;AAS9CC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAgCC,oBAAoB,CAACF,WAAD,EAAcC,OAAd,CAApD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KATyC;AAU9CE,EAAAA,SAAS,EAAED,oBAVmC;AAW9CD,EAAAA,OAAO,EAAE;AAXqC,CAAhD;;AAcA,SAASC,oBAAT,CACEF,WADF,EAEEC,OAFF,EAGyB;AACvB,MAAI,CAACD,WAAL,EAAkB,OAAO,IAAP;AAClB,MAAMI,IAAI,GAAG,+BAASJ,WAAT,EAAsBK,qBAAtB,CAAb;AAGA,SAAOD,IAAP;AACD;;eAEcd,qB","sourcesContent":["import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {BinaryFeatures} from '@loaders.gl/schema';\n\nimport {TileReader} from './carto-tile';\nimport {parsePbf} from './tile-loader-utils';\n\nconst CartoVectorTileLoader: LoaderWithParser = {\n  name: 'CARTO Vector Tile',\n  version: '1',\n  id: 'cartoVectorTile',\n  module: 'carto',\n  extensions: ['pbf'],\n  mimeTypes: ['application/vnd.carto-vector-tile'],\n  category: 'geometry',\n  worker: false,\n  parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),\n  parseSync: parseCartoVectorTile,\n  options: {}\n};\n\nfunction parseCartoVectorTile(\n  arrayBuffer: ArrayBuffer,\n  options?: LoaderOptions\n): BinaryFeatures | null {\n  if (!arrayBuffer) return null;\n  const tile = parsePbf(arrayBuffer, TileReader);\n\n  // Note: there is slight, difference in `numericProps` type, however geojson/mvtlayer can cope with this\n  return tile as unknown as BinaryFeatures;\n}\n\nexport default CartoVectorTileLoader;\n"],"file":"carto-vector-tile-loader.js"}
+{"version":3,"sources":["../../../../src/layers/schema/carto-vector-tile-loader.ts"],"names":["VERSION","id","DEFAULT_OPTIONS","cartoVectorTile","workerUrl","CartoVectorTileLoader","name","version","module","extensions","mimeTypes","category","parse","arrayBuffer","options","parseCartoVectorTile","parseSync","worker","tile","TileReader"],"mappings":";;;;;;;;;;;;;AAGA;;AACA;;AACA;;AAEA,IAAMA,OAAO,GAAG,oBAAuB,WAAvB,cAAmD,QAAnE;AACA,IAAMC,EAAE,GAAG,iBAAX;AAQA,IAAMC,eAA6C,GAAG;AACpDC,EAAAA,eAAe,EAAE;AACfC,IAAAA,SAAS,EAAE,yBAAaH,EAAb,EAAiBD,OAAjB;AADI;AADmC,CAAtD;AAMA,IAAMK,qBAAuC,GAAG;AAC9CC,EAAAA,IAAI,EAAE,mBADwC;AAE9CC,EAAAA,OAAO,EAAEP,OAFqC;AAG9CC,EAAAA,EAAE,EAAFA,EAH8C;AAI9CO,EAAAA,MAAM,EAAE,OAJsC;AAK9CC,EAAAA,UAAU,EAAE,CAAC,KAAD,CALkC;AAM9CC,EAAAA,SAAS,EAAE,CAAC,mCAAD,CANmC;AAO9CC,EAAAA,QAAQ,EAAE,UAPoC;AAQ9CC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CACLC,oBAAoB,CAACF,WAAD,EAAcC,OAAd,CADf;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KARyC;AAU9CE,EAAAA,SAAS,EAAED,oBAVmC;AAW9CE,EAAAA,MAAM,EAAE,KAXsC;AAY9CH,EAAAA,OAAO,EAAEZ;AAZqC,CAAhD;;AAeA,SAASa,oBAAT,CACEF,WADF,EAEEC,OAFF,EAGyB;AACvB,MAAI,CAACD,WAAL,EAAkB,OAAO,IAAP;AAClB,MAAMK,IAAI,GAAG,+BAASL,WAAT,EAAsBM,qBAAtB,CAAb;AAGA,SAAOD,IAAP;AACD;;eAEcb,qB","sourcesContent":["import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {BinaryFeatures} from '@loaders.gl/schema';\n\nimport {TileReader} from './carto-tile';\nimport {parsePbf} from './tile-loader-utils';\nimport {getWorkerUrl} from '../../utils';\n\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\nconst id = 'cartoVectorTile';\n\ntype CartoVectorTileLoaderOptions = LoaderOptions & {\n  cartoVectorTile?: {\n    workerUrl: string;\n  };\n};\n\nconst DEFAULT_OPTIONS: CartoVectorTileLoaderOptions = {\n  cartoVectorTile: {\n    workerUrl: getWorkerUrl(id, VERSION)\n  }\n};\n\nconst CartoVectorTileLoader: LoaderWithParser = {\n  name: 'CARTO Vector Tile',\n  version: VERSION,\n  id,\n  module: 'carto',\n  extensions: ['pbf'],\n  mimeTypes: ['application/vnd.carto-vector-tile'],\n  category: 'geometry',\n  parse: async (arrayBuffer, options?: CartoVectorTileLoaderOptions) =>\n    parseCartoVectorTile(arrayBuffer, options),\n  parseSync: parseCartoVectorTile,\n  worker: false, // TODO set to true once workers deployed to unpkg\n  options: DEFAULT_OPTIONS\n};\n\nfunction parseCartoVectorTile(\n  arrayBuffer: ArrayBuffer,\n  options?: CartoVectorTileLoaderOptions\n): BinaryFeatures | null {\n  if (!arrayBuffer) return null;\n  const tile = parsePbf(arrayBuffer, TileReader);\n\n  // Note: there is slight, difference in `numericProps` type, however geojson/mvtlayer can cope with this\n  return tile as unknown as BinaryFeatures;\n}\n\nexport default CartoVectorTileLoader;\n"],"file":"carto-vector-tile-loader.js"}