bruce-cesium 7.3.9 → 7.4.1

package/dist/types/rendering/render-managers/common/entity-label.d.ts

@@ -1,12 +1,134 @@
 import * as Cesium from "cesium";
 import { VisualsRegister } from "../../visuals-register";
-import { BruceApi } from "bruce-models";
+import { BruceApi, Calculator } from "bruce-models";
+import { GetClusterIconPriority } from "./point-clustering-core";
 /**
  * Util for generating labels within cesium space on entities.
 */
 export declare namespace EntityLabel {
     const ATTACH_KEY = "nextspace-navigator-entity-label";
+    interface IOptions {
+        presentation?: "text" | "icon" | "icon-text-above" | "icon-text-side";
+        text?: string;
+        icon?: string;
+        iconUrl?: string;
+        iconClass?: string | Calculator.IField[];
+        iconColor?: string | Calculator.IField[];
+        iconBackground?: boolean;
+        iconSize?: number;
+        iconScale?: number;
+        iconPriority?: number;
+        iconStatus?: string;
+        leader?: boolean;
+        leaderLength?: number;
+        leaderColor?: string;
+        attributes?: string[];
+        near?: number;
+        far?: number;
+        overlapOpacity?: number;
+        selectOnClick?: boolean;
+        pointerAvoidance?: {
+            enabled?: boolean;
+            gap?: number;
+            delay?: number;
+            transitionDuration?: number;
+        };
+        anchorRing?: {
+            enabled?: boolean;
+            nearDistance?: number;
+            nearRadius?: number;
+            hoverDistance?: number;
+            hoverRadius?: number;
+            transitionDuration?: number;
+        };
+        cluster?: {
+            enabled?: boolean;
+            pixelRange?: number;
+            minSize?: number;
+            representative?: "status" | "nearest";
+        };
+    }
+    interface IHoverRingState {
+        animation?: {
+            target: number;
+            start: number;
+            outer: number;
+            inner: number;
+            fromOuter: number;
+            fromInner: number;
+            arcOffset?: number;
+            arcOpen?: number;
+            arcTime?: number;
+        };
+    }
+    interface IFrame {
+        canFlip?: boolean;
+        textWrapped?: boolean;
+        hasLeader?: boolean;
+        transient?: boolean;
+        extendedGeometry?: boolean;
+        viewportWidth?: number;
+        leaderLength?: number;
+        distance?: number;
+        id: string;
+        text?: string;
+        clusterBounds?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        entityKey?: string;
+        entityId?: string;
+        group?: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchorX?: number;
+        anchorY?: number;
+        depth: number;
+        opacity: number;
+        priority?: number;
+        options?: IOptions;
+    }
+    interface IPlacement {
+        textSide?: "left" | "right";
+        summaryMore?: boolean;
+        frame: IFrame;
+        text?: string;
+        visible: boolean;
+        opacity: number;
+        zIndex: number;
+        members: string[];
+        entityIds: string[];
+    }
+    class PlacementMemory {
+        private previous;
+        private nextOrder;
+        Resolve(frames: IFrame[]): Map<string, {
+            frame: IFrame;
+            side: "left" | "right";
+        }>;
+    }
+    const IconPriority: typeof GetClusterIconPriority;
+    function Layout(input: IFrame[], memory?: PlacementMemory): IPlacement[];
+    function SetContainer(viewer: Cesium.Viewer, container?: HTMLElement | null): void;
     class Label {
+        private id;
+        private options;
+        private groupId;
+        Persistent: boolean;
+        Transient: boolean;
+        get HasText(): boolean;
+        private hoverFade;
+        private retainedHoverPosition;
+        private ringAnimation;
+        private cursorMotion;
+        private hoverRingState;
+        SetHoverVisible(visible: boolean): void;
+        private HoverOpacity;
+        private visible;
         private counter;
         private viewer;
         private api;
@@ -25,6 +147,7 @@ export declare namespace EntityLabel {
         private loadTimeout;
         private loadedName;
         private line;
+        private anchor;
         private additionalTexts;
         constructor(params: {
             rego: VisualsRegister.IVisualRego;
@@ -32,6 +155,12 @@ export declare namespace EntityLabel {
             pos3d?: Cesium.Cartesian3;
             visualRegister?: VisualsRegister.Register;
             api?: BruceApi.Api;
+            options?: IOptions;
+            groupId?: string;
+            persistent?: boolean;
+            transient?: boolean;
+            hoverRingState?: IHoverRingState;
+            visible?: () => boolean;
         });
         /**
          * Loads the Entity's name and updates the corresponding visual rego.
@@ -42,6 +171,7 @@ export declare namespace EntityLabel {
          * Recalling will be ignored.
          */
         Dispose(): void;
+        Configure(options?: IOptions, groupId?: string): void;
         /**
          * Creates cesium entity for the label if one does not exist.
          * @param starterPos3d optional position to create label at. Ignored for billboard labels.
@@ -62,6 +192,12 @@ export declare namespace EntityLabel {
         pos3d?: Cesium.Cartesian3;
         visualRegister?: VisualsRegister.Register;
         api?: BruceApi.Api;
+        options?: IOptions;
+        groupId?: string;
+        persistent?: boolean;
+        transient?: boolean;
+        hoverRingState?: IHoverRingState;
+        visible?: () => boolean;
     }): Label;
     /**
      * Removes an entity label from a given rego.
@@ -70,6 +206,7 @@ export declare namespace EntityLabel {
     function Detatch(params: {
         rego?: VisualsRegister.IVisualRego;
         label?: Label;
+        force?: boolean;
     }): void;
     /**
      * Returns label instance from given rego if one exists.

package/dist/types/rendering/render-managers/common/point-clustering-core.d.ts

@@ -0,0 +1,17 @@
+export interface IClusterIconMetadata {
+    iconPriority?: number;
+    iconStatus?: string;
+    icon?: string;
+    iconUrl?: string;
+}
+export declare function GetClusterIconPriority(options?: IClusterIconMetadata): number;
+export declare function ClusterItems<T>(params: {
+    items: T[];
+    id: (item: T) => string;
+    neighbours: (item: T) => T[];
+    eligible?: (item: T) => boolean;
+    minSize?: number;
+}): {
+    representative: T;
+    members: T[];
+}[];

package/dist/types/rendering/render-managers/common/point-clustering.d.ts

@@ -1,91 +1,56 @@
-import { MenuItem } from "bruce-models";
+import { Calculator, Entity, MenuItem } from "bruce-models";
 import * as Cesium from "cesium";
 import { VisualsRegister } from "../../visuals-register";
+import { IClusterIconMetadata } from "./point-clustering-core";
+export { ClusterItems } from "./point-clustering-core";
+export type TEntityClusterKind = "point" | "polyline" | "polygon" | "model" | "other";
+export interface IPointClusteringSettings extends MenuItem.Item.IClustering {
+    iconPriority?: number | Calculator.IField[];
+    iconStatus?: string | Calculator.IField[];
+    representative?: "status" | "nearest";
+    selectOnClick?: boolean;
+    minDistanceByType?: Partial<Record<TEntityClusterKind, number>>;
+}
+export interface IPointClusterItem extends IClusterIconMetadata {
+    entity?: Entity.IEntity;
+}
+interface IClusterView {
+    entity: Cesium.Entity;
+    entityIds: string[];
+    representativeId: string;
+    selected: boolean;
+}
+export declare function PointClusterSize(count: number): number;
 export declare class PointClustering {
+    private register;
+    private menuItemId;
+    private settings;
     private minDistance;
     private minTotalCount;
     private quadTree;
-    private prevClusteredEntities;
     private currClusteredEntities;
     private viewer;
-    private register;
     private updateQueue;
     private clusterEntities;
-    private disposed;
-    private listenCameraRemoval;
-    private listenUpdateRemoval;
-    private menuItemId;
+    private clusterViews;
     private registeredEntityIds;
-    private pointColorBg;
-    private pointColorTxt;
-    private iconUrl;
-    private updateEntityQueue;
-    private queueInterval;
-    constructor(register: VisualsRegister.Register, menuItemId: string, settings?: MenuItem.Item.IClustering);
+    private records;
+    private disposed;
+    private removals;
+    private picker;
+    private selectionQueued;
+    constructor(register: VisualsRegister.Register, menuItemId: string, settings?: IPointClusteringSettings);
     Update(): void;
-    private queueForceUpdate;
-    private runForceUpdateQueue;
-    /**
-     * Starts listening to camera changes.
-     * This will trigger the clustering update whenever camera is moved.
-     */
-    private listenCamera;
-    /**
-     * Stops listening to camera changes.
-     */
-    private unlistenCamera;
-    /**
-     * Starts listening to entity selection changes.
-     * Selected entities are not clustered.
-     */
-    private listenSelection;
-    private unlistenSelection;
-    /**
-     * Removes all clusters and updates entities to no longer be suppressed.
-     * @returns
-     */
+    GetClusters(): IClusterView[];
     Dispose(): void;
-    /**
-     * Calculates center of given points.
-     * @param points
-     * @returns
-     */
-    private calculateCentroid;
-    /**
-     * Gathers current clusters and renders them.
-     * @returns
-     */
+    private refreshSelection;
+    private selectCluster;
+    private resolveGeometry;
+    private appearance;
     private doUpdate;
     private getClusterSpacing;
     private getClusters;
-    /**
-     * Removes Cesium cluster entity.
-     * @param clusterId
-     */
     private removeClusterEntity;
-    private convertCartesianToCartographic;
-    /**
-     * Adds new entity to the clustering logic.
-     * @param id Bruce entity ID.
-     * @param cartesian3 entity's position.
-     */
-    private addPoint;
-    /**
-     * Adds entity to clustering logic.
-     * Will return false if entity could not be clustered and therefor should not be hidden.
-     * @param id
-     * @param entity
-     * @param queueUpdate
-     * @returns
-     */
-    AddEntity(id: string, entity: Cesium.Entity, queueUpdate?: boolean): boolean;
-    /**
-     * Removes entity from clustering logic.
-     * Warning: This will not reveal the entity, suppressShow will remain true.
-     * This is made with the assumption that the entity is being removed from viewer.
-     * @param id
-     * @param queueUpdate
-     * @returns
-     */
+    AddEntity(id: string, visual: Cesium.Entity, queueUpdate?: boolean, metadata?: IPointClusterItem): boolean;
     RemoveEntity(id: string, queueUpdate?: boolean): void;
 }

package/dist/types/rendering/visuals-register.d.ts

@@ -1,6 +1,8 @@
 import { ApiGetters, BruceEvent, Cartes, Entity, EntityRelation, IDictionary, MenuItem, ProjectViewBookmark } from "bruce-models";
 import * as Cesium from "cesium";
 import { IShowGate } from "../internal/cesium-show-gate";
+import { EntityLabel } from "../rendering/render-managers/common/entity-label";
+import { EntityLabelGroup } from "./render-managers/common/entity-label-group";
 /**
  * Manages a registry of all Bruce visuals being rendered by menu items.
  */
@@ -112,12 +114,20 @@ export declare namespace VisualsRegister {
         private updateQueueIds;
         private updateQueueSettings;
         private updateQueueInterval;
+        private menuItemSources;
+        private sourceOrderDirty;
+        private labelGroups;
+        private labelGroupsChanged;
+        get OnLabelGroupsChanged(): BruceEvent<void>;
+        private labelHover;
+        private hoverLabel;
+        private hoverRingState;
+        private hoverRingReset;
+        private retiringHoverLabels;
         constructor(params: {
             viewer: Cesium.Viewer;
             apiGetters?: ApiGetters;
         });
-        private menuItemSources;
-        private sourceOrderDirty;
         /**
          * Returns the collection a menu item's visuals belong in, creating its data source on first use.
          * Returns null when there is nothing to key off, leaving the caller on the viewer's own collection.
@@ -552,5 +562,36 @@ export declare namespace VisualsRegister {
          * @returns
          */
         GetOpacityMap(): IDictionary<number>;
+        private ReleaseHoverLabel;
+        SetLabelHover(params?: {
+            entityId: string;
+            menuItemId?: string;
+            position?: {
+                x: number;
+                y: number;
+            };
+            createIfMissing?: boolean;
+        } | null): void;
+        ClearLabelHover: () => void;
+        private CheckLabelHoverBounds;
+        GetLabelHoverPosition(entityId: string, menuItemId?: string): Readonly<{
+            x: number;
+            y: number;
+        }> | undefined;
+        private SyncLabelHover;
+        SetLabelContainer(container?: HTMLElement | null): void;
+        ClearLabelContainer(): void;
+        SetLabelGroup(group: EntityLabelGroup.IGroup): Promise<EntityLabelGroup.IResult>;
+        RemoveLabelGroup(id: string): void;
+        RefreshLabelGroup(id: string): Promise<EntityLabelGroup.IResult>;
+        SetLabelGroupVisible(id: string, visible: boolean): boolean;
+        ClearLabelGroups(): void;
+        GetLabelGroups(): EntityLabelGroup.IState[];
+        GetLabelGroupFor(entityId: string, menuItemId?: string): {
+            groupId: string;
+            options: EntityLabel.IOptions;
+            item: EntityLabelGroup.IItem;
+        };
+        RefreshLabelGroupEntity(entityId: string): void;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bruce-cesium",
-  "version": "7.3.9",
+  "version": "7.4.1",
   "description": "",
   "keywords": [],
   "main": "dist/bruce-cesium.umd.js",