@arcgis/map-components 4.29.0-test.0 → 4.29.0

package/dist/components/arcgis-bookmarks.js

@@ -0,0 +1,307 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { g as newWidgetsBookmarks, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const bookmarksCss = "";
+
+const ArcgisBookmarks$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisBookmarks extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisBookmarksReady = createEvent(this, "arcgisBookmarksReady", 7);
+        this.bookmarkEdit = createEvent(this, "bookmarkEdit", 7);
+        this.bookmarkSelect = createEvent(this, "bookmarkSelect", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.bookmarks = undefined;
+        this.defaultCreateOptions = undefined;
+        this.defaultEditOptions = undefined;
+        this.disabled = false;
+        this.dragEnabled = false;
+        this.filterPlaceholder = undefined;
+        this.filterText = undefined;
+        this.icon = undefined;
+        this.visibleElementsAddBookmarkButton = false;
+        this.visibleElementsCloseButton = false;
+        this.visibleElementsCollapseButton = false;
+        this.visibleElementsEditBookmarkButton = false;
+        this.visibleElementsFilter = false;
+        this.visibleElementsFlow = true;
+        this.visibleElementsHeading = false;
+        this.visibleElementsThumbnail = true;
+        this.visibleElementsTime = true;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    bookmarksWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.bookmarks = value;
+        }
+    }
+    defaultCreateOptionsWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.defaultCreateOptions = value;
+        }
+    }
+    defaultEditOptionsWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.defaultEditOptions = value;
+        }
+    }
+    disabledWatcher(value, old) {
+        if (this.widget && value !== old) {
+            this.widget.disabled = value;
+        }
+    }
+    dragEnabledWatcher(value) {
+        if (this.widget) {
+            this.widget.dragEnabled = value;
+        }
+    }
+    filterPlaceholderWatcher(value) {
+        if (this.widget) {
+            this.widget.filterPlaceholder = value;
+        }
+    }
+    filterTextWatcher(value) {
+        if (this.widget) {
+            this.widget.filterText = value;
+        }
+    }
+    iconWatcher(value) {
+        if (this.widget) {
+            this.widget.icon = value;
+            this.widget.iconClass = value;
+        }
+    }
+    visibleElementsAddBookmarkButtonWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, addBookmarkButton: value };
+        }
+    }
+    visibleElementsCloseButtonWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, closeButton: value };
+        }
+    }
+    visibleElementsCollapseButtonWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, collapseButton: value };
+        }
+    }
+    visibleElementsEditBookmarkButtonWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, editBookmarkButton: value };
+        }
+    }
+    visibleElementsFilterWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, filter: value };
+        }
+    }
+    visibleElementsFlowWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, flow: value };
+        }
+    }
+    visibleElementsHeadingWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, heading: value };
+        }
+    }
+    visibleElementsThumbnailWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, thumbnail: value };
+        }
+    }
+    visibleElementsTimeWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, time: value };
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsBookmarks(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this._addContainer();
+        this.arcgisBookmarksReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, [
+            watch(() => this.widget.disabled, (value) => (this.disabled = value))
+        ]);
+    }
+    _createParams() {
+        const params = {};
+        params.visibleElements = {
+            addBookmarkButton: this.visibleElementsAddBookmarkButton,
+            closeButton: this.visibleElementsCloseButton,
+            collapseButton: this.visibleElementsCollapseButton,
+            editBookmarkButton: this.visibleElementsEditBookmarkButton,
+            filter: this.visibleElementsFilter,
+            flow: this.visibleElementsFlow,
+            heading: this.visibleElementsHeading,
+            thumbnail: this.visibleElementsThumbnail,
+            time: this.visibleElementsTime
+        };
+        if (this.view) {
+            params.view = this.view;
+        }
+        if (this.bookmarks) {
+            params.bookmarks = this.bookmarks;
+        }
+        if (this.defaultCreateOptions) {
+            params.defaultCreateOptions = this.defaultCreateOptions;
+        }
+        if (this.defaultEditOptions) {
+            params.defaultEditOptions = this.defaultEditOptions;
+        }
+        if (this.dragEnabled !== undefined) {
+            params.dragEnabled = this.dragEnabled;
+        }
+        if (this.filterPlaceholder) {
+            params.filterPlaceholder = this.filterPlaceholder;
+        }
+        if (this.filterText) {
+            params.filterText = this.filterText;
+        }
+        if (this.icon) {
+            params.icon = this.icon;
+            params.iconClass = this.icon;
+        }
+        return params;
+    }
+    _proxyEvents() {
+        this.widget.on("bookmark-edit", (e) => this.bookmarkEdit.emit(e));
+        this.widget.on("bookmark-select", (e) => this.bookmarkSelect.emit(e));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "bookmarks": ["bookmarksWatcher"],
+        "defaultCreateOptions": ["defaultCreateOptionsWatcher"],
+        "defaultEditOptions": ["defaultEditOptionsWatcher"],
+        "disabled": ["disabledWatcher"],
+        "dragEnabled": ["dragEnabledWatcher"],
+        "filterPlaceholder": ["filterPlaceholderWatcher"],
+        "filterText": ["filterTextWatcher"],
+        "icon": ["iconWatcher"],
+        "visibleElementsAddBookmarkButton": ["visibleElementsAddBookmarkButtonWatcher"],
+        "visibleElementsCloseButton": ["visibleElementsCloseButtonWatcher"],
+        "visibleElementsCollapseButton": ["visibleElementsCollapseButtonWatcher"],
+        "visibleElementsEditBookmarkButton": ["visibleElementsEditBookmarkButtonWatcher"],
+        "visibleElementsFilter": ["visibleElementsFilterWatcher"],
+        "visibleElementsFlow": ["visibleElementsFlowWatcher"],
+        "visibleElementsHeading": ["visibleElementsHeadingWatcher"],
+        "visibleElementsThumbnail": ["visibleElementsThumbnailWatcher"],
+        "visibleElementsTime": ["visibleElementsTimeWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return bookmarksCss; }
+}, [0, "arcgis-bookmarks", {
+        "referenceElement": [1, "reference-element"],
+        "bookmarks": [16],
+        "defaultCreateOptions": [16],
+        "defaultEditOptions": [16],
+        "disabled": [1540],
+        "dragEnabled": [4, "drag-enabled"],
+        "filterPlaceholder": [1, "filter-placeholder"],
+        "filterText": [1, "filter-text"],
+        "icon": [1],
+        "visibleElementsAddBookmarkButton": [4, "visible-elements-add-bookmark-button"],
+        "visibleElementsCloseButton": [4, "visible-elements-close-button"],
+        "visibleElementsCollapseButton": [4, "visible-elements-collapse-button"],
+        "visibleElementsEditBookmarkButton": [4, "visible-elements-edit-bookmark-button"],
+        "visibleElementsFilter": [4, "visible-elements-filter"],
+        "visibleElementsFlow": [4, "visible-elements-flow"],
+        "visibleElementsHeading": [4, "visible-elements-heading"],
+        "visibleElementsThumbnail": [4, "visible-elements-thumbnail"],
+        "visibleElementsTime": [4, "visible-elements-time"],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "bookmarks": ["bookmarksWatcher"],
+        "defaultCreateOptions": ["defaultCreateOptionsWatcher"],
+        "defaultEditOptions": ["defaultEditOptionsWatcher"],
+        "disabled": ["disabledWatcher"],
+        "dragEnabled": ["dragEnabledWatcher"],
+        "filterPlaceholder": ["filterPlaceholderWatcher"],
+        "filterText": ["filterTextWatcher"],
+        "icon": ["iconWatcher"],
+        "visibleElementsAddBookmarkButton": ["visibleElementsAddBookmarkButtonWatcher"],
+        "visibleElementsCloseButton": ["visibleElementsCloseButtonWatcher"],
+        "visibleElementsCollapseButton": ["visibleElementsCollapseButtonWatcher"],
+        "visibleElementsEditBookmarkButton": ["visibleElementsEditBookmarkButtonWatcher"],
+        "visibleElementsFilter": ["visibleElementsFilterWatcher"],
+        "visibleElementsFlow": ["visibleElementsFlowWatcher"],
+        "visibleElementsHeading": ["visibleElementsHeadingWatcher"],
+        "visibleElementsThumbnail": ["visibleElementsThumbnailWatcher"],
+        "visibleElementsTime": ["visibleElementsTimeWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-bookmarks"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-bookmarks":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisBookmarks$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisBookmarks = ArcgisBookmarks$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisBookmarks, defineCustomElement };

package/{components → dist/components}/arcgis-building-explorer.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisBuildingExplorer extends Components.ArcgisBuildingExplorer, HTMLElement {}
 export const ArcgisBuildingExplorer: {
-  prototype: ArcgisBuildingExplorer;
-  new (): ArcgisBuildingExplorer;
+    prototype: ArcgisBuildingExplorer;
+    new (): ArcgisBuildingExplorer;
 };
 /**
  * Used to define this component and all nested components recursively.

package/dist/components/arcgis-building-explorer.js

@@ -0,0 +1,183 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { h as newWidgetsBuildingExplorer, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const buildingExplorerCss = "";
+
+const ArcgisBuildingExplorer$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisBuildingExplorer extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisBuildingExplorerReady = createEvent(this, "arcgisBuildingExplorerReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.icon = undefined;
+        this.layers = undefined;
+        this.level = undefined;
+        this.phase = undefined;
+        this.state = "disabled";
+        this.visibleElementsLevels = true;
+        this.visibleElementsPhases = true;
+        this.visibleElementsDisciplines = true;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    iconWatcher(value) {
+        if (this.widget) {
+            this.widget.icon = value;
+        }
+    }
+    layersWatcher(value) {
+        if (this.widget) {
+            this.widget.layers = value;
+        }
+    }
+    visibleElementsLevelsWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, levels: value };
+        }
+    }
+    visibleElementsPhasesWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, phases: value };
+        }
+    }
+    visibleElementsDisciplinesWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = { ...this.widget.visibleElements, disciplines: value };
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsBuildingExplorer(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._addContainer();
+        this.arcgisBuildingExplorerReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, [
+            watch(() => this.widget.viewModel.level, (value) => (this.level = value), {
+                initial: true
+            }),
+            watch(() => this.widget.viewModel.phase, (value) => (this.phase = value), {
+                initial: true
+            }),
+            watch(() => this.widget.viewModel.state, (value) => (this.state = value), {
+                initial: true
+            })
+        ]);
+    }
+    _createParams() {
+        const params = {};
+        params.visibleElements = {
+            levels: this.visibleElementsLevels,
+            phases: this.visibleElementsPhases,
+            disciplines: this.visibleElementsDisciplines
+        };
+        if (this.icon) {
+            params.icon = this.icon;
+        }
+        if (this.layers) {
+            params.layers = this.layers;
+        }
+        if (this.view) {
+            params.view = this.view;
+        }
+        return params;
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "icon": ["iconWatcher"],
+        "layers": ["layersWatcher"],
+        "visibleElementsLevels": ["visibleElementsLevelsWatcher"],
+        "visibleElementsPhases": ["visibleElementsPhasesWatcher"],
+        "visibleElementsDisciplines": ["visibleElementsDisciplinesWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return buildingExplorerCss; }
+}, [0, "arcgis-building-explorer", {
+        "referenceElement": [1, "reference-element"],
+        "icon": [1],
+        "layers": [16],
+        "level": [1040],
+        "phase": [1040],
+        "state": [1025],
+        "visibleElementsLevels": [4, "visible-elements-levels"],
+        "visibleElementsPhases": [4, "visible-elements-phases"],
+        "visibleElementsDisciplines": [4, "visible-elements-disciplines"],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "icon": ["iconWatcher"],
+        "layers": ["layersWatcher"],
+        "visibleElementsLevels": ["visibleElementsLevelsWatcher"],
+        "visibleElementsPhases": ["visibleElementsPhasesWatcher"],
+        "visibleElementsDisciplines": ["visibleElementsDisciplinesWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-building-explorer"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-building-explorer":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisBuildingExplorer$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisBuildingExplorer = ArcgisBuildingExplorer$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisBuildingExplorer, defineCustomElement };

package/{components → dist/components}/arcgis-compass.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisCompass extends Components.ArcgisCompass, HTMLElement {}
 export const ArcgisCompass: {
-  prototype: ArcgisCompass;
-  new (): ArcgisCompass;
+    prototype: ArcgisCompass;
+    new (): ArcgisCompass;
 };
 /**
  * Used to define this component and all nested components recursively.

package/dist/components/arcgis-compass.js

@@ -0,0 +1,158 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { j as newWidgetsCompass, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const compassCss = "";
+
+function notSameOrientation(a, b) {
+    return a.x !== b.x || a.y !== b.y || a.z !== b.z;
+}
+const ArcgisCompass$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisCompass extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisCompassReady = createEvent(this, "arcgisCompassReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.orientation = { x: 0, y: 0, z: 0 };
+        this.icon = undefined;
+        this.state = "disabled";
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    orientationWatcher(value, old) {
+        if (this.widget && notSameOrientation(value, old)) {
+            this.widget.viewModel.orientation = value;
+        }
+    }
+    iconWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.icon = value;
+            this.widget.iconClass = value;
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async reset() {
+        this.widget?.reset();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsCompass(params);
+        this.widget = widget;
+        this._addContainer();
+        this._setViewModelParams();
+        await this._addWatchers();
+        this.arcgisCompassReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, [
+            watch(() => this.widget?.viewModel.orientation, (value) => (this.orientation = value)),
+            watch(() => this.widget?.viewModel.state, (value) => (this.state = value))
+        ]);
+    }
+    _createParams() {
+        const params = {};
+        if (this.icon) {
+            params.icon = this.icon;
+            params.iconClass = this.icon;
+        }
+        if (this.view) {
+            params.view = this.view;
+        }
+        return params;
+    }
+    _setViewModelParams() {
+        const params = {
+            orientation: this.orientation
+        };
+        this.widget.viewModel.set(params);
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "orientation": ["orientationWatcher"],
+        "icon": ["iconWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return compassCss; }
+}, [0, "arcgis-compass", {
+        "referenceElement": [1, "reference-element"],
+        "orientation": [1040],
+        "icon": [1],
+        "state": [1537],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040],
+        "reset": [64]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "orientation": ["orientationWatcher"],
+        "icon": ["iconWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-compass"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-compass":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisCompass$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisCompass = ArcgisCompass$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisCompass, defineCustomElement };

package/{components → dist/components}/arcgis-coordinate-conversion.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisCoordinateConversion extends Components.ArcgisCoordinateConversion, HTMLElement {}
 export const ArcgisCoordinateConversion: {
-  prototype: ArcgisCoordinateConversion;
-  new (): ArcgisCoordinateConversion;
+    prototype: ArcgisCoordinateConversion;
+    new (): ArcgisCoordinateConversion;
 };
 /**
  * Used to define this component and all nested components recursively.