@gis_victory/gismap 2.0.23 → 2.0.25

package/dist/components/MapContainer/index.vue.d.ts

@@ -0,0 +1,344 @@
+import { LayerService, MarkerService } from '../../domain';
+import { MapContext } from '../../services';
+import { MapAdapter, MapInitOptions } from '../../adapters';
+interface Props {
+    adapter?: MapAdapter;
+    accessToken?: string;
+    tdtToken?: string;
+    options?: Partial<MapInitOptions>;
+    center?: [number, number];
+    zoom?: number;
+    pitch?: number;
+    bearing?: number;
+    initIcons?: Array<{
+        name: string;
+        url: string;
+    }>;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'top-left'?(_: {}): any;
+        'top-right'?(_: {}): any;
+        'bottom-left'?(_: {}): any;
+        'bottom-right'?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+        mapContainerRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    context: () => {
+        readonly adapter: {
+            getMap: () => any;
+            initialize: (container: HTMLElement, options: MapInitOptions) => Promise<void>;
+            dispose: () => void;
+            setView: (center: [number, number], zoom: number, options?: import('../../adapters').ViewOptions) => void;
+            flyTo: (center: [number, number], options?: import('../../adapters').FlyToOptions) => void;
+            fitBounds: (bounds: [[number, number], [number, number]], options?: import('../../adapters').FitBoundsOptions) => void;
+            getViewState: () => import('../../adapters').MapViewState;
+            addMarker: (id: string, options: import('../../adapters').MarkerOptions) => any;
+            removeMarker: (id: string) => void;
+            updateMarkerPosition: (id: string, position: [number, number]) => void;
+            addPopup: (id: string, options: import('../../adapters').PopupOptions) => any;
+            removePopup: (id: string) => void;
+            onViewChange: (callback: (view: import('../../adapters').MapViewState) => void) => void;
+            onClick: (callback: (event: import('../../adapters').MapClickEvent) => void) => void;
+            onLoad: (callback: () => void) => void;
+            onError: (callback: (error: Error) => void) => void;
+            queryFeatures: (point: [number, number], options?: import('../../adapters').QueryOptions) => any[];
+            queryRenderedFeatures: (geometry: [number, number] | [[number, number], [number, number]], options?: import('../../adapters').QueryOptions) => any[];
+        };
+        readonly events: {
+            on: <K extends keyof import('../../core').CoreMapEvents>(event: K, handler: import('../../core').EventHandler<import('../../core').CoreMapEvents[K]>) => import('../../core').Unsubscribe;
+            once: <K extends keyof import('../../core').CoreMapEvents>(event: K, handler: import('../../core').EventHandler<import('../../core').CoreMapEvents[K]>) => import('../../core').Unsubscribe;
+            emit: <K extends keyof import('../../core').CoreMapEvents>(event: K, payload: import('../../core').CoreMapEvents[K]) => void;
+            off: <K extends keyof import('../../core').CoreMapEvents>(event?: K | undefined, handler?: import('../../core').EventHandler<import('../../core').CoreMapEvents[K]> | undefined) => void;
+            listenerCount: <K extends keyof import('../../core').CoreMapEvents>(event: K) => number;
+            hasListeners: <K extends keyof import('../../core').CoreMapEvents>(event?: K | undefined) => boolean;
+            clearHistory: () => void;
+            getHistory: () => import('../../core').EventHistoryItem[];
+            dispose: () => void;
+        };
+        readonly state: {
+            getState: () => import('../../core').MapState;
+            get: <K extends keyof import('../../core').MapState>(key: K) => import('../../core').MapState[K];
+            setState: (partial: Partial<import('../../core').MapState>) => void;
+            set: <K extends keyof import('../../core').MapState>(key: K, value: import('../../core').MapState[K]) => void;
+            subscribe: (listener: import('../../core').StateListener<import('../../core').MapState>) => () => void;
+            subscribeKey: <K extends keyof import('../../core').MapState>(key: K, listener: (value: import('../../core').MapState[K], prevValue: import('../../core').MapState[K]) => void) => () => void;
+            select: <R>(selector: import('../../core').StateSelector<import('../../core').MapState, R>) => R;
+            reset: () => void;
+            dispose: () => void;
+        };
+        readonly container?: {
+            register: <T>(token: import('../../core').Token<T>, provider: import('../../core').Provider<T>) => import('../../core').IContainer;
+            resolve: <T>(token: import('../../core').Token<T>) => T;
+            has: <T>(token: import('../../core').Token<T>) => boolean;
+            createScope: () => import('../../core').IContainer;
+            dispose: () => void;
+        } | undefined;
+        readonly tdtToken?: string | undefined;
+        readonly initIcons?: {
+            name: string;
+            url: string;
+        }[] | undefined;
+        readonly measureOptions?: {
+            sourceId?: string | undefined;
+            pointColor?: string | undefined;
+            lineColor?: string | undefined;
+            polygonColor?: string | undefined;
+            textColor?: string | undefined;
+            coordinateType?: import('../../manager/mapbox/MeasureManager').CoordinateType | undefined;
+            lnglatDecimal?: number | undefined;
+            mercatorDecimal?: number | undefined;
+            distanceUnit?: import('../../manager/mapbox/MeasureManager').DistanceUnit | undefined;
+            areaUnit?: import('../../manager/mapbox/MeasureManager').AreaUnit | undefined;
+        } | undefined;
+        readonly layers: {
+            initialize: () => void;
+            dispose: () => void;
+            addLayer: (config: import('../../domain').LayerConfig, beforeId?: string) => import('../../domain').LayerEntity;
+            removeLayer: (layerId: import('../../domain').EntityId) => boolean;
+            getLayer: (layerId: import('../../domain').EntityId) => import('../../domain').LayerEntity | undefined;
+            getLayers: () => import('../../domain').LayerEntity[];
+            hasLayer: (layerId: import('../../domain').EntityId) => boolean;
+            updateLayer: (layerId: import('../../domain').EntityId, updates: Partial<import('../../domain').LayerConfig>) => import('../../domain').LayerEntity;
+            showLayer: (layerId: import('../../domain').EntityId) => void;
+            hideLayer: (layerId: import('../../domain').EntityId) => void;
+            toggleLayer: (layerId: import('../../domain').EntityId) => boolean;
+            setLayerOpacity: (layerId: import('../../domain').EntityId, opacity: number) => void;
+            createGroup: (name: string, id?: import('../../domain').EntityId) => import('../../domain').LayerGroup;
+            getGroup: (groupId: import('../../domain').EntityId) => import('../../domain').LayerGroup | undefined;
+            removeGroup: (groupId: import('../../domain').EntityId) => boolean;
+            addLayerToGroup: (layerId: import('../../domain').EntityId, groupId: import('../../domain').EntityId) => void;
+            registerSource: (source: import('../../domain').SourceConfig) => void;
+            addSource: (source: import('../../domain').SourceConfig) => void;
+            getSource: (sourceId: import('../../domain').EntityId) => import('../../domain').SourceConfig | undefined;
+            removeSource: (sourceId: import('../../domain').EntityId) => boolean;
+            moveLayer: (layerId: import('../../domain').EntityId, beforeId?: string) => void;
+            getLayerOrder: () => import('../../domain').EntityId[];
+            getLayersByType: (type: string) => import('../../domain').LayerEntity[];
+            getVisibleLayers: () => import('../../domain').LayerEntity[];
+            getQueryableLayers: () => import('../../domain').LayerEntity[];
+            showAll: () => void;
+            hideAll: () => void;
+            removeAll: () => void;
+        };
+        readonly markers: {
+            initialize: () => void;
+            dispose: () => void;
+            addMarker: (config: import('../../domain').MarkerConfig) => import('../../domain').MarkerEntity;
+            removeMarker: (markerId: import('../../domain').EntityId) => boolean;
+            getMarker: (markerId: import('../../domain').EntityId) => import('../../domain').MarkerEntity | undefined;
+            getMarkers: () => import('../../domain').MarkerEntity[];
+            hasMarker: (markerId: import('../../domain').EntityId) => boolean;
+            updateMarker: (markerId: import('../../domain').EntityId, updates: Partial<import('../../domain').MarkerConfig>) => import('../../domain').MarkerEntity;
+            setPosition: (markerId: import('../../domain').EntityId, position: [number, number]) => void;
+            moveMarker: (markerId: import('../../domain').EntityId, position: [number, number], _animate?: boolean) => void;
+            showMarker: (markerId: import('../../domain').EntityId) => void;
+            hideMarker: (markerId: import('../../domain').EntityId) => void;
+            toggleMarker: (markerId: import('../../domain').EntityId) => boolean;
+            openPopup: (markerId: import('../../domain').EntityId) => void;
+            closePopup: (markerId: import('../../domain').EntityId) => void;
+            togglePopup: (markerId: import('../../domain').EntityId) => boolean;
+            setDraggable: (markerId: import('../../domain').EntityId, draggable: boolean) => void;
+            startDrag: (markerId: import('../../domain').EntityId) => void;
+            endDrag: (markerId: import('../../domain').EntityId) => void;
+            showAll: () => void;
+            hideAll: () => void;
+            removeAll: () => void;
+            getMarkersInBounds: (bounds: [[number, number], [number, number]]) => import('../../domain').MarkerEntity[];
+        };
+        readonly tdtManager: {
+            addImgLayer: (sourceConfig?: any, beforeId?: string) => void;
+            removeImgLayer: () => void;
+            addVecLayer: (sourceConfig?: any, beforeId?: string) => void;
+            removeVecLayer: () => void;
+            addCiaLayer: (sourceConfig?: any, beforeId?: string) => void;
+            removeCiaLayer: () => void;
+            clear: () => void;
+            show: () => void;
+            hideAll: () => void;
+            hide: (layerId: string) => void;
+        } | undefined;
+        readonly terrainManager: {
+            addSource: (options: {
+                tiles: string[];
+                minzoom?: number;
+                maxzoom?: number;
+                tileSize?: number;
+                [key: string]: any;
+            }) => import('../../manager/TerrainManager').default;
+            add: (options?: {
+                source?: any;
+                layer?: {
+                    exaggeration?: number;
+                    [key: string]: any;
+                };
+            }) => import('../../manager/TerrainManager').default;
+            remove: () => import('../../manager/TerrainManager').default;
+            addHillshade: () => import('../../manager/TerrainManager').default;
+            removeHillshade: () => import('../../manager/TerrainManager').default;
+            show: (options?: Parameters<import('../../manager/TerrainManager').default["add"]>[0]) => import('../../manager/TerrainManager').default;
+            hide: () => import('../../manager/TerrainManager').default;
+        } | undefined;
+        readonly radarManager: {
+            add: (options: import('../../manager/RadarManager').RadarOptions) => import('../..').RadarManager;
+            startScan: () => import('../..').RadarManager;
+            stopScan: () => import('../..').RadarManager;
+            remove: () => void;
+        } | undefined;
+        readonly iconManager: {
+            load: (icons: import('../../manager/IconManager').IconConfig[]) => Promise<void>;
+        } | undefined;
+        readonly placeholderManager: {
+            addLayer: (options?: {
+                beforeLayerPointId?: string;
+                beforeLayerLineId?: string;
+                beforeLayerFillId?: string;
+                beforeMaskLayerId?: string;
+            }) => void;
+        } | undefined;
+        readonly drawManager: {
+            startDraw: (type: import('../../manager/mapbox/DrawManager').DrawType, callback?: import('../../manager/mapbox/DrawManager').DrawCallback) => void;
+            stopDraw: () => void;
+            clearDrawing: () => void;
+            getAllFeatures: () => import('../../manager/mapbox/DrawManager').DrawFeature[];
+            getGeoJSON: () => GeoJSON.FeatureCollection;
+            getFeature: (id: string) => import('../../manager/mapbox/DrawManager').DrawFeature | undefined;
+            deleteFeature: (id: string) => boolean;
+            deleteAllFeatures: () => void;
+            getFeatureCount: () => number;
+            selectFeature: (id: string) => import('../../manager/mapbox/DrawManager').DrawFeature | null;
+            clearSelection: () => void;
+            getSelectedFeature: () => import('../../manager/mapbox/DrawManager').DrawFeature | null;
+            getSelectedId: () => string | null;
+            hasSelection: () => boolean;
+            getIsDrawing: () => boolean;
+            getDrawType: () => import('../../manager/mapbox/DrawManager').DrawType | "none";
+            onDraw: (callback: import('../../manager/mapbox/DrawManager').DrawCallback) => void;
+            onSelect: (callback: import('../../manager/mapbox/DrawManager').SelectCallback) => void;
+            destroy: () => void;
+        } | undefined;
+        readonly measureManager: {
+            startMeasure: (type: import('../../manager/mapbox/MeasureManager').MeasureType, callback?: import('../../manager/mapbox/MeasureManager').MeasureCallback) => void;
+            stopMeasure: () => void;
+            clearMeasuring: () => void;
+            getAllResults: () => import('../../manager/mapbox/MeasureManager').MeasureResult[];
+            getResult: (id: string) => import('../../manager/mapbox/MeasureManager').MeasureResult | undefined;
+            deleteResult: (id: string) => boolean;
+            clearAllResults: () => void;
+            getResultCount: () => number;
+            getIsMeasuring: () => boolean;
+            getMeasureType: () => import('../../manager/mapbox/MeasureManager').MeasureType;
+            updateOptions: (options: Partial<import('../../manager/mapbox/MeasureManager').MeasureManagerOptions>) => void;
+            destroy: () => void;
+        } | undefined;
+        readonly layerManager: {
+            queryLayerIds: string[];
+            addSource: (source: any) => void;
+            addLayer: (layerConfig: any, beforeLayerId?: string) => import('../..').LayerManager;
+            addGroupLayer: (layer: any) => void;
+            removeLayer: (layer: any) => void;
+            removeGroupLayer: (layer: any) => void;
+            getCheckedLayers: () => any[];
+            getLayer: (id: string) => any;
+            readonly name: string;
+            readonly isInitialized: boolean;
+            readonly isEnabled: boolean;
+            initialize: () => void;
+            dispose: () => void;
+            enable: () => void;
+            disable: () => void;
+            reset: () => void;
+        } | undefined;
+        readonly templateManager: {
+            initialize: (templateItems: import('../../types/ITemplate').TemplateItem[]) => void;
+            getTemplate: (templateId: string) => import('../../types/ITemplate').TemplateItem | undefined;
+            addTemplate: (templateId: string, template: import('../../types/ITemplate').TemplateItem) => void;
+            removeTemplate: (templateId: string) => void;
+            updateTemplate: (templateId: string, template: import('../../types/ITemplate').TemplateItem) => void;
+            getAllTemplates: () => Map<string, import('../../types/ITemplate').TemplateItem>;
+            getTemplateIds: () => string[];
+            hasTemplate: (templateId: string) => boolean;
+            clear: () => void;
+        } | undefined;
+        initialize: (services: {
+            layerService: LayerService;
+            markerService: MarkerService;
+        }) => void;
+        dispose: () => void;
+        getMap: () => any;
+        setView: (center: [number, number], zoom: number, options?: {
+            bearing?: number;
+            pitch?: number;
+            animate?: boolean;
+        }) => void;
+        flyTo: (center: [number, number], options?: {
+            zoom?: number;
+            duration?: number;
+        }) => void;
+        fitBounds: (bounds: [[number, number], [number, number]], options?: {
+            padding?: number;
+        }) => void;
+        getViewState: () => import('../../core').ViewState;
+        readonly isReady: boolean;
+        on: <K extends keyof import('../../core').CoreMapEvents>(event: K, handler: (payload: import('../../core').CoreMapEvents[K]) => void) => () => void;
+        once: <K extends keyof import('../../core').CoreMapEvents>(event: K, handler: (payload: import('../../core').CoreMapEvents[K]) => void) => () => void;
+    } | null;
+    map: () => any;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    ready: (context: MapContext) => any;
+    click: (event: {
+        coordinates: [number, number];
+        feature?: any;
+    }) => any;
+    load: (context: MapContext) => any;
+    viewChange: (view: {
+        center: [number, number];
+        zoom: number;
+        pitch: number;
+        bearing: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onReady?: ((context: MapContext) => any) | undefined;
+    onClick?: ((event: {
+        coordinates: [number, number];
+        feature?: any;
+    }) => any) | undefined;
+    onLoad?: ((context: MapContext) => any) | undefined;
+    onViewChange?: ((view: {
+        center: [number, number];
+        zoom: number;
+        pitch: number;
+        bearing: number;
+    }) => any) | undefined;
+}>, {
+    center: [number, number];
+    zoom: number;
+    bearing: number;
+    pitch: number;
+    accessToken: string;
+    adapter: MapAdapter;
+    tdtToken: string;
+    initIcons: Array<{
+        name: string;
+        url: string;
+    }>;
+    options: Partial<MapInitOptions>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    mapContainerRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MapLayer/components/CustomLayerDialog.vue.d.ts

@@ -0,0 +1,22 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:visible": (value: boolean) => any;
+    create: (layer: any) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onCreate?: ((layer: any) => any) | undefined;
+}>, {
+    visible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    formRef: unknown;
+}, any>;
+export default _default;