bruce-cesium 6.9.1 → 6.9.3

package/dist/bruce-cesium.umd.js

@@ -2597,7 +2597,9 @@
             constructor(params) {
                 this.widgetId = BModels.ObjectUtils.UId();
                 let { viewer, container, manager } = params;
-                if (!container) {
+                // A host app can pass an undefined viewer (eg. mid-teardown); fall back to
+                // no container rather than crashing on viewer.container.
+                if (!container && viewer) {
                     container = viewer.container;
                 }
                 this._viewer = viewer;
@@ -3153,7 +3155,10 @@
             this.customControls = new Map();
             this._generateStyles();
             this._generateElement();
-            this._viewer[VIEWER_VIEW_BAR_WIDGET_KEY] = this;
+            // Guard against a host app constructing this widget with no live viewer.
+            if (this._viewer) {
+                this._viewer[VIEWER_VIEW_BAR_WIDGET_KEY] = this;
+            }
         }
         Dispose() {
             super.Dispose();
@@ -23350,7 +23355,10 @@
             this._viewId = params.viewId;
             this._generateStyles();
             this._generateElement();
-            this._viewer[VIEWER_LEFT_PANEL_WIDGET_KEY] = this;
+            // Guard against a host app constructing this widget with no live viewer.
+            if (this._viewer) {
+                this._viewer[VIEWER_LEFT_PANEL_WIDGET_KEY] = this;
+            }
             this._loading = this.loadBookmarks();
             this._loading.then(() => {
                 if (params.runFirstBookmark && this.bookmarks.length) {
@@ -23792,10 +23800,18 @@
                             return;
                         }
                         const clazz = this.customTabs.get(this._enabledPanelTab);
-                        tabContent = new clazz({
-                            widget: this,
-                            container: container
-                        });
+                        try {
+                            tabContent = new clazz({
+                                widget: this,
+                                container: container
+                            });
+                        }
+                        catch (e) {
+                            // Partner-supplied tab content class; a throwing constructor shouldn't take
+                            // down the whole panel.
+                            console.error(e);
+                            return;
+                        }
                         break;
                 }
                 this._enabledTabContent = tabContent;
@@ -23817,17 +23833,18 @@
             document.documentElement.style.setProperty(VIEWER_LEFT_PANEL_CSS_VAR_LEFT, "0px");
         }
         SelectBookmark(bookmark) {
+            var _a;
             const isFirstEnabled = !this._lastEnabledBookmarkId;
             this._lastEnabledBookmarkId = bookmark.ID;
             exports.ViewRenderEngine.Render({
-                apiGetter: this._apiGetters.GetBruceGetter(),
+                apiGetter: (_a = this._apiGetters) === null || _a === void 0 ? void 0 : _a.GetBruceGetter(),
                 bookmark: bookmark,
                 bookmarkId: bookmark.ID,
                 manager: this._manager,
                 skipTransition: isFirstEnabled,
                 viewer: this._viewer,
                 viewId: this._viewId
-            });
+            }).catch((e) => console.error(e));
             if (this._onBookmarkSelect) {
                 this._onBookmarkSelect.Trigger(bookmark);
             }
@@ -26523,7 +26540,10 @@
                 }
                 this._updateBookmarks();
             });
