@arcgis/map-components 4.29.0-beta.7 → 4.29.0-beta.72

package/dist/cjs/arcgis-basemap-gallery_3.cjs.entry.js

@@ -0,0 +1,887 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-fbce570d.js');
+const index$1 = require('./index-09a0e90f.js');
+const componentUtils = require('./component-utils-48cee518.js');
+const disconnected = require('./disconnected-4490368b.js');
+
+const basemapGalleryCss = "";
+
+const ArcgisBasemapGallery = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.widgetReady = index.createEvent(this, "widgetReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.activeBasemap = undefined;
+        this.position = "bottom-left";
+        this.expandable = false;
+        this.source = undefined;
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(newValue) {
+        componentUtils.referenceElementHelper(this, newValue);
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, newValue);
+        }
+    }
+    sourceWatcher(newValue) {
+        if (this.widget) {
+            this.widget.source = newValue;
+        }
+    }
+    viewWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.view = newValue;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await index$1.newWidgetsBasemapGallery(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this.widgetReady.emit({ widget: this.widget });
+        componentUtils.checkForView(this);
+    }
+    disconnectedCallback() {
+        disconnected.onDisconnectedHelper(this);
+    }
+    render() {
+        if (this.expandable) {
+            return (index.h("arcgis-expand", { position: this.position, ref: (el) => (this.expandElem = el) }, index.h("div", { ref: (el) => (this.childElem = el) })));
+        }
+        return index.h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Interal Methods
+    //
+    //--------------------------------------------------------------------------
+    async _addWatchers() {
+        const { watch } = await index$1.importCoreReactiveUtils();
+        componentUtils.addHandles(this, watch(() => this.widget.source, () => (this.source = this.widget.source), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.activeBasemap, (basemap) => (this.activeBasemap = basemap), {
+            initial: true
+        }));
+    }
+    _createParams() {
+        const params = {
+            container: this.childElem
+        };
+        if (this.view) {
+            params.view = this.view;
+        }
+        return params;
+    }
+    get el() { return index.getElement(this); }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "position": ["positionWatcher"],
+        "source": ["sourceWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+};
+ArcgisBasemapGallery.style = basemapGalleryCss;
+
+const expandCss = "arcgis-expand>.esri-expand__content--expanded{background-color:var(--calcite-ui-background)}";
+
+const ArcgisExpand = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.widgetReady = index.createEvent(this, "widgetReady", 7);
+        this._watchHandles = [];
+        this.autoCollapse = false;
+        this.closeOnEsc = true;
+        this.collapseIcon = undefined;
+        this.collapseTooltip = undefined;
+        this.expanded = false;
+        this.expandIcon = undefined;
+        this.expandTooltip = undefined;
+        this.group = undefined;
+        this.iconNumber = undefined;
+        this.mode = "auto";
+        this.referenceElement = undefined;
+        this.position = "top-right";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    autoCollapseWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.autoCollapse = newValue;
+        }
+    }
+    closeOnEscWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.closeOnEsc = newValue;
+        }
+    }
+    collapseIconWatcher(newValue) {
+        if (this.widget) {
+            this.widget.collapseIcon = newValue;
+            this.widget.collapseIconClass = newValue;
+        }
+    }
+    collapseTooltipWatcher(newValue) {
+        if (this.widget) {
+            this.widget.collapseTooltip = newValue;
+        }
+    }
+    expandedWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.expanded = newValue;
+        }
+    }
+    expandIconWatcher(newValue) {
+        if (this.widget) {
+            this.widget.expandIcon = newValue;
+            this.widget.expandIconClass = newValue;
+        }
+    }
+    expandTooltipWatcher(newValue) {
+        if (this.widget) {
+            this.widget.expandTooltip = newValue;
+        }
+    }
+    groupWatcher(newValue) {
+        if (this.widget) {
+            this.widget.group = newValue;
+        }
+    }
+    iconNumberWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.iconNumber = newValue;
+        }
+    }
+    modeWatcher(newValue) {
+        if (this.widget) {
+            this.widget.mode = newValue;
+        }
+    }
+    referenceElementWatcher(newValue) {
+        componentUtils.referenceElementHelper(this, newValue);
+    }
+    viewWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.view = newValue;
+        }
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, newValue);
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async collapse() {
+        this.widget?.collapse();
+    }
+    async expand() {
+        this.widget?.expand();
+    }
+    async toggle() {
+        if (this.expanded)
+            await this.collapse();
+        else
+            await this.expand();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await index$1.newWidgetsExpand(params);
+        this.widget = widget;
+        this._checkForView();
+    }
+    disconnectedCallback() {
+        disconnected.onDisconnectedHelper(this);
+    }
+    render() {
+        return index.h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Internal Methods
+    //
+    //--------------------------------------------------------------------------
+    _createParams() {
+        const params = {
+            container: this.childElem
+        };
+        if (this.autoCollapse !== undefined) {
+            params.autoCollapse = this.autoCollapse;
+        }
+        if (this.closeOnEsc !== undefined) {
+            params.closeOnEsc = this.closeOnEsc;
+        }
+        if (this.collapseIcon) {
+            params.collapseIcon = this.collapseIcon;
+            params.collapseIconClass = this.collapseIcon;
+        }
+        if (this.collapseTooltip) {
+            params.collapseTooltip = this.collapseTooltip;
+        }
+        if (this.expanded !== undefined) {
+            params.expanded = this.expanded;
+        }
+        if (this.expandIcon) {
+            console.log("expandIcon", this.expandIcon);
+            params.expandIcon = this.expandIcon;
+            params.expandIconClass = this.expandIcon;
+        }
+        if (this.expandTooltip) {
+            params.expandTooltip = this.expandTooltip;
+        }
+        if (this.group) {
+            params.group = this.group;
+        }
+        if (this.iconNumber !== undefined) {
+            params.iconNumber = this.iconNumber;
+        }
+        if (this.mode) {
+            params.mode = this.mode;
+        }
+        if (this.view) {
+            params.view = this.view;
+        }
+        return params;
+    }
+    _checkForView() {
+        const viewRef = this.el.closest("arcgis-map") || this.el.closest("arcgis-scene");
+        if (viewRef?.view) {
+            this.view = viewRef.view;
+            this.view.ui.add(this.childElem, this.position);
+            this.widgetReady.emit({ widget: this.widget });
+        }
+        else if (viewRef) {
+            const handler = () => {
+                viewRef.removeEventListener("arcgisViewReadyChange", handler, false);
+                this.view = viewRef.view;
+                this.view.ui.add(this.childElem, this.position);
+                this.widgetReady.emit({ widget: this.widget });
+            };
+            viewRef.addEventListener("arcgisViewReadyChange", handler, false);
+        }
+    }
+    get el() { return index.getElement(this); }
+    static get watchers() { return {
+        "autoCollapse": ["autoCollapseWatcher"],
+        "closeOnEsc": ["closeOnEscWatcher"],
+        "collapseIcon": ["collapseIconWatcher"],
+        "collapseTooltip": ["collapseTooltipWatcher"],
+        "expanded": ["expandedWatcher"],
+        "expandIcon": ["expandIconWatcher"],
+        "expandTooltip": ["expandTooltipWatcher"],
+        "group": ["groupWatcher"],
+        "iconNumber": ["iconNumberWatcher"],
+        "mode": ["modeWatcher"],
+        "referenceElement": ["referenceElementWatcher"],
+        "view": ["viewWatcher"],
+        "position": ["positionWatcher"]
+    }; }
+};
+ArcgisExpand.style = expandCss;
+
+const sceneCss = ".arcgis-scene{padding:0;margin:0;height:100%;width:100%}";
+
+const ArcgisScene = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.arcgisViewReadyChange = index.createEvent(this, "arcgisViewReadyChange", 7);
+        this.arcgisViewChange = index.createEvent(this, "arcgisViewChange", 7);
+        this.arcgisViewClick = index.createEvent(this, "arcgisViewClick", 7);
+        this.arcgisViewDoubleClick = index.createEvent(this, "arcgisViewDoubleClick", 7);
+        this.arcgisViewDrag = index.createEvent(this, "arcgisViewDrag", 7);
+        this.arcgisViewHold = index.createEvent(this, "arcgisViewHold", 7);
+        this.arcgisViewImmediateClick = index.createEvent(this, "arcgisViewImmediateClick", 7);
+        this.arcgisViewImmediateDoubleClick = index.createEvent(this, "arcgisViewImmediateDoubleClick", 7);
+        this.arcgisViewKeyDown = index.createEvent(this, "arcgisViewKeyDown", 7);
+        this.arcgisViewKeyUp = index.createEvent(this, "arcgisViewKeyUp", 7);
+        this.arcgisViewLayerviewCreate = index.createEvent(this, "arcgisViewLayerviewCreate", 7);
+        this.arcgisViewLayerviewCreateError = index.createEvent(this, "arcgisViewLayerviewCreateError", 7);
+        this.arcgisViewLayerviewDestroy = index.createEvent(this, "arcgisViewLayerviewDestroy", 7);
+        this.arcgisViewMouseWheel = index.createEvent(this, "arcgisViewMouseWheel", 7);
+        this.arcgisViewPointerDown = index.createEvent(this, "arcgisViewPointerDown", 7);
+        this.arcgisViewPointerEnter = index.createEvent(this, "arcgisViewPointerEnter", 7);
+        this.arcgisViewPointerLeave = index.createEvent(this, "arcgisViewPointerLeave", 7);
+        this.arcgisViewPointerMove = index.createEvent(this, "arcgisViewPointerMove", 7);
+        this.arcgisViewPointerUp = index.createEvent(this, "arcgisViewPointerUp", 7);
+        this._watchHandles = [];
+        this.allLayerViews = undefined;
+        this.alphaCompositingEnabled = undefined;
+        this.analyses = undefined;
+        this.basemapView = undefined;
+        this.basemap = undefined;
+        this.camera = undefined;
+        this.center = undefined;
+        this.clippingArea = undefined;
+        this.constraints = undefined;
+        this.destroyDisabled = false;
+        this.environment = undefined;
+        this.extent = undefined;
+        this.fatalError = undefined;
+        this.floors = undefined;
+        this.graphics = undefined;
+        this.groundView = undefined;
+        this.highlightOptions = undefined;
+        this.interacting = undefined;
+        this.itemId = undefined;
+        this.layerViews = undefined;
+        this.magnifier = undefined;
+        this.map = undefined;
+        this.navigating = undefined;
+        this.navigation = undefined;
+        this.padding = undefined;
+        this.performanceInfo = undefined;
+        this.popup = undefined;
+        this.popupEnabled = undefined;
+        this.qualityProfile = undefined;
+        this.ready = undefined;
+        this.resolution = undefined;
+        this.scale = undefined;
+        this.spatialReference = undefined;
+        this.stationary = undefined;
+        this.suspended = undefined;
+        this.theme = undefined;
+        this.timeExtent = undefined;
+        this.toMap = undefined;
+        this.toScreen = undefined;
+        this.updating = undefined;
+        this.viewingMode = undefined;
+        this.viewpoint = undefined;
+        this.zoom = undefined;
+        this.view = undefined;
+        this.disableNavigation = false;
+    }
+    alphaCompositingEnabledWatcher(value) {
+        if (value !== undefined && this.view) {
+            this.view.alphaCompositingEnabled = value;
+        }
+    }
+    basemapWatcher(value) {
+        if (this.view?.map && componentUtils.isNullOrEmptyString(value)) {
+            this.view.map.basemap = value;
+        }
+    }
+    cameraWatcher(value) {
+        if (this.view && value && componentUtils.isNotSameCamera(this.view.camera, value)) {
+            this.view.camera = value;
+        }
+    }
+    centerWatcher(value) {
+        if (this.view && value && !this.view.center?.equals(value)) {
+            this.view.center = value;
+        }
+    }
+    clippingAreaWatcher(value) {
+        if (this.view && value && !this.view.clippingArea?.equals(value)) {
+            this.view.clippingArea = value;
+        }
+    }
+    constraintsWatcher(value) {
+        if (this.view) {
+            this.view.constraints = value;
+        }
+    }
+    environmentWatcher(value) {
+        if (this.view &&
+            value &&
+            componentUtils.isNotSameEnvironment(this.view.environment, value)) {
+            this.view.environment = value;
+        }
+    }
+    extentWatcher(value) {
+        if (this.view && value && !this.view.extent.equals(value)) {
+            this.view.extent = value;
+        }
+    }
+    floorsWatcher(value) {
+        if (this.view) {
+            this.view.floors = value;
+        }
+    }
+    graphicsWatcher(value) {
+        if (this.view) {
+            this.view.graphics = value;
+        }
+    }
+    highlightOptionsWatcher(value) {
+        if (this.view) {
+            this.view.highlightOptions = value;
+        }
+    }
+    itemIdWatcher(value, old) {
+        // NOTE: there is an issue when users set the value to undefined.
+        // https://github.com/ionic-team/stencil/issues/2814
+        // If user sets `itemid` to `undefined`, Stencil 2 will log the following warning:
+        // `The state/prop "${propName}" changed during rendering.`
+        // `This can potentially lead to infinite-loops and other bugs.`
+        //
+        // It appears consumer setting the value to null does not cause this warning.
+        // In Stencil 4, if a user sets property to undefined, will trigger change, but
+        // will not remove attribute from DOM.
+        if (value !== old) {
+            if (this.view?.map) {
+                this._updateMap();
+            }
+            else {
+                this._loadMap();
+            }
+        }
+    }
+    mapWatcher(value) {
+        if (this.view) {
+            this.view.map = value;
+        }
+    }
+    navigationWatcher(value) {
+        if (this.view) {
+            this.view.navigation = value;
+        }
+    }
+    paddingWatcher(value) {
+        if (this.view) {
+            this.view.padding = value;
+        }
+    }
+    popupEnabledWatcher(value) {
+        if (value !== undefined && this.view) {
+            this.view.popupEnabled = value;
+        }
+    }
+    qualityProfileWatcher(value) {
+        if (this.view && this.view.qualityProfile !== value) {
+            this.view.qualityProfile = value;
+        }
+    }
+    scaleWatcher(value, old) {
+        if (this.view && this.view.stationary && !this.view.interacting && value != null && value !== old) {
+            this.view.scale = value;
+        }
+    }
+    spatialReferenceWatcher(value) {
+        if (this.view && value && !this.view.spatialReference.equals(value)) {
+            this.view.spatialReference = value;
+        }
+    }
+    themeWatcher(value) {
+        if (this.view) {
+            this.view.theme = value;
+        }
+    }
+    timeExtentWatcher(value) {
+        if (this.view) {
+            this.view.timeExtent = value;
+        }
+    }
+    viewingModeWatcher(value) {
+        if (this.view) {
+            this.view.viewingMode = value;
+        }
+    }
+    viewpointWatcher(value) {
+        if (this.view && componentUtils.isNotSameViewpoint(this.view.viewpoint, value)) {
+            this.view.viewpoint = value;
+        }
+    }
+    zoomWatcher(value, old) {
+        if (this.view && this.view.stationary && !this.view.interacting && value !== old && componentUtils.isValidInteger(value)) {
+            this.view.zoom = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async closePopup() {
+        this.view?.closePopup();
+    }
+    async destroy() {
+        if (this.destroyDisabled) {
+            this._clearWatchHandles();
+            this.view.destroy();
+        }
+    }
+    async goTo(target, options) {
+        return await this.view?.goTo(target, options);
+    }
+    async hitTest(screenPoint, options) {
+        return await this.view?.hitTest(screenPoint, options);
+    }
+    async openPopup(options) {
+        return await this.view?.openPopup(options);
+    }
+    async takeScreenshot(options) {
+        return await this.view?.takeScreenshot(options);
+    }
+    async tryFatalErrorRecovery() {
+        this.view?.tryFatalErrorRecovery();
+    }
+    async whenAnalysisView(analysis) {
+        return await this.view?.whenAnalysisView(analysis);
+    }
+    async whenLayerView(layer) {
+        return await this.view?.whenLayerView(layer);
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async connectedCallback() {
+        this.view = await index$1.newViewsSceneView({});
+    }
+    async componentWillLoad() {
+        await this._loadMap();
+    }
+    componentDidRender() {
+        if (this.view && !this.view.container) {
+            this.view.container = this.el;
+        }
+    }
+    componentDidLoad() {
+        this._proxyEvents();
+    }
+    disconnectedCallback() {
+        this.destroy();
+    }
+    render() {
+        return index.h("div", { class: "arcgis-scene", ref: (el) => (this.el = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _clearWatchHandles() {
+        this._watchHandles.forEach((handle) => handle.remove());
+        this._watchHandles = [];
+    }
+    async _addWatchers() {
+        const { watch, when } = await index$1.importCoreReactiveUtils();
+        componentUtils.addHandles(this, [
+            // watch for ready and emit arcgisViewReadyChange event
+            watch(() => this.view.ready, () => {
+                this.ready = this.view.ready;
+                this.arcgisViewReadyChange.emit();
+            }, {
+                initial: true
+            }),
+            // watch for stationary and emit arcgisViewChange event
+            watch(() => this.view.stationary, () => {
+                this.stationary = this.view.stationary;
+                this.interacting = this.view.interacting;
+                this.navigating = this.view.navigating;
+                this.arcgisViewChange.emit();
+            }, {
+                initial: true
+            }),
+            // when view stationary is true, update these props:
+            // zoom, scale, center, rotation, extent, camera, viewpoint
+            when(() => this.view.stationary, () => {
+                this.camera = this.view.camera;
+                this.center = this.view.center;
+                this.extent = this.view.extent;
+                this.scale = this.view.scale;
+                this.viewpoint = this.view.viewpoint;
+                this.zoom = this.view.zoom;
+                this.spatialReference = this.view.spatialReference;
+            }),
+            // watchers for other props to update component
+            watch(() => this.view.allLayerViews, () => {
+                this.allLayerViews = this.view.allLayerViews;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.analyses, () => {
+                this.analyses = this.view.analyses;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.map?.basemap, () => {
+                this.basemap = this.view.map?.basemap;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.basemapView, () => {
+                this.basemapView = this.view.basemapView;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.environment, () => {
+                this.environment = this.view.environment;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.fatalError, () => {
+                this.fatalError = this.view.fatalError;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.graphics, () => {
+                this.graphics = this.view.graphics;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.groundView, () => {
+                this.groundView = this.view.groundView;
+            }, {
+                initial: true
+            }),
+            // Start: arcgisStationaryChange events
+            watch(() => this.view.interacting, () => {
+                this.interacting = this.view.interacting;
+            }),
+            watch(() => this.view.navigating, () => {
+                this.navigating = this.view.navigating;
+            }),
+            watch(() => this.view.stationary, () => {
+                this.stationary = this.view.stationary;
+            }),
+            watch(() => this.view.layerViews, () => {
+                this.layerViews = this.view.layerViews;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.navigation, () => {
+                this.navigation = this.view.navigation;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.map, () => {
+                this.map = this.view.map;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.performanceInfo, () => {
+                this.performanceInfo = this.view.performanceInfo;
+            }),
+            watch(() => this.view.popup, () => {
+                this.popup = this.view.popup;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.qualityProfile, () => {
+                this.qualityProfile = this.view.qualityProfile;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.resolution, () => {
+                this.resolution = this.view.resolution;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.suspended, () => {
+                this.suspended = this.view.suspended;
+            }, {
+                initial: true
+            }),
+            watch(() => this.view.updating, () => {
+                this.updating = this.view.updating;
+            }, {
+                initial: true
+            })
+        ]);
+    }
+    async _createMap() {
+        const mapParams = {};
+        if (this.itemId) {
+            mapParams.portalItem = this._createPortalItem();
+        }
+        if (this.basemap) {
+            mapParams.basemap = this.basemap;
+        }
+        else if (componentUtils.isNullOrEmptyString(this.itemId)) {
+            mapParams.basemap = "topo-vector";
+        }
+        const map = await index$1.newWebScene(mapParams);
+        return map;
+    }
+    _createPortalItem() {
+        const item = {};
+        if (this.itemId) {
+            item.id = this.itemId;
+        }
+        return item;
+    }
+    _createViewParams() {
+        const params = {};
+        if (this.center) {
+            if (typeof this.center === "string") {
+                params.center = this.center.split(",").map((x) => Number(x));
+            }
+            else {
+                params.center = this.center;
+            }
+        }
+        if (this.constraints) {
+            params.constraints = this.constraints;
+        }
+        if (this.extent) {
+            params.extent = this.extent;
+        }
+        if (this.floors) {
+            params.floors = this.floors;
+        }
+        if (this.highlightOptions) {
+            params.highlightOptions = this.highlightOptions;
+        }
+        if (this.map) {
+            params.map = this.map;
+        }
+        if (this.navigation) {
+            params.navigation = this.navigation;
+        }
+        if (this.popupEnabled !== undefined) {
+            params.popupEnabled = this.popupEnabled;
+        }
+        if (this.scale !== undefined) {
+            params.scale = this.scale;
+        }
+        if (this.spatialReference) {
+            params.spatialReference = this.spatialReference;
+        }
+        if (this.theme) {
+            params.theme = this.theme;
+        }
+        if (this.timeExtent) {
+            params.timeExtent = this.timeExtent;
+        }
+        if (this.viewpoint) {
+            params.viewpoint = this.viewpoint;
+        }
+        if (this.zoom !== undefined) {
+            params.zoom = this.zoom;
+        }
+        return params;
+    }
+    async _loadMap() {
+        const map = await this._createMap();
+        const params = this._createViewParams();
+        const view = await index$1.newViewsSceneView({
+            map,
+            ...params
+        });
+        this.view = view;
+        view.when(async () => {
+            // proxy view functions
+            this.toMap = view.toMap.bind(view);
+            this.toScreen = view.toScreen.bind(view);
+            await this._addWatchers();
+        });
+    }
+    _proxyEvents() {
+        componentUtils.addHandles(this, [
+            this.view.on("click", (event) => {
+                this.arcgisViewClick.emit(event);
+            }),
+            this.view.on("double-click", (event) => {
+                this.arcgisViewDoubleClick.emit(event);
+            }),
+            this.view.on("drag", (event) => {
+                this.arcgisViewDrag.emit(event);
+            }),
+            this.view.on("hold", (event) => {
+                this.arcgisViewHold.emit(event);
+            }),
+            this.view.on("immediate-click", (event) => {
+                this.arcgisViewImmediateClick.emit(event);
+            }),
+            this.view.on("immediate-double-click", (event) => {
+                this.arcgisViewImmediateDoubleClick.emit(event);
+            }),
+            this.view.on("key-down", (event) => {
+                this.arcgisViewKeyDown.emit(event);
+            }),
+            this.view.on("key-up", (event) => {
+                this.arcgisViewKeyUp.emit(event);
+            }),
+            this.view.on("layerview-create", (event) => {
+                this.arcgisViewLayerviewCreate.emit(event);
+            }),
+            this.view.on("layerview-create-error", (event) => {
+                this.arcgisViewLayerviewCreateError.emit(event);
+            }),
+            this.view.on("layerview-destroy", (event) => {
+                this.arcgisViewLayerviewDestroy.emit(event);
+            }),
+            this.view.on("mouse-wheel", (event) => {
+                this.arcgisViewMouseWheel.emit(event);
+            }),
+            this.view.on("pointer-down", (event) => {
+                this.arcgisViewPointerDown.emit(event);
+            }),
+            this.view.on("pointer-enter", (event) => {
+                this.arcgisViewPointerEnter.emit(event);
+            }),
+            this.view.on("pointer-leave", (event) => {
+                this.arcgisViewPointerLeave.emit(event);
+            }),
+            this.view.on("pointer-move", (event) => {
+                this.arcgisViewPointerMove.emit(event);
+            }),
+            this.view.on("pointer-up", (event) => {
+                this.arcgisViewPointerUp.emit(event);
+            })
+        ]);
+    }
+    async _updateMap() {
+        if (this.view?.map) {
+            this.view.map.destroy();
+            const map = await this._createMap();
+            this.view.map = map;
+        }
+    }
+    get _hostElement() { return index.getElement(this); }
+    static get watchers() { return {
+        "alphaCompositingEnabled": ["alphaCompositingEnabledWatcher"],
+        "basemap": ["basemapWatcher"],
+        "camera": ["cameraWatcher"],
+        "center": ["centerWatcher"],
+        "clippingArea": ["clippingAreaWatcher"],
+        "constraints": ["constraintsWatcher"],
+        "environment": ["environmentWatcher"],
+        "extent": ["extentWatcher"],
+        "floors": ["floorsWatcher"],
+        "graphics": ["graphicsWatcher"],
+        "highlightOptions": ["highlightOptionsWatcher"],
+        "itemId": ["itemIdWatcher"],
+        "map": ["mapWatcher"],
+        "navigation": ["navigationWatcher"],
+        "padding": ["paddingWatcher"],
+        "popupEnabled": ["popupEnabledWatcher"],
+        "qualityProfile": ["qualityProfileWatcher"],
+        "scale": ["scaleWatcher"],
+        "spatialReference": ["spatialReferenceWatcher"],
+        "theme": ["themeWatcher"],
+        "timeExtent": ["timeExtentWatcher"],
+        "viewingMode": ["viewingModeWatcher"],
+        "viewpoint": ["viewpointWatcher"],
+        "zoom": ["zoomWatcher"]
+    }; }
+};
+ArcgisScene.style = sceneCss;
+
+exports.arcgis_basemap_gallery = ArcgisBasemapGallery;
+exports.arcgis_expand = ArcgisExpand;
+exports.arcgis_scene = ArcgisScene;
+
+//# sourceMappingURL=arcgis-basemap-gallery_3.cjs.entry.js.map