@carto/ps-react-maps 2.0.0 → 3.0.0-canary.0

package/dist/types/editable/measurement-tools/modes/custom-measurement-buffer.class.d.ts

@@ -0,0 +1,28 @@
+import { DrawCircleFromCenterMode, ClickEvent, FeatureCollection, Geometry, GuideFeatureCollection, ModeProps, PointerMoveEvent, Position, Tooltip } from '@deck.gl-community/editable-layers';
+import { ValueOf } from 'type-fest';
+import { MapMeasurementUnitAuto } from '../const';
+import { MeasurementToolsTextProps } from '../types';
+export declare class CustomMeasureBufferMode extends DrawCircleFromCenterMode {
+    _isMeasuringSessionFinished: boolean;
+    _currentArea: number;
+    resultPolygon: FeatureCollection;
+    tooltips: Tooltip[];
+    handleClick(event: ClickEvent, props: ModeProps<FeatureCollection>): void;
+    handlePointerMove(event: PointerMoveEvent, props: ModeProps<FeatureCollection>): void;
+    checkAndFinishPolygon(props: ModeProps<FeatureCollection>): void;
+    handleKeyUp(event: KeyboardEvent, props: ModeProps<FeatureCollection>): void;
+    getGuides(props: ModeProps<FeatureCollection>): GuideFeatureCollection;
+    isFinalizedEdition(clickSequence: Position[], tentativeFeature: {
+        geometry: Geometry;
+    }): boolean;
+    finalizeEdition(props: ModeProps<FeatureCollection>): void;
+    resetEdition(props: ModeProps<FeatureCollection>): void;
+    resetClickSequence(): void;
+    getTooltips(): Tooltip[];
+    getTooltipText({ meters, locale, unit, options, }: {
+        meters: number;
+        unit: ValueOf<typeof MapMeasurementUnitAuto>;
+        locale: string;
+        options?: MeasurementToolsTextProps;
+    }): string;
+}

package/dist/types/editable/measurement-tools/modes/custom-measurement-distance.class.d.ts

@@ -0,0 +1,16 @@
+import { MeasureDistanceMode, FeatureCollection, ModeProps } from '@deck.gl-community/editable-layers';
+import { BasePointerEvent } from 'node_modules/@deck.gl-community/editable-layers/dist/edit-modes/types';
+import { ValueOf } from 'type-fest';
+import { MapMeasurementUnitAuto } from '../const';
+import { MeasurementToolsTextProps } from '../types';
+export declare class CustomMeasureDistanceMode extends MeasureDistanceMode {
+    handleClick(event: BasePointerEvent, props: ModeProps<FeatureCollection>): void;
+    handleKeyUp(event: KeyboardEvent, props: ModeProps<FeatureCollection>): void;
+    resetClickSequence(): void;
+    getTooltipText({ meters, locale, unit, options, }: {
+        meters: number;
+        unit: ValueOf<typeof MapMeasurementUnitAuto>;
+        locale: string;
+        options?: MeasurementToolsTextProps;
+    }): string;
+}

package/dist/types/editable/measurement-tools/provider/provider.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+import { MeasurementToolsProviderProps, MeasurementToolsStore } from './types';
+export declare function MeasurementToolsProvider({ children, values, }: PropsWithChildren<MeasurementToolsProviderProps>): import("react/jsx-runtime").JSX.Element;
+export declare function useMeasurementToolsState<T>(selector: (state: MeasurementToolsStore) => T): T;

package/dist/types/editable/measurement-tools/provider/store.d.ts

@@ -0,0 +1,2 @@
+import { MeasurementToolsProviderProps, MeasurementToolsStore } from './types';
+export declare const createMeasurementToolsStore: (initProps: MeasurementToolsProviderProps["values"]) => import('zustand').StoreApi<MeasurementToolsStore>;

package/dist/types/editable/measurement-tools/provider/types.d.ts

