earthsdk3-cesium 3.7.0-beta.15 → 3.7.0-beta.17

package/dist/types/CzmObjects/base/InnerClass/CzmImagery/extends/MVTImageryProviderVector.d.ts

@@ -0,0 +1,72 @@
+import { Credit, Event, WebMercatorTilingScheme, DefaultProxy, GeographicTilingScheme, Resource } from "cesium";
+import { MVTImageryProviderOptions, StyleSpecification } from "./type";
+import { Viewer } from "cesium";
+import { SceneObjectKey } from "earthsdk3";
+import { VectorTilesManager } from "../../../../../ESCesiumViewer/ViewerExtensions/VectorTilesManager";
+declare class MVTImageryProviderVector {
+    viewer?: Viewer;
+    esSceneObjectId?: SceneObjectKey;
+    vectorTileManager?: VectorTilesManager;
+    ready: boolean;
+    readyPromise?: Promise<boolean>;
+    rectangle: any;
+    tileSize: number;
+    tileWidth: number;
+    tileHeight: number;
+    maximumLevel: number;
+    minimumLevel: number;
+    tileDiscardPolicy: undefined;
+    credit: Credit;
+    proxy: DefaultProxy;
+    layerStyle: {
+        [xx: string]: any;
+    }[];
+    hasAlphaChannel: boolean;
+    sourceFilter: any;
+    tilingScheme: WebMercatorTilingScheme | GeographicTilingScheme;
+    private _destroyed;
+    private _error;
+    private _accessToken;
+    private _enablePickFeatures;
+    /**
+     * create a MVTImageryProviderVector Object
+     * @param {MVTImageryProviderOptions} options MVTImageryProviderVector options as follow:
+     * @param {Resource | string | StyleSpecification} options.style - mapbox style object or url Resource.
+     * @param {string} options.accessToken - mapbox style accessToken.
+     * @param {RequestTransformFunction} options.transformRequest - use transformRequest to modify tile requests.
+     * @param {Number} [options.tileSize = 256] - can be 256 or 512. defaults to 256.
+     * @param {Number} [options.maximumLevel = 18] - if cesium zoom level exceeds maximumLevel, layer will be invisible, defaults to 18.
+     * @param {Number} [options.minimumLevel = 0] - if cesium zoom level belows minimumLevel, layer will be invisible, defaults to 0.
+     * @param {Boolean} [options.showCanvas = false] - if show canvas for debug.
+     * @param {Boolean} [options.enablePickFeatures = true] - enable pickFeatures or not, defaults to true.
+     * @param {Function} options.sourceFilter - sourceFilter is used to filter which source participate in pickFeature process.
+     * @param {WebMercatorTilingScheme | GeographicTilingScheme} [options.tilingScheme = WebMercatorTilingScheme] - Cesium tilingScheme, defaults to WebMercatorTilingScheme(EPSG: 3857).
+     * @param {Credit} options.credit - A credit contains data pertaining to how to display attributions/credits for certain content on the screen.
+     * @example
+     * const imageryProvider = new MVTImageryProviderVector({
+          style: 'https://demotiles.maplibre.org/style.json'
+        });
+     */
+    constructor(options: MVTImageryProviderOptions & {
+        /**
+         * Deprecated
+         *
+         * You can use fromUrl instead
+         * @example
+         * const provider = await MVTImageryProviderVector.fromUrl(url)
+         */
+        style: string | Resource | StyleSpecification;
+    });
+    get isDestroyed(): boolean;
+    /**
+     * Gets an event that will be raised if an error is encountered during processing.
+     * @memberof GeoJsonDataSource.prototype
+     * @type {Event}
+     */
+    get errorEvent(): Event<(...args: any[]) => void>;
+    static fromUrl(url: Resource | string | StyleSpecification, options?: MVTImageryProviderOptions): Promise<MVTImageryProviderVector>;
+    requestImage(x: number, y: number, level: number, releaseTile?: boolean): Promise<HTMLImageElement | HTMLCanvasElement | any> | undefined;
+    pickFeatures(x: number, y: number, zoom: number, longitude: number, latitude: number): undefined;
+    destroy(): void;
+}
+export default MVTImageryProviderVector;