-            this._viewer[VIEWER_BOOKMARKS_WIDGET_KEY] = this;
+            // Guard against a host app constructing this widget with no live viewer.
+            if (this._viewer) {
+                this._viewer[VIEWER_BOOKMARKS_WIDGET_KEY] = this;
+            }
         }
         LoadViewId(params) {
             let { viewId, runFirstBookmark, autoPlay, bookmarkId } = params;
@@ -26901,9 +26921,10 @@
         `;
         }
         _updateBookmarks() {
+            var _a;
             const bookmarks = this.bookmarks;
             this._element.style.display = bookmarks.length ? "flex" : "none";
-            const api = this._apiGetters.GetBruceApi();
+            const api = (_a = this._apiGetters) === null || _a === void 0 ? void 0 : _a.GetBruceApi();
             const row = this._row;
             row.innerHTML = "";
             for (const bookmark of bookmarks) {
@@ -26945,7 +26966,7 @@
                 skipTransition: isFirstEnabled,
                 viewId: this._viewId,
                 viewer: this._viewer
-            });
+            }).catch((e) => console.error(e));
         }
         _updateBookmark() {
             const allBookmarks = this._row.querySelectorAll(".NextspaceBookmarksRowItem");
@@ -29026,7 +29047,12 @@
             this._cesiumEventRemoval = null;
         }
         _listenSelection() {
+            var _a, _b;
             this._disposeCesiumEvent();
+            // No live viewer/scene to attach cursor listeners to (eg. widget constructed without one).
+            if (!((_b = (_a = this._viewer) === null || _a === void 0 ? void 0 : _a.scene) === null || _b === void 0 ? void 0 : _b.canvas)) {
+                return;
+            }
             const events = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
             const throttle = new CursorBarMouseEventThrottle(this._viewer);
             let lastHoverPos = null;
@@ -36531,7 +36557,7 @@
     }
 
     (function (EntityRenderEnginePolygon) {
-        function Render(params) {
+        async function Render(params) {
             var _a, _b;
             const entity = params.entity;
             const pRings = BModels.Entity.GetValue({
@@ -36542,9 +36568,26 @@
                 return null;
             }
             const style = params.style;
+            const fillType = style.fillType || BModels.Style.EPolygonFillType.Color;
             const fillColorTrace = style.fillColor ? BModels.Calculator.TraceGetColor(style.fillColor, entity, params.tags) : { value: null, effective: null };
             const bFillColor = fillColorTrace.value;
             const cFillColor = bFillColor ? ColorToCColor(bFillColor) : Cesium.Color.fromCssColorString("rgba(139, 195, 74, 0.8)");
+            let textureDataUri = null;
+            let textureTraceEffective = null;
+            if (fillType === BModels.Style.EPolygonFillType.Texture) {
+                const resolved = await resolveTexturedFill({
+                    api: params.api,
+                    style,
+                    entity,
+                    tags: params.tags
+                });
+                textureDataUri = resolved.dataUri;
+                textureTraceEffective = resolved.effective;
+            }
+            const hasFill = fillType === BModels.Style.EPolygonFillType.Texture ? Boolean(textureDataUri) : cFillColor.alpha > 0;
+            const fillMaterial = textureDataUri
+                ? new Cesium.ImageMaterialProperty({ image: textureDataUri, transparent: true })
+                : cFillColor;
             const lineColorTrace = style.lineColor ? BModels.Calculator.TraceGetColor(style.lineColor, entity, params.tags) : { value: null, effective: null };
             const bLineColor = lineColorTrace.value;
             const cLineColor = bLineColor ? ColorToCColor(bLineColor) : Cesium.Color.fromCssColorString("rgba(80, 80, 80, 0.8)");
@@ -36563,7 +36606,7 @@
             }
             // If both outline and fill is not available then don't render anything.
             if ((width <= 0 || cLineColor.alpha <= 0) &&
-                cFillColor.alpha <= 0) {
+                !hasFill) {
                 return null;
             }
             let heightRef = getHeightRef$3(style);
@@ -36618,7 +36661,7 @@
                     id: BModels.ObjectUtils.UId(15),
                     polygon: {
                         hierarchy: new Cesium.PolygonHierarchy(posses, holePosses.map(x => new Cesium.PolygonHierarchy(x))),
-                        material: cFillColor,
+                        material: fillMaterial,
                         extrudedHeight: extrusion.value,
                         extrudedHeightReference: extrusion.exHeightRef,
                         shadows: Cesium.ShadowMode.ENABLED,
@@ -36683,15 +36726,21 @@
                 cEntity.polygon.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true));
                 cEntity.polygon.shadows = new Cesium.ConstantProperty(Cesium.ShadowMode.ENABLED);
                 cEntity.polygon.classificationType = new Cesium.ConstantProperty(classification);
-                // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
-                // WARNING: polygon does not support animation (yet?).
-                exports.CesiumEntityStyler.SetDefaultColor({
-                    color: cFillColor,
-                    entity: cEntity,
-                    viewer: params.viewer,
-                    override: true,
-                    requestRender: false
-                });
+                // TODO: animate the texture!
+                if (textureDataUri) {
+                    cEntity.polygon.material = fillMaterial;
+                }
+                else {
+                    // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                    // WARNING: polygon does not support animation (yet?).
+                    exports.CesiumEntityStyler.SetDefaultColor({
+                        color: cFillColor,
+                        entity: cEntity,
+                        viewer: params.viewer,
+                        override: true,
+                        requestRender: false
+                    });
+                }
                 cEntity.show = true;
             }
             if (hasOutline) {
@@ -36839,6 +36888,7 @@
             }
             cEntity.styleEffective = exports.StyleEffective.Combine([
                 { key: "color", effective: fillColorTrace.effective },
+                { key: "texture", effective: textureTraceEffective },
                 { key: "lineColor", effective: lineColorTrace.effective },
                 { key: "lineWidth", effective: lineWidthTrace.effective }
             ]);
@@ -36890,11 +36940,12 @@
                     }
                 }
                 const pStyle = (_b = style === null || style === void 0 ? void 0 : style.polygonStyle) !== null && _b !== void 0 ? _b : {};
-                const cEntity = Render({
+                const cEntity = await Render({
                     entity: entity,
                     style: pStyle,
                     tags: tags,
                     viewer: params.viewer,
+                    api,
                     maxDistance: zoomItem.MaxZoom,
                     minDistance: zoomItem.MinZoom,
                     // Temporarily disabling re-using graphics for polygons as they have some bugs, and
@@ -37012,6 +37063,95 @@
         }
         return style;
     }
+    // Cache of tinted texture data URIs, keyed by resolved url + color mask, so repeated renders of the
+    // same polygon (or multiple polygons sharing a texture) don't refetch/reprocess the same image.
+    const _textureCache = new BModels.LRUCache(50);
+    /**
+     * Returns if a resolved texture value looks like a URL rather than a client file ID.
+     * @param value
+     */
+    function looksLikeTextureUrl(value) {
+        return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value) || value.startsWith("//") || value.startsWith("data:");
+    }
+    /**
+     * Resolves a polygon style's texture field and if a color ask is needed it tints the resulting image.
+     * @param params
+     */
+    async function resolveTexturedFill(params) {
+        const { api, style, entity, tags } = params;
+        const textureTrace = style.texture ? BModels.Calculator.TraceGetString(style.texture, entity, tags) : { value: null, effective: null };
+        const raw = textureTrace.value;
+        if (!raw || typeof raw != "string" || !api) {
+            return { dataUri: null, effective: textureTrace.effective };
+        }
+        let url = raw;
+        if (!looksLikeTextureUrl(raw)) {
+            await api.Loading;
+            url = BModels.ClientFile.GetUrl({
+                api,
+                fileId: raw,
+                viaCdn: true
+            });
+        }
+        const mask = style.textureColorMask;
+        const cacheKey = "texture-" + url + "-" + (mask ? mask.type + "-" + mask.minColor + "-" + mask.maxColor : "none");
+        let prom = _textureCache.Get(cacheKey);
+        if (!prom) {
+            prom = buildTintedTextureDataUri(url, mask).catch(() => null);
+            _textureCache.Set(cacheKey, prom);
+        }
+        return { dataUri: await prom, effective: textureTrace.effective };
+    }
+    /**
+     * Fetches an image and, if a color mask is provided, remaps its (assumed grayscale) pixel values
+     * into a gradient between the mask's minColor/maxColor, preserving source alpha.
+     * @param url
+     * @param mask
+     */
+    async function buildTintedTextureDataUri(url, mask) {
+        const response = await fetch(url);
+        const blob = await response.blob();
+        const objectUrl = URL.createObjectURL(blob);
+        let image;
+        try {
+            image = await loadImage(objectUrl);
+        }
+        finally {
+            URL.revokeObjectURL(objectUrl);
+        }
+        const canvas = document.createElement("canvas");
+        canvas.width = image.width;
+        canvas.height = image.height;
+        const context = canvas.getContext("2d");
+        context.drawImage(image, 0, 0);
+        if (mask && mask.type === BModels.Style.ETextureColorMaskType.BlackWhite) {
+            const minColor = BModels.Color.ColorFromStr(mask.minColor) || { red: 0, green: 0, blue: 0, alpha: 1 };
+            const maxColor = BModels.Color.ColorFromStr(mask.maxColor) || { red: 255, green: 255, blue: 255, alpha: 1 };
+            const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+            const data = imageData.data;
+            for (let i = 0; i < data.length; i += 4) {
+                // The texture is rendered black-to-white server-side, so any channel carries the value.
+                const t = data[i] / 255;
+                data[i] = Math.round(minColor.red + (maxColor.red - minColor.red) * t);
+                data[i + 1] = Math.round(minColor.green + (maxColor.green - minColor.green) * t);
+                data[i + 2] = Math.round(minColor.blue + (maxColor.blue - minColor.blue) * t);
+                // Preserve source transparency (eg unrasterized pixels) blended with the mask's own alpha.
+                const srcAlpha = data[i + 3] / 255;
+                const maskAlpha = minColor.alpha + (maxColor.alpha - minColor.alpha) * t;
+                data[i + 3] = Math.round(srcAlpha * maskAlpha * 255);
+            }
+            context.putImageData(imageData, 0, 0);
+        }
+        return canvas.toDataURL("image/png");
+    }
+    function loadImage(src) {
+        return new Promise((res, rej) => {
+            const image = new Image();
+            image.onload = () => res(image);
+            image.onerror = (e) => rej(e);
+            image.src = src;
+        });
+    }
     /**
      * Compares two color materials.
      * Returns if they are equal.
@@ -38297,7 +38437,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "6.9.1";
+    const VERSION = "6.9.3";
     /**
      * 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.