@@ -0,0 +1,18 @@
+import { MeasurementToolsState } from '../types';
+export interface ValueProps extends Partial<MeasurementToolsState> {
+    mapId: MeasurementToolsState['mapId'];
+}
+export interface MeasurementToolsProviderProps {
+    values: ValueProps[];
+}
+export interface MeasurementToolsStore {
+    measurements: Record<MeasurementToolsState['mapId'], Omit<MeasurementToolsState, 'mapId'>>;
+    setModeInstance: (mapId: MeasurementToolsState['mapId'], mode: MeasurementToolsState['modeInstance']) => void;
+    setModeSelected: (mapId: MeasurementToolsState['mapId'], mode: MeasurementToolsState['modeSelected']) => void;
+    setFinished: (mapId: MeasurementToolsState['mapId'], finished: MeasurementToolsState['finished']) => void;
+    setDistance: (mapId: MeasurementToolsState['mapId'], distance: MeasurementToolsState['distance']) => void;
+    setUnit: (mapId: MeasurementToolsState['mapId'], unit: MeasurementToolsState['unit']) => void;
+    setLocale: (mapId: MeasurementToolsState['mapId'], locale: MeasurementToolsState['locale']) => void;
+    setPositions: (mapId: MeasurementToolsState['mapId'], positions: MeasurementToolsState['positions']) => void;
+    setEnable: (mapId: MeasurementToolsState['mapId'], enabled: MeasurementToolsState['enabled']) => void;
+}

package/dist/types/editable/measurement-tools/types.d.ts

@@ -0,0 +1,97 @@
+import { Color } from '@deck.gl/core';
+import { Position } from 'geojson';
+import { EditableGeojsonLayerProps } from 'node_modules/@deck.gl-community/editable-layers/dist/editable-layers/editable-geojson-layer';
+import { Class, ValueOf } from 'type-fest';
+import { CustomMeasureMode, MeasurementModes, MeasurementUnits, MapComponentProps, Tooltip } from '../../types';
+import { MapMeasurementUnitAuto } from './const';
+import { GeoJsonEditMode } from '@deck.gl-community/editable-layers';
+export interface MeasurementToolsState {
+    mapId: MapComponentProps['id'];
+    modeInstance?: CustomMeasureMode<GeoJsonEditMode>;
+    modeSelected?: keyof MeasurementModes;
+    modes: MeasurementModes<keyof MeasurementModes, CustomMeasureMode<GeoJsonEditMode>>;
+    units: MeasurementUnits;
+    enabled: boolean;
+    finished: boolean;
+    distance: number;
+    unit: ValueOf<typeof MapMeasurementUnitAuto>;
+    locale: string;
+    clearLayerOnStart?: boolean;
+    positions: Position[];
+}
+export interface MeasurementToolsLayerProps {
+    enabled: boolean;
+    layerProps: MeasurementToolsLayersProps<never>;
+    locale: MeasurementToolsState['locale'];
+    unit: MeasurementToolsState['unit'];
+    onEdit: (args: MeasurementToolsLayerEditProps) => void;
+    guideColor: Color;
+    pointColor: Color;
+    mode: CustomMeasureMode<GeoJsonEditMode>;
+    textOptions?: MeasurementToolsTextProps;
+}
+export interface MeasurementToolsLayersProps<D = unknown> extends Omit<EditableGeojsonLayerProps<D>, 'onHover' | 'mode'> {
+    selectedFeatures: D[];
+    onChangeFeatures: (features: D[]) => void;
+    onHover?: MeasurementToolsLayerHoverProps;
+}
+export interface EditableLayerHoverProps {
+    distance: number;
+    unit: string;
+    locale: string;
+}
+export type MeasurementToolsLayerHoverProps = (info: Tooltip, args: EditableLayerHoverProps) => void;
+export interface MeasurementToolsLayerEditProps {
+    editType: string;
+    editContext: {
+        distance: MeasurementToolsState['distance'];
+        finished: MeasurementToolsState['finished'];
+        positions: MeasurementToolsState['positions'];
+    };
+}
+export interface MeasurementToolsControlProps {
+    mapId: MeasurementToolsProps['mapId'];
+    textOptions?: MeasurementToolsProps['textOptions'];
+    children: (props: Required<MeasurementToolChildrenProps<string, GeoJsonEditMode>>) => React.ReactNode;
+}
+export interface DefaultMeasureToolProps {
+    styles: {
+        colors: {
+            editing: Color;
+            finished: Color;
+            point: Color;
+        };
+    };
+}
+export interface MeasurementToolsProps<M extends string = string, T = GeoJsonEditMode> {
+    mapId: string;
+    modeSelected: keyof MeasurementModes<M, T>;
+    defaultProps?: Partial<DefaultMeasureToolProps>;
+    layerProps?: MeasurementToolsLayerProps['layerProps'];
+    mode?: Class<CustomMeasureMode<T>>;
+    textOptions?: MeasurementToolsTextProps;
+}
+export type MeasurementToolChildrenProps<M extends string, T = unknown> = Partial<MeasurementToolsState> & {
+    value: string;
+    modes: MeasurementModes<M, T>;
+    modeSelected?: keyof MeasurementModes<M, T>;
+    units: MeasurementUnits;
+    setModeSelected: (mode: MeasurementToolsState['modeSelected']) => void;
+    setFinished: (finished: MeasurementToolsState['finished']) => void;
+    setDistance: (distance: MeasurementToolsState['distance']) => void;
+    setUnit: (unit: MeasurementToolsState['unit']) => void;
+    setLocale: (locale: MeasurementToolsState['locale']) => void;
+    setPositions: (positions: MeasurementToolsState['positions']) => void;
+    setEnable: (enabled: MeasurementToolsState['enabled']) => void;
+    toggleLayer: (enabled: boolean) => void;
+    clearLayer: () => void;
+};
+export type MeasurementToolsTextProps = Intl.NumberFormatOptions & {
+    autoSplitNumber?: number;
+};
+export interface EditModeConfig {
+    formatTooltip?: (radius: number) => string;
+    turfOptions: {
+        units: string;
+    };
+}

