@wwsy/cesium 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -0,0 +1,747 @@
+import { Camera } from 'cesium';
+import * as Cesium from 'cesium';
+import { Clock } from 'cesium';
+import { Event as Event_3 } from 'cesium';
+import { Scene } from 'cesium';
+
+declare class AmapImageryProvider extends Cesium.UrlTemplateImageryProvider {
+    constructor(options: imageryProviderOptions);
+}
+
+/**
+ * 基础覆盖物、图层
+ * **/
+declare class BaseEntityLayer {
+    private _entityName;
+    private _customId;
+    private _customData;
+    private _bVisible;
+    private _bLocked;
+    protected _data: any;
+    constructor(data: BasicEntityLayerType);
+    _setBasic(): void;
+    get entityName(): string;
+    set entityName(value: string);
+    GetEntityName(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetEntityName(value: string): void;
+    get customId(): string;
+    set customId(value: string);
+    GetCustomId(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetCustomId(value: string): void;
+    get customData(): Record<string, any>;
+    set customData(value: Record<string, any>);
+    GetCustomData(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetCustomData(value: Record<string, any>): void;
+    get bVisible(): boolean;
+    set bVisible(value: boolean);
+    protected _visibleHook(value: boolean): void;
+    GetVisible(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetVisible(value: boolean): void;
+    get bLocked(): boolean;
+    set bLocked(value: boolean);
+    GetLocked(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetLocked(value: boolean): void;
+    Update(data: any): void;
+    protected _updateHook(): void;
+}
+
+declare interface BaseImageryLayer {
+    id: string;
+    layers: Cesium.ImageryLayer[];
+    cache: Cesium.ImageryLayer[];
+    options: Cesium.ImageryLayer.ConstructorOptions & {
+        name: string;
+        iconUrl?: string;
+    };
+}
+
+declare type BasicEntityLayerType = Partial<BasicInfoAtomType> & Partial<VisibleAtomType> & Partial<EntityFlagAtomType>;
+
+/**
+ * @interface BasicInfoAtomType
+ * @param {string} entityName
+ * @param {string} customId
+ * @param {any} customData
+ * @param {string} parentEid
+ */
+declare interface BasicInfoAtomType {
+    entityName: string;
+    customId: string;
+    customData: any;
+    parentEid: string;
+}
+
+declare interface CameraBase {
+    location: number[];
+    locationLimit: number[][];
+    rotation: {
+        pitch: number;
+        yaw: number;
+    };
+    pitchLimit: number[];
+    yawLimit: number[];
+    viewDistanceLimit: number[];
+    fieldOfView: number;
+}
+
+declare class CameraControl {
+    private _options;
+    private _viewer;
+    private _animationInstance;
+    constructor(viewer: Viewer);
+    private _CameraChange;
+    ToggleCameraSelfRotate(enable: boolean): void;
+    GetCameraPose(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetCameraPose(options: CameraPoseData): void;
+    ResetCameraPose(): void;
+    GetCameraLimit(): void;
+    SetCameraLimit(): void;
+    SetCameraLockLimit(): void;
+    ResetCameraLimit(): void;
+    SetCameraSpeed(): void;
+    GetCameraSpeed(): void;
+    SetCameraAnimation(): void;
+    GetCameraAnimation(): void;
+    GetCameraInfo(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    UpdateCamera(options: CameraBase & CameraPoseData): void;
+    Move(): void;
+    Rotate(): void;
+    Around(): void;
+    Stop(): void;
+    CameraStepMove(): void;
+    CameraStepRotate(): void;
+    CameraStepZoom(): void;
+    StopCameraStepUpdate(): void;
+    FlyTo(options: CameraFlytoData): void;
+    FocusToNodes(): void;
+    Focus(): void;
+    FocusToAll(options?: {
+        types: string[];
+        bFilterForExclude: boolean;
+    }): void;
+    Follow(): void;
+    PlayRoam(): void;
+    StopRoam(): void;
+    GetCameraRoamingInfo(): void;
+}
+
+declare interface CameraFlytoData extends Pick<CameraBase, 'rotation'> {
+    targetPosition: number[];
+    flyTime: number;
+}
+
+declare interface CameraPoseData extends Pick<CameraBase, 'location' | 'rotation'> {
+    flyTime: number;
+}
+
+declare class CameraRoam {
+    constructor();
+}
+
+/**
+ * @type {Coord2DType}
+ * @alias Array<number>
+ */
+declare type Coord2DType = Array<number>;
+
+declare class Coordinate {
+    private _viewer;
+    get Picker(): {
+        PickWorldPointByScreenPos: any;
+    };
+    constructor(viewer: any);
+    GISToCartesian(coord: CoordType[]): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    CartesianToGIS(coord: CoordType[]): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    GISToScreenPos(coord: CoordType[]): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    PickWorldPointByScreenPos(position: number[]): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    CreateCADGeoRef(): void;
+    LocalToGlobalGeoRef(): void;
+    Exchange(): void;
+}
+
+declare type CoordType = Array<number>;
+
+/**
+ * @type {CoordType}
+ * @alias Array<number>
+ */
+declare type CoordType_2 = Array<number>;
+
+/**
+ * @type {CoordZRefType}
+ * @alias 'surface'|'ground'|'altitude'
+ */
+declare type CoordZRefType = 'surface' | 'ground' | 'altitude';
+
+/**
+ * @type {deepPartial<T>}
+ */
+declare type deepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? deepPartial<T[K]> : T[K];
+};
+
+declare interface EntityDrillAtomType {
+    allowDrillPicking: boolean;
+}
+
+/**
+ * @interface EntityEidType
+ * @param {string | null} eid (optional)
+ */
+declare interface EntityEidType {
+    eid?: string | null;
+}
+
+/**
+ * @interface EntityFlagAtomType
+ * @param {boolean} bLocked
+ */
+declare interface EntityFlagAtomType {
+    bLocked: boolean;
+}
+
+/**
+ * @interface EntityOutlinerAtomType
+ * @param {string} index
+ */
+declare interface EntityOutlinerAtomType {
+    index: string;
+}
+
+declare class Event_2 {
+    _types: {
+        [key: string]: any;
+    };
+    _cache: {
+        [key: string]: Cesium.Event;
+    };
+    constructor(types?: {
+        [key: string]: any;
+    });
+    on(type: any, callback: any, context?: any): Cesium.Event.RemoveCallback | undefined;
+    once(type: any, callback: any, context?: any): void;
+    off(type: any, callback: any, context?: any): boolean;
+    emit(type: any, ...args: any[]): void;
+    _registerEvent(): void;
+    getEvent(type: string): Cesium.Event | undefined;
+}
+
+declare class GroundSkyBox extends SkyBox_2 {
+    constructor(options?: any);
+    update(frameState: any, useHdr: any): any;
+}
+
+/**
+ * @interface ICalculateCoordZ
+ * @param {CoordZRefType} coordZRef
+ * @param {number} coordZOffset
+ */
+declare interface ICalculateCoordZ {
+    coordZRef: CoordZRefType;
+    coordZOffset: number;
+}
+
+/**
+ * @interface ICamera
+ * @param {number} hideDistance
+ * @param {string} hideType
+ * @param {string} scaleMode
+ */
+declare interface ICamera {
+    hideDistance: number;
+    hideType: string;
+    scaleMode: string;
+    url?: string;
+    size?: Array<number>;
+}
+
+/**
+ * @interface IEntity
+ * @param {number} overlapOrder
+ */
+declare interface IEntity {
+    overlapOrder: number;
+}
+
+/**
+ * @interface IInteraction
+ * @param {boolean} clickTop
+ * @param {boolean} hoverTop
+ */
+declare interface IInteraction {
+    clickTop: boolean;
+    hoverTop: boolean;
+}
+
+declare class ImageryProvider {
+    static createAmapImageryProvider(options: imageryProviderOptions): Promise<AmapImageryProvider>;
+    static createTianDiTuImageryProvider(options: imageryProviderOptions): Promise<TianDiTuImageryProvider>;
+    static createImageryProvider(type: string, options: imageryProviderOptions): Promise<AmapImageryProvider>;
+}
+
+declare interface imageryProviderOptions extends Partial<Cesium.UrlTemplateImageryProvider.ConstructorOptions> {
+    style: imageryProviderStyle;
+    key?: string;
+}
+
+/**
+ * 地图图层类型
+ * - VECTOR: 矢量图层
+ * - RASTER: 影像图层
+ * - TOPOGRAPHY: 地形图层
+ */
+declare type imageryProviderStyle = 'vector' | 'raster' | 'topography' | 'vectorMark' | 'rasterMark' | 'topographyMark';
+
+/**
+ * @interface IOperations
+ * @param {ICalculateCoordZ} calculateCoordZ
+ */
+declare interface IOperations {
+    calculateCoordZ: ICalculateCoordZ;
+}
+
+declare type layerSource = 'gaode' | 'tianditu';
+
+declare class MapSwitch extends Widget {
+    private _cache;
+    private _config;
+    constructor(viewer: Viewer);
+    _installHook(): void;
+    _addItem(map: BaseImageryLayer['options']): void;
+    addMap(map: BaseImageryLayer['options']): void;
+}
+
+/**
+ * @type {MinMaxType}
+ * @alias Array<number>
+ */
+declare type MinMaxType = Array<number>;
+
+declare class Overlay extends BaseEntityLayer {
+    private _eid;
+    protected oType: string;
+    protected type: string;
+    private _state;
+    private _bRemoved;
+    private _allowDrillPicking;
+    private _overlayEvent;
+    private _layer;
+    private _operations;
+    protected layerType: string;
+    _delegate: any;
+    constructor(data: BasicEntityLayerType & Partial<EntityDrillAtomType>);
+    get EntityType(): string;
+    get Eid(): string;
+    get overlayEvent(): OverlayEvent;
+    private _getLayerCollection;
+    protected _mountedHook(): void;
+    private _onAdd;
+    protected _addedHook(): void;
+    private _onRemove;
+    protected _removedHook(): void;
+    Delete(): void;
+    emit(type: any, ...params: any[]): void;
+    onClick(callback: any, context?: any): void;
+    onMouseEnter(callback: any, context?: any): void;
+    onMouseLeave(callback: any, context?: any): void;
+    protected _visibleHook(visible: any): void;
+    protected _getCalculateCoordZ(): {
+        reference: Cesium.HeightReference;
+        height: number;
+    };
+}
+
+declare class OverlayEvent extends Event_2 {
+    constructor();
+}
+
+declare class Poi extends Overlay {
+    private _styleCache;
+    private _bHover;
+    constructor(data: PoiType);
+    _mountedHook(): void;
+    updateStyle(): Promise<void>;
+    private applyBillboard;
+    _renderBillboard(poiStyle?: Partial<PoiEntityAtomType>): Promise<{
+        image?: undefined;
+        pixelOffset?: undefined;
+        horizontalOrigin?: undefined;
+        verticalOrigin?: undefined;
+    } | {
+        image: string;
+        pixelOffset: Cesium.Cartesian2;
+        horizontalOrigin: Cesium.HorizontalOrigin;
+        verticalOrigin: Cesium.VerticalOrigin;
+    }>;
+    computeLayout(poiStyle?: Partial<PoiEntityAtomType>): {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker?: undefined;
+        label?: undefined;
+        text?: undefined;
+    } | {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        label: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        text: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+    };
+    getClientHeightWidth(poiStyle?: Partial<PoiEntityAtomType>): {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker?: undefined;
+        label?: undefined;
+        text?: undefined;
+    } | {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        label: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        text: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+    };
+    _updateHook(): void;
+}
+
+declare interface PoiEntityAtomType {
+    markerVisible: boolean;
+    markerNormalUrl: string;
+    markerActivateUrl: string;
+    markerSize: MinMaxType;
+    labelVisible: boolean;
+    labelBgImageUrl: string;
+    labelBgSize: MinMaxType;
+    labelBgOffset: Coord2DType;
+    labelContent: Array<string>;
+    labelContentOffset: Coord2DType;
+    labelTop: boolean;
+    scrollSpeed: number;
+    textBoxWidth: number;
+    labelContentJustification: Tjustification;
+    labelContentAutoWrap: boolean;
+    scrollPolicy: TscrollPolicy;
+}
+
+declare interface PoiType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtom2DType>, Partial<VisibleAtomType>, Partial<EntityFlagAtomType>, Partial<EntityOutlinerAtomType> {
+    poiStyle?: Partial<PoiEntityAtomType>;
+    visible2D?: deepPartial<Visible2DAtomType>;
+}
+
+declare interface RegisterEvent {
+    name: any;
+    func: (...args: any) => void;
+}
+
+declare class Renderer {
+    private _rendererEvent;
+    private _viewer;
+    private _removeEventsCache;
+    constructor(viewer: Viewer);
+    Stop(): void;
+    RegisterEvent(events: RegisterEvent[]): void;
+    RegisterSceneEvent(events: RegisterEvent[]): void;
+    RegisterErrorEvent(events: RegisterEvent[]): void;
+    UnRegisterEvent(data: string[]): void;
+    UnRegisterSceneEvent(data: string[]): void;
+    UnRegisterErrorEvent(data: string[]): void;
+    emit(eventName: string, ...args: any): void;
+}
+
+declare class Scene_2 {
+    private _viewer;
+    private _entitys;
+    private _layers;
+    get entitys(): any[];
+    get layers(): any[];
+    constructor(viewer: Viewer);
+    Add(entity: any, operations?: IOperations): void;
+    Update(): void;
+    Updates(): void;
+    Create(): void;
+    Creates(): void;
+    GetAll(): void;
+    GetLayers(): any[];
+    GetByEids(eids: string[]): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    GetByEntityName(): void;
+    GetByCustomId(): void;
+    GetByTypes(): void;
+    Delete(): void;
+    _DeleteCache(id: string): void;
+    ClearByTypes(): void;
+    ClearByObjects(): void;
+    ClearByEids(): void;
+    ClearByCustomId(): void;
+    ClearByEntityName(): void;
+    UpdateByCustomId(): void;
+    UpdateByCustomIds(): void;
+    UpdateByEntityName(): void;
+    UpdateByEntityNames(): void;
+    SetVisibleByObjects(): void;
+    SetVisible(): void;
+    SetLocation(): void;
+    SetLocations(): void;
+    SetRotator(): void;
+    SetRotators(): void;
+    SetScale3D(): void;
+    SetScale3Ds(): void;
+    SetLocked(): void;
+    GetBound(): void;
+}
+
+declare class SceneEvent extends Event_2 {
+    _camera: Camera;
+    _scene: Scene;
+    _clock: Clock;
+    constructor(viewer: Viewer);
+    on(type: any, callback: any, context?: any): Event_3.RemoveCallback | undefined;
+    off(type: any, callback: any, context?: any): boolean;
+}
+
+declare class SkyBox {
+    private _defaultSkyBox;
+    private _groundSkyBox;
+    private _height;
+    private _viewer;
+    constructor(viewer: Viewer);
+    /**
+     * 创建近地天空盒
+     * @param options 近地天空盒参数
+     * @returns 近地天空盒实例
+     */
+    GroundSkyBox(options: ConstructorParameters<typeof GroundSkyBox>[0] & {
+        offsetAngle?: number;
+    }): void;
+    /**
+     * 设置默认天空盒
+     */
+    Default(options: ConstructorParameters<typeof Cesium.SkyBox>[0]): void;
+    /**
+     * 重置天空盒为默认值
+     */
+    Reset(): void;
+    _SetSkyBox(skyBox: Cesium.SkyBox, skyAtmosphere: boolean): void;
+    EventListener(): void;
+}
+
+declare const SkyBox_2: any;
+
+declare class Terrain {
+    private _scene;
+    constructor(scene: Cesium.Scene);
+    createEllipsoidTerrain(options?: ConstructorParameters<typeof Cesium.EllipsoidTerrainProvider>[0]): Promise<Cesium.EllipsoidTerrainProvider>;
+    createWorldTerrain(options?: Parameters<typeof Cesium.Terrain.fromWorldTerrain>[0]): Cesium.Terrain;
+    createUrlTerrain(options?: Cesium.CesiumTerrainProvider.ConstructorOptions & {
+        url: string;
+    }): Promise<Cesium.CesiumTerrainProvider>;
+    createGoogleTerrain(options?: Cesium.GoogleEarthEnterpriseTerrainProvider.ConstructorOptions): Promise<Cesium.GoogleEarthEnterpriseTerrainProvider>;
+    createArcgisTerrain(options: any): Promise<Cesium.ArcGISTiledElevationTerrainProvider>;
+    createTerrain(type: any, options?: any): Promise<Cesium.CesiumTerrainProvider> | Cesium.Terrain;
+    setTerrain(terrain?: Cesium.Terrain | Promise<Cesium.TerrainProvider>): void;
+}
+
+declare class TianDiTuImageryProvider extends Cesium.UrlTemplateImageryProvider {
+    constructor(options: imageryProviderOptions);
+}
+
+declare type Tjustification = 'Left' | 'Center' | 'Right';
+
+declare class Tools {
+    private _coordinate;
+    constructor(viewer: any);
+    get Coordinate(): Coordinate;
+}
+
+/**
+ * @interface TransformAtom2DType
+ * @param {CoordType} location
+ */
+declare interface TransformAtom2DType {
+    location: CoordType_2;
+}
+
+declare type TscrollPolicy = 'default' | 'always';
+
+declare class Viewer {
+    private _delegate;
+    private _baseLayerPicker;
+    private _widgetContainer;
+    private _widgets;
+    private _skyBox;
+    private _renderer;
+    private _sceneEvent;
+    private _viewerEvent;
+    private _mouseEvent;
+    private _terrain;
+    private _scene;
+    private _cameraControl;
+    private _tools;
+    ImageryProvider: typeof ImageryProvider;
+    CameraRoam: typeof CameraRoam;
+    get delegate(): Cesium.CesiumWidget;
+    get clock(): Cesium.Clock;
+    get scene(): Cesium.Scene;
+    get camera(): Cesium.Camera;
+    get dataSources(): Cesium.DataSourceCollection;
+    get canvas(): HTMLCanvasElement;
+    get widgetContainer(): HTMLElement;
+    get widgets(): {
+        mapSwitch: MapSwitch;
+    };
+    get skyBox(): SkyBox;
+    get Renderer(): Renderer;
+    get viewerEvent(): ViewerEvent;
+    get sceneEvent(): SceneEvent;
+    get Terrain(): Terrain;
+    get Scene(): Scene_2;
+    get CameraControl(): CameraControl;
+    get Tools(): Tools;
+    get imageryLayers(): Cesium.ImageryLayerCollection;
+    get Poi(): typeof Poi;
+    constructor(options: WWSYCesiumType);
+    private init;
+    destroy(): void;
+    addBaseLayer(baseLayer: Cesium.ImageryLayer | Cesium.ImageryLayer[], options: BaseImageryLayer['options']): this;
+    changeBaseLayer(index: number): void;
+}
+export default Viewer;
+
+declare class ViewerEvent extends Event_2 {
+    constructor();
+}
+
+/**
+ * @interface Visible2DAtomType
+ * @param {ICamera} camera
+ * @param {IInteraction} interaction
+ * @param {IEntity} entity
+ */
+declare interface Visible2DAtomType {
+    camera: ICamera;
+    interaction: IInteraction;
+    entity: IEntity;
+}
+
+/**
+ * @interface VisibleAtomType
+ * @param {boolean} bVisible
+ */
+declare interface VisibleAtomType {
+    bVisible: boolean;
+}
+
+declare class Widget {
+    _enable: boolean;
+    _wrapper: HTMLElement | undefined;
+    _ready: boolean;
+    _viewer: Viewer;
+    constructor(viewer: Viewer);
+    Start(): void;
+    End(): void;
+    hide(): void;
+}
+
+declare interface WWSYCesiumType {
+    target: string;
+    accessToken: string;
+    tiandituKey?: string;
+    layerSource?: layerSource;
+    layerType?: 'vector' | 'raster' | 'topography';
+    layerMark?: boolean;
+    resolution: [number, number];
+    northFixAngle?: number;
+}
+
+export { }