xgis-ol/dist/components/XMapView/index.vue.d.ts

基于openlayers + ol-ext库进行封装

import { PropType } from 'vue';
import { XMap } from '../../core';
import { Projection } from 'ol/proj';
import { ViewOptions } from 'ol/view';
declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    hasLayerTree: {
        type: BooleanConstructor;
        default: boolean;
    };
    viewHeight: {
        type: NumberConstructor;
        isRequired: boolean;
    };
    viewWidth: {
        type: NumberConstructor;
        isRequired: boolean;
    };
    mapid: {
        type: StringConstructor;
        default: string;
    };
    mapgroup: {
        type: StringConstructor;
        default: string;
    };
    viewProjection: {
        type: (ObjectConstructor | StringConstructor)[];
        default: string;
    };
    initTDTLayers: {
        type: PropType<string[]>;
        default: () => string[];
    };
    viewOptions: {
        type: PropType<ViewOptions>;
    };
    multiWorld: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    heightStyle: import('vue').ComputedRef<string>;
    widthStyle: import('vue').ComputedRef<string>;
    layerTreeVisible: import('vue').ComputedRef<boolean>;
    mapInitedHandler: (res: any) => void;
    mapRef: import('vue').Ref<any, any>;
    mainContainStyle: import('vue').ComputedRef<string>;
    hasLayerTreeRef: import('vue').Ref<boolean, boolean>;
    initTDTLayersRef: import('vue').Ref<string[], string[]>;
    viewProjectionRef: import('vue').Ref<string | Projection, string | Projection>;
    doLocation: (x: number, y: number, z: number | undefined) => void;
    measureToolVisible: import('vue').ComputedRef<boolean>;
    drawToolVisible: import('vue').ComputedRef<boolean>;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "mapInited"[], "mapInited", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    hasLayerTree: {
        type: BooleanConstructor;
        default: boolean;
    };
    viewHeight: {
        type: NumberConstructor;
        isRequired: boolean;
    };
    viewWidth: {
        type: NumberConstructor;
        isRequired: boolean;
    };
    mapid: {
        type: StringConstructor;
        default: string;
    };
    mapgroup: {
        type: StringConstructor;
        default: string;
    };
    viewProjection: {
        type: (ObjectConstructor | StringConstructor)[];
        default: string;
    };
    initTDTLayers: {
        type: PropType<string[]>;
        default: () => string[];
    };
    viewOptions: {
        type: PropType<ViewOptions>;
    };
    multiWorld: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onMapInited?: (...args: any[]) => any;
}>, {
    hasLayerTree: boolean;
    mapid: string;
    mapgroup: string;
    initTDTLayers: string[];
    viewProjection: string | Record<string, any>;
    multiWorld: boolean;
}, {}, {
    OLXMap: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        mapid: {
            type: StringConstructor;
            default: string;
        };
        mapgroup: {
            type: StringConstructor;
            default: string;
        };
        hasLayerManager: {
            type: BooleanConstructor;
            default: boolean;
        };
        initTDTLayers: {
            type: PropType<string[]>;
            default: () => string[];
        };
        viewProjection: {
            type: (ObjectConstructor | StringConstructor)[];
            default: string;
        };
        defaultCenter: {
            type: PropType<number[]>;
            default: () => number[];
        };
        viewOptions: {
            type: PropType<ViewOptions>;
        };
        multiWorld: {
            type: BooleanConstructor;
            default: boolean;
        };
        enableContextMenu: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        mapIDRef: import('vue').Ref<string, string>;
        mapContainerRef: import('vue').Ref<string, string>;
        mapRef: import('vue').Ref<XMap, XMap>;
        enableMenuComputed: import('vue').ComputedRef<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "mapInited"[], "mapInited", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        mapid: {
            type: StringConstructor;
            default: string;
        };
        mapgroup: {
            type: StringConstructor;
            default: string;
        };
        hasLayerManager: {
            type: BooleanConstructor;
            default: boolean;
        };
        initTDTLayers: {
            type: PropType<string[]>;
            default: () => string[];
        };
        viewProjection: {
            type: (ObjectConstructor | StringConstructor)[];
            default: string;
        };
        defaultCenter: {
            type: PropType<number[]>;
            default: () => number[];
        };
        viewOptions: {
            type: PropType<ViewOptions>;
        };
        multiWorld: {
            type: BooleanConstructor;
            default: boolean;
        };
        enableContextMenu: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onMapInited?: (...args: any[]) => any;
    }>, {
        mapid: string;
        mapgroup: string;
        hasLayerManager: boolean;
        initTDTLayers: string[];
        viewProjection: string | Record<string, any>;
        defaultCenter: number[];
        multiWorld: boolean;
        enableContextMenu: boolean;
    }, {}, {
        ZoomFullBar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            xmap: {
                type: PropType<XMap>;
            };
            hasLayerTree: {
                type: BooleanConstructor;
                default: boolean;
            };
            isInternet: {
                type: BooleanConstructor;
                default: boolean;
            };
            hasFullScreen: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            isFullScreen: import('vue').Ref<boolean, boolean>;
            toggleMapScreen: () => void;
            fullScreenTip: import('vue').ComputedRef<"退出全屏" | "地图全屏">;
            fullScreenStyle: import('vue').ComputedRef<string>;
            zoomInOut: (isIn?: boolean) => void;
            layerTreeSelected: import('vue').ComputedRef<string>;
            changeLayerTree: () => void;
            hasLayerTreeRef: import('vue').ComputedRef<boolean>;
            isInternetRef: import('vue').ComputedRef<boolean>;
            goHomeView: () => void;
            doGeoLocation: () => void;
            hasFullScreenRef: import('vue').ComputedRef<boolean>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "locate"[], "locate", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            xmap: {
                type: PropType<XMap>;
            };
            hasLayerTree: {
                type: BooleanConstructor;
                default: boolean;
            };
            isInternet: {
                type: BooleanConstructor;
                default: boolean;
            };
            hasFullScreen: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onLocate?: (...args: any[]) => any;
        }>, {
            hasLayerTree: boolean;
            isInternet: boolean;
            hasFullScreen: boolean;
        }, {}, {
            Icon: import('vue').DefineSetupFnComponent<import('@iconify/vue').IconProps, {}, {}, import('@iconify/vue').IconProps, import('vue').PublicProps>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        ContextMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            xmap: {
                type: typeof XMap;
                required: true;
            };
            replace: {
                type: BooleanConstructor;
                default: boolean;
            };
            moreMenuList: {
                type: {
                    (arrayLength: number): import('../..').IMapContextItem[];
                    (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                    new (arrayLength: number): import('../..').IMapContextItem[];
                    new (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                    isArray(arg: any): arg is any[];
                    readonly prototype: any[];
                    from<T>(arrayLike: ArrayLike<T>): T[];
                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                    of<T>(...items: T[]): T[];
                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
                    readonly [Symbol.species]: ArrayConstructor;
                };
                default: any[];
            };
            target: {
                type: (StringConstructor | BooleanConstructor | {
                    new (): Element;
                    prototype: Element;
                })[];
                default: string;
            };
        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            itemClicked: (...args: any[]) => void;
        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            xmap: {
                type: typeof XMap;
                required: true;
            };
            replace: {
                type: BooleanConstructor;
                default: boolean;
            };
            moreMenuList: {
                type: {
                    (arrayLength: number): import('../..').IMapContextItem[];
                    (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                    new (arrayLength: number): import('../..').IMapContextItem[];
                    new (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                    isArray(arg: any): arg is any[];
                    readonly prototype: any[];
                    from<T>(arrayLike: ArrayLike<T>): T[];
                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                    of<T>(...items: T[]): T[];
                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
                    readonly [Symbol.species]: ArrayConstructor;
                };
                default: any[];
            };
            target: {
                type: (StringConstructor | BooleanConstructor | {
                    new (): Element;
                    prototype: Element;
                })[];
                default: string;
            };
        }>> & Readonly<{
            onItemClicked?: (...args: any[]) => any;
        }>, {
            target: string | boolean | Element;
            replace: boolean;
            moreMenuList: import('../..').IMapContextItem[];
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    DrawToolBar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        xmap: typeof XMap;
    }>, {
        changeType: (num: string) => void;
        clearPic: () => void;
        clearboard: () => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        xmap: typeof XMap;
    }>> & Readonly<{}>, {}, {}, {
        Icon: import('vue').DefineSetupFnComponent<import('@iconify/vue').IconProps, {}, {}, import('@iconify/vue').IconProps, import('vue').PublicProps>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    MeasureToolBar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        xmap: typeof XMap;
    }>, {
        measureLine: () => void;
        measureArea: () => void;
        unloadMeasure: () => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        xmap: typeof XMap;
    }>> & Readonly<{}>, {}, {}, {
        Icon: import('vue').DefineSetupFnComponent<import('@iconify/vue').IconProps, {}, {}, import('@iconify/vue').IconProps, import('vue').PublicProps>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    MenuToolBar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        xmap: {
            type: PropType<XMap>;
            required: true;
        };
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        locate: (...args: any[]) => void;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        xmap: {
            type: PropType<XMap>;
            required: true;
        };
    }>> & Readonly<{
        onLocate?: (...args: any[]) => any;
    }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
declare const _default: typeof __VLS_export;
export default _default;