package/dist/types/CzmObjects/base/InnerClass/XbsjGroundPolylinePrimitive/GroundPolylinePrimitive.d.ts

@@ -0,0 +1,148 @@
+import * as Cesium from 'cesium';
+
+// declare class GroundPolylinePrimitive extends Destroyable {
+//     constructor()
+// }
+
+type GeometryInstance = Cesium.GeometryInstance;
+type Appearance = Cesium.Appearance;
+type ClassificationType = Cesium.ClassificationType;
+type Scene = Cesium.Scene;
+
+declare class GroundPolylinePrimitive {
+    constructor(options?: {
+        geometryInstances?: any[] | GeometryInstance;
+        appearance?: Appearance;
+        show?: boolean;
+        interleave?: boolean;
+        releaseGeometryInstances?: boolean;
+        allowPicking?: boolean;
+        asynchronous?: boolean;
+        classificationType?: ClassificationType;
+        debugShowBoundingVolume?: boolean;
+        debugShowShadowVolume?: boolean;
+    });
+    /**
+     * The geometry instances rendered with this primitive. This may
+     * be <code>undefined</code> if <code>options.releaseGeometryInstances</code>
+     * is <code>true</code> when the primitive is constructed.
+     * <p>
+     * Changing this property after the primitive is rendered has no effect.
+     * </p>
+     */
+    readonly geometryInstances: any[] | GeometryInstance;
+    /**
+     * The {@link Appearance} used to shade this primitive. Each geometry
+     * instance is shaded with the same appearance.  Some appearances, like
+     * {@link PolylineColorAppearance} allow giving each instance unique
+     * properties.
+     */
+    appearance: Appearance;
+    /**
+     * Determines if the primitive will be shown.  This affects all geometry
+     * instances in the primitive.
+     */
+    show: boolean;
+    /**
+     * Determines whether terrain, 3D Tiles or both will be classified.
+     */
+    classificationType: ClassificationType;
+    /**
+     * This property is for debugging only; it is not for production use nor is it optimized.
+     * <p>
+     * Draws the bounding sphere for each draw command in the primitive.
+     * </p>
+     */
+    debugShowBoundingVolume: boolean;
+    /**
+     * Determines if geometry vertex attributes are interleaved, which can slightly improve rendering performance.
+     */
+    readonly interleave: boolean;
+    /**
+     * When <code>true</code>, the primitive does not keep a reference to the input <code>geometryInstances</code> to save memory.
+     */
+    readonly releaseGeometryInstances: boolean;
+    /**
+     * When <code>true</code>, each geometry instance will only be pickable with {@link Scene#pick}.  When <code>false</code>, GPU memory is saved.
+     */
+    readonly allowPicking: boolean;
+    /**
+     * Determines if the geometry instances will be created and batched on a web worker.
+     */
+    readonly asynchronous: boolean;
+    /**
+     * Determines if the primitive is complete and ready to render.  If this property is
+     * true, the primitive will be rendered the next time that {@link GroundPolylinePrimitive#update}
+     * is called.
+     */
+    readonly ready: boolean;
+    /**
+     * Gets a promise that resolves when the primitive is ready to render.
+     */
+    readonly readyPromise: Promise<GroundPolylinePrimitive>;
+    /**
+     * This property is for debugging only; it is not for production use nor is it optimized.
+     * <p>
+     * If true, draws the shadow volume for each geometry in the primitive.
+     * </p>
+     */
+    readonly debugShowShadowVolume: boolean;
+    /**
+     * Initializes the minimum and maximum terrain heights. This only needs to be called if you are creating the
+     * GroundPolylinePrimitive synchronously.
+     * @returns A promise that will resolve once the terrain heights have been loaded.
+     */
+    static initializeTerrainHeights(): Promise<void>;
+    /**
+     * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
+     * get the draw commands needed to render this primitive.
+     * <p>
+     * Do not call this function directly.  This is documented just to
+     * list the exceptions that may be propagated when the scene is rendered:
+     * </p>
+     */
+    update(): void;
+    /**
+     * Returns the modifiable per-instance attributes for a {@link GeometryInstance}.
+     * @example
+     * const attributes = primitive.getGeometryInstanceAttributes('an id');
+     * attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
+     * attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(true);
+     * @param id - The id of the {@link GeometryInstance}.
+     * @returns The typed array in the attribute's format or undefined if the is no instance with id.
+     */
+    getGeometryInstanceAttributes(id: any): any;
+    /**
+     * Checks if the given Scene supports GroundPolylinePrimitives.
+     * GroundPolylinePrimitives require support for the WEBGL_depth_texture extension.
+     * @param scene - The current scene.
+     * @returns Whether or not the current scene supports GroundPolylinePrimitives.
+     */
+    static isSupported(scene: Scene): boolean;
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <p>
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     * </p>
+     * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <p>
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     * </p>
+     * @example
+     * e = e && e.destroy();
+     */
+    destroy(): void;
+}
+
+export default GroundPolylinePrimitive;
+
+
+

