@xyo-network/react-map 2.64.0-rc.7 → 2.64.1

package/dist/browser/Components/AnimatedHeatMap.cjs

@@ -0,0 +1,673 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Components/AnimatedHeatMap.tsx
+var AnimatedHeatMap_exports = {};
+__export(AnimatedHeatMap_exports, {
+  AnimatedHeatMap: () => AnimatedHeatMap
+});
+module.exports = __toCommonJS(AnimatedHeatMap_exports);
+var import_material3 = require("@mui/material");
+var import_react_flexbox3 = require("@xylabs/react-flexbox");
+var import_react12 = require("react");
+
+// src/Contexts/HeatMapInitializer/Provider.tsx
+var import_forget2 = require("@xylabs/forget");
+var import_react10 = require("react");
+
+// src/hooks/useDynamicMapResize.tsx
+var import_react = require("react");
+var useDynamicMapResize = (mapContainerRef, mapCanvasRef, mapInstance, active = true) => {
+  const [dependenciesReady, setDependenciesReady] = (0, import_react.useState)(false);
+  const resizer = (0, import_react.useMemo)(
+    () => new ResizeObserver(() => {
+      const width = mapContainerRef.current?.getBoundingClientRect().width;
+      if (width && mapCanvasRef.current) {
+        mapCanvasRef.current.style.width = `${width}px`;
+        setTimeout(() => mapInstance?.resize());
+      }
+    }),
+    [mapCanvasRef, mapContainerRef, mapInstance]
+  );
+  (0, import_react.useEffect)(() => {
+    const dependenciesReady2 = !!(active && mapInstance && mapContainerRef?.current && mapCanvasRef.current);
+    setDependenciesReady(dependenciesReady2);
+  }, [active, mapCanvasRef, mapContainerRef, mapInstance]);
+  (0, import_react.useEffect)(() => {
+    if (dependenciesReady) {
+      if (mapContainerRef.current) {
+        resizer.observe(mapContainerRef.current);
+      }
+      return () => {
+        resizer.disconnect();
+      };
+    }
+  }, [active, dependenciesReady, mapCanvasRef, mapContainerRef, mapInstance, resizer]);
+};
+
+// src/hooks/useDynamicPositioning.tsx
+var import_react_shared = require("@xylabs/react-shared");
+var import_react2 = require("react");
+var defaultZoom = 1.6;
+var defaultAspectRatioRange = [0.5, 2];
+var latRange = [0.9121644205263664, 1.71785031559439];
+var lngRange = [-81.4742014851959, 12.788958675506933];
+var linearInterpolate = (aspectRatio, degreeRange, aspectRatioRange) => {
+  const [degreeMin, degreeMax] = degreeRange;
+  const [aspectRatioMin, aspectRatioMax] = aspectRatioRange || defaultAspectRatioRange;
+  const aspectRatioRangeSpan = aspectRatioMax - aspectRatioMin;
+  const degreeRangeSpan = degreeMax - degreeMin;
+  const percent = (aspectRatio - aspectRatioMin) / aspectRatioRangeSpan;
+  const scaledDegree = percent * degreeRangeSpan + degreeMin;
+  return scaledDegree;
+};
+var useDynamicPositioning = () => {
+  const [options, setOptions] = (0, import_react2.useState)({});
+  const { width, height } = (0, import_react_shared.useWindowSize)();
+  (0, import_react2.useEffect)(() => {
+    if (width && height) {
+      const aspectRatio = width / height;
+      setOptions({
+        center: [linearInterpolate(aspectRatio, lngRange), linearInterpolate(aspectRatio, latRange)],
+        zoom: defaultZoom
+      });
+    }
+  }, [height, width]);
+  return { options };
+};
+
+// src/MapBoxClasses/MapBase.ts
+var import_assert = require("@xylabs/assert");
+var import_sdk_geo = require("@xyo-network/sdk-geo");
+var MapBase = class {
+  _config;
+  constructor(config) {
+    this._config = { requestLocation: true, zoom: 2, ...config };
+  }
+  get isMapReady() {
+    return !!this._config.map;
+  }
+  initializeMapSource(layer) {
+    const getSource = () => {
+      const featuresCollection = import_sdk_geo.GeoJson.featureCollection(this._config.features);
+      return import_sdk_geo.GeoJson.featuresSource(featuresCollection);
+    };
+    const existingSource = this._config.map.getSource(layer.source);
+    const source = getSource();
+    if (existingSource) {
+      existingSource.setData((0, import_assert.assertEx)(source.data));
+    } else {
+      this._config.map.addSource(layer.source, source);
+    }
+    layer.update(this._config.map, true);
+    return this;
+  }
+};
+
+// src/MapBoxClasses/MapHeat.ts
+var import_assert2 = require("@xylabs/assert");
+var import_delay = require("@xylabs/delay");
+var import_forget = require("@xylabs/forget");
+var import_sdk_geo2 = require("@xyo-network/sdk-geo");
+var import_mapbox_gl = require("mapbox-gl");
+var MapHeat = class extends MapBase {
+  static animationStarted = false;
+  config;
+  constructor(config) {
+    super(config);
+    this.config = config;
+  }
+  static initialMapPositioning(options, map, features, initialBounds) {
+    if (!features) {
+      return;
+    }
+    let bounds;
+    if (initialBounds) {
+      bounds = initialBounds;
+    } else {
+      bounds = new import_mapbox_gl.LngLatBounds();
+      features.forEach((feature) => {
+        feature.geometry.coordinates.forEach((coordinates) => {
+          coordinates.forEach((position) => {
+            bounds.extend(position);
+          });
+        });
+      });
+    }
+    map.setCenter(bounds.getCenter());
+    map.fitBounds(bounds, options);
+    return this;
+  }
+  static async initializeAnimatedHeatMapSource(layers, featureSet, map, startColor, endColor) {
+    this.animationStarted = true;
+    let layerTick = 0;
+    let sourceTick = 0;
+    const sources = featureSet.map((feature) => {
+      const featuresCollection = import_sdk_geo2.GeoJson.featureCollection(feature);
+      return import_sdk_geo2.GeoJson.featuresSource(featuresCollection);
+    });
+    this.updateLayer(map, layers[0], sources[0]);
+    this.updateLayer(map, layers[1], sources[1]);
+    layers.forEach((layer) => {
+      map.setPaintProperty(layer.id, "fill-opacity", 0);
+    });
+    const frameLength = 3e3;
+    const initialPad = 0.5;
+    const factor = 10;
+    const steps = 30;
+    const stepLength = frameLength / steps;
+    const lowUsageColor = startColor ?? "#FFB3B3";
+    const highUsageColor = endColor ?? "#FF0000";
+    const dynamicFillColor = (factor2, initialPad2, i) => {
+      const sinFade = Math.sin(i / steps * Math.PI / 2);
+      const cosFade = Math.cos(i / steps * Math.PI / 2);
+      const divisor = factor2 + factor2 * sinFade;
+      const offset = initialPad2 * cosFade;
+      return [
+        "let",
+        "density",
+        ["+", ["/", ["number", ["get", "value"]], divisor], offset],
+        ["interpolate", ["linear"], ["var", "density"], 0, lowUsageColor, 0.5, highUsageColor]
+      ];
+    };
+    const fadedIn = layers.map((_) => false);
+    const fadeIn = async (id, index) => {
+      for (let i = steps; i >= 1; i--) {
+        map.setPaintProperty(id, "fill-color", dynamicFillColor(factor, initialPad, i * (180 / stepLength)));
+        await (0, import_delay.delay)(stepLength);
+      }
+      fadedIn[index] = true;
+    };
+    const fadeOut = async (id, index) => {
+      for (let i = 1; i <= steps; i++) {
+        map.setPaintProperty(id, "fill-color", dynamicFillColor(factor, initialPad, i * (180 / stepLength)));
+        await (0, import_delay.delay)(stepLength);
+      }
+      fadedIn[index] = false;
+    };
+    let started = false;
+    const startAnimation = async () => {
+      (0, import_assert2.assertEx)(!started, "Animation Already Started");
+      started = true;
+      while (this.animationStarted) {
+        const upLayer = layerTick % layers.length;
+        const downLayer = (layerTick + 1) % layers.length;
+        const incomingSource = sourceTick % featureSet.length;
+        const outgoingSource = (sourceTick + 1) % featureSet.length;
+        if (fadedIn[upLayer]) {
+          this.updateLayer(map, layers[upLayer], sources[incomingSource]);
+          (0, import_forget.forget)(fadeOut(layers[upLayer].id, upLayer));
+        }
+        if (!fadedIn[downLayer]) {
+          this.updateLayer(map, layers[downLayer], sources[outgoingSource]);
+          (0, import_forget.forget)(fadeIn(layers[downLayer].id, downLayer));
+        }
+        while ((fadedIn[upLayer] || !fadedIn[downLayer]) && this.animationStarted) {
+          await (0, import_delay.delay)(1e3);
+        }
+        layerTick++;
+        sourceTick++;
+      }
+    };
+    await startAnimation();
+  }
+  static updateLayer(map, layer, source) {
+    const existingSource = map.getSource(layer.source);
+    if (existingSource && source.data) {
+      existingSource.setData(source.data);
+    } else if (source) {
+      map.addSource(layer.source, source);
+    }
+    layer.update(map, true);
+  }
+  // Build layers each with the same features
+  initializeHeatMapSource(layers) {
+    const getSource = (_) => {
+      const featuresCollection = import_sdk_geo2.GeoJson.featureCollection(this.config.features);
+      return import_sdk_geo2.GeoJson.featuresSource(featuresCollection);
+    };
+    layers.forEach((layer, index) => {
+      const existingSource = this.config.map.getSource(layer.source);
+      const source = getSource(index);
+      if (existingSource) {
+        existingSource.setData((0, import_assert2.assertEx)(source.data));
+      } else {
+        this.config.map.addSource(layer.source, source);
+      }
+      layer.update(this.config.map, true);
+    });
+    return this;
+  }
+};
+
+// src/MapBoxClasses/MapSettings.ts
+var import_mapbox_gl2 = require("mapbox-gl");
+var MapSettings = class _MapSettings {
+  static geoLocateControl;
+  static mapListeners = {
+    logData: (ev, map) => {
+      const target = map || ev?.target;
+      if (target) {
+        console.log("zoom", target.getZoom());
+        console.log("center", target.getCenter());
+      }
+    }
+  };
+  static navControl;
+  static requestLocation;
+  static toggleControls(value, map, zoom, requestLocation) {
+    if (value) {
+      _MapSettings.addControls(map, zoom, requestLocation);
+    } else {
+      _MapSettings.removeControls(map);
+    }
+    return this;
+  }
+  static toggleDebugLayer(value, map, layerName) {
+    const debugLayer = map.getLayer(layerName);
+    if (debugLayer) {
+      if (value) {
+        map.setLayoutProperty(layerName, "visibility", "visible");
+      } else {
+        map.setLayoutProperty(layerName, "visibility", "none");
+      }
+    }
+    return this;
+  }
+  static toggleDebugLogging(value, map) {
+    const debugEvents = ["resize", "zoomend", "dragend"];
+    if (value) {
+      this.mapListeners.logData(void 0, map);
+      debugEvents.forEach((event) => map.on(event, this.mapListeners.logData));
+    } else {
+      debugEvents.forEach((event) => map.off(event, this.mapListeners.logData));
+    }
+  }
+  static toggleScrollToZoom(value, map) {
+    if (value) {
+      map.scrollZoom.enable();
+    } else {
+      map.scrollZoom.disable();
+    }
+    return this;
+  }
+  static updateSettings(config) {
+    const { settings, map, zoom, requestLocation, debugLayerName = "" } = config;
+    const { scrollToZoom, enableControls, debugLayer, debugLogging } = settings;
+    _MapSettings.toggleControls(enableControls?.value, map, zoom, requestLocation).toggleScrollToZoom(scrollToZoom?.value, map).toggleDebugLayer(debugLayer?.value, map, debugLayerName).toggleDebugLogging(debugLogging.value, map);
+  }
+  // Needs to be static so we ensure controls are only instantiated once
+  static addControls(map, zoom, requestLocation) {
+    const geolocateControl = new import_mapbox_gl2.GeolocateControl({
+      fitBoundsOptions: {
+        zoom: zoom || 2
+      },
+      positionOptions: {
+        enableHighAccuracy: true
+      },
+      trackUserLocation: true
+    });
+    const navControl = new import_mapbox_gl2.NavigationControl({
+      showCompass: false
+    });
+    this.geoLocateControl = this.geoLocateControl || geolocateControl;
+    this.navControl = this.navControl || navControl;
+    if (!map.hasControl(this.geoLocateControl)) {
+      if (requestLocation) {
+        map.addControl(this.geoLocateControl);
+      }
+    }
+    if (!map.hasControl(this.navControl)) {
+      map.addControl(this.navControl, "top-left");
+    }
+    return this;
+  }
+  static removeControls(map) {
+    if (this.geoLocateControl && map.hasControl(this.geoLocateControl)) {
+      if (this.requestLocation) {
+        map.removeControl(this.geoLocateControl);
+      }
+    }
+    if (this.navControl && map.hasControl(this.navControl)) {
+      map.removeControl(this.navControl);
+    }
+    return this;
+  }
+};
+
+// src/Contexts/MapBoxInstance/Provider.tsx
+var import_react4 = require("react");
+
+// src/Contexts/MapBoxInstance/Context.ts
+var import_react3 = require("react");
+var MapBoxInstanceContext = (0, import_react3.createContext)({});
+
+// src/Contexts/MapBoxInstance/Provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var MapBoxInstanceProvider = ({ children }) => {
+  const [map, setMapBoxInstance] = (0, import_react4.useState)();
+  const [mapInitialized, setMapInitialized] = (0, import_react4.useState)(false);
+  const value = { map, mapInitialized, setMapBoxInstance };
+  (0, import_react4.useEffect)(() => {
+    if (!mapInitialized && map) {
+      map?.on("load", () => {
+        setMapInitialized(true);
+      });
+    }
+  }, [map, mapInitialized, setMapInitialized]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MapBoxInstanceContext.Provider, { value, children });
+};
+
+// src/Contexts/MapBoxInstance/useMapBoxInstance.tsx
+var import_assert3 = require("@xylabs/assert");
+var import_react5 = require("react");
+var useMapBoxInstance = () => {
+  const context = (0, import_react5.useContext)(MapBoxInstanceContext);
+  (0, import_assert3.assertEx)("map" in context, "useMapBoxInstance must be used within a MapBoxInstanceContext");
+  return context;
+};
+
+// src/Contexts/MapSettings/Provider.tsx
+var import_react7 = require("react");
+
+// src/Contexts/MapSettings/Context.ts
+var import_react6 = require("react");
+var MapSettingsContext = (0, import_react6.createContext)({});
+
+// src/Contexts/MapSettings/Provider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var MapSettingsProvider = ({
+  children,
+  debugLayerName,
+  defaultMapSettings,
+  requestLocation,
+  zoom = 1
+}) => {
+  const [mapSettings, setMapSettings] = (0, import_react7.useState)(defaultMapSettings || {});
+  const { map, mapInitialized } = useMapBoxInstance();
+  const value = {
+    mapSettings,
+    setMapSettings
+  };
+  (0, import_react7.useEffect)(() => {
+    if (mapSettings && map && mapInitialized) {
+      MapSettings.updateSettings({ debugLayerName, map, requestLocation, settings: mapSettings, zoom });
+    }
+  }, [debugLayerName, map, mapInitialized, mapSettings, requestLocation, zoom]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MapSettingsContext.Provider, { value, children });
+};
+
+// src/Contexts/MapSettings/useMapSettings.tsx
+var import_react8 = require("react");
+var useMapSettings = () => {
+  const context = (0, import_react8.useContext)(MapSettingsContext);
+  return context;
+};
+
+// src/Contexts/HeatMapInitializer/Context.ts
+var import_react9 = require("react");
+var HeatMapInitializerContext = (0, import_react9.createContext)({});
+
+// src/Contexts/HeatMapInitializer/Provider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var HeatMapInitializerProvider = ({
+  children,
+  featureSets,
+  featureSetsLayers,
+  features,
+  fitToPadding,
+  heatMapColorProps,
+  layers,
+  zoom
+}) => {
+  const [mapHeat, setMapHeat] = (0, import_react10.useState)();
+  const { options } = useDynamicPositioning();
+  const { mapSettings } = useMapSettings();
+  const { map, mapInitialized } = useMapBoxInstance();
+  const value = {
+    MapHeat: mapHeat,
+    heatMapColorProps
+  };
+  (0, import_react10.useEffect)(() => {
+    if (mapInitialized && featureSets?.length && featureSets[0].length && map && featureSetsLayers?.length) {
+      const { lowUsageColor, highUsageColor } = heatMapColorProps;
+      (0, import_forget2.forget)(MapHeat.initializeAnimatedHeatMapSource(featureSetsLayers, featureSets, map, lowUsageColor, highUsageColor));
+    }
+    return () => {
+      MapHeat.animationStarted = false;
+    };
+  }, [featureSets, featureSetsLayers, mapInitialized, map, heatMapColorProps]);
+  (0, import_react10.useEffect)(() => {
+    if (mapHeat && mapInitialized && features?.length && layers?.length) {
+      mapHeat.initializeHeatMapSource(layers);
+    }
+  }, [mapHeat, features?.length, layers, mapInitialized]);
+  (0, import_react10.useEffect)(() => {
+    if (mapInitialized) {
+      const { fitToPoints } = mapSettings || {};
+      if (map) {
+        if (fitToPoints?.value === true) {
+          MapHeat.initialMapPositioning({ padding: fitToPadding }, map, features);
+        } else if (options.zoom && options.center) {
+          map.setZoom(options.zoom);
+          map.setCenter(options.center);
+        }
+      }
+    }
+  }, [mapHeat, map, mapSettings, fitToPadding, options, mapInitialized, features]);
+  (0, import_react10.useEffect)(() => {
+    if (map && features?.length) {
+      setMapHeat(new MapHeat({ features, map, zoom }));
+    }
+  }, [map, features, zoom]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(HeatMapInitializerContext.Provider, { value, children });
+};
+
+// src/Layers/Configs/HeatMapFillLayerConfig.ts
+var HeatMapFillLayerConfig = (color) => ({
+  paint: {
+    "fill-color": color,
+    "fill-opacity": [
+      "let",
+      "density",
+      ["+", ["/", ["number", ["get", "value"]], 4], 0.125],
+      ["interpolate", ["linear"], ["var", "density"], 0.8, ["var", "density"], 1, 0.85]
+    ]
+  }
+});
+
+// src/Layers/FillLayer.ts
+var import_sdk_geo3 = require("@xyo-network/sdk-geo");
+var FillLayerBuilder = class extends import_sdk_geo3.LayerBase {
+  FillLayerOptions;
+  // ensures this class passes for `AnyLayer` type in MapBox
+  type = "fill";
+  constructor(id, source, FillLayerOptions) {
+    super(id, source);
+    this.FillLayerOptions = FillLayerOptions || { id: this.id, source: this.source };
+  }
+  buildLayer() {
+    return {
+      ...this.FillLayerOptions,
+      id: this.id,
+      source: this.source,
+      type: this.type
+    };
+  }
+};
+
+// src/Layers/Builders/LocationHeatMapLayerBuilder.ts
+var MapHeatConstants = {
+  LocationDebugLayerId: "location-debug-id",
+  LocationDebugLayerSource: "location-debug-source",
+  LocationFillLayerId: "location-fill-id",
+  LocationFillLayerSource: "location-fill-source",
+  LocationLineLayerId: "location-line-id",
+  LocationLineLayerSource: "location-line-source"
+};
+
+// src/Layers/Builders/LocationHeatMapLayerBuilderAnimated.ts
+var MapHeatConstants2 = (index, type) => ({
+  LocationDebugLayerId: `location-${type}-debug-id-${index}`,
+  LocationDebugLayerSource: `location-${type}-debug-source-${index}`,
+  LocationFillLayerId: `location-${type}-fill-id-${index}`,
+  LocationFillLayerSource: `location-${type}-fill-source-${index}`,
+  LocationLineLayerId: `location-${type}-line-id-${index}`,
+  LocationLineLayerSource: `location-${type}-line-source-${index}`
+});
+var LocationHeatMapLayerBuilderAnimated = (color, index, type = "") => {
+  const { LocationFillLayerId, LocationFillLayerSource } = MapHeatConstants2(index, type);
+  const fillLayerConfig = HeatMapFillLayerConfig(color);
+  const fillLayer = new FillLayerBuilder(LocationFillLayerId, LocationFillLayerSource, fillLayerConfig);
+  return fillLayer;
+};
+
+// src/Components/MapBoxHeat.tsx
+var import_react_flexbox2 = require("@xylabs/react-flexbox");
+
+// src/Components/MapBox.tsx
+var import_mapbox_gl3 = require("mapbox-gl/dist/mapbox-gl.css");
+var import_mapbox_gl4 = require("mapbox-gl");
+var import_react11 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var MapBox = ({ accessToken, darkMode = false, options, zoom = 2, ...props }) => {
+  const [map, setMap] = (0, import_react11.useState)();
+  const mapContainerRef = (0, import_react11.useRef)(null);
+  const mapCanvasRef = (0, import_react11.useRef)(null);
+  const { setMapBoxInstance, map: mapInstance } = useMapBoxInstance();
+  const { mapSettings } = useMapSettings();
+  const activeResize = mapSettings?.dynamicMapResize.value;
+  useDynamicMapResize(mapContainerRef, mapCanvasRef, mapInstance, activeResize);
+  (0, import_react11.useEffect)(() => {
+    if (mapSettings?.preferDark?.value === true) {
+      map?.setStyle(`mapbox://styles/${"mapbox/dark-v10" /* Dark */}`);
+    } else {
+      map?.setStyle(`mapbox://styles/${darkMode ? "mapbox/dark-v10" /* Dark */ : "mapbox/light-v10" /* Light */}`);
+    }
+  }, [map, darkMode, mapSettings]);
+  (0, import_react11.useEffect)(() => {
+    const map2 = new import_mapbox_gl4.Map({
+      accessToken,
+      center: [0, 0],
+      container: mapContainerRef.current ?? "",
+      style: `mapbox://styles/${"mapbox/light-v10" /* Light */}`,
+      zoom,
+      ...options
+    });
+    setMapBoxInstance?.(map2);
+    setMap(map2);
+    mapCanvasRef.current = document.querySelector(".mapboxgl-canvas");
+    console.log("Created Map");
+    return () => {
+      console.log("Removing Map");
+      map2.remove();
+    };
+  }, [mapContainerRef, setMap, options, zoom, setMapBoxInstance, accessToken]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "div",
+    {
+      ref: (el) => mapContainerRef.current = el,
+      style: {
+        bottom: 0,
+        left: 0,
+        position: "absolute",
+        right: 0,
+        top: 0,
+        ...props
+      }
+    }
+  );
+};
+
+// src/Components/MapSettingsComponents/Setting.tsx
+var import_material = require("@mui/material");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var MapSettingSwitch = ({ developerMode, field, ...props }) => {
+  const { mapSettings, setMapSettings } = useMapSettings();
+  const setting = mapSettings?.[field];
+  const onLocalChange = (event) => {
+    if (setting) {
+      setMapSettings?.((previous) => {
+        previous[setting.field].value = event.target.checked;
+        return { ...previous };
+      });
+    }
+  };
+  if (setting?.devMode && developerMode === false) {
+    return null;
+  }
+  return setting?.hidden ? null : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_material.FormControlLabel, { label: setting?.label, control: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_material.Switch, { checked: setting?.value, onChange: onLocalChange, ...props }) });
+};
+
+// src/Components/MapSettingsComponents/SettingsBox.tsx
+var import_material2 = require("@mui/material");
+var import_react_flexbox = require("@xylabs/react-flexbox");
+var import_react_app_settings = require("@xyo-network/react-app-settings");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var MapSettingsBox = ({ developerMode, ...props }) => {
+  const { mapSettings } = useMapSettings();
+  const { developerMode: devModeFromContext } = (0, import_react_app_settings.useAppSettings)();
+  const resolveDeveloperMode = developerMode ?? devModeFromContext;
+  return mapSettings && resolveDeveloperMode ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_flexbox.FlexGrowRow, { bottom: 36, left: 10, position: "absolute", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_flexbox.FlexRow, { paddingX: 2, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_material2.Paper, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_material2.Stack, { direction: "row", spacing: 1, marginX: 1, children: Object.keys(mapSettings).map((key, index) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(MapSettingSwitch, { field: mapSettings[key].field, developerMode }, index);
+  }) }) }) }) }) : null;
+};
+
+// src/Components/MapBoxHeat.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var MapboxHeatFlexBox = ({ accessToken, children, mapBoxOptions, zoom, legend, developerMode, ...props }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_flexbox2.FlexCol, { ...props, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(MapBox, { accessToken, options: mapBoxOptions, zoom }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(MapSettingsBox, { developerMode }),
+    legend,
+    children
+  ] });
+};
+
+// src/Components/AnimatedHeatMap.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var AnimatedHeatMap = ({
+  accessToken,
+  animatedFeatureSets,
+  defaultMapSettings,
+  heatMapColorProps,
+  staticFeatureSet,
+  ...props
+}) => {
+  const theme = (0, import_material3.useTheme)();
+  const { staticMapColor, lowUsageColor, highUsageColor } = heatMapColorProps || {};
+  const localStaticMapColor = staticMapColor ?? theme.palette.primary.light;
+  const [layers] = (0, import_react12.useState)([
+    LocationHeatMapLayerBuilderAnimated(localStaticMapColor, 0, "static"),
+    LocationHeatMapLayerBuilderAnimated(lowUsageColor || localStaticMapColor, 0, "animated"),
+    LocationHeatMapLayerBuilderAnimated(highUsageColor || (0, import_material3.darken)(localStaticMapColor, 0.9), 1, "animated")
+  ]);
+  return animatedFeatureSets?.length ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(MapBoxInstanceProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(MapSettingsProvider, { defaultMapSettings, debugLayerName: MapHeatConstants.LocationDebugLayerId, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    HeatMapInitializerProvider,
+    {
+      features: staticFeatureSet,
+      layers: [layers[0]],
+      featureSets: animatedFeatureSets,
+      featureSetsLayers: layers.slice(1, 3),
+      heatMapColorProps,
+      children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(MapboxHeatFlexBox, { accessToken, ...props })
+    }
+  ) }) }) : /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_flexbox3.FlexCol, { minHeight: 160, minWidth: 160, busy: true });
+};
+//# sourceMappingURL=AnimatedHeatMap.cjs.map