@gis_victory/gismap 2.0.25 → 2.0.26

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

@@ -1,344 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;