package/dist/types/editable/measurement-tools/use-measurement-tools.d.ts

@@ -0,0 +1,36 @@
+import { MeasurementToolsState } from './types';
+export declare function useMeasurementTools({ mapId }: {
+    mapId: string;
+}): {
+    modes: import('../..').MeasurementModes<import('../..').MeasurementMode, import('@deck.gl-community/editable-layers').GeoJsonEditMode>;
+    units: import('../..').MeasurementUnits;
+    distance: number;
+    clearLayerOnStart: boolean | undefined;
+    modeSelected: import('../..').MeasurementMode | undefined;
+    enabled: boolean;
+    finished: boolean;
+    locale: string;
+    modeInstance: import('@deck.gl-community/editable-layers').GeoJsonEditMode | undefined;
+    positions: import('geojson').Position[];
+    unit: import('type-fest').ValueOf<{
+        readonly kilometer: "kilometer";
+        readonly meter: "meter";
+        readonly centimeter: "centimeter";
+        readonly milimeter: "milimeter";
+        readonly mile: "mile";
+        readonly yard: "yard";
+        readonly feet: "feet";
+        readonly 'm-km': "m-km";
+        readonly 'ft-mi': "ft-mi";
+    }>;
+    setDistance: (distance: number) => void;
+    setModeSelected: (mode: MeasurementToolsState["modeSelected"]) => void;
+    setFinished: (finished: MeasurementToolsState["finished"]) => void;
+    setLocale: (locale: MeasurementToolsState["locale"]) => void;
+    setPositions: (positions: MeasurementToolsState["positions"]) => void;
+    setUnit: (unit: MeasurementToolsState["unit"]) => void;
+    setEnable: (enabled: MeasurementToolsState["enabled"]) => void;
+    toggleLayer: (enabled: boolean) => void;
+    clearLayer: () => void;
+    setModeInstance: (modeInstance: MeasurementToolsState["modeInstance"]) => void;
+};

package/dist/types/editable/measurement-tools/utils.d.ts

@@ -0,0 +1,17 @@
+import { Tooltip, Position } from '@deck.gl-community/editable-layers';
+import { ControllerOptions } from 'node_modules/@deck.gl/core/dist/controllers/controller';
+import { ValueOf } from 'type-fest';
+import { DeckGLComponentProps } from '../../types';
+import { MapMeasurementUnit, MapMeasurementUnitAuto } from './const';
+import { EditModeConfig, MeasurementToolsTextProps } from './types';
+export declare function convertMetersTo(distance: number, unit: ValueOf<typeof MapMeasurementUnit>): number;
+export declare function getTextLayerFormattedDistance({ meters, unit, locale, options: { autoSplitNumber, ...intlOptions }, }: {
+    meters: number;
+    unit: ValueOf<typeof MapMeasurementUnitAuto>;
+    locale: string;
+    options?: MeasurementToolsTextProps;
+}): string;
+export declare function getDeckController(controller: DeckGLComponentProps['controller'], { hasDoubleClickZoom, }: {
+    hasDoubleClickZoom: boolean;
+}): ControllerOptions;
+export declare function buildTooltip(value: number, position: Position, modeConfig: EditModeConfig): Tooltip[];