package/dist/types/CzmObjects/general/CzmESMVTLayer/index.d.ts

@@ -1,6 +1,7 @@
 import { CzmESVisualObject } from "../../base";
 import { ESCesiumViewer } from "../../../ESCesiumViewer";
 import { ESMVTLayer } from "../../../ESObjects";
+import { Event } from "earthsdk3";
 export declare class CzmESMVTLayer extends CzmESVisualObject<ESMVTLayer> {
     static readonly type: string;
     private _czmImagery;
@@ -13,6 +14,7 @@ export declare class CzmESMVTLayer extends CzmESVisualObject<ESMVTLayer> {
         pointJson: any[];
         otherJson: any[];
     };
+    mvtLayerJsonChanged: Event<[]>;
     constructor(sceneObject: ESMVTLayer, czmViewer: ESCesiumViewer);
     flyTo(duration: number | undefined, id: number): boolean;
     flyIn(duration: number | undefined, id: number): boolean;

package/dist/types/CzmObjects/general/CzmESSignalTransmission/XbsjPolyline/XbsjPolylineGeometry.d.ts

@@ -0,0 +1,3 @@
+export default class {
+    
+}

package/dist/types/CzmObjects/general/CzmESSignalTransmission/XbsjPolyline/xbsjCreateODLinesPrimitive.d.ts

@@ -0,0 +1,29 @@
+import * as Cesium from 'cesium';
+import { XbsjRoutePath } from './XbsjRoutePath';
+import { SceneObjectKey } from "earthsdk3";
+
+export type XbsjPositionCallbackResultType = {
+    timeRatio: number;
+    repeat: number;
+    color: [number, number, number, number];
+    bgColor: [number, number, number, number];
+    bidirectional: 0 | 1 | 2 | 3; // 0/1表示单向，2表示双向, 3表示无信号
+};
+
+export type XbsjODLinesPostionCallback = (
+    instanceIndex: number,
+    frameState: Cesium.FrameState,
+    result: XbsjPositionCallbackResultType,
+) => XbsjPositionCallbackResultType;
+
+export default function xbsjCreateODLinesPrimitive(
+    routePaths: XbsjRoutePath[],
+    color: [number, number, number, number],
+    arcType: Cesium.ArcType,
+    postionCallback: (instanceIndex: number, frameState: Cesium.FrameState | undefined, result: XbsjPositionCallbackResultType) => XbsjPositionCallbackResultType,
+    brightening?: boolean,
+    depthTest?: boolean,
+    getTextureFunc?: () => Cesium.Texture,
+    id?: SceneObjectKey
+): Cesium.Primitive;
+

package/dist/types/CzmObjects/general/CzmESVideoFusion/XbsjCameraVideo/XbsjCameraVideo.d.ts

@@ -0,0 +1,18 @@
+import * as Cesium from 'cesium';
+
+export declare class XbsjCameraVideo {
+    constructor(options: {
+        inverseViewMatrix: Cesium.Matrix4,
+        frustum: Cesium.PerspectiveFrustum,
+        // videoElement: HTMLVideoElement | string | undefined,
+        videoTextureFunc?: (() => Cesium.Texture | undefined) | undefined,
+        alphaTextureFunc?: (() => Cesium.Texture | undefined) | undefined,
+        showHelperPrimitive: true,
+    });
+    // videoElement: HTMLVideoElement | string | undefined;
+    // alphaImage: string;
+    videoTextureFunc: (() => Cesium.Texture | undefined) | undefined;
+    alphaTextureFunc: (() => Cesium.Texture | undefined) | undefined;
+    showHelperPrimitive: boolean;
+    destroy(): void;
+}

package/dist/types/CzmObjects/general/CzmESViewShed/XbsjViewshed/XbsjViewshed.d.ts

@@ -0,0 +1,16 @@
+import * as Cesium from 'cesium';
+
+export declare class XbsjViewshed {
+    constructor(scene: Cesium.Scene, id?: string);
+    enabled: boolean;
+    showHelper: boolean;
+    fovH: number;
+    fovV: number;
+    near: number;
+    far: number;
+    position: Cesium.Cartesian3;
+    heading: number;
+    pitch: number;
+    roll: number;
+    destroy(): void;
+}

package/dist/types/ESCesiumViewer/BackGroundImage/BackGroundImage.d.ts

@@ -0,0 +1,5 @@
+export declare class BackGroundImage {
+    show: boolean;
+    material: Cesium.Material;
+    destroy(): void;
+}

package/dist/types/ESCesiumViewer/LocalSkyBox/SkyAtmosphere.d.ts

@@ -0,0 +1,14 @@
+import * as Cesium from 'cesium';
+
+declare class SkyAtmosphere {
+    constructor(ellipsoid: Cesium.Ellipsoid | undefined, sources: {
+        positiveX: string;
+        negativeX: string;
+        positiveY: string;
+        negativeY: string;
+        positiveZ: string;
+        negativeZ: string;
+    });
+}
+
+export = SkyAtmosphere;

package/dist/types/ESCesiumViewer/ViewerExtensions/ScreenManager/AvoidanceManager.d.ts

@@ -1,4 +1,4 @@
-import { Destroyable, ESJScreenLayerInfo, ESJScreenRules } from "earthsdk3";
+import { Destroyable, ESJScreenLayerInfo } from "earthsdk3";
 import * as Cesium from "cesium";
 import { ScreenManager } from ".";
 /**
@@ -10,19 +10,28 @@ import { ScreenManager } from ".";
 export declare class AvoidanceManager extends Destroyable {
     rectangleCollisionCheck: Cesium.RectangleCollisionChecker;
     screenManager: ScreenManager;
-    enable: boolean;
     forceRebuildNext: boolean;
     avoidanceLayers: string[];
+    customLayers: string[];
     private _processingQueue;
     private _isProcessing;
+    /** 单帧最多处理多少个对象，适当调大可以加快收敛，调小可以减轻单帧压力 */
     private BATCH_SIZE;
+    /** 总共参与避让计算的对象上限，超过后只保留优先级最高的一部分（zOrder 最大） */
+    private MAX_OBJECTS;
+    /** 屏幕网格大小（像素），用于做候选抽样，保证一块区域内只保留少量候选点 */
+    private GRID_SIZE;
+    /** 每个网格 cell 内最多参与避让的对象数量 */
+    private MAX_PER_CELL;
     private _cache;
     private _lastCameraState;
+    /** 摄像机移动触发全量重建的阈值，适当调大避免频繁 clear 树 */
     private CAMERA_MOVE_THRESHOLD;
     constructor(screenManager: ScreenManager);
     update(): void;
     setAvoidanceLayer(): void;
-    updateAvoidanceLayer(avoidance: ESJScreenRules['avoidance'], layer?: ESJScreenLayerInfo['layer']): void;
+    add(layer?: ESJScreenLayerInfo['layer']): void;
+    remove(layer?: ESJScreenLayerInfo['layer']): void;
     private _shouldForceRebuild;
     private _updateLastCameraState;
     private _buildProcessingQueue;

package/dist/types/ESCesiumViewer/ViewerExtensions/ScreenManager/ScreenLayer.d.ts

@@ -2,18 +2,19 @@ import { Destroyable, SceneObjectKey } from "earthsdk3";
 import * as Cesium from "cesium";
 import { ESJScreenObjectInfo } from "earthsdk3";
 import { CzmBillboard, CzmLabel, ESCesiumViewer, ScreenManager } from "../../../index";
-import { ScreenObject, ScreenObjectType } from "./ScreenObject";
+import { ScreenObject, ScreenObjectKey, ScreenObjectType } from "./ScreenObject";
 /**
  * 管理一类对象（同图层）
  * 负责增删改 ScreenObject
  * 提供快速访问索引 objects: Map<SceneObjectKey, ScreenObject>
  */
 export declare class ScreenLayer extends Destroyable {
-    objects: Map<SceneObjectKey, ScreenObject>;
-    screenManager: ScreenManager;
+    protected screenManager: ScreenManager;
+    protected screenManagerLayerName: string;
+    objects: Map<ScreenObjectKey, ScreenObject>;
     czmViewer: ESCesiumViewer;
     viewer: Cesium.Viewer;
-    constructor(screenManager: ScreenManager);
+    constructor(screenManager: ScreenManager, screenManagerLayerName: string);
     /**
      * 检查图层是否包含有效对象
      * @returns 如果图层中存在有效对象则返回 true，否则返回 false

package/dist/types/ESCesiumViewer/ViewerExtensions/ScreenManager/ScreenObject.d.ts

@@ -2,6 +2,7 @@ import { Destroyable, Event, SceneObjectKey } from "earthsdk3";
 import * as Cesium from 'cesium';
 export declare const ScreenObjectTypes: readonly ["label", "billboard", "rectangle"];
 export type ScreenObjectType = typeof ScreenObjectTypes[number];
+export type ScreenObjectKey = string;
 /**
  * 储存相同位置下的对象的信息
  * 代表一个场景对象
@@ -12,7 +13,10 @@ export type ScreenObjectType = typeof ScreenObjectTypes[number];
  */
 export declare class ScreenObject extends Destroyable {
     id: string;
-    position: Cesium.Cartesian3;
+    private _position;
+    get position(): Cesium.Cartesian3;
+    set position(value: Cesium.Cartesian3);
+    get positionChanged(): import("earthsdk3").Listener<[Cesium.Cartesian3, Cesium.Cartesian3]>;
     label: Cesium.Label | undefined;
     billboard: Cesium.Billboard | undefined;
     rectangle: Record<string, any> | undefined;
@@ -20,9 +24,16 @@ export declare class ScreenObject extends Destroyable {
     labelRefCount: number;
     billboardRefCount: number;
     rectangleRefCount: number;
+    labelIgnorePlacement: boolean;
+    billboardIgnorePlacement: boolean;
+    rectangleIgnorePlacement: boolean;
+    labelAllowOverlap: boolean;
+    billboardAllowOverlap: boolean;
+    rectangleAllowOverlap: boolean;
     private _showEvent;
     get showEvent(): Event<[boolean]>;
     show(show: boolean): void;
     constructor(id: SceneObjectKey, position: Cesium.Cartesian3);
     updateShow(show: boolean): void;
+    updatePosition(position: Cesium.Cartesian3): void;
 }

package/dist/types/ESCesiumViewer/ViewerExtensions/ScreenManager/index.d.ts

@@ -20,6 +20,8 @@ export declare class ScreenManager extends Destroyable {
     collectionMap: Record<ScreenObjectType, any>;
     private _refreshEvent;
     get refreshEvent(): Event<[]>;
+    /** 是否已经在本帧调度了 refresh，防止一帧内被调用成千上万次 */
+    private _refreshScheduled;
     refresh(): void;
     constructor(_czmViewer: ESCesiumViewer);
     getLayer(layerName: string): ScreenLayer;

package/dist/types/ESCesiumViewer/ViewerExtensions/VectorTilesManager/StyleManager.d.ts

@@ -2,6 +2,7 @@ import { Destroyable, SceneObjectKey } from "earthsdk3";
 import { CzmESMVTLayer, CzmLabel } from '../../../index';
 import { BackgroundLayerSpecification, LayerSpecification } from "../../../CzmObjects/base/InnerClass/CzmImagery/extends/type";
 export type LayerStyle = Exclude<LayerSpecification, BackgroundLayerSpecification> & {
+    symbolStyle?: any;
     labelStyle?: any;
     billboardStyle?: any;
     polygonStyle?: any;
@@ -9,6 +10,7 @@ export type LayerStyle = Exclude<LayerSpecification, BackgroundLayerSpecificatio
 };
 export type mapboxLabel = CzmLabel & {
     'text-transform'?: string;
+    "maxWidth"?: number;
 };
 export declare const textTransform: {
     none: (s: string) => string;

package/dist/types/ESCesiumViewer/ViewerExtensions/VectorTilesManager/TileLoader.d.ts

@@ -1,15 +1,14 @@
-import { sourceName } from "./index";
+import { sourceName, VectorTilesManager } from "./index";
 import { Destroyable, SceneObjectKey } from "earthsdk3";
 import { CzmESMVTLayer } from "../../../CzmObjects";
 import { TileNode } from './TileNode';
-import { TilesCache } from "./TilesCache.";
-import { WorkerPool } from "./WorkerPool";
+import { TilesCache } from "./TilesCache";
 /**
  * 瓦片加载器
  * 只负责加载瓦片数据并解析为GeoJson格式
  */
 export declare class TileLoader extends Destroyable {
-    tilesCache: TilesCache;
+    vectorTilesManager: VectorTilesManager;
     /**
      * 等待请求的瓦片服务
      */
@@ -23,14 +22,14 @@ export declare class TileLoader extends Destroyable {
         minzoom?: number;
         maxzoom?: number;
     }>>;
-    workerPool: WorkerPool;
+    tilesCache: TilesCache;
     /**
      * 切片方案
      * xyz: 谷歌瓦片方案
      * tms: 瓦片服务方案
      */
     tileSchemes: Map<SceneObjectKey, "xyz" | "tms">;
-    constructor(tilesCache: TilesCache);
+    constructor(vectorTilesManager: VectorTilesManager);
     add(czmESMVTLayer: CzmESMVTLayer): void;
     remove(czmESMVTLayer: CzmESMVTLayer): void;
     fetchTile(sceneObjectId: SceneObjectKey, tileKey: string): Promise<TileNode | undefined>;

package/dist/types/ESCesiumViewer/ViewerExtensions/VectorTilesManager/TileNode.d.ts

@@ -1,5 +1,5 @@
 import { Destroyable } from "earthsdk3";
-import { FeatureDate, layerName, sourceName, TileKey, TileNodeState } from ".";
+import { layerName, sourceName, TileKey, TileNodeState } from ".";
 export declare class TileNode extends Destroyable {
     x: number;
     y: number;
@@ -7,8 +7,23 @@ export declare class TileNode extends Destroyable {
     tileKey: TileKey;
     parent: TileNode | null;
     children: Set<TileNode>;
-    data: Map<sourceName, Map<layerName, Set<FeatureDate>>>;
-    state: TileNodeState;
-    constructor(tileKey: TileKey);
-    fillParentAndChildren(tileCache: Map<TileKey, TileNode | undefined>): void;
+    data: Map<sourceName, Map<layerName, Set<GeoJSON.Feature<Exclude<GeoJSON.Geometry, GeoJSON.GeometryCollection>>>>>;
+    private _state;
+    get state(): TileNodeState;
+    set state(value: TileNodeState);
+    get stateChanged(): import("earthsdk3").Listener<[TileNodeState, TileNodeState]>;
+    refCount: number;
+    lastUsedFrame: number;
+    screenIds: Set<string> | null;
+    /** 瓦片渲染结果，可以是 Canvas 或 ImageBitmap（优先 ImageBitmap，减少主线程绘制开销） */
+    image: HTMLCanvasElement | ImageBitmap | null;
+    /** 该瓦片对应的影像渲染 Promise，用于避免重复开启 worker 计算 */
+    imagePromise?: Promise<HTMLCanvasElement | ImageBitmap>;
+    constructor(tileCache: Map<string, TileNode | undefined>, tileKey: TileKey);
+    attachToParent(tileCache: Map<string, TileNode | undefined>): void;
+    getParentTileKey(): string | undefined;
+    getChildrenTileKeys(): string[];
+    idReady(): boolean;
+    hasReadyChildren(): boolean;
+    allChildrenReady(): boolean;
 }

package/dist/types/ESCesiumViewer/ViewerExtensions/VectorTilesManager/{TilesCache..d.ts → TilesCache.d.ts}

@@ -1,5 +1,5 @@
 import { Destroyable, Event, SceneObjectKey } from "earthsdk3";
-import { TileKey } from "./index";
+import { TileKey, VectorTilesManager } from "./index";
 import { CzmESMVTLayer } from "../../../CzmObjects";
 import { TileNode } from "./TileNode";
 /**
@@ -7,18 +7,23 @@ import { TileNode } from "./TileNode";
  * 缓存请求的xyz瓦片数据，超过缓存数量后，将最旧的瓦片删除
  */
 export declare class TilesCache extends Destroyable {
+    vectorTilesManager: VectorTilesManager;
     cache: Map<SceneObjectKey, Map<TileKey, TileNode | undefined>>;
+    private _cacheEvent;
+    get cacheEvent(): Event<[string, string, TileNode]>;
     maxSize: number;
     private _deleteTileEvent;
     get deleteTileEvent(): Event<[string, string | undefined]>;
     deleteTile(sceneObjectId: SceneObjectKey, tileKey?: TileKey): void;
-    constructor();
+    constructor(vectorTilesManager: VectorTilesManager);
     has(sceneObjectId: SceneObjectKey, tileKey?: TileKey): boolean;
-    get(sceneObjectId: SceneObjectKey): Map<TileKey, TileNode | undefined> | undefined;
+    get(sceneObjectId: SceneObjectKey): Map<TileKey, TileNode | undefined>;
     get(sceneObjectId: SceneObjectKey, tileKey: TileKey): TileNode | undefined;
-    set(sceneObjectId: SceneObjectKey, tileKey: TileKey, tileNode: TileNode | undefined): void;
+    set(sceneObjectId: SceneObjectKey, tileKey: TileKey, tileNode: TileNode): void;
     remove(sceneObject: SceneObjectKey): void;
     remove(sceneObject: CzmESMVTLayer): void;
     remove(sceneObject: SceneObjectKey, tileKey: TileKey): void;
     remove(sceneObject: CzmESMVTLayer, tileKey: TileKey): void;
+    requestImage(sceneObjectId: SceneObjectKey, x: number, y: number, z: number): Promise<HTMLCanvasElement | ImageBitmap>;
+    private _requestImageWorker;
 }

package/dist/types/ESCesiumViewer/ViewerExtensions/VectorTilesManager/index.d.ts

@@ -1,11 +1,12 @@
 import { Destroyable, SceneObjectKey } from "earthsdk3";
-import { TilesCache } from "./TilesCache.";
+import { TilesCache } from "./TilesCache";
 import { TileLoader } from "./TileLoader";
 import { TileRenderer } from "./TileRenderer";
 import { StyleManager } from "./StyleManager";
 import { EventManager } from "./EventManager";
 import { CzmESMVTLayer } from "../../../index";
 import * as Cesium from 'cesium';
+import { WorkerPool } from "./WorkerPool";
 /**
 * Viewer Camera/LOD
 *        ↓
@@ -19,11 +20,6 @@ import * as Cesium from 'cesium';
 *        ↓
 * EventManager 绑定事件
 */
-export interface FeatureDate {
-    id: string | number;
-    geometry: any;
-    properties: Record<string, any>;
-}
 export type TileKey = string;
 export type sourceName = string;
 export type layerName = string;
@@ -44,9 +40,19 @@ export declare class VectorTilesManager extends Destroyable {
     styleManager: StyleManager;
     eventManager: EventManager;
     lastImageryTileMap: Map<SceneObjectKey, Set<TileKey>>;
+    workerPool: WorkerPool;
+    /**
+     * 最近一次瓦片集合发生变化的时间，用于避免相机缩放/平移过程中频繁隐藏导致的闪烁
+     */
+    private lastTilesChangedTime;
+    /**
+     * 视图稳定多久后才开始真正隐藏旧瓦片（毫秒）
+     */
+    private readonly hideDelayWhenCameraMoving;
     constructor(viewer: Cesium.Viewer);
     add(czmESMVTLayer: CzmESMVTLayer): Promise<void>;
     remove(czmESMVTLayer: CzmESMVTLayer): void;
     refreshVisibleTiles(forceUpdate?: boolean): void;
     updateTiles(tileMap: Map<SceneObjectKey, Set<TileKey>>, forceUpdate?: boolean): void;
+    requestImage(sceneObjectId: SceneObjectKey, x: number, y: number, z: number): Promise<HTMLCanvasElement | ImageBitmap>;
 }

package/dist/types/ESCesiumViewer/ViewerExtensions/VectorTilesManager/utils.d.ts

@@ -1,2 +1,5 @@
+import * as Cesium from "cesium";
 export declare function getMapboxTextField(textField: any, zoom: number): string | string[] | null;
 export declare function tileDataToGeoJSON(tileData: Record<string, any>): Map<string, Set<any>>;
+export declare function interpolateTextAlongPath(viewer: Cesium.Viewer, positions: Cesium.Cartesian3[], text: string, font: string): Map<Cesium.Cartesian3, Cesium.Cartesian3[]>;
+export declare function wrapByPixel(text: any, maxWidth: any, font: any): string;

package/dist/types/ESCesiumViewer/initCesiumViewer/fixGoogleEarth/cesiumFixGoogleEarth.d.ts

@@ -0,0 +1 @@
+export declare function cesiumFixGoogleEarth(Cesium: any): void;

package/dist/types/ESCesiumViewer/initCesiumViewer/fixLabel.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 扩展Cesium.Label，增加positions属性，可直接操作单字符位置
+ * 传入位置不足时，默认使用label.position
+ */
+export declare function fixLabel(): void;

package/dist/types/ESCesiumViewer/initCesiumViewer/fixLabelCollection.d.ts

@@ -0,0 +1,8 @@
+import * as Cesium from 'cesium';
+export declare function fixLabelCollection(): void;
+/**
+ * 根据传入点数量，对 Cartesian3 数组做均匀插值
+ * @param points 原始点数组（至少两个）
+ * @param targetCount 目标插值数量（包含起终点）
+ */
+export declare function interpolateCartesian3(points: Cesium.Cartesian3[], targetCount: number): Cesium.Cartesian3[];

package/dist/types/ESJTypesCzm/czmObject/CzmBillboard.d.ts

@@ -1,9 +1,13 @@
 import * as Cesium from 'cesium';
+import { ESJVector4D } from 'earthsdk3';
 export type CzmBillboard = Partial<{
     position: Cesium.Cartesian3;
     id: any;
     show: boolean;
     image: string | HTMLCanvasElement;
+    avoidancePadding: ESJVector4D;
+    ignorePlacement: boolean;
+    allowOverlap: boolean;
     scale: number;
     pixelOffset: Cesium.Cartesian2;
     eyeOffset: Cesium.Cartesian3;