@xyo-network/react-map 2.81.10 → 2.83.0

package/dist/browser/index.d.ts

@@ -1,11 +1,356 @@
-export * from './AnimatedHeatMapSettings.js';
-export * from './Colors/index.js';
-export * from './Components/index.js';
-export * from './Contexts/index.js';
-export * from './hooks/index.js';
-export * from './Layers/index.js';
-export * from './lib/index.js';
-export * from './MapBoxClasses/index.js';
-export * from './Settings/index.js';
-export * from './types/index.js';
-//# sourceMappingURL=index.d.ts.map
+import { WithChildren } from '@xylabs/react-shared';
+import * as geojson from 'geojson';
+import { Feature, Polygon, Point, Geometry } from 'geojson';
+import * as React$1 from 'react';
+import React__default, { ReactNode, Dispatch, SetStateAction, MutableRefObject } from 'react';
+import { FlexBoxProps } from '@xylabs/react-flexbox';
+import { LayerBase } from '@xyo-network/sdk-geo';
+import * as mapbox_gl from 'mapbox-gl';
+import { FillLayerSpecification, LineLayerSpecification, SymbolLayerSpecification, CircleLayerSpecification, Layer, LayerSpecification, MapOptions, Map, LngLatBounds, GeolocateControl, MapEventOf, MapEventType, NavigationControl } from 'mapbox-gl';
+import { SwitchProps } from '@mui/material';
+import * as _xyo_network_react_shared from '@xyo-network/react-shared';
+import { ContextExState } from '@xyo-network/react-shared';
+import * as _xyo_network_payload_model from '@xyo-network/payload-model';
+import { Payload } from '@xyo-network/payload-model';
+
+type MapSettingFields = 'debugLayer' | 'fitToPoints' | 'scrollToZoom' | 'enableControls' | 'debugLogging' | 'preferDark' | 'dynamicMapResize';
+type MapSetting = {
+    [field in MapSettingFields | string]: {
+        devMode?: boolean;
+        field: string;
+        hidden?: boolean;
+        label: string;
+        value: boolean;
+    };
+};
+
+declare const AnimatedHeatMapSettings: MapSetting;
+
+interface HeatMapColorProps {
+    staticMapColor: string;
+}
+interface AnimatedHeatMapColorProps extends HeatMapColorProps {
+    highUsageColor: string;
+    lowUsageColor: string;
+}
+interface ColorGradientLegendProps {
+    endColor: string;
+    endLabel: string;
+    heading: string;
+    startColor: string;
+    startLabel: string;
+    textColor: string;
+}
+type LegendProps = ColorGradientLegendProps;
+
+declare const DefaultMapSettings: () => MapSetting;
+
+interface AnimatedHeatMapProps {
+    accessToken: string;
+    animatedFeatureSets: Feature<Polygon>[][];
+    defaultMapSettings?: MapSetting;
+    heatMapColorProps: AnimatedHeatMapColorProps;
+    staticFeatureSet: Feature<Polygon>[];
+}
+declare const AnimatedHeatMap: React__default.FC<WithChildren<AnimatedHeatMapProps>>;
+
+interface AnimatedHeatMapLoadedProps extends FlexBoxProps {
+    accessToken: string;
+    archivistNameOrAddress: string;
+}
+declare const AnimatedHeatMapLoaded: React__default.FC<AnimatedHeatMapLoadedProps>;
+
+declare class FillLayerBuilder extends LayerBase<FillLayerSpecification> {
+    FillLayerOptions: Partial<FillLayerSpecification>;
+    type: 'fill';
+    constructor(id: string, source: string, FillLayerOptions?: Partial<FillLayerSpecification>);
+    buildLayer(): FillLayerSpecification;
+}
+
+declare class LineLayerBuilder extends LayerBase<LineLayerSpecification> {
+    LineLayerOptions: Partial<LineLayerSpecification>;
+    type: 'line';
+    constructor(id: string, source: string, LineLayerOptions?: Partial<LineLayerSpecification>);
+    buildLayer(): LineLayerSpecification;
+}
+
+declare class SymbolLayerBuilder extends LayerBase<SymbolLayerSpecification> {
+    SymbolLayerOptions: Partial<SymbolLayerSpecification>;
+    type: 'symbol';
+    constructor(id: string, source: string, SymbolLayerOptions?: Partial<SymbolLayerSpecification>);
+    buildLayer(): SymbolLayerSpecification;
+}
+
+declare const MapHeatConstants: {
+    LocationDebugLayerId: string;
+    LocationDebugLayerSource: string;
+    LocationFillLayerId: string;
+    LocationFillLayerSource: string;
+    LocationLineLayerId: string;
+    LocationLineLayerSource: string;
+};
+declare const LocationHeatMapLayerBuilder: (color: string, alternateColor?: string) => (FillLayerBuilder | LineLayerBuilder | SymbolLayerBuilder)[];
+
+declare const LocationHeatMapLayerBuilderAnimated: (color: string, index: number, type?: string) => FillLayerBuilder;
+
+declare class CircleLayerBuilder extends LayerBase<CircleLayerSpecification> {
+    CircleLayerOptions: Partial<CircleLayerSpecification>;
+    type: 'circle';
+    constructor(id: string, source: string, CircleLayerOptions?: Partial<CircleLayerSpecification>);
+    buildLayer(): CircleLayerSpecification;
+}
+
+declare const MapPointsConstants: {
+    LocationDotsLayerId: string;
+    LocationDotsLayerSource: string;
+};
+declare const LocationPointsMapLayerBuilder: (color: string, circleRadius?: number, circleOpacity?: number) => CircleLayerBuilder[];
+
+declare const HeatMapFillLayerConfig: (color: string) => Partial<FillLayerSpecification>;
+
+declare const HeatMapLineLayerConfig: (color: string) => Partial<LineLayerSpecification>;
+
+declare const HeatMapSymbolLayerConfig: (color: string) => Partial<SymbolLayerSpecification>;
+
+declare const LocationPointLayerConfig: (color: string, circleRadius: number, circleOpacity: number) => Partial<CircleLayerSpecification>;
+
+interface MapLayer extends Layer {
+    update: LayerBase<LayerSpecification>['update'];
+}
+
+interface FeaturesToLayersMap {
+    features: Feature<Polygon>[];
+    layers: MapLayer[];
+}
+
+declare const HeatMapSettings: MapSetting;
+
+interface MapboxFlexBoxProps extends FlexBoxProps {
+    accessToken: string;
+    developerMode?: boolean;
+    disableControls?: boolean;
+    disableFitToPoints?: boolean;
+    features?: Feature[];
+    fitToPointsPadding?: number;
+    layers?: MapLayer[];
+    legend?: ReactNode;
+    mapBoxOptions?: Partial<MapOptions>;
+    requestLocation?: boolean;
+    zoom?: number;
+}
+
+declare enum MapStyle {
+    Dark = "mapbox/dark-v10",
+    Light = "mapbox/light-v10",
+    Outdoors = "mapbox/outdoors-v11",
+    Satellite = "mapbox/satellite-v9",
+    SatelliteStreets = "mapbox/satellite-streets-v11",
+    Streets = "mapbox/streets-v11"
+}
+
+interface LayerAnimatorProps {
+    animateLayers?: boolean;
+    layers: MapboxFlexBoxProps['layers'];
+    layersInitialized: boolean;
+    map: Map | undefined;
+}
+declare const LayerAnimator: React__default.FC<WithChildren<LayerAnimatorProps>>;
+
+declare const AnimatedHeatMapLegend: React__default.FC<ColorGradientLegendProps>;
+
+declare const ColorGradientLegend: React__default.FC<ColorGradientLegendProps>;
+
+interface MapBoxProps {
+    accessToken: string;
+    darkMode?: boolean;
+    options?: Partial<MapOptions>;
+    zoom?: number;
+}
+declare const MapBox: React__default.FC<MapBoxProps>;
+
+declare const MapboxHeatFlexBox: React__default.FC<MapboxFlexBoxProps>;
+
+interface MapboxPointsFlexBoxProps extends MapboxFlexBoxProps {
+    accessToken: string;
+    features?: Feature<Point>[];
+}
+declare const MapboxPointsFlexBox: React__default.FC<MapboxPointsFlexBoxProps>;
+
+interface MapSettingSwitchProps extends SwitchProps {
+    developerMode?: boolean;
+    field: string;
+}
+declare const MapSettingSwitch: React__default.FC<MapSettingSwitchProps>;
+
+interface MapSettingsBoxProps extends FlexBoxProps {
+    developerMode?: boolean;
+}
+declare const MapSettingsBox: React__default.FC<MapSettingsBoxProps>;
+
+interface MapInitializerProviderProps {
+    featureSets?: Feature<Polygon>[][];
+    featureSetsLayers?: MapLayer[];
+    features?: Feature<Polygon>[];
+    fitToPadding?: number;
+    heatMapColorProps: HeatMapColorProps | AnimatedHeatMapColorProps;
+    layers?: MapLayer[];
+    zoom?: number;
+}
+declare const HeatMapInitializerProvider: React__default.FC<WithChildren<MapInitializerProviderProps>>;
+
+interface MapBaseConfig<T extends Geometry> {
+    features: Feature<T>[];
+    map: Map;
+    requestLocation?: boolean;
+    zoom?: number;
+}
+declare abstract class MapBase<T extends Geometry> {
+    private _config;
+    constructor(config: MapBaseConfig<T>);
+    get isMapReady(): boolean;
+    initializeMapSource(layer: MapLayer): this;
+}
+
+declare class MapHeat extends MapBase<Polygon> {
+    static animationStarted: boolean;
+    config: MapBaseConfig<Polygon>;
+    constructor(config: MapBaseConfig<Polygon>);
+    static initialMapPositioning(options: MapOptions['fitBoundsOptions'], map: Map, features?: Feature<Polygon>[], initialBounds?: LngLatBounds): typeof MapHeat | undefined;
+    static initializeAnimatedHeatMapSource(layers: MapLayer[], featureSet: Feature<Polygon>[][], map: Map, startColor?: string, endColor?: string): Promise<void>;
+    private static updateLayer;
+    initializeHeatMapSource(layers: MapLayer[]): this;
+}
+
+interface MapPointsConfig extends MapBaseConfig<Point> {
+    features: Feature<Point>[];
+}
+declare class MapPoints extends MapBase<Point> {
+    private config;
+    constructor(config: MapPointsConfig);
+    initialMapPositioning(options: MapOptions['fitBoundsOptions'], initialBounds?: LngLatBounds): mapbox_gl.Map;
+}
+
+interface MapSettingsConfig {
+    debugLayerName?: string;
+    map: Map;
+    requestLocation?: boolean;
+    settings: MapSetting;
+    zoom?: number;
+}
+declare class MapSettings {
+    static geoLocateControl: GeolocateControl | undefined;
+    static mapListeners: {
+        logData: (ev?: MapEventOf<MapEventType>, map?: Map) => void;
+    };
+    static navControl: NavigationControl | undefined;
+    static requestLocation: boolean | undefined;
+    static toggleControls(value: boolean | undefined, map: Map, zoom?: number, requestLocation?: boolean): typeof MapSettings;
+    static toggleDebugLayer(value: boolean | undefined, map: Map, layerName: string): typeof MapSettings;
+    static toggleDebugLogging(value: boolean | undefined, map: Map): void;
+    static toggleScrollToZoom(value: boolean | undefined, map: Map): typeof MapSettings;
+    static updateSettings(config: MapSettingsConfig): void;
+    private static addControls;
+    private static removeControls;
+}
+
+interface HeatMapInitializerState {
+    MapHeat?: MapHeat;
+    heatMapColorProps?: HeatMapColorProps;
+}
+
+declare const useHeatMapInitializer: () => HeatMapInitializerState;
+
+interface MapboxAccessTokenContextState extends ContextExState {
+    accessToken?: string;
+    setAccessToken?: Dispatch<string>;
+}
+
+declare const MapboxAccessTokenContext: React$1.Context<MapboxAccessTokenContextState & _xyo_network_react_shared.ContextExState>;
+
+interface MapboxAccessTokenProviderProps {
+    defaultAccessToken?: string;
+}
+declare const MapboxAccessTokenProvider: React__default.FC<WithChildren<MapboxAccessTokenProviderProps>>;
+
+declare const useMapboxAccessToken: (required?: boolean) => Omit<MapboxAccessTokenContextState & _xyo_network_react_shared.ContextExState, "provided">;
+
+declare const MapBoxInstanceProvider: React__default.FC<WithChildren>;
+
+interface MapBoxInstanceState {
+    map?: Map;
+    mapInitialized?: boolean;
+    setMapBoxInstance?: Dispatch<SetStateAction<Map | undefined>>;
+}
+
+declare const useMapBoxInstance: () => MapBoxInstanceState;
+
+interface MapSettingsProviderProps {
+    debugLayerName?: string;
+    defaultMapSettings?: MapSetting;
+    requestLocation?: boolean;
+    zoom?: number;
+}
+declare const MapSettingsProvider: React__default.FC<WithChildren<MapSettingsProviderProps>>;
+
+interface MapSettingsState {
+    mapSettings?: MapSetting;
+    setMapSettings?: Dispatch<React.SetStateAction<MapSetting>>;
+}
+
+declare const useMapSettings: () => MapSettingsState;
+
+declare const useDynamicMapResize: (mapContainerRef: MutableRefObject<HTMLDivElement | null>, mapCanvasRef: MutableRefObject<HTMLCanvasElement | null>, mapInstance?: Map, active?: boolean) => void;
+
+declare const useDynamicPositioning: () => {
+    options: Partial<MapOptions>;
+};
+
+declare const useFindHashes: () => Lowercase<string>[];
+
+declare const useHeatMapColors: () => {
+    heatMapColorProps: AnimatedHeatMapColorProps;
+    legendProps: ColorGradientLegendProps;
+};
+
+interface NetworkLocationAnswerBase<T> {
+    result: T;
+}
+declare const NetworkLocationAnswerSchema = "network.xyo.location.range.answer";
+type NetworkLocationAnswerSchema = 'network.xyo.location.range.answer';
+type NetworkLocationAnswerPayload = Payload<NetworkLocationAnswerBase<{
+    features: Feature<Point>[];
+}>, NetworkLocationAnswerSchema>;
+declare const isNetworkLocationAnswer: (x?: unknown | null) => x is _xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & NetworkLocationAnswerBase<{
+    features: Feature<Point>[];
+}> & {
+    schema: "network.xyo.location.range.answer";
+};
+declare const NetworkLocationHeatmapAnswerSchema = "network.xyo.location.heatmap.answer";
+type NetworkLocationHeatmapAnswerSchema = 'network.xyo.location.heatmap.answer';
+type NetworkLocationHeatmapAnswerPayload = Payload<NetworkLocationAnswerBase<{
+    features: Feature<Polygon>[];
+}>, NetworkLocationHeatmapAnswerSchema>;
+declare const isNetworkLocationHeatmapAnswer: (x?: unknown | null) => x is _xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & NetworkLocationAnswerBase<{
+    features: Feature<Polygon>[];
+}> & {
+    schema: "network.xyo.location.heatmap.answer";
+};
+declare const NetworkLocationHeatmapQuadkeyAnswerSchema = "network.xyo.location.heatmap.quadkey.answer";
+type NetworkLocationHeatmapQuadkeyAnswerSchema = 'network.xyo.location.heatmap.quadkey.answer';
+type NetworkLocationHeatmapQuadkeyAnswerPayload = Payload<NetworkLocationAnswerBase<{
+    density: number;
+    quadkey: string;
+}[]>, NetworkLocationHeatmapQuadkeyAnswerSchema>;
+declare const isNetworkLocationHeatmapQuadkeyAnswer: (x?: unknown | null) => x is _xyo_network_payload_model.SchemaFields & _xyo_network_payload_model.PayloadFields & NetworkLocationAnswerBase<{
+    features: Feature<Polygon>[];
+}> & {
+    schema: "network.xyo.location.heatmap.answer";
+};
+
+declare const useQuadKeyPayloadsToFeatures: (payloads?: NetworkLocationHeatmapQuadkeyAnswerPayload[] | NetworkLocationHeatmapQuadkeyAnswerPayload) => {
+    error: Error | undefined;
+    features: Feature<Geometry, geojson.GeoJsonProperties>[];
+    multipleFeatureSets: Feature<Geometry, geojson.GeoJsonProperties>[][];
+};
+
+export { AnimatedHeatMap, type AnimatedHeatMapColorProps, AnimatedHeatMapLegend, AnimatedHeatMapLoaded, type AnimatedHeatMapLoadedProps, type AnimatedHeatMapProps, AnimatedHeatMapSettings, CircleLayerBuilder, ColorGradientLegend, type ColorGradientLegendProps, DefaultMapSettings, type FeaturesToLayersMap, FillLayerBuilder, type HeatMapColorProps, HeatMapFillLayerConfig, HeatMapInitializerProvider, type HeatMapInitializerState, HeatMapLineLayerConfig, HeatMapSettings, HeatMapSymbolLayerConfig, LayerAnimator, type LayerAnimatorProps, type LegendProps, LineLayerBuilder, LocationHeatMapLayerBuilder, LocationHeatMapLayerBuilderAnimated, LocationPointLayerConfig, LocationPointsMapLayerBuilder, MapBase, type MapBaseConfig, MapBox, MapBoxInstanceProvider, type MapBoxInstanceState, type MapBoxProps, MapHeat, MapHeatConstants, type MapInitializerProviderProps, type MapLayer, MapPoints, type MapPointsConfig, MapPointsConstants, type MapSetting, type MapSettingFields, MapSettingSwitch, type MapSettingSwitchProps, MapSettings, MapSettingsBox, type MapSettingsBoxProps, type MapSettingsConfig, MapSettingsProvider, type MapSettingsProviderProps, type MapSettingsState, MapStyle, MapboxAccessTokenContext, type MapboxAccessTokenContextState, MapboxAccessTokenProvider, type MapboxAccessTokenProviderProps, type MapboxFlexBoxProps, MapboxHeatFlexBox, MapboxPointsFlexBox, type MapboxPointsFlexBoxProps, type NetworkLocationAnswerBase, type NetworkLocationAnswerPayload, NetworkLocationAnswerSchema, type NetworkLocationHeatmapAnswerPayload, NetworkLocationHeatmapAnswerSchema, type NetworkLocationHeatmapQuadkeyAnswerPayload, NetworkLocationHeatmapQuadkeyAnswerSchema, SymbolLayerBuilder, isNetworkLocationAnswer, isNetworkLocationHeatmapAnswer, isNetworkLocationHeatmapQuadkeyAnswer, useDynamicMapResize, useDynamicPositioning, useFindHashes, useHeatMapColors, useHeatMapInitializer, useMapBoxInstance, useMapSettings, useMapboxAccessToken, useQuadKeyPayloadsToFeatures };