@deck.gl/carto 8.9.0 → 8.9.1

package/dist/dist.dev.js

@@ -1,5 +1,11 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['deck'] = factory();
+  else root['deck'] = factory();})(globalThis, function () {
 "use strict";
-var deck = (() => {
+var __exports__ = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -43,14 +49,14 @@ var deck = (() => {
   // external-global-plugin:@deck.gl/core
   var require_core = __commonJS({
     "external-global-plugin:@deck.gl/core"(exports, module) {
-      module.exports = globalThis.deck;
+      module.exports = typeof __require === "function" ? require_core() : null;
     }
   });
 
   // external-global-plugin:@deck.gl/geo-layers
   var require_geo_layers = __commonJS({
     "external-global-plugin:@deck.gl/geo-layers"(exports, module) {
-      module.exports = globalThis.deck;
+      module.exports = typeof __require === "function" ? require_geo_layers() : null;
     }
   });
 
@@ -5318,14 +5324,21 @@ var deck = (() => {
   // external-global-plugin:@deck.gl/aggregation-layers
   var require_aggregation_layers = __commonJS({
     "external-global-plugin:@deck.gl/aggregation-layers"(exports, module) {
-      module.exports = globalThis.deck;
+      module.exports = typeof __require === "function" ? require_aggregation_layers() : null;
     }
   });
 
   // external-global-plugin:@deck.gl/layers
   var require_layers = __commonJS({
     "external-global-plugin:@deck.gl/layers"(exports, module) {
-      module.exports = globalThis.deck;
+      module.exports = typeof __require === "function" ? require_layers() : null;
+    }
+  });
+
+  // external-global-plugin:@loaders.gl/core
+  var require_core2 = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = typeof __require === "function" ? require_core2() : null;
     }
   });
 
@@ -6068,14 +6081,14 @@ var deck = (() => {
   // external-global-plugin:@deck.gl/extensions
   var require_extensions = __commonJS({
     "external-global-plugin:@deck.gl/extensions"(exports, module) {
-      module.exports = globalThis.deck;
+      module.exports = typeof __require === "function" ? require_extensions() : null;
     }
   });
 
   // external-global-plugin:h3-js
   var require_h3_js = __commonJS({
     "external-global-plugin:h3-js"(exports, module) {
-      module.exports = globalThis.h3 || {};
+      module.exports = typeof __require === "function" ? require_h3_js() : null;
     }
   });
 
@@ -11111,76 +11124,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var import_layers2 = __toESM(require_layers());
   var import_geo_layers7 = __toESM(require_geo_layers());
 
-  // ../../node_modules/@loaders.gl/loader-utils/dist/esm/lib/env-utils/assert.js
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../../node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/option-utils.js
-  function getGlobalLoaderState() {
-    globalThis.loaders = globalThis.loaders || {};
-    const {
-      loaders
-    } = globalThis;
-    loaders._state = loaders._state || {};
-    return loaders._state;
-  }
-
-  // ../../node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/normalize-loader.js
-  function isLoaderObject(loader) {
-    var _loader;
-    if (!loader) {
-      return false;
-    }
-    if (Array.isArray(loader)) {
-      loader = loader[0];
-    }
-    const hasExtensions = Array.isArray((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.extensions);
-    return hasExtensions;
-  }
-  function normalizeLoader(loader) {
-    var _loader2, _loader3;
-    assert(loader, "null loader");
-    assert(isLoaderObject(loader), "invalid loader");
-    let options;
-    if (Array.isArray(loader)) {
-      options = loader[1];
-      loader = loader[0];
-      loader = {
-        ...loader,
-        options: {
-          ...loader.options,
-          ...options
-        }
-      };
-    }
-    if ((_loader2 = loader) !== null && _loader2 !== void 0 && _loader2.parseTextSync || (_loader3 = loader) !== null && _loader3 !== void 0 && _loader3.parseText) {
-      loader.text = true;
-    }
-    if (!loader.text) {
-      loader.binary = true;
-    }
-    return loader;
-  }
-
-  // ../../node_modules/@loaders.gl/core/dist/esm/lib/api/register-loaders.js
-  var getGlobalLoaderRegistry = () => {
-    const state = getGlobalLoaderState();
-    state.loaderRegistry = state.loaderRegistry || [];
-    return state.loaderRegistry;
-  };
-  function registerLoaders(loaders) {
-    const loaderRegistry = getGlobalLoaderRegistry();
-    loaders = Array.isArray(loaders) ? loaders : [loaders];
-    for (const loader of loaders) {
-      const normalizedLoader = normalizeLoader(loader);
-      if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
-        loaderRegistry.unshift(normalizedLoader);
-      }
-    }
-  }
+  // src/layers/carto-tile-layer.ts
+  var import_core = __toESM(require_core2());
 
   // src/layers/schema/carto-tile.ts
   var KeyValueObjectReader = class {
@@ -11680,7 +11625,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/carto-tile-layer.ts
-  registerLoaders([carto_vector_tile_loader_default]);
+  (0, import_core.registerLoaders)([carto_vector_tile_loader_default]);
   var defaultTileFormat = TILE_FORMATS.BINARY;
   var defaultProps = {
     ...import_geo_layers.MVTLayer.defaultProps,
@@ -11864,6 +11809,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
 
+  // src/layers/spatial-index-tile-layer.ts
+  var import_core2 = __toESM(require_core2());
+
   // src/layers/schema/carto-spatial-tile.ts
   var IndicesReader = class {
     static read(pbf, end) {
@@ -12057,7 +12005,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/layers/spatial-index-tile-layer.ts
   var import_geo_layers3 = __toESM(require_geo_layers());
-  registerLoaders([carto_spatial_tile_loader_default]);
+  (0, import_core2.registerLoaders)([carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
@@ -12397,7 +12345,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/utils.ts
   var import_core5 = __toESM(require_core());
-  function assert3(condition, message) {
+  function assert2(condition, message) {
     import_core5.log.assert(condition, message);
   }
 
@@ -12582,7 +12530,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       }
     };
     const layer = layerTypeDefs[type];
-    assert3(layer, `Unsupported layer type: ${type}`);
+    assert2(layer, `Unsupported layer type: ${type}`);
     return {
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
@@ -12863,7 +12811,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       datasets,
       token
     } = json;
-    assert3(keplerMapConfig.version === "v1", "Only support Kepler v1");
+    assert2(keplerMapConfig.version === "v1", "Only support Kepler v1");
     const {
       mapState,
       mapStyle
@@ -12893,11 +12841,11 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
             dataId
           } = config;
           const dataset = datasets.find((d) => d.id === dataId);
-          assert3(dataset, `No dataset matching dataId: ${dataId}`);
+          assert2(dataset, `No dataset matching dataId: ${dataId}`);
           const {
             data
           } = dataset;
-          assert3(data, `No data loaded for dataId: ${dataId}`);
+          assert2(data, `No data loaded for dataId: ${dataId}`);
           const {
             Layer,
             propMap,
@@ -13372,20 +13320,20 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     aggregationExp,
     aggregationResLevel
   }) {
-    assert3(connection, "Must define connection");
-    assert3(type, "Must define a type");
-    assert3(source, "Must define a source");
-    assert3(credentials2.apiVersion === API_VERSIONS.V3, "Method only available for v3");
-    assert3(credentials2.apiBaseUrl, "Must define apiBaseUrl");
-    assert3(credentials2.accessToken, "Must define an accessToken");
+    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");
     if (columns) {
-      assert3(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
+      assert2(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
     }
     if (geoColumn) {
-      assert3(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
+      assert2(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
     } else {
-      assert3(!aggregationExp, "Have aggregationExp, but geoColumn parameter is missing");
-      assert3(!aggregationResLevel, "Have aggregationResLevel, but geoColumn parameter is missing");
+      assert2(!aggregationExp, "Have aggregationExp, but geoColumn parameter is missing");
+      assert2(!aggregationResLevel, "Have aggregationResLevel, but geoColumn parameter is missing");
     }
   }
   async function fetchLayerData({
@@ -13493,7 +13441,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (format2) {
       mapFormat = format2;
       url = getUrlFromMetadata(metadata, format2);
-      assert3(url, `Format ${format2} not available`);
+      assert2(url, `Format ${format2} not available`);
     } else {
       const prioritizedFormats = [FORMATS.GEOJSON, FORMATS.JSON, FORMATS.NDJSON, FORMATS.TILEJSON];
       for (const f of prioritizedFormats) {
@@ -13503,7 +13451,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           break;
         }
       }
-      assert3(url && mapFormat, "Unsupported data formats received from backend.");
+      assert2(url && mapFormat, "Unsupported data formats received from backend.");
     }
     if (format2 === FORMATS.TILEJSON && formatTiles) {
       import_core7.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
@@ -13663,16 +13611,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const {
       accessToken
     } = localCreds;
-    assert3(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
-    assert3(localCreds.apiVersion === API_VERSIONS.V3, "Method only available for v3");
-    assert3(localCreds.apiBaseUrl, "Must define apiBaseUrl");
+    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");
     if (!localCreds.mapsUrl) {
       localCreds.mapsUrl = buildMapsUrlFromBase(localCreds.apiBaseUrl);
     }
     if (autoRefresh || onNewData) {
-      assert3(onNewData, "Must define `onNewData` when using autoRefresh");
-      assert3(typeof onNewData === "function", "`onNewData` must be a function");
-      assert3(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
+      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");
     }
     const url = `${localCreds.mapsUrl}/public/${cartoMapId}`;
     const errorContext = {
@@ -13872,7 +13820,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       }
     }
     _getSubLayerAndProps() {
-      assert3(this.state);
+      assert2(this.state);
       const {
         data,
         apiVersion
@@ -13896,7 +13844,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return [layerFromTileDataset(props.formatTiles, data.scheme), props];
     }
     renderLayers() {
-      assert3(this.state);
+      assert2(this.state);
       const {
         apiVersion,
         data
@@ -13951,14 +13899,14 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/style/utils.ts
   var ALLOWED_ATTR_TYPES = Object.freeze(["function", "string"]);
   function getAttrValue(attr, d) {
-    assert4(typeof d === "object", 'Expected "data" to be an object');
-    assert4(ALLOWED_ATTR_TYPES.includes(typeof attr), 'Expected "attr" to be a function or string');
+    assert3(typeof d === "object", 'Expected "data" to be an object');
+    assert3(ALLOWED_ATTR_TYPES.includes(typeof attr), 'Expected "attr" to be a function or string');
     if (typeof attr === "function") {
       return attr(d);
     }
     return d?.properties?.[attr];
   }
-  function assert4(condition, message = "") {
+  function assert3(condition, message = "") {
     if (!condition) {
       throw new Error(`CARTO style error: ${message}`);
     }
@@ -13971,7 +13919,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   function getPalette(name, numCategories) {
     const palette = cartoColors[name];
     let paletteIndex = numCategories;
-    assert4(palette, `Palette "${name}" not found. Expected a CARTOColors string`);
+    assert3(palette, `Palette "${name}" not found. Expected a CARTOColors string`);
     const palettesColorVariants = Object.keys(palette).filter((p) => p !== "tags").map(Number);
     const longestPaletteIndex = Math.max(...palettesColorVariants);
     const smallestPaletteIndex = Math.min(...palettesColorVariants);
@@ -14000,7 +13948,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), 255];
     }
     result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex2);
-    assert4(result, `Hexadecimal color "${hex2}" was not parsed correctly`);
+    assert3(result, `Hexadecimal color "${hex2}" was not parsed correctly`);
     return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), parseInt(result[4], 16)];
   }
 
@@ -14011,7 +13959,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     colors = DEFAULT_PALETTE,
     nullColor = NULL_COLOR
   }) {
-    assert4(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
+    assert3(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
     const palette = typeof colors === "string" ? getPalette(colors, domain.length + 1) : colors;
     const color2 = threshold().domain(domain).range(palette);
     return (d) => {
@@ -14028,7 +13976,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     nullColor = NULL_COLOR,
     othersColor = OTHERS_COLOR
   }) {
-    assert4(Array.isArray(domain), 'Expected "domain" to be an array of numbers or strings');
+    assert3(Array.isArray(domain), 'Expected "domain" to be an array of numbers or strings');
     const colorsByCategory = {};
     const palette = typeof colors === "string" ? getPalette(colors, domain.length) : colors;
     for (const [i, c] of domain.entries()) {
@@ -14047,7 +13995,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     colors = DEFAULT_PALETTE,
     nullColor = NULL_COLOR
   }) {
-    assert4(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
+    assert3(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
     const palette = typeof colors === "string" ? getPalette(colors, domain.length) : colors;
     const color2 = linear2().domain(domain).range(palette);
     return (d) => {
@@ -14069,3 +14017,5 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var carto = src_exports;
   return __toCommonJS(bundle_exports);
 })();
+      return __exports__;
+      });