@xyo-network/react-map 2.53.0 → 2.54.0

package/src/Components/LayerAnimator.tsx

@@ -2,12 +2,12 @@ import { useInterval, WithChildren } from '@xylabs/react-shared'
 import { Map } from 'mapbox-gl'
 import { useCallback, useEffect, useRef, useState } from 'react'
 
-import { XyoMapLayer } from '../Layers'
-import { XyoMapboxFlexBoxProps } from '../lib'
+import { MapLayer } from '../Layers'
+import { MapboxFlexBoxProps } from '../lib'
 
 export interface LayerAnimatorProps {
   animateLayers?: boolean
-  layers: XyoMapboxFlexBoxProps['layers']
+  layers: MapboxFlexBoxProps['layers']
   layersInitialized: boolean
   map: Map | undefined
 }
@@ -16,7 +16,7 @@ const timeIncrement = 2000
 const animatedLayerCount = 3
 
 export const LayerAnimator: React.FC<WithChildren<LayerAnimatorProps>> = ({ animateLayers, children, layers, layersInitialized, map }) => {
-  const [fillLayers, setFillLayers] = useState<XyoMapLayer[]>([])
+  const [fillLayers, setFillLayers] = useState<MapLayer[]>([])
   const layerIndexQueue = useRef<number[]>([])
 
   const incrementQueue = useCallback(
@@ -52,7 +52,7 @@ export const LayerAnimator: React.FC<WithChildren<LayerAnimatorProps>> = ({ anim
   }, [fillLayers, incrementQueue, lastQueuedIndex])
 
   const layerAnimateWorker = useCallback(
-    (layer: XyoMapLayer) => {
+    (layer: MapLayer) => {
       if (layer) {
         map?.setPaintProperty(layer.id, 'fill-opacity', 0.85)
         setTimeout(() => {
@@ -83,7 +83,7 @@ export const LayerAnimator: React.FC<WithChildren<LayerAnimatorProps>> = ({ anim
 
   //
   const queueLayerAnimation = useCallback(() => {
-    const animatedLayers: XyoMapLayer[] = []
+    const animatedLayers: MapLayer[] = []
 
     for (let i = 0; i < animatedLayerCount; i++) {
       animatedLayers.push(getNextLayer())

package/src/Components/MapBox.stories.tsx

@@ -6,7 +6,7 @@ import { useRef } from 'react'
 import { MapBoxInstanceProvider, MapSettingsProvider } from '../Contexts'
 import { DefaultMapSettings } from '../Settings'
 import { MapBox } from './MapBox'
-import { MapSettings } from './MapSettingsComponents'
+import { MapSettingsBox } from './MapSettingsComponents'
 
 const WithMapboxProviders: Decorator = (Story, props) => {
   const defaultSettings = DefaultMapSettings()
@@ -26,7 +26,7 @@ const WithMapSettingsDecorator: Decorator = (Story, args) => {
   return (
     <>
       <Story {...args} />
-      <MapSettings developerMode={true} />
+      <MapSettingsBox developerMode={true} />
     </>
   )
 }

package/src/Components/MapBox.tsx

@@ -6,7 +6,7 @@ import { useEffect, useRef, useState } from 'react'
 
 import { useMapBoxInstance, useMapSettings } from '../Contexts'
 import { useDynamicMapResize } from '../hooks'
-import { XyoMapStyle } from '../lib'
+import { MapStyle } from '../lib'
 
 export interface MapBoxProps {
   accessToken: string
@@ -27,9 +27,9 @@ export const MapBox: React.FC<MapBoxProps> = ({ accessToken, darkMode = false, o
 
   useEffect(() => {
     if (mapSettings?.preferDark?.value === true) {
-      map?.setStyle(`mapbox://styles/${XyoMapStyle.Dark}`)
+      map?.setStyle(`mapbox://styles/${MapStyle.Dark}`)
     } else {
-      map?.setStyle(`mapbox://styles/${darkMode ? XyoMapStyle.Dark : XyoMapStyle.Light}`)
+      map?.setStyle(`mapbox://styles/${darkMode ? MapStyle.Dark : MapStyle.Light}`)
     }
   }, [map, darkMode, mapSettings])
 
@@ -38,7 +38,7 @@ export const MapBox: React.FC<MapBoxProps> = ({ accessToken, darkMode = false, o
       accessToken,
       center: [0, 0],
       container: mapContainerRef.current ?? '',
-      style: `mapbox://styles/${XyoMapStyle.Light}`,
+      style: `mapbox://styles/${MapStyle.Light}`,
       zoom,
       ...options,
     })

package/src/Components/MapBoxHeat.tsx

@@ -1,22 +1,14 @@
 import { FlexCol } from '@xylabs/react-flexbox'
 
-import { XyoMapboxFlexBoxProps } from '../lib'
+import { MapboxFlexBoxProps } from '../lib'
 import { MapBox } from './MapBox'
-import { MapSettings } from './MapSettingsComponents'
+import { MapSettingsBox } from './MapSettingsComponents'
 
-export const XyoMapboxHeatFlexBox: React.FC<XyoMapboxFlexBoxProps> = ({
-  accessToken,
-  children,
-  mapBoxOptions,
-  zoom,
-  legend,
-  developerMode,
-  ...props
-}) => {
+export const MapboxHeatFlexBox: React.FC<MapboxFlexBoxProps> = ({ accessToken, children, mapBoxOptions, zoom, legend, developerMode, ...props }) => {
   return (
     <FlexCol {...props}>
       <MapBox accessToken={accessToken} options={mapBoxOptions} zoom={zoom} />
-      <MapSettings developerMode={developerMode} />
+      <MapSettingsBox developerMode={developerMode} />
       {legend}
       {children}
     </FlexCol>

package/src/Components/MapBoxPoints.tsx

@@ -5,17 +5,17 @@ import { FitBoundsOptions } from 'mapbox-gl'
 import { useCallback, useEffect, useState } from 'react'
 
 import { useMapBoxInstance, useMapSettings } from '../Contexts'
-import { XyoMapboxFlexBoxProps } from '../lib'
-import { XyoMapPoints } from '../MapBoxClasses'
+import { MapboxFlexBoxProps } from '../lib'
+import { MapPoints } from '../MapBoxClasses'
 import { MapBox } from './MapBox'
-import { MapSettings } from './MapSettingsComponents'
+import { MapSettingsBox } from './MapSettingsComponents'
 
-export interface XyoMapboxPointsFlexBoxProps extends XyoMapboxFlexBoxProps {
+export interface MapboxPointsFlexBoxProps extends MapboxFlexBoxProps {
   accessToken: string
   features?: Feature<Point>[]
 }
 
-export const XyoMapboxPointsFlexBox: React.FC<XyoMapboxPointsFlexBoxProps> = ({
+export const MapboxPointsFlexBox: React.FC<MapboxPointsFlexBoxProps> = ({
   accessToken,
   features,
   fitToPointsPadding = 20,
@@ -23,7 +23,7 @@ export const XyoMapboxPointsFlexBox: React.FC<XyoMapboxPointsFlexBoxProps> = ({
   zoom,
   ...props
 }) => {
-  const [MapPoints, setMapPoints] = useState<XyoMapPoints>()
+  const [mapPoints, setMapPoints] = useState<MapPoints>()
   const { mapSettings } = useMapSettings()
   const { map, mapInitialized } = useMapBoxInstance()
 
@@ -41,31 +41,31 @@ export const XyoMapboxPointsFlexBox: React.FC<XyoMapboxPointsFlexBoxProps> = ({
   }
 
   const updateFeatures = useCallback(() => {
-    if (MapPoints?.isMapReady && features?.length) {
+    if (mapPoints?.isMapReady && features?.length) {
       layers?.forEach((layer) => {
-        MapPoints.initializeMapSource(layer)
+        mapPoints.initializeMapSource(layer)
       })
     }
-  }, [MapPoints, features, layers])
+  }, [mapPoints, features, layers])
 
   const updateMapSetup = useCallback(() => {
     const { fitToPoints } = mapSettings || {}
 
-    if (MapPoints && map) {
+    if (mapPoints && map) {
       if (fitToPoints?.value === true) {
-        MapPoints.initialMapPositioning({ padding: fitToPointsPadding, ...customFitToBoundsOptions(zoom) })
+        mapPoints.initialMapPositioning({ padding: fitToPointsPadding, ...customFitToBoundsOptions(zoom) })
       }
     }
-  }, [mapSettings, MapPoints, map, fitToPointsPadding, zoom])
+  }, [mapSettings, mapPoints, map, fitToPointsPadding, zoom])
 
   const reInitializeMap = useCallback(() => {
-    MapPoints?.initialMapPositioning({ padding: fitToPointsPadding, ...customFitToBoundsOptions(zoom) })
+    mapPoints?.initialMapPositioning({ padding: fitToPointsPadding, ...customFitToBoundsOptions(zoom) })
     updateFeatures()
-  }, [MapPoints, fitToPointsPadding, updateFeatures, zoom])
+  }, [mapPoints, fitToPointsPadding, updateFeatures, zoom])
 
   useEffect(() => {
     if (map && features?.length) {
-      setMapPoints(new XyoMapPoints({ features, map, zoom }))
+      setMapPoints(new MapPoints({ features, map, zoom }))
     }
   }, [map, features, zoom])
 
@@ -81,7 +81,7 @@ export const XyoMapboxPointsFlexBox: React.FC<XyoMapboxPointsFlexBoxProps> = ({
       {features ? (
         <>
           <MapBox accessToken={accessToken} zoom={zoom} />
-          <MapSettings />
+          <MapSettingsBox />
         </>
       ) : (
         <Alert severity="error">No data to show</Alert>

package/src/Components/MapSettingsComponents/{Settings.tsx → SettingsBox.tsx}

@@ -5,11 +5,11 @@ import { useAppSettings } from '@xyo-network/react-app-settings'
 import { useMapSettings } from '../../Contexts'
 import { MapSettingSwitch } from './Setting'
 
-export interface MapSettingsProps extends FlexBoxProps {
+export interface MapSettingsBoxProps extends FlexBoxProps {
   developerMode?: boolean
 }
 
-export const MapSettings: React.FC<MapSettingsProps> = ({ developerMode, ...props }) => {
+export const MapSettingsBox: React.FC<MapSettingsBoxProps> = ({ developerMode, ...props }) => {
   const { mapSettings } = useMapSettings()
   const { developerMode: devModeFromContext } = useAppSettings()
   const resolveDeveloperMode = developerMode ?? devModeFromContext

package/src/Components/MapSettingsComponents/index.tsx

@@ -1,2 +1,2 @@
 export * from './Setting'
-export * from './Settings'
+export * from './SettingsBox'

package/src/Contexts/HeatMapInitializer/Provider.tsx

@@ -3,10 +3,10 @@ import { WithChildren } from '@xylabs/react-shared'
 import { Feature, Polygon } from 'geojson'
 import { useEffect, useState } from 'react'
 
-import { XyoAnimatedHeatMapColorProps, XyoHeatMapColorProps } from '../../Colors'
+import { AnimatedHeatMapColorProps, HeatMapColorProps } from '../../Colors'
 import { useDynamicPositioning } from '../../hooks'
-import { XyoMapLayer } from '../../Layers'
-import { XyoMapHeat } from '../../MapBoxClasses'
+import { MapLayer } from '../../Layers'
+import { MapHeat } from '../../MapBoxClasses'
 import { useMapBoxInstance } from '../MapBoxInstance'
 import { useMapSettings } from '../MapSettings'
 import { HeatMapInitializerContext } from './Context'
@@ -14,11 +14,11 @@ import { HeatMapInitializerState } from './State'
 
 export interface MapInitializerProviderProps {
   featureSets?: Feature<Polygon>[][]
-  featureSetsLayers?: XyoMapLayer[]
+  featureSetsLayers?: MapLayer[]
   features?: Feature<Polygon>[]
   fitToPadding?: number
-  heatMapColorProps: XyoHeatMapColorProps | XyoAnimatedHeatMapColorProps
-  layers?: XyoMapLayer[]
+  heatMapColorProps: HeatMapColorProps | AnimatedHeatMapColorProps
+  layers?: MapLayer[]
   zoom?: number
 }
 
@@ -32,32 +32,32 @@ export const HeatMapInitializerProvider: React.FC<WithChildren<MapInitializerPro
   layers,
   zoom,
 }) => {
-  const [MapHeat, setMapHeat] = useState<XyoMapHeat>()
+  const [mapHeat, setMapHeat] = useState<MapHeat>()
   const { options } = useDynamicPositioning()
   const { mapSettings } = useMapSettings()
   const { map, mapInitialized } = useMapBoxInstance()
 
   const value: HeatMapInitializerState = {
-    MapHeat,
+    MapHeat: mapHeat,
     heatMapColorProps,
   }
 
   useEffect(() => {
     if (mapInitialized && featureSets?.length && featureSets[0].length && map && featureSetsLayers?.length) {
-      const { lowUsageColor, highUsageColor } = heatMapColorProps as XyoAnimatedHeatMapColorProps
-      forget(XyoMapHeat.initializeAnimatedHeatMapSource(featureSetsLayers, featureSets, map, lowUsageColor, highUsageColor))
+      const { lowUsageColor, highUsageColor } = heatMapColorProps as AnimatedHeatMapColorProps
+      forget(MapHeat.initializeAnimatedHeatMapSource(featureSetsLayers, featureSets, map, lowUsageColor, highUsageColor))
     }
 
     return () => {
-      XyoMapHeat.animationStarted = false
+      MapHeat.animationStarted = false
     }
   }, [featureSets, featureSetsLayers, mapInitialized, map, heatMapColorProps])
 
   useEffect(() => {
-    if (MapHeat && mapInitialized && features?.length && layers?.length) {
-      MapHeat.initializeHeatMapSource(layers)
+    if (mapHeat && mapInitialized && features?.length && layers?.length) {
+      mapHeat.initializeHeatMapSource(layers)
     }
-  }, [MapHeat, features?.length, layers, mapInitialized])
+  }, [mapHeat, features?.length, layers, mapInitialized])
 
   useEffect(() => {
     if (mapInitialized) {
@@ -65,19 +65,19 @@ export const HeatMapInitializerProvider: React.FC<WithChildren<MapInitializerPro
 
       if (map) {
         if (fitToPoints?.value === true) {
-          XyoMapHeat.initialMapPositioning({ padding: fitToPadding }, map, features)
+          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])
+  }, [mapHeat, map, mapSettings, fitToPadding, options, mapInitialized, features])
 
   useEffect(() => {
     if (map && features?.length) {
       // Every time we get a new map or features, we make a new class
-      setMapHeat(new XyoMapHeat({ features, map, zoom }))
+      setMapHeat(new MapHeat({ features, map, zoom }))
     }
   }, [map, features, zoom])
 

package/src/Contexts/HeatMapInitializer/State.ts

@@ -1,7 +1,7 @@
-import { XyoHeatMapColorProps } from '../../Colors'
-import { XyoMapHeat } from '../../MapBoxClasses'
+import { HeatMapColorProps } from '../../Colors'
+import { MapHeat } from '../../MapBoxClasses'
 
 export interface HeatMapInitializerState {
-  MapHeat?: XyoMapHeat
-  heatMapColorProps?: XyoHeatMapColorProps
+  MapHeat?: MapHeat
+  heatMapColorProps?: HeatMapColorProps
 }

package/src/Contexts/MapSettings/Provider.tsx

@@ -1,7 +1,7 @@
 import { WithChildren } from '@xylabs/react-shared'
 import { useEffect, useState } from 'react'
 
-import { XyoMapSettings } from '../../MapBoxClasses'
+import { MapSettings } from '../../MapBoxClasses'
 import { MapSetting } from '../../Settings'
 import { useMapBoxInstance } from '../MapBoxInstance'
 import { MapSettingsContext } from './Context'
@@ -31,7 +31,7 @@ export const MapSettingsProvider: React.FC<WithChildren<MapSettingsProviderProps
 
   useEffect(() => {
     if (mapSettings && map && mapInitialized) {
-      XyoMapSettings.updateSettings({ debugLayerName, map, requestLocation, settings: mapSettings, zoom })
+      MapSettings.updateSettings({ debugLayerName, map, requestLocation, settings: mapSettings, zoom })
     }
   }, [debugLayerName, map, mapInitialized, mapSettings, requestLocation, zoom])
 

package/src/Layers/{XyoMapLayer.ts → MapLayer.ts}

@@ -2,6 +2,6 @@ import { LayerBase } from '@xyo-network/sdk-geo'
 // eslint-disable-next-line no-restricted-imports
 import { AnyLayer, Layer } from 'mapbox-gl'
 
-export interface XyoMapLayer extends Layer {
+export interface MapLayer extends Layer {
   update: LayerBase<AnyLayer>['update']
 }

package/src/Layers/index.ts

@@ -3,5 +3,5 @@ export * from './CircleLayer'
 export * from './Configs'
 export * from './FillLayer'
 export * from './LineLayer'
+export * from './MapLayer'
 export * from './SymbolLayer'
-export * from './XyoMapLayer'

package/src/MapBoxClasses/{XyoMapBase.ts → MapBase.ts}

@@ -4,19 +4,19 @@ import { Feature, Geometry } from 'geojson'
 // eslint-disable-next-line no-restricted-imports
 import { GeoJSONSource, Map } from 'mapbox-gl'
 
-import { XyoMapLayer } from '../Layers'
+import { MapLayer } from '../Layers'
 
-export interface XyoMapBaseConfig<T extends Geometry> {
+export interface MapBaseConfig<T extends Geometry> {
   features: Feature<T>[]
   map: Map
   requestLocation?: boolean
   zoom?: number
 }
 
-export abstract class XyoMapBase<T extends Geometry> {
-  private _config: XyoMapBaseConfig<T>
+export abstract class MapBase<T extends Geometry> {
+  private _config: MapBaseConfig<T>
 
-  constructor(config: XyoMapBaseConfig<T>) {
+  constructor(config: MapBaseConfig<T>) {
     this._config = { requestLocation: true, zoom: 2, ...config }
   }
 
@@ -24,7 +24,7 @@ export abstract class XyoMapBase<T extends Geometry> {
     return !!this._config.map
   }
 
-  initializeMapSource(layer: XyoMapLayer) {
+  initializeMapSource(layer: MapLayer) {
     const getSource = () => {
       const featuresCollection = GeoJson.featureCollection(this._config.features)
       return GeoJson.featuresSource(featuresCollection)

package/src/MapBoxClasses/{XyoMapHeat.ts → MapHeat.ts}

@@ -5,14 +5,14 @@ import { GeoJson } from '@xyo-network/sdk-geo'
 import { Feature, Polygon } from 'geojson'
 import { FitBoundsOptions, GeoJSONSource, GeoJSONSourceRaw, LngLatBounds, Map } from 'mapbox-gl'
 
-import { XyoMapLayer } from '../Layers'
-import { XyoMapBase, XyoMapBaseConfig } from './XyoMapBase'
+import { MapLayer } from '../Layers'
+import { MapBase, MapBaseConfig } from './MapBase'
 
-export class XyoMapHeat extends XyoMapBase<Polygon> {
+export class MapHeat extends MapBase<Polygon> {
   static animationStarted = false
 
-  config: XyoMapBaseConfig<Polygon>
-  constructor(config: XyoMapBaseConfig<Polygon>) {
+  config: MapBaseConfig<Polygon>
+  constructor(config: MapBaseConfig<Polygon>) {
     super(config)
     this.config = config
   }
@@ -44,7 +44,7 @@ export class XyoMapHeat extends XyoMapBase<Polygon> {
   }
 
   static async initializeAnimatedHeatMapSource(
-    layers: XyoMapLayer[],
+    layers: MapLayer[],
     featureSet: Feature<Polygon>[][],
     map: Map,
     startColor?: string,
@@ -144,7 +144,7 @@ export class XyoMapHeat extends XyoMapBase<Polygon> {
     await startAnimation()
   }
 
-  private static updateLayer(map: Map, layer: XyoMapLayer, source: GeoJSONSourceRaw) {
+  private static updateLayer(map: Map, layer: MapLayer, source: GeoJSONSourceRaw) {
     const existingSource = map.getSource(layer.source as string) as GeoJSONSource
     if (existingSource && source.data) {
       existingSource.setData(source.data as GeoJSON.Feature<GeoJSON.Geometry> | GeoJSON.FeatureCollection<GeoJSON.Geometry>)
@@ -155,7 +155,7 @@ export class XyoMapHeat extends XyoMapBase<Polygon> {
   }
 
   // Build layers each with the same features
-  initializeHeatMapSource(layers: XyoMapLayer[]) {
+  initializeHeatMapSource(layers: MapLayer[]) {
     const getSource = (_: number) => {
       const featuresCollection = GeoJson.featureCollection(this.config.features)
       return GeoJson.featuresSource(featuresCollection)

package/src/MapBoxClasses/{XyoMapPoints.ts → MapPoints.ts}

@@ -2,16 +2,16 @@ import { Feature, Point } from 'geojson'
 // eslint-disable-next-line no-restricted-imports
 import { FitBoundsOptions, LngLatBounds } from 'mapbox-gl'
 
-import { XyoMapBase, XyoMapBaseConfig } from './XyoMapBase'
+import { MapBase, MapBaseConfig } from './MapBase'
 
-export interface XyoMapPointsConfig extends XyoMapBaseConfig<Point> {
+export interface MapPointsConfig extends MapBaseConfig<Point> {
   features: Feature<Point>[]
 }
 
-export class XyoMapPoints extends XyoMapBase<Point> {
-  private config: XyoMapPointsConfig
+export class MapPoints extends MapBase<Point> {
+  private config: MapPointsConfig
 
-  constructor(config: XyoMapPointsConfig) {
+  constructor(config: MapPointsConfig) {
     super(config)
     this.config = config
   }

package/src/MapBoxClasses/{XyoMapSettings.ts → MapSettings.ts}

@@ -2,7 +2,7 @@ import { EventData, GeolocateControl, Map, MapLayerMouseEvent, MapLayerTouchEven
 
 import { MapSetting } from '../Settings'
 
-export interface XyoMapSettingsConfig {
+export interface MapSettingsConfig {
   debugLayerName?: string
   map: Map
   requestLocation?: boolean
@@ -15,7 +15,7 @@ export interface XyoMapSettingsConfig {
  *
  * Methods are pure functions dedicated to map manipulation
  */
-export class XyoMapSettings {
+export class MapSettings {
   static geoLocateControl: GeolocateControl | undefined
   static mapListeners = {
     logData: (ev?: MapLayerMouseEvent | (MapLayerTouchEvent & EventData), map?: Map) => {
@@ -31,9 +31,9 @@ export class XyoMapSettings {
 
   static toggleControls(value: boolean | undefined, map: Map, zoom?: number, requestLocation?: boolean) {
     if (value) {
-      XyoMapSettings.addControls(map, zoom, requestLocation)
+      MapSettings.addControls(map, zoom, requestLocation)
     } else {
-      XyoMapSettings.removeControls(map)
+      MapSettings.removeControls(map)
     }
 
     return this
@@ -73,11 +73,11 @@ export class XyoMapSettings {
     return this
   }
 
-  static updateSettings(config: XyoMapSettingsConfig) {
+  static updateSettings(config: MapSettingsConfig) {
     const { settings, map, zoom, requestLocation, debugLayerName = '' } = config
     const { scrollToZoom, enableControls, debugLayer, debugLogging } = settings
 
-    XyoMapSettings.toggleControls(enableControls?.value, map, zoom, requestLocation)
+    MapSettings.toggleControls(enableControls?.value, map, zoom, requestLocation)
       .toggleScrollToZoom(scrollToZoom?.value, map)
       .toggleDebugLayer(debugLayer?.value, map, debugLayerName)
       .toggleDebugLogging(debugLogging.value, map)

package/src/MapBoxClasses/index.ts

@@ -1,4 +1,4 @@
-export * from './XyoMapBase'
-export * from './XyoMapHeat'
-export * from './XyoMapPoints'
-export * from './XyoMapSettings'
+export * from './MapBase'
+export * from './MapHeat'
+export * from './MapPoints'
+export * from './MapSettings'

package/src/hooks/useFetchPayloads.tsx

@@ -5,7 +5,7 @@ import { ModuleError, WrapperError } from '@xyo-network/module'
 import { useArchivist } from '@xyo-network/react-archivist'
 import { useState } from 'react'
 
-import { NetworkXyoLocationHeatmapQuadkeyAnswerPayload } from '../types'
+import { NetworkLocationHeatmapQuadkeyAnswerPayload } from '../types'
 import { useQuadKeyPayloadsToFeatures } from './useQuadKeyPayloadsToFeatures'
 
 /** @deprecated - use useArchivistGet */
@@ -13,7 +13,7 @@ const useFetchPayloads = (hashes?: string[]) => {
   const [archivist] = useArchivist()
 
   const [apiError, setApiError] = useState<ModuleError>()
-  const [payloads, setPayloads] = useState<NetworkXyoLocationHeatmapQuadkeyAnswerPayload[]>()
+  const [payloads, setPayloads] = useState<NetworkLocationHeatmapQuadkeyAnswerPayload[]>()
   const { features, multipleFeatureSets } = useQuadKeyPayloadsToFeatures(payloads)
   const [notFound, setNotFound] = useState(false)
   const [inFlight, setInFlight] = useState(false)
@@ -31,7 +31,7 @@ const useFetchPayloads = (hashes?: string[]) => {
               setNotFound(true)
               setPayloads([])
             } else {
-              setPayloads(payloads as NetworkXyoLocationHeatmapQuadkeyAnswerPayload[])
+              setPayloads(payloads as NetworkLocationHeatmapQuadkeyAnswerPayload[])
             }
           }
         } catch (e) {

package/src/hooks/useFindHashes.tsx

@@ -1,4 +1,4 @@
-import { useNetwork, XyoArchivistPreset } from '@xyo-network/react-network'
+import { ArchivistPreset, useNetwork } from '@xyo-network/react-network'
 import { useMemo } from 'react'
 
 const animatedAnswerHashesConst = [
@@ -19,7 +19,7 @@ const staticAnswerHashConst = 'c7bbf61f61cfd4a1b2def160c28136fc1d100d39fbdb67b22
 
 export const useFindHashes = () => {
   const { network } = useNetwork()
-  const exploreMapHashes = (network?.nodes?.find((node) => node.type === 'archivist') as XyoArchivistPreset)?.explorerMapHashes
+  const exploreMapHashes = (network?.nodes?.find((node) => node.type === 'archivist') as ArchivistPreset)?.explorerMapHashes
   const animatedAnswerHashes = exploreMapHashes?.animatedAnswerHashes || animatedAnswerHashesConst
   const staticAnswerHash = exploreMapHashes?.staticAnswerHash || staticAnswerHashConst
   const foundHashes = useMemo(() => [staticAnswerHash, ...animatedAnswerHashes], [animatedAnswerHashes, staticAnswerHash])

package/src/hooks/useHeatMapColors.tsx

@@ -1,13 +1,13 @@
 import { useTheme } from '@mui/material'
 
-import { ColorGradientLegendProps, XyoAnimatedHeatMapColorProps } from '../Colors'
+import { AnimatedHeatMapColorProps, ColorGradientLegendProps } from '../Colors'
 
 const useHeatMapColors = () => {
   const theme = useTheme()
   const staticMapColor = '#FFFF75'
   const highUsageColor = '#FF0000'
 
-  const heatMapColorProps: XyoAnimatedHeatMapColorProps = {
+  const heatMapColorProps: AnimatedHeatMapColorProps = {
     highUsageColor,
     lowUsageColor: '#FFB3B3',
     staticMapColor,

package/src/hooks/useQuadKeyPayloadsToFeatures.tsx

@@ -3,7 +3,7 @@ import { Feature, Geometry } from 'geojson'
 import compact from 'lodash/compact'
 import { useEffect, useState } from 'react'
 
-import { NetworkXyoLocationHeatmapQuadkeyAnswerPayload } from '../types'
+import { NetworkLocationHeatmapQuadkeyAnswerPayload } from '../types'
 
 const quadKeyToFeature = ({ density, quadkey }: { density: number; quadkey: string }) => {
   const polygonFeature = new GeoJson(quadkey).polygonFeature()
@@ -21,7 +21,7 @@ const setDensity = (feature: Feature) => {
   return feature
 }
 
-const useQuadKeyPayloadsToFeatures = (payloads?: NetworkXyoLocationHeatmapQuadkeyAnswerPayload[] | NetworkXyoLocationHeatmapQuadkeyAnswerPayload) => {
+const useQuadKeyPayloadsToFeatures = (payloads?: NetworkLocationHeatmapQuadkeyAnswerPayload[] | NetworkLocationHeatmapQuadkeyAnswerPayload) => {
   const [multipleFeatureSets, setMultipleFeatureSets] = useState<Feature<Geometry>[][]>([[]])
   const [features, setFeatures] = useState<Feature<Geometry>[]>([])
   const [error, setError] = useState<Error>()
@@ -30,7 +30,7 @@ const useQuadKeyPayloadsToFeatures = (payloads?: NetworkXyoLocationHeatmapQuadke
     // Convert Multiple Payloads from Quadkey to GeoJson
     if (Array.isArray(payloads)) {
       if (compact(payloads).length !== 0) {
-        const payloadsArray = payloads as (NetworkXyoLocationHeatmapQuadkeyAnswerPayload | null)[]
+        const payloadsArray = payloads as (NetworkLocationHeatmapQuadkeyAnswerPayload | null)[]
         const mappedFeatures = payloadsArray?.map((payload) => payload?.result.map(quadKeyToFeature))
 
         setMultipleFeatureSets(mappedFeatures.map((features) => features?.map(setDensity) ?? []))
@@ -40,8 +40,8 @@ const useQuadKeyPayloadsToFeatures = (payloads?: NetworkXyoLocationHeatmapQuadke
     }
 
     // Convert Single Payload from Quadkey to GeoJson
-    if (payloads && (payloads as NetworkXyoLocationHeatmapQuadkeyAnswerPayload).result) {
-      const singlePayload = payloads as NetworkXyoLocationHeatmapQuadkeyAnswerPayload
+    if (payloads && (payloads as NetworkLocationHeatmapQuadkeyAnswerPayload).result) {
+      const singlePayload = payloads as NetworkLocationHeatmapQuadkeyAnswerPayload
       const mappedFeatures = singlePayload.result.map(quadKeyToFeature)
 
       setFeatures(mappedFeatures.map(setDensity))

package/src/lib/{XyoMapBoxBaseProps.ts → MapBoxBaseProps.ts}

@@ -3,16 +3,16 @@ import { Feature } from 'geojson'
 import { MapboxOptions } from 'mapbox-gl'
 import { ReactNode } from 'react'
 
-import { XyoMapLayer } from '../Layers'
+import { MapLayer } from '../Layers'
 
-export interface XyoMapboxFlexBoxProps extends FlexBoxProps {
+export interface MapboxFlexBoxProps extends FlexBoxProps {
   accessToken: string
   developerMode?: boolean
   disableControls?: boolean
   disableFitToPoints?: boolean
   features?: Feature[]
   fitToPointsPadding?: number
-  layers?: XyoMapLayer[]
+  layers?: MapLayer[]
   legend?: ReactNode
   mapBoxOptions?: Partial<MapboxOptions>
   requestLocation?: boolean

package/src/lib/{XyoMapStyle.ts → MapStyle.ts}

@@ -1,4 +1,4 @@
-export enum XyoMapStyle {
+export enum MapStyle {
   Dark = 'mapbox/dark-v10',
   Light = 'mapbox/light-v10',
   Outdoors = 'mapbox/outdoors-v11',