package/dist/types/helpers.d.ts

@@ -0,0 +1,12 @@
+import { Tooltip } from './types';
+export declare function getCursorDefault({ isDragging, isHovering, }: {
+    isHovering: boolean;
+    isDragging: boolean;
+}): "grabbing" | "pointer" | "grab";
+export declare function getTooltipDefault(info: Tooltip): {
+    html: string;
+    style: {
+        padding: string;
+        background: string;
+    };
+} | null;

package/dist/types/index.d.ts

@@ -1,4 +1,41 @@
-export * from './event-manager';
-export * from './map-provider';
-export * from './map-measurement-tool';
-export * from './utils';
+export type { BasemapKey, BasemapType, DeckGLComponentProps, GmapsProps, InstanceRef, LayerType, MapComponentProps, OverlayRef, Tooltip, ViewStateChange, ViewStateChangeCallback, ZoomControl, ZoomControlChildrenProps, CustomMeasureMode, MeasurementMode, MeasurementModeOption, MeasurementModes, MeasurementOptionsMode, MeasurementOptionsUnit, MeasurementSystem, MeasurementUnit, MeasurementUnitImperialDistance, MeasurementUnitMetricDistance, MeasurementUnitOption, MeasurementUnits, LassoToolsMode, LassoToolsModeOption, LassoToolsModes, LassoToolOptionsMode, } from './types';
+export { CartoBasemaps, CartoBasemapURL, GmapsBasemap, MAPS_BASEMAP, MapsTypes, } from './const';
+export { DeckGLComponent } from './deckgl';
+export type { DefaultLassoToolsProps, LassoToolsChildrenProps, LassoToolsControlProps, LassoToolsLayerEditProps, LassoToolsLayerProps, LassoToolsLayersProps, LassoToolsProps, LassoToolsState, } from './editable/lasso-tools/types';
+export { DEFAULT_LASSO_TOOLS_COLORS, DEFAULT_LASSO_TOOLS_LAYER_PROPS, DEFAULT_LASSO_TOOLS_MODES, DEFAULT_LASSO_TOOLS_PROPS, DEFAULT_MASK_LAYER_PROPS, MAP_LASSO_TOOLS_LAYER_ID, MAP_MASK_LAYER_ID, } from './editable/lasso-tools/const';
+export { CustomCompositeEditMode } from './editable/lasso-tools/modes/custom-edit-mode.class';
+export { LassoTools } from './editable/lasso-tools/lasso-tools';
+export { getLassoToolsLayer } from './editable/lasso-tools/layer';
+export { LassoToolsProvider, useLassoToolsState, } from './editable/lasso-tools/provider/provider';
+export { createLassoToolsStore } from './editable/lasso-tools/provider/store';
+export type { LassoToolsProviderProps, LassoToolsStore, } from './editable/lasso-tools/provider/types';
+export { DEFAULT_MEASUREMENT_TOOLS_MODES, DEFAULT_MEASUREMENT_TOOLS_UNITS, MEASUREMENT_TOOLS_UNITS_AREA, MEASUREMENT_TOOLS_UNITS_DISTANCE_VALUES, MEASUREMENT_TOOLS_UNITS_DISTANCE, } from './editable/measurement-tools/const';
+export type { DefaultMeasureToolProps, EditableLayerHoverProps, MeasurementToolChildrenProps, MeasurementToolsLayerEditProps, MeasurementToolsLayerHoverProps, MeasurementToolsLayerProps, MeasurementToolsLayersProps, MeasurementToolsProps, MeasurementToolsState, MeasurementToolsTextProps, MeasurementToolsControlProps, } from './editable/measurement-tools/types';
+export { CONVERSIONS_UNITS, DEFAULT_COLORS as DEFAULT_MEASURE_COLORS, INTL_UNITS, MAP_MEASURE_LAYER_ID, MapMeasurementUnitAuto, MapMeasurementUnitTurf, } from './editable/measurement-tools/const';
+export { EditType as EditableEditType } from './editable/const';
+export { CustomMeasureDistanceMode } from './editable/measurement-tools/modes/custom-measurement-distance.class';
+export { CustomMeasureAreaMode } from './editable/measurement-tools/modes/custom-measurement-area.class';
+export { CustomMeasureBufferMode } from './editable/measurement-tools/modes/custom-measurement-buffer.class';
+export { getMeasurementToolsLayer } from './editable/measurement-tools/layer';
+export { MeasurementTools } from './editable/measurement-tools/measurement-tools';
+export { convertMetersTo, getDeckController, getTextLayerFormattedDistance, } from './editable/measurement-tools/utils';
+export type { MeasurementToolsStore, MeasurementToolsProviderProps, ValueProps, } from './editable/measurement-tools/provider/types';
+export { MeasurementToolsProvider, useMeasurementToolsState, } from './editable/measurement-tools/provider/provider';
+export { createMeasurementToolsStore } from './editable/measurement-tools/provider/store';
+export { getCursorDefault, getTooltipDefault } from './helpers';
+export { MapComponent } from './map';
+export type { Layer, LayerStore } from './providers/layers/types';
+export { useLayers } from './providers/layers/store';
+export type { MapProviderProps, MapStateStore, ViewportRect, } from './providers/map/types';
+export { transitionFlyConfig } from './providers/map/const';
+export { MapProvider, useMapState } from './providers/map/provider';
+export { createMapStateStore } from './providers/map/store';
+export type { QuerySource, Source, SourceStore, TableSource, TilesetSource, } from './providers/sources/types';
+export { ApiBaseUrl, clientID } from './providers/sources/const';
+export { useSource } from './providers/sources/store';
+export { useGetLayers } from './use-get-layers';
+export { useMapScreenshot } from './use-map-screenshot';
+export type { FieldFormatter, Formatter, Formatters, ObjectToHtmlOptions, Value, } from './utils/object-to-html/types';
+export { formatterTypes } from './utils/object-to-html/const';
+export { objectToHtml } from './utils/object-to-html/object-to-html';
+export { ZoomControls } from './zoom-controls';

