@itwin/frontend-devtools 4.0.0-dev.7 → 4.0.0-dev.70

package/lib/esm/tools/MapLayerTool.js

@@ -1,486 +1,505 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { BaseMapLayerSettings, ColorDef, ModelMapLayerSettings } from "@itwin/core-common";
-import { IModelApp, MapLayerSource, MapLayerSources, MapLayerSourceStatus, NotifyMessageDetails, OutputMessagePriority, Tool, WmsUtilities } from "@itwin/core-frontend";
-import { parseBoolean } from "./parseBoolean";
-import { parseToggle } from "./parseToggle";
-/** Base class for attaching map layer tool. */
-class AttachMapLayerBaseTool extends Tool {
-    constructor(_isBackground = true, _isBase = false) {
-        super();
-        this._isBackground = _isBackground;
-        this._isBase = _isBase;
-    }
-    doAttach(source) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (vp === undefined || source === undefined)
-            return;
-        source.validateSource().then((validation) => {
-            if (validation.status === MapLayerSourceStatus.Valid || validation.status === MapLayerSourceStatus.RequireAuth) {
-                if (this._isBase) {
-                    vp.displayStyle.backgroundMapBase = BaseMapLayerSettings.fromJSON({ ...source, subLayers: validation.subLayers });
-                    vp.invalidateRenderPlan();
-                }
-                else {
-                    const settings = source.toLayerSettings(validation.subLayers);
-                    if (settings) {
-                        vp.displayStyle.attachMapLayer({ settings, isOverlay: !this._isBackground });
-                    }
-                }
-                if (validation.status === MapLayerSourceStatus.Valid) {
-                    vp.invalidateRenderPlan();
-                    const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerAttached", { sourceName: source.name, sourceUrl: source.url });
-                    IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Info, msg));
-                }
-                else if (validation.status === MapLayerSourceStatus.RequireAuth) {
-                    const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerAttachedRequiresAuth", { sourceName: source.name });
-                    IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Warning, msg));
-                }
-            }
-            else {
-                const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerValidationFailed", { sourceUrl: source.url });
-                IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, msg));
-            }
-        }).catch((error) => {
-            const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerAttachError", { error, sourceUrl: source.url });
-            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, msg));
-        });
-    }
-}
-/** Attach a map layer from URL base class. A layer is attached for each unique model in the selection
- * @beta
- */
-export class AttachModelMapLayerTool extends Tool {
-    constructor(_formatId) {
-        super();
-        this._formatId = _formatId;
-    }
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 1; }
-    async run(nameIn) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (!vp)
-            return false;
-        const iModel = vp.iModel;
-        const elements = await iModel.elements.getProps(iModel.selectionSet.elements);
-        const modelIds = new Set();
-        for (const element of elements)
-            modelIds.add(element.model);
-        for (const modelId of modelIds) {
-            const modelProps = await iModel.models.getProps(modelId);
-            const modelName = modelProps[0].name ? modelProps[0].name : modelId;
-            const name = nameIn ? (modelIds.size > 1 ? `${nameIn}: ${modelName}` : nameIn) : modelName;
-            const settings = ModelMapLayerSettings.fromJSON({ name, modelId });
-            vp.displayStyle.attachMapLayer({ settings, isOverlay: false });
-        }
-        return true;
-    }
-    async parseAndRun(...args) {
-        return this.run(args[0]);
-    }
-    async onRestartTool() {
-    }
-}
-AttachModelMapLayerTool.toolId = "AttachModelMapLayerTool";
-/** Attach a map layer from URL base class. */
-class AttachMapLayerByURLBaseTool extends AttachMapLayerBaseTool {
-    constructor(_formatId) {
-        super();
-        this._formatId = _formatId;
-    }
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 4; }
-    async run(url, name, userName, password) {
-        const source = MapLayerSource.fromJSON({ url, name: (name ? name : url), formatId: this._formatId });
-        if (source) {
-            source.userName = userName;
-            source.password = password;
-        }
-        this.doAttach(source);
-        return true;
-    }
-    async parseAndRun(...args) {
-        return this.run(args[0], args[1], args[2], args[3]);
-    }
-}
-/** This tool attaches a WMS map layer from a given URL.
- * @beta
- */
-export class AttachWmsMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
-    constructor() { super("WMS"); }
-    /** This method runs the tool, attaching a WMS map layer from a given URL.
-     * @param args contains url, name, userName, password in array order
-     */
-    async parseAndRun(...args) {
-        return this.run(WmsUtilities.getBaseUrl(args[0]), args[1], args[2], args[3]);
-    }
-}
-AttachWmsMapLayerByUrlTool.toolId = "AttachWmsMapLayerTool";
-/** This tool attaches a WMTS map layer from a given URL.
- * @beta
- */
-export class AttachWmtsMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
-    constructor() { super("WMTS"); }
-    /** This method runs the tool, attaching a WMTS map layer from a given URL.
-     * @param args contains url, name, userName, password in array order
-     */
-    async parseAndRun(...args) {
-        return this.run(WmsUtilities.getBaseUrl(args[0]), args[1], args[2], args[3]);
-    }
-}
-AttachWmtsMapLayerByUrlTool.toolId = "AttachWmtsMapLayerTool";
-/** This tool attaches an ArcGIS map layer from a given URL.
- * @beta
- */
-export class AttachArcGISMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
-    constructor() { super("ArcGIS"); }
-}
-AttachArcGISMapLayerByUrlTool.toolId = "AttachArcGISMapLayerTool";
-/** This tool attaches an ArcGIS map layer from a given URL.
- * @beta
- */
-export class AttachArcGISFeatureMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
-    constructor() { super("ArcGISFeature"); }
-}
-AttachArcGISFeatureMapLayerByUrlTool.toolId = "AttachArcGISFeatureMapLayerTool";
-/** This tool attaches a map layer from a given tile URL.
- * @beta
- */
-export class AttachTileURLMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
-    constructor() { super("TileURL"); }
-}
-AttachTileURLMapLayerByUrlTool.toolId = "AttachTileURLMapLayerTool";
-/** This tool add a Map Layer from a specified name (look up in MapLayerSources.json).
- * @beta
- */
-export class AttachMapLayerTool extends AttachMapLayerBaseTool {
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 1; }
-    /** This method runs the tool, adding a map layer from a specified name in MayLayerSources.json.
-     * @param name the name of the map layer to add
-     */
-    async run(name) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (vp === undefined)
-            return false;
-        MapLayerSources.create().then((sources) => {
-            if (sources !== undefined) {
-                const source = sources.findByName(name, this._isBase);
-                if (source !== undefined)
-                    this.doAttach(source);
-            }
-        }).catch((_err) => { });
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `name`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        return this.run(args[0]);
-    }
-}
-AttachMapLayerTool.toolId = "AttachMapLayerTool";
-/** This tool attaches a Overlay map layer.
- * @beta
- */
-export class AttachMapOverlayTool extends AttachMapLayerTool {
-    constructor() {
-        super();
-        this._isBackground = false;
-    }
-}
-AttachMapOverlayTool.toolId = "AttachMapOverlayTool";
-/** Sets map layer base tool.
- * @beta
- */
-export class SetMapBaseTool extends AttachMapLayerTool {
-    constructor() {
-        super();
-        this._isBase = true;
-    }
-}
-SetMapBaseTool.toolId = "SetMapBaseTool";
-/** Detach Map Layers Tool.
- * @beta
- */
-export class DetachMapLayersTool extends Tool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 0; }
-    async parseAndRun(..._args) {
-        return this.run();
-    }
-    async run() {
-        const vp = IModelApp.viewManager.selectedView;
-        if (vp === undefined)
-            return false;
-        vp.displayStyle.detachMapLayerByIndex(-1, true);
-        vp.displayStyle.detachMapLayerByIndex(-1, false);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-}
-DetachMapLayersTool.toolId = "DetachMapLayersTool";
-function parseLayerIndex(args) {
-    const layerIndex = args.length > 1 ? parseInt(args[1], 10) : 0;
-    return isNaN(layerIndex) ? 0 : layerIndex;
-}
-/** This tool sets the visibility of the map layer.
- * @beta
- */
-export class MapLayerVisibilityTool extends Tool {
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 2; }
-    /** This method runs the tool, setting the visibility of a map layer.
-     * @param layerIndex the index of the layer to change
-     * @param visible a boolean that should be true if the layer should be visible
-     */
-    async run(layerIndex, enable) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        const mapLayer = vp.displayStyle.mapLayerAtIndex(layerIndex, false);
-        if (undefined === mapLayer)
-            return false;
-        const visible = (enable === undefined) ? !mapLayer.visible : enable;
-        vp.displayStyle.changeMapLayerProps({ visible }, layerIndex, false);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `enable` and args[1] containing `layerIndex`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const enable = parseToggle(args[0]);
-        const layerIndex = parseLayerIndex(args);
-        if (typeof enable !== "string")
-            await this.run(layerIndex, enable);
-        return true;
-    }
-}
-MapLayerVisibilityTool.toolId = "SetMapLayerVisibility";
-/** This tool reorders map layers.
- * @beta
- */
-export class ReorderMapLayers extends Tool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 2; }
-    /** This method runs the tool, reordering the map layers.
-     * @param from a numeric value specifying the layer index that is being moved
-     * @param from a numeric value specifying the layer index to move that layer to
-     */
-    async run(from, to) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        vp.displayStyle.moveMapLayerToIndex(isNaN(from) ? 0 : from, isNaN(to) ? vp.displayStyle.backgroundMapLayers.length : to, false);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `from` and args[1] containing `to`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const from = parseInt(args[0], 10);
-        const to = parseInt(args[1], 10);
-        await this.run(from, to);
-        return true;
-    }
-}
-ReorderMapLayers.toolId = "ReorderMapLayers";
-/** This tool sets the transparency of a map layer.
- * @beta
- */
-export class MapLayerTransparencyTool extends Tool {
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 2; }
-    /** This method runs the tool, setting the transparency of a map layer.
-     * @param layerIndex the index of the layer to change
-     * @param transparency a numeric value in the range 0.0 (fully opaque) to 1.0 (fully transparent)
-     */
-    async run(layerIndex, transparency) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        vp.displayStyle.changeMapLayerProps({ transparency }, layerIndex, false);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `transparency` and args[1] containing `layerIndex`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const transparency = parseFloat(args[0]);
-        const layerIndex = parseLayerIndex(args);
-        if (transparency >= 0 && transparency <= 1)
-            await this.run(layerIndex, transparency);
-        return true;
-    }
-}
-MapLayerTransparencyTool.toolId = "SetMapLayerTransparency";
-/** This tool sets the visibility of the map sublayer.
- * @beta
- */
-export class MapLayerSubLayerVisibilityTool extends Tool {
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 2; }
-    /** This method runs the tool, setting the visibility of a map sublayer.
-     * @param layerIndex the index of the layer to change
-     * @param visible a boolean that should be true if the sublayer should be visible
-     */
-    async run(layerIndex, visible) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        vp.displayStyle.changeMapSubLayerProps({ visible }, -1, layerIndex, false);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `transparency` and args[1] containing `layerIndex`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const on = args[0] !== "off";
-        const layerIndex = parseLayerIndex(args);
-        await this.run(layerIndex, on);
-        return true;
-    }
-}
-MapLayerSubLayerVisibilityTool.toolId = "SetMapSubLayerVisibility";
-/** This tool changes the viewport so it is zoomed to the range of a map layer.
- * @beta
- */
-export class MapLayerZoomTool extends Tool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 1; }
-    /** This method runs the tool, changing the viewport so it is zoomed to the range of a map layer.
-     * @param layerIndex the index of the layer whose range to zoom to
-     */
-    async run(layerIndex) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        vp.displayStyle.viewMapLayerRange(layerIndex, false, vp).then(() => { }).catch(() => { });
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `layerIndex`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const layerIndex = parseLayerIndex(args);
-        await this.run(layerIndex);
-        return true;
-    }
-}
-MapLayerZoomTool.toolId = "MapLayerZoom";
-/** This tool toggles whether to apply terrain heights to the map.
- * @beta
- */
-export class ToggleTerrainTool extends Tool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 1; }
-    /** This method runs the tool, changing whether to apply terrain heights to the map.
-     * @param enable whether or not to enable terrain heights on the map
-     */
-    async run(enable) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        const applyTerrain = (enable === undefined) ? !vp.displayStyle.backgroundMapSettings.applyTerrain : enable;
-        vp.displayStyle.changeBackgroundMapProps({ applyTerrain });
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `enable`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const enable = parseToggle(args[0]);
-        if (typeof enable !== "string")
-            await this.run(enable);
-        return true;
-    }
-}
-ToggleTerrainTool.toolId = "ToggleTerrain";
-/** This tool changes the color of the base map.
- * @beta
- */
-export class MapBaseColorTool extends Tool {
-    static get minArgs() { return 3; }
-    static get maxArgs() { return 3; }
-    /** This method runs the tool, changing the color of the base map.
-     * @param color the color for the base map
-     */
-    async run(color) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        const curTransparency = vp.displayStyle.backgroundMapBase instanceof ColorDef ? vp.displayStyle.backgroundMapBase.getTransparency() : 0;
-        vp.displayStyle.backgroundMapBase = color.withTransparency(curTransparency);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing a 0 to 255 red component, args[1] containing a 0 to 255 green component, and args[2] containing a 0 to 255 blue component.
-     * These rgb values will be used to construct the `color` parameter passed to this tool's run method.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const red = parseFloat(args[0]), green = parseFloat(args[1]), blue = parseFloat(args[2]);
-        return (isNaN(red) || red < 0 || red > 255 || isNaN(green) || green < 0 || green > 255 || isNaN(blue) || blue < 0 || blue > 255) ? false : this.run(ColorDef.from(red, green, blue));
-    }
-}
-MapBaseColorTool.toolId = "SetMapBaseColorTool";
-/** This tool changes the transparency of the base map.
- * @beta
- */
-export class MapBaseTransparencyTool extends Tool {
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 1; }
-    /** This method runs the tool, changing the transparency of the base map.
-     * @param transparency a numeric value in range 0.0 to 1.0 whether 0.0 means fully opaque and 1.0 means fully transparent
-     */
-    async run(transparency) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView())
-            return false;
-        vp.displayStyle.changeBaseMapTransparency(transparency);
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `transparency`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const transparency = parseFloat(args[0]);
-        return (isNaN(transparency) || transparency < 0 || transparency > 1) ? false : this.run(transparency);
-    }
-}
-MapBaseTransparencyTool.toolId = "SetMapBaseTransparencyTool";
-/** This tool changes the visibility of the base map.
- * @beta
- */
-export class MapBaseVisibilityTool extends Tool {
-    static get minArgs() { return 1; }
-    static get maxArgs() { return 1; }
-    /** This method runs the tool, changing the visibility of the base map.
-     * @param visible a boolean which specifies whether or not to make the base map visible
-     */
-    async run(visible) {
-        const vp = IModelApp.viewManager.selectedView;
-        if (undefined === vp || !vp.view.isSpatialView() || vp.displayStyle.backgroundMapBase instanceof ColorDef)
-            return false;
-        vp.displayStyle.backgroundMapBase = vp.displayStyle.backgroundMapBase.clone({ visible });
-        vp.invalidateRenderPlan();
-        return true;
-    }
-    /** Executes this tool's run method with args[0] containing `visible`.
-     * @see [[run]]
-     */
-    async parseAndRun(...args) {
-        const visible = parseBoolean(args[0]);
-        return (visible !== undefined ? this.run(visible) : false);
-    }
-}
-MapBaseVisibilityTool.toolId = "SetMapBaseVisibilityTool";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { BaseMapLayerSettings, ColorDef, ModelMapLayerSettings } from "@itwin/core-common";
+import { IModelApp, MapLayerSource, MapLayerSources, MapLayerSourceStatus, NotifyMessageDetails, OutputMessagePriority, Tool, WmsUtilities } from "@itwin/core-frontend";
+import { parseBoolean } from "./parseBoolean";
+import { parseToggle } from "./parseToggle";
+/** Base class for attaching map layer tool. */
+class AttachMapLayerBaseTool extends Tool {
+    constructor(_isBackground = true, _isBase = false) {
+        super();
+        this._isBackground = _isBackground;
+        this._isBase = _isBase;
+    }
+    doAttach(source) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (vp === undefined || source === undefined)
+            return;
+        source.validateSource().then((validation) => {
+            if (validation.status === MapLayerSourceStatus.Valid || validation.status === MapLayerSourceStatus.RequireAuth) {
+                if (this._isBase) {
+                    vp.displayStyle.backgroundMapBase = BaseMapLayerSettings.fromJSON({ ...source, subLayers: validation.subLayers });
+                    vp.invalidateRenderPlan();
+                }
+                else {
+                    const settings = source.toLayerSettings(validation.subLayers);
+                    if (settings) {
+                        vp.displayStyle.attachMapLayer({ settings, isOverlay: !this._isBackground });
+                    }
+                }
+                if (validation.status === MapLayerSourceStatus.Valid) {
+                    vp.invalidateRenderPlan();
+                    const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerAttached", { sourceName: source.name, sourceUrl: source.url });
+                    IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Info, msg));
+                }
+                else if (validation.status === MapLayerSourceStatus.RequireAuth) {
+                    const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerAttachedRequiresAuth", { sourceName: source.name });
+                    IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Warning, msg));
+                }
+            }
+            else {
+                const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerValidationFailed", { sourceUrl: source.url });
+                IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, msg));
+            }
+        }).catch((error) => {
+            const msg = IModelApp.localization.getLocalizedString("FrontendDevTools:tools.AttachMapLayerTool.Messages.MapLayerAttachError", { error, sourceUrl: source.url });
+            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, msg));
+        });
+    }
+}
+/** Attach a map layer from URL base class. A layer is attached for each unique model in the selection
+ * @beta
+ */
+class AttachModelMapLayerTool extends Tool {
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 1; }
+    constructor(_formatId) {
+        super();
+        this._formatId = _formatId;
+    }
+    async run(nameIn) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (!vp)
+            return false;
+        const iModel = vp.iModel;
+        const elements = await iModel.elements.getProps(iModel.selectionSet.elements);
+        const modelIds = new Set();
+        for (const element of elements)
+            modelIds.add(element.model);
+        for (const modelId of modelIds) {
+            const modelProps = await iModel.models.getProps(modelId);
+            const modelName = modelProps[0].name ? modelProps[0].name : modelId;
+            const name = nameIn ? (modelIds.size > 1 ? `${nameIn}: ${modelName}` : nameIn) : modelName;
+            const settings = ModelMapLayerSettings.fromJSON({ name, modelId });
+            vp.displayStyle.attachMapLayer({ settings, isOverlay: false });
+        }
+        return true;
+    }
+    async parseAndRun(...args) {
+        return this.run(args[0]);
+    }
+    async onRestartTool() {
+    }
+}
+AttachModelMapLayerTool.toolId = "AttachModelMapLayerTool";
+export { AttachModelMapLayerTool };
+/** Attach a map layer from URL base class. */
+class AttachMapLayerByURLBaseTool extends AttachMapLayerBaseTool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 4; }
+    constructor(_formatId) {
+        super();
+        this._formatId = _formatId;
+    }
+    async run(url, name, userName, password) {
+        const source = MapLayerSource.fromJSON({ url, name: (name ? name : url), formatId: this._formatId });
+        if (source) {
+            source.userName = userName;
+            source.password = password;
+        }
+        this.doAttach(source);
+        return true;
+    }
+    async parseAndRun(...args) {
+        return this.run(args[0], args[1], args[2], args[3]);
+    }
+}
+/** This tool attaches a WMS map layer from a given URL.
+ * @beta
+ */
+class AttachWmsMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
+    constructor() { super("WMS"); }
+    /** This method runs the tool, attaching a WMS map layer from a given URL.
+     * @param args contains url, name, userName, password in array order
+     */
+    async parseAndRun(...args) {
+        return this.run(WmsUtilities.getBaseUrl(args[0]), args[1], args[2], args[3]);
+    }
+}
+AttachWmsMapLayerByUrlTool.toolId = "AttachWmsMapLayerTool";
+export { AttachWmsMapLayerByUrlTool };
+/** This tool attaches a WMTS map layer from a given URL.
+ * @beta
+ */
+class AttachWmtsMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
+    constructor() { super("WMTS"); }
+    /** This method runs the tool, attaching a WMTS map layer from a given URL.
+     * @param args contains url, name, userName, password in array order
+     */
+    async parseAndRun(...args) {
+        return this.run(WmsUtilities.getBaseUrl(args[0]), args[1], args[2], args[3]);
+    }
+}
+AttachWmtsMapLayerByUrlTool.toolId = "AttachWmtsMapLayerTool";
+export { AttachWmtsMapLayerByUrlTool };
+/** This tool attaches an ArcGIS map layer from a given URL.
+ * @beta
+ */
+class AttachArcGISMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
+    constructor() { super("ArcGIS"); }
+}
+AttachArcGISMapLayerByUrlTool.toolId = "AttachArcGISMapLayerTool";
+export { AttachArcGISMapLayerByUrlTool };
+/** This tool attaches an ArcGIS map layer from a given URL.
+ * @beta
+ */
+class AttachArcGISFeatureMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
+    constructor() { super("ArcGISFeature"); }
+}
+AttachArcGISFeatureMapLayerByUrlTool.toolId = "AttachArcGISFeatureMapLayerTool";
+export { AttachArcGISFeatureMapLayerByUrlTool };
+/** This tool attaches a map layer from a given tile URL.
+ * @beta
+ */
+class AttachTileURLMapLayerByUrlTool extends AttachMapLayerByURLBaseTool {
+    constructor() { super("TileURL"); }
+}
+AttachTileURLMapLayerByUrlTool.toolId = "AttachTileURLMapLayerTool";
+export { AttachTileURLMapLayerByUrlTool };
+/** This tool add a Map Layer from a specified name (look up in MapLayerSources.json).
+ * @beta
+ */
+class AttachMapLayerTool extends AttachMapLayerBaseTool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 1; }
+    /** This method runs the tool, adding a map layer from a specified name in MayLayerSources.json.
+     * @param name the name of the map layer to add
+     */
+    async run(name) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (vp === undefined)
+            return false;
+        MapLayerSources.create().then((sources) => {
+            if (sources !== undefined) {
+                const source = sources.findByName(name, this._isBase);
+                if (source !== undefined)
+                    this.doAttach(source);
+            }
+        }).catch((_err) => { });
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `name`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        return this.run(args[0]);
+    }
+}
+AttachMapLayerTool.toolId = "AttachMapLayerTool";
+export { AttachMapLayerTool };
+/** This tool attaches a Overlay map layer.
+ * @beta
+ */
+class AttachMapOverlayTool extends AttachMapLayerTool {
+    constructor() {
+        super();
+        this._isBackground = false;
+    }
+}
+AttachMapOverlayTool.toolId = "AttachMapOverlayTool";
+export { AttachMapOverlayTool };
+/** Sets map layer base tool.
+ * @beta
+ */
+class SetMapBaseTool extends AttachMapLayerTool {
+    constructor() {
+        super();
+        this._isBase = true;
+    }
+}
+SetMapBaseTool.toolId = "SetMapBaseTool";
+export { SetMapBaseTool };
+/** Detach Map Layers Tool.
+ * @beta
+ */
+class DetachMapLayersTool extends Tool {
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 0; }
+    async parseAndRun(..._args) {
+        return this.run();
+    }
+    async run() {
+        const vp = IModelApp.viewManager.selectedView;
+        if (vp === undefined)
+            return false;
+        vp.displayStyle.detachMapLayerByIndex(-1, true);
+        vp.displayStyle.detachMapLayerByIndex(-1, false);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+}
+DetachMapLayersTool.toolId = "DetachMapLayersTool";
+export { DetachMapLayersTool };
+function parseLayerIndex(args) {
+    const layerIndex = args.length > 1 ? parseInt(args[1], 10) : 0;
+    return isNaN(layerIndex) ? 0 : layerIndex;
+}
+/** This tool sets the visibility of the map layer.
+ * @beta
+ */
+class MapLayerVisibilityTool extends Tool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 2; }
+    /** This method runs the tool, setting the visibility of a map layer.
+     * @param layerIndex the index of the layer to change
+     * @param visible a boolean that should be true if the layer should be visible
+     */
+    async run(layerIndex, enable) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        const mapLayer = vp.displayStyle.mapLayerAtIndex(layerIndex, false);
+        if (undefined === mapLayer)
+            return false;
+        const visible = (enable === undefined) ? !mapLayer.visible : enable;
+        vp.displayStyle.changeMapLayerProps({ visible }, layerIndex, false);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `enable` and args[1] containing `layerIndex`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const enable = parseToggle(args[0]);
+        const layerIndex = parseLayerIndex(args);
+        if (typeof enable !== "string")
+            await this.run(layerIndex, enable);
+        return true;
+    }
+}
+MapLayerVisibilityTool.toolId = "SetMapLayerVisibility";
+export { MapLayerVisibilityTool };
+/** This tool reorders map layers.
+ * @beta
+ */
+class ReorderMapLayers extends Tool {
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 2; }
+    /** This method runs the tool, reordering the map layers.
+     * @param from a numeric value specifying the layer index that is being moved
+     * @param from a numeric value specifying the layer index to move that layer to
+     */
+    async run(from, to) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        vp.displayStyle.moveMapLayerToIndex(isNaN(from) ? 0 : from, isNaN(to) ? vp.displayStyle.backgroundMapLayers.length : to, false);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `from` and args[1] containing `to`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const from = parseInt(args[0], 10);
+        const to = parseInt(args[1], 10);
+        await this.run(from, to);
+        return true;
+    }
+}
+ReorderMapLayers.toolId = "ReorderMapLayers";
+export { ReorderMapLayers };
+/** This tool sets the transparency of a map layer.
+ * @beta
+ */
+class MapLayerTransparencyTool extends Tool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 2; }
+    /** This method runs the tool, setting the transparency of a map layer.
+     * @param layerIndex the index of the layer to change
+     * @param transparency a numeric value in the range 0.0 (fully opaque) to 1.0 (fully transparent)
+     */
+    async run(layerIndex, transparency) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        vp.displayStyle.changeMapLayerProps({ transparency }, layerIndex, false);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `transparency` and args[1] containing `layerIndex`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const transparency = parseFloat(args[0]);
+        const layerIndex = parseLayerIndex(args);
+        if (transparency >= 0 && transparency <= 1)
+            await this.run(layerIndex, transparency);
+        return true;
+    }
+}
+MapLayerTransparencyTool.toolId = "SetMapLayerTransparency";
+export { MapLayerTransparencyTool };
+/** This tool sets the visibility of the map sublayer.
+ * @beta
+ */
+class MapLayerSubLayerVisibilityTool extends Tool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 2; }
+    /** This method runs the tool, setting the visibility of a map sublayer.
+     * @param layerIndex the index of the layer to change
+     * @param visible a boolean that should be true if the sublayer should be visible
+     */
+    async run(layerIndex, visible) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        vp.displayStyle.changeMapSubLayerProps({ visible }, -1, layerIndex, false);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `transparency` and args[1] containing `layerIndex`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const on = args[0] !== "off";
+        const layerIndex = parseLayerIndex(args);
+        await this.run(layerIndex, on);
+        return true;
+    }
+}
+MapLayerSubLayerVisibilityTool.toolId = "SetMapSubLayerVisibility";
+export { MapLayerSubLayerVisibilityTool };
+/** This tool changes the viewport so it is zoomed to the range of a map layer.
+ * @beta
+ */
+class MapLayerZoomTool extends Tool {
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 1; }
+    /** This method runs the tool, changing the viewport so it is zoomed to the range of a map layer.
+     * @param layerIndex the index of the layer whose range to zoom to
+     */
+    async run(layerIndex) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        vp.displayStyle.viewMapLayerRange(layerIndex, false, vp).then(() => { }).catch(() => { });
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `layerIndex`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const layerIndex = parseLayerIndex(args);
+        await this.run(layerIndex);
+        return true;
+    }
+}
+MapLayerZoomTool.toolId = "MapLayerZoom";
+export { MapLayerZoomTool };
+/** This tool toggles whether to apply terrain heights to the map.
+ * @beta
+ */
+class ToggleTerrainTool extends Tool {
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 1; }
+    /** This method runs the tool, changing whether to apply terrain heights to the map.
+     * @param enable whether or not to enable terrain heights on the map
+     */
+    async run(enable) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        const applyTerrain = (enable === undefined) ? !vp.displayStyle.backgroundMapSettings.applyTerrain : enable;
+        vp.displayStyle.changeBackgroundMapProps({ applyTerrain });
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `enable`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const enable = parseToggle(args[0]);
+        if (typeof enable !== "string")
+            await this.run(enable);
+        return true;
+    }
+}
+ToggleTerrainTool.toolId = "ToggleTerrain";
+export { ToggleTerrainTool };
+/** This tool changes the color of the base map.
+ * @beta
+ */
+class MapBaseColorTool extends Tool {
+    static get minArgs() { return 3; }
+    static get maxArgs() { return 3; }
+    /** This method runs the tool, changing the color of the base map.
+     * @param color the color for the base map
+     */
+    async run(color) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        const curTransparency = vp.displayStyle.backgroundMapBase instanceof ColorDef ? vp.displayStyle.backgroundMapBase.getTransparency() : 0;
+        vp.displayStyle.backgroundMapBase = color.withTransparency(curTransparency);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing a 0 to 255 red component, args[1] containing a 0 to 255 green component, and args[2] containing a 0 to 255 blue component.
+     * These rgb values will be used to construct the `color` parameter passed to this tool's run method.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const red = parseFloat(args[0]), green = parseFloat(args[1]), blue = parseFloat(args[2]);
+        return (isNaN(red) || red < 0 || red > 255 || isNaN(green) || green < 0 || green > 255 || isNaN(blue) || blue < 0 || blue > 255) ? false : this.run(ColorDef.from(red, green, blue));
+    }
+}
+MapBaseColorTool.toolId = "SetMapBaseColorTool";
+export { MapBaseColorTool };
+/** This tool changes the transparency of the base map.
+ * @beta
+ */
+class MapBaseTransparencyTool extends Tool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 1; }
+    /** This method runs the tool, changing the transparency of the base map.
+     * @param transparency a numeric value in range 0.0 to 1.0 whether 0.0 means fully opaque and 1.0 means fully transparent
+     */
+    async run(transparency) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView())
+            return false;
+        vp.displayStyle.changeBaseMapTransparency(transparency);
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `transparency`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const transparency = parseFloat(args[0]);
+        return (isNaN(transparency) || transparency < 0 || transparency > 1) ? false : this.run(transparency);
+    }
+}
+MapBaseTransparencyTool.toolId = "SetMapBaseTransparencyTool";
+export { MapBaseTransparencyTool };
+/** This tool changes the visibility of the base map.
+ * @beta
+ */
+class MapBaseVisibilityTool extends Tool {
+    static get minArgs() { return 1; }
+    static get maxArgs() { return 1; }
+    /** This method runs the tool, changing the visibility of the base map.
+     * @param visible a boolean which specifies whether or not to make the base map visible
+     */
+    async run(visible) {
+        const vp = IModelApp.viewManager.selectedView;
+        if (undefined === vp || !vp.view.isSpatialView() || vp.displayStyle.backgroundMapBase instanceof ColorDef)
+            return false;
+        vp.displayStyle.backgroundMapBase = vp.displayStyle.backgroundMapBase.clone({ visible });
+        vp.invalidateRenderPlan();
+        return true;
+    }
+    /** Executes this tool's run method with args[0] containing `visible`.
+     * @see [[run]]
+     */
+    async parseAndRun(...args) {
+        const visible = parseBoolean(args[0]);
+        return (visible !== undefined ? this.run(visible) : false);
+    }
+}
+MapBaseVisibilityTool.toolId = "SetMapBaseVisibilityTool";
+export { MapBaseVisibilityTool };
 //# sourceMappingURL=MapLayerTool.js.map