bruce-cesium 7.6.7 → 7.6.9

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, JulianDate, Quaternion, HeadingPitchRoll, HeightReference, ConstantPositionProperty, DistanceDisplayCondition, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ArcType, CornerType, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneMode, IntersectionTests, Ray, SceneTransforms, FeatureDetection, Matrix3, NearFarScalar, KmlDataSource, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CustomDataSource, GeometryInstance, PolygonPipeline, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, UrlUtils, Api, Carto, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, RecordChangeFeed, Camera, ProgramKey, ProjectViewLegacyTile, EntitySource, Account, AccountLimits, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, HeightReference, Matrix4, ConstantPositionProperty, DistanceDisplayCondition, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, HorizontalOrigin, VerticalOrigin, ClassificationType, ColorBlendMode, ShadowMode, Model, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, ArcType, CornerType, Rectangle, SceneMode, IntersectionTests, Ray, SceneTransforms, NearFarScalar, Matrix3, FeatureDetection, KmlDataSource, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, IonResource, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, OrthographicFrustum, EasingFunction, Intersect, Cesium3DTileset, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CustomDataSource, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Api, Calculator, ClientFile, Entity as Entity$1, EntityTag, EntityType, ObjectUtils, Style, EntityLod, UrlUtils, Bounds, ClientFileValueMap, Color as Color$1, Geometry as Geometry$1, Carto, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, EntityRelation, BruceApi, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -16555,18 +16555,70 @@ var MenuItemStyleOverlay;
     }
     MenuItemStyleOverlay.With = With;
     /**
-     * Returns true when the two items differ by nothing but their overlay.
+     * Returns the style a bookmark laid on this one item, or null when it carries none.
+     */
+    function GetItemStyle(item) {
+        var _a, _b;
+        return (_b = (_a = item === null || item === void 0 ? void 0 : item.style) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : null;
+    }
+    MenuItemStyleOverlay.GetItemStyle = GetItemStyle;
+    /**
+     * Returns the Style record a bookmark laid on this one item, or null when it names none.
+     */
+    function GetItemStyleId(item) {
+        var _a;
+        const styleId = (_a = item === null || item === void 0 ? void 0 : item.style) === null || _a === void 0 ? void 0 : _a.styleId;
+        return styleId == null || styleId === "" || styleId == -1 ? null : styleId;
+    }
+    MenuItemStyleOverlay.GetItemStyleId = GetItemStyleId;
+    /**
+     * Returns a copy carrying the given bookmark style, inline or by record, or without one for null.
+     */
+    function WithItemStyle(item, itemStyle) {
+        const has = Boolean(itemStyle === null || itemStyle === void 0 ? void 0 : itemStyle.style) || (itemStyle === null || itemStyle === void 0 ? void 0 : itemStyle.styleId) != null;
+        if (!item || (!has && !item.style)) {
+            return item;
+        }
+        const next = { ...item };
+        if (has) {
+            next.style = { ...itemStyle };
+        }
+        else {
+            delete next.style;
+        }
+        return next;
+    }
+    MenuItemStyleOverlay.WithItemStyle = WithItemStyle;
+    /**
+     * Returns the overlay an item renders with: its inline or loaded bookmark style, under the scene-wide one.
+     */
+    function Effective(item, overlay, record) {
+        var _a, _b;
+        const own = (_b = (_a = GetItemStyle(item)) !== null && _a !== void 0 ? _a : record) !== null && _b !== void 0 ? _b : null;
+        // Either alone is used as it is, so an unchanged overlay still compares equal.
+        return own ? Merge(own, overlay) : overlay;
+    }
+    MenuItemStyleOverlay.Effective = Effective;
+    /**
+     * Returns a copy without its overlay or bookmark style, so what else two items differ by can be compared.
+     */
+    function Strip(item) {
+        return With(WithItemStyle(item, null), null);
+    }
+    MenuItemStyleOverlay.Strip = Strip;
+    /**
+     * Returns true when the two items differ by nothing but their overlay or bookmark style.
      */
     function IsChangeOnly(from, to) {
         if (!from || !to || from.Type !== to.Type) {
             return false;
         }
-        const toOverlay = Get(to);
-        if (JSON.stringify(Get(from)) === JSON.stringify(toOverlay)) {
+        const sameOverlay = JSON.stringify(Get(from)) === JSON.stringify(Get(to));
+        if (sameOverlay && JSON.stringify(from.style) === JSON.stringify(to.style)) {
             return false;
         }
-        // A false mismatch only costs the in-place swap, so key order is not normalized.
-        return JSON.stringify(With(from, toOverlay)) === JSON.stringify(to);
+        // Removing keys keeps the order of the rest, so the two compare as text.
+        return JSON.stringify(Strip(from)) === JSON.stringify(Strip(to));
     }
     MenuItemStyleOverlay.IsChangeOnly = IsChangeOnly;
     /*
@@ -20684,6 +20736,8 @@ class TilesetStyler {
         this.fallbackStyle = null;
         // Laid over whichever style each feature resolves, so it only changes the fields it sets.
         this.styleOverlay = null;
+        // The tileset's blend before an overlay's colours replaced it, put back once no overlay colours it.
+        this.blendBeforeOverlay = null;
         this.styleFallbackLoaded = false;
         this.loadingCounter = 0;
         // Entity IDs -> boolean to indicate if we should override the feature colour.
@@ -20742,7 +20796,12 @@ class TilesetStyler {
         this.monitor = monitor;
         this.viewer = viewer;
         this.api = api;
+        // A tileset handed in fresh still has its own blend, so nothing is left to put back on it.
+        if (cTileset !== this.cTileset) {
+            this.blendBeforeOverlay = null;
+        }
         this.cTileset = cTileset;
+        this.applyOverlayBlend();
         this.bakedAttributes = getBakedAttributes(cTileset);
         this.register = register;
         this.menuItemId = menuItemId;
@@ -20874,6 +20933,7 @@ class TilesetStyler {
         // Left as it is when a caller omits it, so a mapping change keeps the scene-wide style.
         if (params.styleOverlay !== undefined) {
             this.styleOverlay = params.styleOverlay;
+            this.applyOverlayBlend();
         }
         if (params.scenario != null) {
             if (!this.shouldUpdateRegoStates && !!this.scenario) {
@@ -20963,6 +21023,25 @@ class TilesetStyler {
         }
         this.queueTilesetFeatureStyle(regos, highPriority);
     }
+    /*
+     * Replaces the tileset's own colours while an overlay sets a model fill, so features show exactly what it maps to.
+     */
+    applyOverlayBlend() {
+        var _a, _b, _c, _d;
+        if (!this.cTileset || ((_b = (_a = this.cTileset).isDestroyed) === null || _b === void 0 ? void 0 : _b.call(_a))) {
+            return;
+        }
+        const fill = (_d = (_c = this.styleOverlay) === null || _c === void 0 ? void 0 : _c.modelStyle) === null || _d === void 0 ? void 0 : _d.fillColor;
+        const colours = Array.isArray(fill) ? fill.length > 0 : fill != null;
+        if (colours && this.blendBeforeOverlay == null) {
+            this.blendBeforeOverlay = this.cTileset.colorBlendMode;
+            this.cTileset.colorBlendMode = Cesium3DTileColorBlendMode.REPLACE;
+        }
+        else if (!colours && this.blendBeforeOverlay != null) {
+            this.cTileset.colorBlendMode = this.blendBeforeOverlay;
+            this.blendBeforeOverlay = null;
+        }
+    }
     /**
      * Calculates the current progress % and updates the progress if there is a change.
      */
@@ -32066,17 +32145,21 @@ var MenuItemStyles;
     }
     MenuItemStyles.Resolve = Resolve;
     /**
-     * Returns a copy on the style a bookmark alternation picked, or the item itself when that is not an option.
+     * Returns a copy on the style a bookmark alternation picked and carrying any style it laid on the item.
      */
     function ApplyAlternation(item, alternation) {
         var _a, _b, _c;
         // Alternations are partial items and may carry no Type, so the pick is read from whichever field is present.
         const alt = alternation;
         const picked = (_a = alt === null || alt === void 0 ? void 0 : alt.styleId) !== null && _a !== void 0 ? _a : (_b = getVisibleRow(alt === null || alt === void 0 ? void 0 : alt.CameraZoomSettings)) === null || _b === void 0 ? void 0 : _b.StyleID;
-        if (picked == null) {
-            return item;
+        const next = picked == null ? item : ((_c = WithStyleId(item, picked)) !== null && _c !== void 0 ? _c : item);
+        // A style laid by record need not be one of the item's own, unlike the pick.
+        const itemStyle = alternation === null || alternation === void 0 ? void 0 : alternation.style;
+        const laid = MenuItemStyleOverlay.GetItemStyle(alternation) || MenuItemStyleOverlay.GetItemStyleId(alternation);
+        if (laid == null) {
+            return next;
         }
-        return (_c = WithStyleId(item, picked)) !== null && _c !== void 0 ? _c : item;
+        return MenuItemStyleOverlay.WithItemStyle(next, itemStyle);
     }
     MenuItemStyles.ApplyAlternation = ApplyAlternation;
     /**
@@ -32372,6 +32455,9 @@ var MenuItemManager;
             // Laid over each item's own style where it can take one, including items rendered after it was set.
             this.styleOverlay = null;
             this.styleOverlayCounter = 0;
+            // Style records bookmark styles name by ID, loaded once each; null for one that failed to load.
+            this.itemStyleRecords = new Map();
+            this.itemStyleRecordsLoading = new Set();
             this.onUpdate = null;
             // Segments discovered so far per menu item ID.
             this.seriesSegments = new Map();
@@ -32454,14 +32540,15 @@ var MenuItemManager;
             // An item with a style set renders its first style unless the caller already picked one of them.
             params = { ...params, item: MenuItemStyles.Resolve(params.item) };
             // The overlay rides on the rendered copy, so the view's item never carries it.
-            params = { ...params, item: MenuItemStyleOverlay.With(params.item, this.styleOverlay) };
+            const effective = this.getEffectiveOverlay(params.item, this.styleOverlay);
+            params = { ...params, item: MenuItemStyleOverlay.With(params.item, effective) };
             let rItem = this.items.find(x => x.id == params.item.id);
             let create = true;
             // Item already exists so we'll check if we should re-create it.
             if (rItem) {
-                // Only the style pick or overlay changed, so the drawn graphics are restyled, not rebuilt.
-                const aligned = MenuItemStyleOverlay.With(rItem.item, MenuItemStyleOverlay.Get(params.item));
-                const pickOnly = MenuItemStyles.IsStyleChangeOnly(aligned, params.item);
+                // Only the style pick, overlay or bookmark style changed, so the graphics are restyled, not rebuilt.
+                const stripped = MenuItemStyleOverlay.Strip(params.item);
+                const pickOnly = MenuItemStyles.IsStyleChangeOnly(MenuItemStyleOverlay.Strip(rItem.item), stripped);
                 const restyleOnly = pickOnly || MenuItemStyleOverlay.IsChangeOnly(rItem.item, params.item);
                 if (restyleOnly && this.isStyleSwapCapable(rItem.renderManager)) {
                     rItem.renderManager.SwapStyle(params.item);
@@ -32901,10 +32988,13 @@ var MenuItemManager;
             if (!rItem || !this.isStyleSwapCapable(rItem.renderManager) || rItem.renderManager.Disposed) {
                 return false;
             }
-            const next = MenuItemStyles.WithStyleId(rItem.item, styleId);
-            if (!next) {
+            const picked = MenuItemStyles.WithStyleId(rItem.item, styleId);
+            if (!picked) {
                 return false;
             }
+            // A Style record a bookmark laid is drawn over the pick, so picking one of the item's own takes it off.
+            const chosen = MenuItemStyleOverlay.WithItemStyle(picked, null);
+            const next = MenuItemStyleOverlay.With(chosen, this.getEffectiveOverlay(chosen, this.styleOverlay));
             rItem.renderManager.SwapStyle(next);
             rItem.item = next;
             (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger({ isEnabling: true, itemId: rItem.id });
@@ -32936,7 +33026,7 @@ var MenuItemManager;
             }
             this.styleOverlay = overlay;
             for (const rItem of this.items) {
-                const next = MenuItemStyleOverlay.With(rItem.item, overlay);
+                const next = MenuItemStyleOverlay.With(rItem.item, this.getEffectiveOverlay(rItem.item, overlay));
                 // Setting the same overlay again would otherwise restyle every feature for nothing.
                 const unchanged = JSON.stringify(MenuItemStyleOverlay.Get(next)) === JSON.stringify(MenuItemStyleOverlay.Get(rItem.item));
                 if (unchanged ||
@@ -32949,6 +33039,81 @@ var MenuItemManager;
                 (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger({ isEnabling: true, itemId: rItem.id });
             }
         }
+        /**
+         * Lays an inline style or any Style record on one enabled item under the scene-wide one; neither clears it.
+         */
+        SetItemStyleOverlay(params) {
+            var _a;
+            const rItem = this.items.find(x => x.id === params.menuItemId);
+            let itemStyle = null;
+            if (params.style) {
+                itemStyle = { style: params.style };
+            }
+            else if (params.styleId != null) {
+                itemStyle = { styleId: params.styleId };
+            }
+            if (!rItem ||
+                !this.isStyleSwapCapable(rItem.renderManager) ||
+                rItem.renderManager.Disposed ||
+                (itemStyle && !MenuItemStyleOverlay.Supports(rItem.item))) {
+                return false;
+            }
+            const styled = MenuItemStyleOverlay.WithItemStyle(rItem.item, itemStyle);
+            const next = MenuItemStyleOverlay.With(styled, this.getEffectiveOverlay(styled, this.styleOverlay));
+            rItem.renderManager.SwapStyle(next);
+            rItem.item = next;
+            (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger({ isEnabling: true, itemId: rItem.id });
+            return true;
+        }
+        /*
+         * Returns the overlay the item renders with, starting the load of a record it names that is not loaded yet.
+         */
+        getEffectiveOverlay(item, overlay) {
+            const styleId = MenuItemStyleOverlay.GetItemStyle(item) ? null : MenuItemStyleOverlay.GetItemStyleId(item);
+            if (styleId != null && !this.itemStyleRecords.has(String(styleId))) {
+                this.loadItemStyleRecord(styleId);
+            }
+            const record = styleId != null ? this.itemStyleRecords.get(String(styleId)) : null;
+            return MenuItemStyleOverlay.Effective(item, overlay, record !== null && record !== void 0 ? record : undefined);
+        }
+        /*
+         * Loads a record a bookmark style names, then restyles every enabled item that names it.
+         */
+        async loadItemStyleRecord(styleId) {
+            var _a, _b;
+            const key = String(styleId);
+            if (this.itemStyleRecordsLoading.has(key)) {
+                return;
+            }
+            this.itemStyleRecordsLoading.add(key);
+            let settings = null;
+            // A record that fails to load leaves the item on its own style.
+            try {
+                const { style } = await Style.Get({
+                    api: this.getters.GetBruceApi(),
+                    styleId
+                });
+                settings = (_a = style === null || style === void 0 ? void 0 : style.Settings) !== null && _a !== void 0 ? _a : null;
+            }
+            catch (e) {
+                console.error(e);
+            }
+            this.itemStyleRecordsLoading.delete(key);
+            this.itemStyleRecords.set(key, settings);
+            for (const rItem of this.items) {
+                if (String(MenuItemStyleOverlay.GetItemStyleId(rItem.item)) !== key ||
+                    MenuItemStyleOverlay.GetItemStyle(rItem.item) ||
+                    !this.isStyleSwapCapable(rItem.renderManager) ||
+                    rItem.renderManager.Disposed) {
+                    continue;
+                }
+                const effective = this.getEffectiveOverlay(rItem.item, this.styleOverlay);
+                const next = MenuItemStyleOverlay.With(rItem.item, effective);
+                rItem.renderManager.SwapStyle(next);
+                rItem.item = next;
+                (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({ isEnabling: true, itemId: rItem.id });
+            }
+        }
         /*
          * Picks the child the caller asked for, else the one already enabled, else the first.
          */
@@ -56523,7 +56688,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.6.7";
+const VERSION = "7.6.9";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.