package/dist/types/map.d.ts

@@ -0,0 +1,2 @@
+import { MapComponentProps } from './types';
+export declare function MapComponent({ id, onLoad, onViewStateChange, ...props }: MapComponentProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/providers/layers/store.d.ts

@@ -0,0 +1,2 @@
+import { LayerStore } from './types';
+export declare const useLayers: import('zustand').UseBoundStore<import('zustand').StoreApi<LayerStore>>;

package/dist/types/providers/layers/types.d.ts

@@ -0,0 +1,9 @@
+import { LayerType } from '../../types';
+export interface Layer extends LayerType {
+    order?: number;
+    legend?: string;
+}
+export interface LayerStore {
+    layers: Record<string, Layer>;
+    setLayer: (id: string, layer?: Partial<Layer>) => void;
+}

package/dist/types/providers/map/const.d.ts

@@ -0,0 +1,2 @@
+import { MapViewState } from '@deck.gl/core';
+export declare const transitionFlyConfig: Pick<MapViewState, 'transitionDuration' | 'transitionInterpolator'>;

package/dist/types/providers/map/provider.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+import { MapProviderProps, MapStateStore } from './types';
+export declare function MapProvider({ children, values, }: PropsWithChildren<MapProviderProps>): import("react/jsx-runtime").JSX.Element;
+export declare function useMapState<T>(selector: (state: MapStateStore) => T): T;

package/dist/types/providers/map/store.d.ts

@@ -0,0 +1,2 @@
+import { MapProviderProps, MapStateStore } from './types';
+export declare const createMapStateStore: (initProps: MapProviderProps["values"]) => import('zustand').StoreApi<MapStateStore>;

package/dist/types/providers/map/types.d.ts

@@ -0,0 +1,59 @@
+import { MapViewState, WebMercatorViewport } from '@deck.gl/core';
+import { InstanceRef, MapComponentProps, OverlayRef } from '../../types';
+interface ValueProps {
+    id: MapComponentProps['id'];
+    viewState: MapComponentProps['viewState'];
+    isLoaded: boolean;
+    basemap: NonNullable<MapComponentProps['basemap']>;
+    layers?: string[];
+}
+export interface MapProviderProps {
+    values: Omit<ValueProps, 'isLoaded'>[];
+}
+export interface MapStore {
+    maps: Record<ValueProps['id'], Pick<ValueProps, 'basemap' | 'isLoaded'> & {
+        instanceRef?: MapComponentProps['instanceRef'];
+        overlayRef?: MapComponentProps['overlayRef'];
+    } & {
+        layers: NonNullable<ValueProps['layers']>;
+        areLayersLoaded: boolean;
+    }>;
+    setBasemap: (id: ValueProps['id'], basemap: ValueProps['basemap']) => void;
+    setLoad: (id: ValueProps['id'], isLoaded: boolean) => void;
+    setLayersLoad: (id: ValueProps['id'], isLoaded: boolean) => void;
+    getDeckInstance: (id: ValueProps['id']) => InstanceRef['deck'];
+    getOverlayInstance: (id: ValueProps['id']) => OverlayRef;
+    getViewState: (id: ValueProps['id']) => ValueProps['viewState'];
+    getViewports: (id: ValueProps['id'], rect?: ViewportRect) => WebMercatorViewport[] | undefined;
+    getViewport: (id: ValueProps['id'], index?: number, rect?: ViewportRect) => WebMercatorViewport | undefined;
+    addLayers: (id: ValueProps['id'], layers: NonNullable<ValueProps['layers']>) => void;
+    removeLayers: (id: ValueProps['id'], layer: NonNullable<ValueProps['layers']>) => void;
+}
+export interface ViewStateStore {
+    viewStates: Record<ValueProps['id'], ValueProps['viewState']>;
+    setViewState: (id: MapComponentProps['id'], viewState: MapViewState) => void;
+    setZoom: (id: MapComponentProps['id'], zoom: MapViewState['zoom']) => void;
+    setMinZoom: (id: MapComponentProps['id'], minZoom: MapViewState['minZoom']) => void;
+    setMaxZoom: (id: MapComponentProps['id'], maxZoom: MapViewState['maxPitch']) => void;
+}
+export interface CommonStore {
+    fitBounds: (id: ValueProps['id'], bounds: Parameters<WebMercatorViewport['fitBounds']>[0], options?: {
+        boundsOptions?: Parameters<WebMercatorViewport['fitBounds']>[1];
+        viewStateOptions?: Omit<MapViewState, 'latitude' | 'longitude' | 'zoom'>;
+    }) => void;
+    flyTo: (id: ValueProps['id'], target: {
+        longitude?: MapViewState['longitude'];
+        latitude?: MapViewState['latitude'];
+        zoom?: MapViewState['zoom'];
+    }, options?: {
+        viewStateOptions?: Omit<MapViewState, 'latitude' | 'longitude' | 'zoom'>;
+    }) => void;
+}
+export type MapStateStore = MapStore & ViewStateStore & CommonStore;
+export interface ViewportRect {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+export {};

package/dist/types/providers/sources/const.d.ts

@@ -0,0 +1,2 @@
+export declare const ApiBaseUrl = "https://gcp-us-east1.api.carto.com";
+export declare const clientID = "ps";

package/dist/types/providers/sources/store.d.ts

@@ -0,0 +1,2 @@
+import { SourceStore } from './types';
+export declare const useSource: import('zustand').UseBoundStore<import('zustand').StoreApi<SourceStore>>;

package/dist/types/providers/sources/types.d.ts

@@ -0,0 +1,17 @@
+import { VectorQuerySourceOptions, VectorTableSourceOptions, VectorTilesetSourceOptions } from '@deck.gl/carto';
+export type QuerySource = {
+    type: 'query';
+} & Omit<VectorQuerySourceOptions, 'accessToken' | 'sqlQuery'>;
+export type TilesetSource = {
+    type: 'tileset';
+} & Omit<VectorTilesetSourceOptions, 'accessToken' | 'tableName'>;
+export type TableSource = {
+    type: 'table';
+} & Omit<VectorTableSourceOptions, 'accessToken' | 'tableName'>;
+export type Source = (QuerySource | TilesetSource | TableSource) & {
+    data: string;
+};
+export interface SourceStore {
+    sources: Record<string, Source>;
+    setSource: (id: string, source?: Partial<Source>) => void;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,56 @@
+import { Class, ValueOf } from 'type-fest';
+import { MutableRefObject, ReactNode, RefObject } from 'react';
+import { Layer, MapViewState, PickingInfo, ViewStateChangeParameters } from '@deck.gl/core';
+import { DeckGLProps, DeckGLRef } from '@deck.gl/react';
+import { MapRef } from 'react-map-gl/maplibre';
+import { CartoBasemaps, GmapsBasemap, MapsTypes } from './const';
+import { MapProps, APIProviderProps } from '@vis.gl/react-google-maps';
+import { ViewStateStore } from './providers/map/types';
+export * from '../types/common';
+export type BasemapKey = keyof typeof CartoBasemaps | keyof typeof GmapsBasemap;
+export type BasemapType = ValueOf<typeof MapsTypes>;
+export interface Tooltip extends PickingInfo {
+    text?: string | undefined;
+    html?: string | undefined;
+    className?: string | undefined;
+    style?: Partial<CSSStyleDeclaration> | undefined;
+}
+export interface LayerType<T extends Class<Layer> = Class<Layer>> {
+    type: T | null;
+    props: unknown;
+}
+export type InstanceRef = DeckGLRef;
+export type OverlayRef = MapRef | google.maps.Map | null | undefined;
+export type GmapsProps = Omit<MapProps, 'mapTypeId'> & {
+    apiKey: string;
+    APIProviderProps?: Omit<APIProviderProps, 'apiKey'>;
+};
+export interface DeckGLComponentProps extends Omit<DeckGLProps, 'layers' | 'onLoad'> {
+    basemap?: BasemapKey;
+    instanceRef?: RefObject<InstanceRef>;
+    overlayRef?: MutableRefObject<OverlayRef>;
+    layers: LayerType[];
+    gmapsProps?: GmapsProps;
+    onLoad?: (value: boolean) => void;
+}
+export type ViewStateChange = ViewStateChangeParameters<MapViewState>;
+export type ViewStateChangeCallback = (id: MapComponentProps['id'], props: MapViewState) => void;
+export interface MapComponentProps extends Omit<DeckGLComponentProps, 'onViewStateChange' | 'layers'> {
+    id: NonNullable<DeckGLComponentProps['id']>;
+    onViewStateChange?: (props: ViewStateChangeParameters<MapViewState>, callback: ViewStateChangeCallback) => void;
+}
+export interface LayersLoadedProps {
+    id: MapComponentProps['id'];
+}
+export interface ZoomControl {
+    id: MapComponentProps['id'];
+    children: (props: ZoomControlChildrenProps) => ReactNode;
+}
+export interface ZoomControlChildrenProps {
+    zoom: MapViewState['zoom'];
+    maxZoom: MapViewState['maxZoom'];
+    minZoom: MapViewState['minZoom'];
+    isLoading: boolean;
+    setZoom: (zoom: Parameters<ViewStateStore['setZoom']>[1]) => void;
+    flyTo: (viewState: MapViewState) => void;
+}

package/dist/types/use-get-layers.d.ts

@@ -0,0 +1,4 @@
+import { MapComponentProps } from './types';
+export declare function useGetLayers({ id }: {
+    id: MapComponentProps['id'];
+}): import('.').Layer[];

package/dist/types/use-map-screenshot.d.ts

@@ -0,0 +1,8 @@
+import { MapComponentProps } from './types';
+export declare function useMapScreenshot({ mapId, }: {
+    mapId: MapComponentProps['id'];
+}): {
+    takeScreenshot: () => void;
+    isLoading: boolean;
+    screenshot: string | undefined;
+};

package/dist/types/utils/object-to-html/const.d.ts

@@ -0,0 +1,5 @@
+export declare const formatterTypes: {
+    readonly currency: "CURRENCY";
+    readonly default: "DEFAULT";
+    readonly number: "NUMBER";
+};

package/dist/types/utils/object-to-html/object-to-html.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/object-to-html/types.d.ts

@@ -1,10 +1,7 @@
-export declare enum FormatterTypes {
-    CURRENCY = "CURRENCY",
-    DEFAULT = "DEFAULT",
-    NUMBER = "NUMBER"
-}
+import { ValueOf } from 'type-fest';
+import { formatterTypes } from './const';
 export type Format = (value: Value, locale: string) => string;
-export type FormatterType = `${FormatterTypes}` | FormatterTypes;
+export type FormatterType = ValueOf<typeof formatterTypes>;
 export interface Formatter {
     type: FormatterType;
     format: Format;

package/dist/types/zoom-controls.d.ts

@@ -0,0 +1,2 @@
+import { ZoomControl } from './types';
+export declare function ZoomControls({ children, id }: ZoomControl): import('react').ReactNode;