@esri/solutions-components 1.2.0-next.95 → 1.2.0-next.97

package/dist/components/layer-table/customElement.js

@@ -1,22 +1,23 @@
-import { c as w } from "../../chunks/runtime.js";
-import { a as I, d as T, g as v } from "../../chunks/mapViewUtils.js";
-import { c as E } from "../../chunks/queryUtils.js";
-import { d as x } from "../../chunks/downloadUtils.js";
-import { B as g } from "../../chunks/interfaces.js";
-import { defineCustomElements as S } from "@arcgis/instant-apps-components/loader";
-import { u as O } from "../../chunks/useT9n.js";
-import { css as F, html as o, nothing as c } from "lit";
-import { createRef as b, ref as p } from "lit-html/directives/ref.js";
-import { LitElement as C, createEvent as _, noShadowRoot as A, safeClassMap as y } from "@arcgis/lumina";
-import { k as H } from "../../chunks/helpers.js";
-import L from "@arcgis/core/widgets/FeatureTable";
-import * as u from "@arcgis/core/core/reactiveUtils";
-import $ from "@arcgis/core/rest/support/RelationshipQuery";
-import m from "@arcgis/core/widgets/FeatureTable/support/TableTemplate";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/1.2/esri/copyright.txt for details.
-v1.2.0-next.94 */
-const D = F`@layer{/** @license
+v1.2.0-next.96 */
+import { c as customElement } from "../../chunks/runtime.js";
+import { a as goToSelection, d as getLayerOrTable, g as getFeatureLayerView } from "../../chunks/mapViewUtils.js";
+import { c as queryFeaturesByGlobalID } from "../../chunks/queryUtils.js";
+import { d as downloadCSV } from "../../chunks/downloadUtils.js";
+import { B as BATCH_EDIT_LIMIT } from "../../chunks/interfaces.js";
+import { defineCustomElements } from "@arcgis/instant-apps-components/loader";
+import { u as useT9n } from "../../chunks/useT9n.js";
+import { css, html, nothing } from "lit";
+import { createRef, ref } from "lit-html/directives/ref.js";
+import { LitElement, createEvent, noShadowRoot, safeClassMap } from "@arcgis/lumina";
+import { l as getEnabledLayerIds } from "../../chunks/helpers.js";
+import FeatureTable from "@arcgis/core/widgets/FeatureTable";
+import * as reactiveUtils from "@arcgis/core/core/reactiveUtils";
+import RelationshipQuery from "@arcgis/core/rest/support/RelationshipQuery";
+import TableTemplate from "@arcgis/core/widgets/FeatureTable/support/TableTemplate";
+const styles = css`@layer{
+/** @license
  * Copyright 2025 Esri
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,28 +31,324 @@ const D = F`@layer{/** @license
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */:host{display:block}.height-full{height:100%}.height-full-adjusted{height:calc(100% - 20px)}.width-full{width:100%}.display-flex{display:flex}.display-none{display:none}.table-border{border:1px solid var(--calcite-color-border-2)}.border-end{border-inline-end:1px solid var(--calcite-color-border-2)}.border-bottom{border-bottom:1px solid var(--calcite-color-border-2)}.padding-5{padding:5px}.padding-end-1{padding-inline-end:1rem}.height-51-px{height:51px}.height-50-px{height:50px}.bottom-left{position:absolute;left:0;bottom:0;padding-left:5px}html[dir=rtl] .bottom-left{position:absolute;right:0;bottom:0;padding-right:5px}.height-19{height:19px}.background{background-color:var(--calcite-color-background)}.text-color{color:var(--calcite-color-text-1)}.align-center{align-items:center}.danger-color{color:var(--calcite-color-status-danger)}.esri-feature-table vaadin-grid{border:none!important}vaadin-grid-cell-content{font-size:14px!important;color:var(--calcite-color-text-3)!important}.absolute-right{position:absolute;right:0;left:unset}html[dir=rtl] .absolute-right{left:0;right:unset}.disabled{cursor:default!important;user-select:none;opacity:var(--calcite-opacity-disabled);pointer-events:none}.actions-end{height:50px!important;display:inline-flex}.border-top{border-top:1px solid var(--calcite-color-border-2)}.modal{--calcite-dialog-content-space: 0}.esri-feature-table__table-container{height:100%}.search-container{background-color:var(--calcite-color-foreground-1)!important}.search{--calcite-color-border-input: var(--calcite-color-border-3);width:60%;padding:10px}.delete-red{--calcite-icon-color: var(--calcite-color-status-danger);--calcite-color-text-1: var(--calcite-color-status-danger);--calcite-color-text-3: var(--calcite-color-status-danger)}.label-override{white-space:nowrap}.padding-start-1-4{padding-inline-start:.5rem}.panel-header-override{--calcite-panel-header-content-space: 0px}.danger-label-color{color:var(--calcite-color-status-danger)}.danger-icon-color{--calcite-icon-color: var(--calcite-color-status-danger)}.width-51{width:51px}.height-51{height:51px}calcite-action-bar{--calcite-internal-action-bar-gap: 0px;--calcite-internal-action-bar-padding: 0px}}`;
-class M extends C {
+ */
+
+:host {
+  display: block;
+}
+
+.height-full {
+  height: 100%;
+}
+
+.height-full-adjusted {
+  height: calc(100% - 20px);
+}
+
+.width-full {
+  width: 100%;
+}
+
+.display-flex {
+  display: flex;
+}
+
+.display-none {
+  display: none;
+}
+
+.table-border {
+  border: 1px solid var(--calcite-color-border-2);
+}
+
+.border-end {
+  border-inline-end: 1px solid var(--calcite-color-border-2);
+}
+
+.border-bottom {
+  border-bottom: 1px solid var(--calcite-color-border-2);
+}
+
+.padding-5 {
+  padding: 5px;
+}
+
+.padding-end-1 {
+  padding-inline-end: 1rem;
+}
+
+.height-51-px {
+  height: 51px;
+}
+
+.height-50-px {
+  height: 50px;
+}
+
+.bottom-left {
+  position: absolute;
+  left: 0;
+  bottom: 0;
+  padding-left: 5px;
+}
+
+html[dir='rtl'] .bottom-left {
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  padding-right: 5px;
+}
+
+.height-19 {
+  height: 19px;
+}
+
+.background {
+  background-color: var(--calcite-color-background);
+}
+
+.text-color {
+  color: var(--calcite-color-text-1);
+}
+
+.align-center {
+  align-items: center;
+}
+
+.danger-color {
+  color: var(--calcite-color-status-danger);
+}
+
+.esri-feature-table vaadin-grid {
+  border: none !important;
+}
+
+vaadin-grid-cell-content {
+  font-size: 14px !important;
+  color: var(--calcite-color-text-3) !important;
+}
+
+.absolute-right {
+  position: absolute;
+  right: 0;
+  left: unset;
+}
+
+html[dir='rtl'] .absolute-right {
+  left: 0;
+  right: unset;
+}
+
+.disabled {
+  cursor: default !important;
+  user-select: none;
+  opacity: var(--calcite-opacity-disabled);
+  pointer-events: none;
+}
+
+.actions-end {
+  height: 50px !important;
+  display: inline-flex;
+}
+
+.border-top {
+  border-top: 1px solid var(--calcite-color-border-2);
+}
+
+.modal {
+  --calcite-dialog-content-space: 0;
+}
+
+.esri-feature-table__table-container {
+  height: 100%;
+}
+
+.search-container {
+  background-color: var(--calcite-color-foreground-1) !important;
+}
+
+.search {
+  --calcite-color-border-input: var(--calcite-color-border-3);
+  width: 60%;
+  padding: 10px;
+}
+
+.delete-red {
+  --calcite-icon-color: var(--calcite-color-status-danger);
+  --calcite-color-text-1: var(--calcite-color-status-danger);
+  --calcite-color-text-3: var(--calcite-color-status-danger);
+}
+
+.label-override {
+  white-space: nowrap;
+}
+
+.padding-start-1-4 {
+  padding-inline-start: .5rem;
+}
+
+.panel-header-override {
+  --calcite-panel-header-content-space: 0px;
+}
+
+.danger-label-color {
+  color: var(--calcite-color-status-danger);
+}
+
+.danger-icon-color {
+  --calcite-icon-color: var(--calcite-color-status-danger);
+}
+
+.width-51 {
+  width: 51px;
+}
+
+.height-51 {
+  height: 51px;
+}
+
+calcite-action-bar {
+  --calcite-internal-action-bar-gap: 0px;
+  --calcite-internal-action-bar-padding: 0px;
+}
+}`;
+class LayerTable extends LitElement {
   constructor() {
-    super(), this.defaultGlobalId = [], this.defaultLayerId = "", this.defaultOid = [], this.enableAutoRefresh = !1, this.enableColumnReorder = !0, this.enableCSV = !1, this.enableInlineEdit = !1, this.enableShare = !1, this.featureSelectionMode = "multiple", this.selectedRelatedIds = [], this.honorMapFieldSettings = !1, this.isMobile = !1, this.mapHidden = !1, this.showOnlyUpdatableLayers = !1, this.selectedIds = [], this.shareIncludeEmbed = !1, this.shareIncludeSocial = !1, this.showNewestFirst = !1, this.zoomAndScrollToSelected = !1, this._allIds = [], this._configLayerOrderDefined = !1, this._csvExporting = !1, this._fetchingData = !1, this._hideTable = !1, this._filterActive = !1, this._selectAllActive = !1, this._showHideOpen = !1, this._showOnlySelected = !1, this._toolInfos = [], this._translations = O({ name: "layer-table", blocking: !0 }), this._fullTextSearchInfo = [], this._searchPlaceHolder = "", this._size = 0, this._queryingData = !1, this._editEnabled = !1, this._enabledLayerIds = [], this._defaultGlobalIdHonored = !1, this._defaultOidHonored = !1, this._deleteEnabled = !1, this._floorExpression = "", this._floorField = "", this._floorLevel = "", this._loaded = !1, this._shareNode = b(), this._toolbar = b(), this._searchExpression = "", this._skipEditCheck = !1, this._tempSelectedIds = [], this._outOFExtentOids = [], this._shouldUpdateTableOnExtentChange = !0, this._creatingFeature = !1, this._searchNode = b(), this.columnReorder = _(), this.featureSelectionChange = _(), this.toggleFilter = _(), this.showDelete = _(), this.relatedRecordToggled = _(), this.editMultipleFeatures = _(), this.listenOn(window, "beforeMapInfoChange", this.beforeMapInfoChange, { capture: !0 }), this.listenOn(window, "editorInitialized", this.editorInitialized), this.listenOn(window, "closeEdit", this.closeEdit), this.listenOn(window, "selectionChanged", this.selectionChanged), this.listenOn(window, "beforeLayerSelectionChange", this.beforeLayerSelectionChange), this.listenOn(window, "layerSelectionChange", this.layerSelectionChange), this.listenOn(window, "editsComplete", this.editsComplete), this.listenOn(window, "facilityChanged", this.facilityChanged), this.listenOn(window, "levelChanged", this.levelChanged), this.listenOn(window, "siteChanged", this.siteChanged), this.listenOn(window, "noLayersFound", this.noLayersFound), this.listenOn(window, "clearSelection", this.clearSelection), this.listenOn(window, "mapChanged", this.mapChanged), this.listenOn(window, "featuresSelected", this.featuresSelected), this.listenOn(window, "createWorkFlowStarted", this.createWorkFlowStarted), this.listenOn(window, "backFromCreateWorkFlow", this.backFromCreateWorkFlow), S(window);
+    super();
+    this.defaultGlobalId = [];
+    this.defaultLayerId = "";
+    this.defaultOid = [];
+    this.enableAutoRefresh = false;
+    this.enableColumnReorder = true;
+    this.enableCSV = false;
+    this.enableInlineEdit = false;
+    this.enableShare = false;
+    this.enableTableAutosave = true;
+    this.featureSelectionMode = "multiple";
+    this.selectedRelatedIds = [];
+    this.honorMapFieldSettings = false;
+    this.isMobile = false;
+    this.mapHidden = false;
+    this.showOnlyUpdatableLayers = false;
+    this.selectedIds = [];
+    this.shareIncludeEmbed = false;
+    this.shareIncludeSocial = false;
+    this.showNewestFirst = false;
+    this.zoomAndScrollToSelected = false;
+    this._allIds = [];
+    this._configLayerOrderDefined = false;
+    this._csvExporting = false;
+    this._fetchingData = false;
+    this._hideTable = false;
+    this._filterActive = false;
+    this._selectAllActive = false;
+    this._showHideOpen = false;
+    this._showOnlySelected = false;
+    this._toolInfos = [];
+    this._translations = useT9n({ name: "layer-table", blocking: true });
+    this._fullTextSearchInfo = [];
+    this._searchPlaceHolder = "";
+    this._size = 0;
+    this._queryingData = false;
+    this._editEnabled = false;
+    this._enabledLayerIds = [];
+    this._defaultGlobalIdHonored = false;
+    this._defaultOidHonored = false;
+    this._deleteEnabled = false;
+    this._floorExpression = "";
+    this._floorField = "";
+    this._floorLevel = "";
+    this._loaded = false;
+    this._shareNode = createRef();
+    this._toolbar = createRef();
+    this._searchExpression = "";
+    this._skipEditCheck = false;
+    this._tempSelectedIds = [];
+    this._outOFExtentOids = [];
+    this._shouldUpdateTableOnExtentChange = true;
+    this._creatingFeature = false;
+    this._searchNode = createRef();
+    this.columnReorder = createEvent();
+    this.featureSelectionChange = createEvent();
+    this.toggleFilter = createEvent();
+    this.showDelete = createEvent();
+    this.relatedRecordToggled = createEvent();
+    this.editMultipleFeatures = createEvent();
+    this.listenOn(window, "beforeMapInfoChange", this.beforeMapInfoChange, { capture: true });
+    this.listenOn(window, "editorInitialized", this.editorInitialized);
+    this.listenOn(window, "closeEdit", this.closeEdit);
+    this.listenOn(window, "selectionChanged", this.selectionChanged);
+    this.listenOn(window, "beforeLayerSelectionChange", this.beforeLayerSelectionChange);
+    this.listenOn(window, "layerSelectionChange", this.layerSelectionChange);
+    this.listenOn(window, "editsComplete", this.editsComplete);
+    this.listenOn(window, "facilityChanged", this.facilityChanged);
+    this.listenOn(window, "levelChanged", this.levelChanged);
+    this.listenOn(window, "siteChanged", this.siteChanged);
+    this.listenOn(window, "noLayersFound", this.noLayersFound);
+    this.listenOn(window, "clearSelection", this.clearSelection);
+    this.listenOn(window, "mapChanged", this.mapChanged);
+    this.listenOn(window, "featuresSelected", this.featuresSelected);
+    this.listenOn(window, "createWorkFlowStarted", this.createWorkFlowStarted);
+    this.listenOn(window, "backFromCreateWorkFlow", this.backFromCreateWorkFlow);
+    defineCustomElements(window);
   }
   static {
-    this.properties = { appLayout: 1, defaultGlobalId: 0, defaultLayerId: 1, defaultOid: 0, enableAutoRefresh: 5, enableColumnReorder: 5, enableCSV: 5, enableInlineEdit: 5, enableShare: 5, featureSelectionMode: 1, selectedRelatedIds: 0, honorMapFieldSettings: 5, isMobile: 5, mapHidden: 5, mapInfo: 0, mapView: 0, showOnlyUpdatableLayers: 5, selectedIds: 0, shareIncludeEmbed: 5, shareIncludeSocial: 5, showNewestFirst: 5, zoomAndScrollToSelected: 5, zoomToScale: 9, _allIds: 16, _configLayerOrderDefined: 16, _csvExporting: 16, _fetchingData: 16, _hideTable: 16, _filterActive: 16, _layer: 16, _selectAllActive: 16, _showHideOpen: 16, _showOnlySelected: 16, _toolInfos: 16, _translations: 16, _fullTextSearchInfo: 16, _searchPlaceHolder: 16, _size: 16, _queryingData: 16 };
+    this.properties = { appLayout: 1, defaultGlobalId: [0, {}, { attribute: false }], defaultLayerId: 1, defaultOid: [0, {}, { attribute: false }], enableAutoRefresh: [5, {}, { type: Boolean }], enableColumnReorder: [5, {}, { type: Boolean }], enableCSV: [5, {}, { type: Boolean }], enableInlineEdit: [5, {}, { type: Boolean }], enableShare: [5, {}, { type: Boolean }], enableTableAutosave: [5, {}, { type: Boolean }], featureSelectionMode: 1, selectedRelatedIds: [0, {}, { attribute: false }], honorMapFieldSettings: [5, {}, { type: Boolean }], isMobile: [5, {}, { type: Boolean }], mapHidden: [5, {}, { type: Boolean }], mapInfo: [0, {}, { attribute: false }], mapView: [0, {}, { attribute: false }], showOnlyUpdatableLayers: [5, {}, { type: Boolean }], selectedIds: [0, {}, { attribute: false }], shareIncludeEmbed: [5, {}, { type: Boolean }], shareIncludeSocial: [5, {}, { type: Boolean }], showNewestFirst: [5, {}, { type: Boolean }], zoomAndScrollToSelected: [5, {}, { type: Boolean }], zoomToScale: [9, {}, { type: Number }], _allIds: [16, {}, { state: true }], _configLayerOrderDefined: [16, {}, { state: true }], _csvExporting: [16, {}, { state: true }], _fetchingData: [16, {}, { state: true }], _hideTable: [16, {}, { state: true }], _filterActive: [16, {}, { state: true }], _layer: [16, {}, { state: true }], _selectAllActive: [16, {}, { state: true }], _showHideOpen: [16, {}, { state: true }], _showOnlySelected: [16, {}, { state: true }], _toolInfos: [16, {}, { state: true }], _translations: [16, {}, { state: true }], _fullTextSearchInfo: [16, {}, { state: true }], _searchPlaceHolder: [16, {}, { state: true }], _size: [16, {}, { state: true }], _queryingData: [16, {}, { state: true }] };
   }
   static {
-    this.styles = D;
+    this.styles = styles;
   }
   static {
-    this.shadowRootOptions = A;
+    this.shadowRootOptions = noShadowRoot;
   }
-  willUpdate(e) {
-    if (e.has("appLayout") && this.appLayoutWatchHandler(), e.has("defaultOid") && this.defaultOidWatchHandler(), e.has("defaultGlobalId") && this.defaultGlobalIdWatchHandler(), e.has("enableCSV") && this.enableCSVWatchHandler(), e.has("enableInlineEdit") && this.enableInlineEditWatchHandler(), e.has("mapHidden") && this.mapHiddenWatchHandler(), e.has("isMobile") && this.isMobileWatchHandler(), e.has("mapInfo") && this.mapInfoWatchHandler(), e.has("mapView") && this.mapViewWatchHandler(), e.has("_layer") && this._layerWatchHandler(), e.has("selectedIds") && (this.hasUpdated || JSON.stringify(e.get("selectedIds")) !== JSON.stringify(this.selectedIds)) && this.selectedIdsWatchHandler(), e.has("selectedRelatedIds") && (this.hasUpdated || JSON.stringify(e.get("selectedRelatedIds")) !== JSON.stringify(this.selectedRelatedIds)) && this.selectedRelatedIdsWatchHandler(), e.has("_translations")) {
-      const t = this._translations._lang, i = e.get("_translations")?._lang;
-      t && i && t !== i && this._initToolInfos();
+  willUpdate(changes) {
+    if (changes.has("appLayout")) {
+      this.appLayoutWatchHandler();
+    }
+    if (changes.has("defaultOid")) {
+      void this.defaultOidWatchHandler();
+    }
+    if (changes.has("defaultGlobalId")) {
+      void this.defaultGlobalIdWatchHandler();
+    }
+    if (changes.has("enableCSV")) {
+      this.enableCSVWatchHandler();
+    }
+    if (changes.has("enableInlineEdit")) {
+      this.enableInlineEditWatchHandler();
+    }
+    if (changes.has("mapHidden")) {
+      this.mapHiddenWatchHandler();
+    }
+    if (changes.has("isMobile")) {
+      this.isMobileWatchHandler();
+    }
+    if (changes.has("mapInfo")) {
+      void this.mapInfoWatchHandler();
+    }
+    if (changes.has("mapView")) {
+      void this.mapViewWatchHandler();
+    }
+    if (changes.has("_layer")) {
+      void this._layerWatchHandler();
+    }
+    if (changes.has("selectedIds") && (this.hasUpdated || JSON.stringify(changes.get("selectedIds")) !== JSON.stringify(this.selectedIds))) {
+      void this.selectedIdsWatchHandler();
+    }
+    if (changes.has("selectedRelatedIds") && (this.hasUpdated || JSON.stringify(changes.get("selectedRelatedIds")) !== JSON.stringify(this.selectedRelatedIds))) {
+      this.selectedRelatedIdsWatchHandler();
+    }
+    if (changes.has("_translations")) {
+      const newLang = this._translations._lang;
+      const oldLang = changes.get("_translations")?._lang;
+      if (newLang && oldLang && newLang !== oldLang) {
+        this._initToolInfos();
+      }
     }
   }
   async appLayoutWatchHandler() {
-    await this._initToolInfos(), this._updateShareUrl();
+    await this._initToolInfos();
+    this._updateShareUrl();
   }
   async defaultOidWatchHandler() {
     await this._handleDefaults();
@@ -60,210 +357,358 @@ class M extends C {
     await this._handleDefaults();
   }
   async enableCSVWatchHandler() {
-    this._toolInfos?.length > 0 && await this._initToolInfos();
+    if (this._toolInfos?.length > 0) {
+      await this._initToolInfos();
+    }
   }
   enableInlineEditWatchHandler() {
-    this._table && (this._table.editingEnabled = this._editEnabled && this.enableInlineEdit);
+    if (this._table) {
+      this._table.editingEnabled = this._editEnabled && this.enableInlineEdit;
+    }
   }
   async mapHiddenWatchHandler() {
-    this._toolInfos?.length > 0 && await this._initToolInfos();
+    if (this._toolInfos?.length > 0) {
+      await this._initToolInfos();
+    }
   }
   async isMobileWatchHandler() {
-    !this._toolInfos && !this.isMobile && await this._initToolInfos();
+    if (!this._toolInfos && !this.isMobile) {
+      await this._initToolInfos();
+    }
   }
   async mapInfoWatchHandler() {
-    this._configLayerOrderDefined = "configLayerOrder" in (this.mapInfo?.layerOptions || {}), this._enabledLayerIds = H(this.mapInfo?.layerOptions?.layers || [], this.mapInfo?.layerOptions?.configLayerOrder), this._table && (this._resetColumnTemplates(), this._sortTable());
+    this._configLayerOrderDefined = "configLayerOrder" in (this.mapInfo?.layerOptions || {});
+    this._enabledLayerIds = getEnabledLayerIds(this.mapInfo?.layerOptions?.layers || [], this.mapInfo?.layerOptions?.configLayerOrder);
+    if (this._table) {
+      this._resetColumnTemplates();
+      void this._sortTable();
+    }
   }
   async mapViewWatchHandler() {
-    this._mapClickHandle && this._mapClickHandle.remove(), this.mapView && (this._floorExpression = "", this._searchExpression = "undefined", this.mapView.highlights = [
-      {
-        name: "default",
-        color: "#00FFFF"
-      },
-      {
-        name: "current-selection",
-        color: "#ff00ff"
-      },
-      {
-        name: "temporary",
-        color: "#FFFF00"
-      }
-    ], this._updateShareUrl(), this._mapClickHandle = u.on(() => this.mapView, "click", (e) => {
-      this._creatingFeature || this._mapClicked(e);
-    }));
+    if (this._mapClickHandle) {
+      this._mapClickHandle.remove();
+    }
+    if (this.mapView) {
+      this._floorExpression = "";
+      this._searchExpression = "undefined";
+      this.mapView.highlights = [
+        {
+          name: "default",
+          color: "#00FFFF"
+        },
+        {
+          name: "current-selection",
+          color: "#ff00ff"
+        },
+        {
+          name: "temporary",
+          color: "#FFFF00"
+        }
+      ];
+      this._updateShareUrl();
+      this._mapClickHandle = reactiveUtils.on(() => this.mapView, "click", (event) => {
+        if (!this._creatingFeature) {
+          void this._mapClicked(event);
+        }
+      });
+    }
   }
   async _layerWatchHandler() {
-    if (this._hideTable = !1, this._fetchingData = !0, !this._layer) {
-      this._fetchingData = !1, this._hideTable = !0;
+    this._hideTable = false;
+    this._fetchingData = true;
+    if (!this._layer) {
+      this._fetchingData = false;
+      this._hideTable = true;
       return;
     }
     try {
-      await this._layer.when(), this._floorField = this._layer.floorInfo?.floorField || "", this._updateFloorDefinitionExpression(), await this._resetTable(), this._updateShareUrl();
-    } catch (e) {
-      console.error(e), this._hideTable = !0;
+      await this._layer.when();
+      this._floorField = this._layer.floorInfo?.floorField || "";
+      this._updateFloorDefinitionExpression();
+      await this._resetTable();
+      this._updateShareUrl();
+    } catch (err) {
+      console.error(err);
+      this._hideTable = true;
     } finally {
-      this._fetchingData = !1;
+      this._fetchingData = false;
     }
   }
   async selectedIdsWatchHandler() {
-    this._updateShareUrl(), this._validateEnabledActions(), this._selectAllActive && this.selectedIds.length !== this._allIds.length && (this._selectAllActive = !1), this.selectedIds.length > 0 && (this._table.rowHighlightIds.removeAll(), this._table.rowHighlightIds.add(this.selectedIds[0])), this.selectedIds.length === 0 && setTimeout(() => {
-      this.featureSelectionChange.emit(this.selectedIds);
-    }, 700);
+    this._updateShareUrl();
+    this._validateEnabledActions();
+    if (this._selectAllActive && this.selectedIds.length !== this._allIds.length) {
+      this._selectAllActive = false;
+    }
+    if (this.selectedIds.length > 0) {
+      this._table.rowHighlightIds.removeAll();
+      this._table.rowHighlightIds.add(this.selectedIds[0]);
+    }
+    if (this.selectedIds.length === 0) {
+      setTimeout(() => {
+        this.featureSelectionChange.emit(this.selectedIds);
+      }, 700);
+    }
   }
   async selectedRelatedIdsWatchHandler() {
-    this._validateEnabledActions(), this.selectedRelatedIds.length > 0 && (this._relatedFeatureTable?.rowHighlightIds.removeAll(), this._relatedFeatureTable?.rowHighlightIds.add(this.selectedRelatedIds[0]));
+    this._validateEnabledActions();
+    if (this.selectedRelatedIds.length > 0) {
+      this._relatedFeatureTable?.rowHighlightIds.removeAll();
+      this._relatedFeatureTable?.rowHighlightIds.add(this.selectedRelatedIds[0]);
+    }
   }
   async closeFilter() {
     await this._closeFilter();
   }
   async filterReset() {
-    this._filterByExtentHandle && (this._table && (this._table.filterGeometry = void 0), this._filterByExtentHandle.remove(), this._filterByExtentHandle = void 0), await this._handleFilterListReset();
-  }
-  async filterUpdate(e, t) {
-    await this._handleFilterUpdate(e), t ? (this._shouldUpdateTableOnExtentChange = !0, this._handleTableOnMapExtent()) : t === !1 && (this._table && (this._table.filterGeometry = void 0), this._filterByExtentHandle?.remove(), this._filterByExtentHandle = void 0, await this._updateAllIds());
+    if (this._filterByExtentHandle) {
+      if (this._table) {
+        this._table.filterGeometry = void 0;
+      }
+      this._filterByExtentHandle.remove();
+      this._filterByExtentHandle = void 0;
+    }
+    await this._handleFilterListReset();
+  }
+  async filterUpdate(filterActive, keepTableUpdatingOnMapExtentChange) {
+    await this._handleFilterUpdate(filterActive);
+    if (keepTableUpdatingOnMapExtentChange) {
+      this._shouldUpdateTableOnExtentChange = true;
+      this._handleTableOnMapExtent();
+    } else if (keepTableUpdatingOnMapExtentChange === false) {
+      if (this._table) {
+        this._table.filterGeometry = void 0;
+      }
+      this._filterByExtentHandle?.remove();
+      this._filterByExtentHandle = void 0;
+      await this._updateAllIds();
+    }
   }
-  async validateTableUpdate(e) {
-    this._shouldUpdateTableOnExtentChange = e;
+  async validateTableUpdate(shouldUpdateTableOnExtentChange) {
+    this._shouldUpdateTableOnExtentChange = shouldUpdateTableOnExtentChange;
   }
   async validateActiveEdits() {
     return this._validateActiveEdits([], this.selectedIds);
   }
   async refresh() {
-    this._table && await this._refresh();
-  }
-  async setColumnOrder(e) {
-    this._setColumnTemplates(e);
+    if (this._table) {
+      await this._refresh();
+    }
   }
-  async beforeMapInfoChange(e) {
-    const t = e.detail.ref, i = e.detail.mapInfo;
-    if (this._hasPendingEdits()) {
-      e.preventDefault();
-      const a = await this._validateActiveEdits([], this.selectedIds);
-      await t.setMapByID(a ? i.id : e.detail.currentId, !a);
+  async setColumnOrder(columnTemplates) {
+    this._setColumnTemplates(columnTemplates);
+  }
+  async beforeMapInfoChange(_evt) {
+    const mapPicker = _evt.detail.ref;
+    const mapInfo = _evt.detail.mapInfo;
+    const hasPendingEdits = this._hasPendingEdits();
+    if (hasPendingEdits) {
+      _evt.preventDefault();
+      const editsDiscarded = await this._validateActiveEdits([], this.selectedIds);
+      await mapPicker.setMapByID(editsDiscarded ? mapInfo.id : _evt.detail.currentId, !editsDiscarded);
     }
   }
-  async editorInitialized(e) {
-    this._shouldUpdateTableOnExtentChange = !1, this._editor = e.detail;
+  async editorInitialized(_evt) {
+    this._shouldUpdateTableOnExtentChange = false;
+    this._editor = _evt.detail;
   }
   async closeEdit() {
-    this._shouldUpdateTableOnExtentChange = !0, this._filterByExtentHandle && this._handleTableOnMapExtent();
+    this._shouldUpdateTableOnExtentChange = true;
+    if (this._filterByExtentHandle) {
+      this._handleTableOnMapExtent();
+    }
   }
-  async selectionChanged(e) {
-    const t = e.detail.selectedFeature[0], i = Number(t.getObjectId()), s = this._table;
-    if (s.rowHighlightIds.length && s.rowHighlightIds.removeAll(), s.rowHighlightIds.add(i), this._highlightFeatures(i), this.zoomAndScrollToSelected && s && this.mapView) {
-      const a = s.viewModel.getObjectIdIndex(i);
-      s.scrollToIndex(a);
-      const l = t.layer, h = this.mapView.allLayerViews.toArray();
-      let n;
-      h.some(async (r) => r.layer.title === l?.title && r.layer.type === "feature" ? (n = r, this.mapView && await I([i], n, this.mapView, !0, void 0, this.zoomToScale), !0) : !1);
+  async selectionChanged(_evt) {
+    const g = _evt.detail.selectedFeature[0];
+    const oid = Number(g.getObjectId());
+    const table = this._table;
+    if (table.rowHighlightIds.length) {
+      table.rowHighlightIds.removeAll();
+    }
+    table.rowHighlightIds.add(oid);
+    this._highlightFeatures(oid);
+    if (this.zoomAndScrollToSelected && table && this.mapView) {
+      const i = table.viewModel.getObjectIdIndex(oid);
+      table.scrollToIndex(i);
+      const layer = g.layer;
+      const layerViews = this.mapView.allLayerViews.toArray();
+      let layerView;
+      layerViews.some(async (lv) => {
+        if (lv.layer.title === layer?.title && lv.layer.type === "feature") {
+          layerView = lv;
+          this.mapView && await goToSelection([oid], layerView, this.mapView, true, void 0, this.zoomToScale);
+          return true;
+        } else {
+          return false;
+        }
+      });
     }
   }
-  async beforeLayerSelectionChange(e) {
-    if (this._hasPendingEdits()) {
-      e.preventDefault();
-      const i = e.detail.ref, s = await this._validateActiveEdits([], this.selectedIds);
-      return e.detail.selectedIds ? await i.setLayerByIds(s ? e.detail.newIds : e.detail.currentIds, !0) : await i.setLayerById(s ? e.detail.newId : e.detail.currentId, !0);
+  async beforeLayerSelectionChange(_evt) {
+    const hasPendingEdits = this._hasPendingEdits();
+    if (hasPendingEdits) {
+      _evt.preventDefault();
+      const mapLayerPicker = _evt.detail.ref;
+      const editsDiscarded = await this._validateActiveEdits([], this.selectedIds);
+      return _evt.detail.selectedIds ? await mapLayerPicker.setLayerByIds(editsDiscarded ? _evt.detail.newIds : _evt.detail.currentIds, true) : await mapLayerPicker.setLayerById(editsDiscarded ? _evt.detail.newId : _evt.detail.currentId, true);
     }
   }
-  async layerSelectionChange(e) {
-    await this._layerSelectionChanged(e);
+  async layerSelectionChange(_evt) {
+    await this._layerSelectionChanged(_evt);
   }
-  async editsComplete(e) {
-    const t = e.detail;
-    (t === "delete" || t === "add") && (this._allIds = await this.queryAllIds()), await this._refresh();
+  async editsComplete(_evt) {
+    const editType = _evt.detail;
+    if (editType === "delete" || editType === "add") {
+      this._allIds = await this.queryAllIds();
+    }
+    await this._refresh();
   }
-  async facilityChanged(e) {
+  async facilityChanged(_evt) {
     this._updateFloorDefinitionExpression();
   }
-  async levelChanged(e) {
-    this._floorLevel = e.detail, this._updateFloorDefinitionExpression();
+  async levelChanged(_evt) {
+    this._floorLevel = _evt.detail;
+    this._updateFloorDefinitionExpression();
   }
-  async siteChanged(e) {
+  async siteChanged(_evt) {
     this._updateFloorDefinitionExpression();
   }
   async noLayersFound() {
-    this._layer = void 0, this._allIds = [], this._size = 0, this._clearSelection();
+    this._layer = void 0;
+    this._allIds = [];
+    this._size = 0;
+    this._clearSelection();
   }
   async clearSelection() {
-    await this._validateActiveEdits([], this.selectedIds) && this._clearSelection();
+    const editsDiscarded = await this._validateActiveEdits([], this.selectedIds);
+    if (editsDiscarded) {
+      this._clearSelection();
+    }
   }
   async mapChanged() {
-    this._queryingData = !1, this._creatingFeature = !1, this._clearSelection();
+    this._queryingData = false;
+    this._creatingFeature = false;
+    this._clearSelection();
   }
   async featuresSelected(e) {
-    e.detail.forEach((i) => {
-      const s = this._table?.highlightIds.indexOf(i);
-      s && s < 0 && this._table?.highlightIds.add(i);
+    const oids = e.detail;
+    oids.forEach((oid) => {
+      const index = this._table?.highlightIds.indexOf(oid);
+      if (index && index < 0) {
+        this._table?.highlightIds.add(oid);
+      }
     });
   }
   createWorkFlowStarted() {
-    this._creatingFeature = !0;
+    this._creatingFeature = true;
   }
   backFromCreateWorkFlow() {
-    this._creatingFeature = !1;
+    this._creatingFeature = false;
   }
   async load() {
     await this._initToolInfos();
   }
   render() {
-    const e = this._fetchingData || this._hideTable ? "display-none" : "", t = this._fetchingData ? "" : "display-none", i = this._queryingData ? "" : "display-none", s = this._size.toString(), a = this.selectedIds.length.toString(), l = this.isMobile ? "height-full" : "height-full-adjusted", h = this._canShowFullTextSearch();
-    return this._validateActiveActions(), o`<div><calcite-scrim class=${y(i)} .loading=${this._queryingData}></calcite-scrim><calcite-shell><div class=${`width-full ${l}`}><calcite-panel class="height-full width-full panel-header-override">${this._getMapLayerPicker("header-actions-start")}${!this.isMobile && o`${this._getTableControlRow("header-content")}${this._getActionsEnd("header-actions-end")}` || ""}${h && o`<div class="search-container border-bottom"><calcite-input class=search clearable icon=search @calciteInputChange=${(n) => {
-      this._searchTextChanged(n);
-    }} .placeholder=${this._searchPlaceHolder} title=${this._searchPlaceHolder ?? c} type=search ${p(this._searchNode)}></calcite-input></div>` || ""}<calcite-loader class=${y(t)} .label=${this._translations.fetchingData} scale=l></calcite-loader><div class=${y(e)} ${p(this.onTableNodeCreate)}></div></calcite-panel></div>${this.isMobile ? void 0 : o`<div class="bottom-left text-color height-19" id=solutions-selected-count-div>${(this._translations.recordsTotal?.replace("{{total-number-of-records}}", s) + " | " + this._translations.recordsSelected.replace("{{selected-number-of-records}}", a)).replace("{{total}}", s).replace("{{selected}}", a)}</div>`}</calcite-shell></div>`;
+    const tableNodeClass = this._fetchingData || this._hideTable ? "display-none" : "";
+    const loadingClass = this._fetchingData ? "" : "display-none";
+    const scrimClass = this._queryingData ? "" : "display-none";
+    const total = this._size.toString();
+    const selected = this.selectedIds.length.toString();
+    const tableHeightClass = this.isMobile ? "height-full" : "height-full-adjusted";
+    const showSearch = this._canShowFullTextSearch();
+    this._validateActiveActions();
+    return html`<div><calcite-scrim class=${safeClassMap(scrimClass)} .loading=${this._queryingData}></calcite-scrim><calcite-shell><div class=${`width-full ${tableHeightClass}`}><calcite-panel class="height-full width-full panel-header-override">${this._getMapLayerPicker("header-actions-start")}${!this.isMobile && html`${this._getTableControlRow("header-content")}${this._getActionsEnd("header-actions-end")}` || ""}${showSearch && html`<div class="search-container border-bottom"><calcite-input class=search clearable icon=search @calciteInputChange=${(_evt) => void this._searchTextChanged(_evt)} .placeholder=${this._searchPlaceHolder} title=${this._searchPlaceHolder ?? nothing} type=search ${ref(this._searchNode)}></calcite-input></div>` || ""}<calcite-loader class=${safeClassMap(loadingClass)} .label=${this._translations.fetchingData} scale=l></calcite-loader><div class=${safeClassMap(tableNodeClass)} ${ref(this.onTableNodeCreate)}></div></calcite-panel></div>${!this.isMobile ? html`<div class="bottom-left text-color height-19" id=solutions-selected-count-div>${(this._translations.recordsTotal?.replace("{{total-number-of-records}}", total) + " | " + this._translations.recordsSelected.replace("{{selected-number-of-records}}", selected)).replace("{{total}}", total).replace("{{selected}}", selected)}</div>` : void 0}</calcite-shell></div>`;
   }
   updated() {
-    this._table && this.updateRelatedAttachmentColumns();
+    if (this._table) {
+      this.updateRelatedAttachmentColumns();
+    }
   }
-  async _searchTextChanged(e) {
-    this._fullTextSearchInfo.forEach((t) => {
-      t.searchTerm = e.target.value;
-    }), this._searchFullText();
+  async _searchTextChanged(event) {
+    this._fullTextSearchInfo.forEach((searchInfo) => {
+      searchInfo.searchTerm = event.target.value;
+    });
+    void this._searchFullText();
   }
   async _searchFullText() {
-    let e = [], t = !1;
-    if (this._showOnlySelected)
-      e = this._tempSelectedIds, t = !0;
-    else if (await this._validateActiveEdits([], this.selectedIds))
-      this._clearSelection(), this._tempSelectedIds = [];
-    else
-      return;
-    this._searchExpression && this._clearSearchDefinitionExpression();
-    let i = [];
+    let selectedIds = [];
+    let showSelected = false;
+    if (this._showOnlySelected) {
+      selectedIds = this._tempSelectedIds;
+      showSelected = true;
+    } else {
+      const editsDiscarded = await this._validateActiveEdits([], this.selectedIds);
+      if (editsDiscarded) {
+        this._clearSelection();
+        this._tempSelectedIds = [];
+      } else {
+        return;
+      }
+    }
+    if (this._searchExpression) {
+      this._clearSearchDefinitionExpression();
+    }
+    let searchedIds = [];
     if (this._fullTextSearchInfo?.length && this._fullTextSearchInfo[0].searchTerm) {
-      const s = this._layer?.createQuery();
-      s.fullText = this._fullTextSearchInfo, i = this._layer ? await this._layer.queryObjectIds(s) : [], t && e?.length && (i = i.filter((a) => e.includes(a))), await this._updateSearchDefinitionExpression(i?.length ? i : [-1]);
+      const searchQueryParams = this._layer?.createQuery();
+      searchQueryParams.fullText = this._fullTextSearchInfo;
+      searchedIds = this._layer ? await this._layer.queryObjectIds(searchQueryParams) : [];
+      if (showSelected && selectedIds?.length) {
+        searchedIds = searchedIds.filter((id) => selectedIds.includes(id));
+      }
+      await this._updateSearchDefinitionExpression(searchedIds?.length ? searchedIds : [-1]);
     }
-    t && i?.length && (this._showOnlySelected = !0, this._table?.highlightIds.addMany(i.reverse())), await new Promise((s) => setTimeout(s, 800)), await this._updateAllIds();
+    if (showSelected && searchedIds?.length) {
+      this._showOnlySelected = true;
+      this._table?.highlightIds.addMany(searchedIds.reverse());
+    }
+    await new Promise((resolve) => setTimeout(resolve, 800));
+    await this._updateAllIds();
   }
   _clearSearchDefinitionExpression() {
-    const e = this._layer?.definitionExpression;
-    this._searchExpression && e && e?.indexOf(this._searchExpression) > -1 && this._layer && (e?.indexOf(" AND (" + this._searchExpression) > -1 ? this._layer.definitionExpression = e.replace(` AND (${this._searchExpression})`, "") : this._layer.definitionExpression = e.replace(this._searchExpression, "")), this._searchExpression = "";
-  }
-  async _updateSearchDefinitionExpression(e) {
-    const t = this._layer?.definitionExpression;
-    if (this._layer)
-      if (e?.length) {
-        const i = `objectId in(${e})`;
-        this._layer.definitionExpression = this._searchExpression && t && t.includes(this._searchExpression) ? t.replace(this._searchExpression, i) : t ? `${t} AND (${i})` : i, this._searchExpression = i;
-      } else
+    const defExp = this._layer?.definitionExpression;
+    if (this._searchExpression && defExp && defExp?.indexOf(this._searchExpression) > -1 && this._layer) {
+      if (defExp?.indexOf(" AND (" + this._searchExpression) > -1) {
+        this._layer.definitionExpression = defExp.replace(` AND (${this._searchExpression})`, "");
+      } else {
+        this._layer.definitionExpression = defExp.replace(this._searchExpression, "");
+      }
+    }
+    this._searchExpression = "";
+  }
+  async _updateSearchDefinitionExpression(searchedIds) {
+    const defExp = this._layer?.definitionExpression;
+    if (this._layer) {
+      if (searchedIds?.length) {
+        const searchExp = `objectId in(${searchedIds})`;
+        this._layer.definitionExpression = this._searchExpression && defExp && defExp.includes(this._searchExpression) ? defExp.replace(this._searchExpression, searchExp) : defExp ? `${defExp} AND (${searchExp})` : searchExp;
+        this._searchExpression = searchExp;
+      } else {
         this._clearSearchDefinitionExpression();
+      }
+    }
   }
   _canShowFullTextSearch() {
-    return this._layer?.capabilities?.query?.supportsFullTextSearch && this._layer.indexes.items.filter((e) => e.indexType == "FullText").length > 0;
+    return this._layer?.capabilities?.query?.supportsFullTextSearch && this._layer.indexes.items.filter((i) => i.indexType == "FullText").length > 0;
   }
   _getFullTextSearchInfo() {
-    if (this._fullTextSearchInfo = [], this._layer?.capabilities?.query?.supportsFullTextSearch) {
-      const e = this._layer.indexes?.filter((t) => t.indexType == "FullText");
-      if (e?.length) {
-        const t = [];
-        e.forEach((s) => {
-          t.push(...s.fields.split(","));
+    this._fullTextSearchInfo = [];
+    if (this._layer?.capabilities?.query?.supportsFullTextSearch) {
+      const fullTextIndexes = this._layer.indexes?.filter((i) => i.indexType == "FullText");
+      if (fullTextIndexes?.length) {
+        const onFields = [];
+        fullTextIndexes.forEach((index) => {
+          onFields.push(...index.fields.split(","));
+        });
+        const fieldAlias = [];
+        onFields.forEach((fieldName) => {
+          const fieldInfo = this._layer?.getField(fieldName.trim());
+          if (fieldInfo?.alias) {
+            fieldAlias.push(fieldInfo.alias);
+          }
         });
-        const i = [];
-        t.forEach((s) => {
-          const a = this._layer?.getField(s.trim());
-          a?.alias && i.push(a.alias);
-        }), this._searchPlaceHolder = this._translations.searchPlaceholder.replace("{{field_names}}", i.join(", ")), this._fullTextSearchInfo.push({
+        this._searchPlaceHolder = this._translations.searchPlaceholder.replace("{{field_names}}", fieldAlias.join(", "));
+        this._fullTextSearchInfo.push({
           onFields: ["*"],
           searchTerm: "",
           searchType: "prefix"
@@ -271,621 +716,1096 @@ class M extends C {
       }
     }
   }
-  _getMapLayerPicker(e) {
-    const t = this.isMobile ? "display-none" : "";
-    return o`<div class=${`border-end ${t}`} id=solutions-map-layer-picker-container slot=${e ?? c}><map-layer-picker appearance=transparent .configLayerOrderDefined=${this._configLayerOrderDefined} .defaultLayerId=${this.defaultLayerId} display=inline-flex .enabledLayerIds=${this._enabledLayerIds} height=50 .isMobile=${this.isMobile} .mapView=${this.mapView} .showOnlyUpdatableLayers=${this.showOnlyUpdatableLayers} .placeholderIcon=${"layers"} scale=l .selectedIds=${this._layer ? [this._layer?.id] : []} show-single-layer-as-label show-tables type=dropdown></map-layer-picker></div>`;
+  _getMapLayerPicker(slot) {
+    const mobileClass = this.isMobile ? "display-none" : "";
+    return html`<div class=${`border-end ${mobileClass}`} id=solutions-map-layer-picker-container slot=${slot ?? nothing}><map-layer-picker appearance=transparent .configLayerOrderDefined=${this._configLayerOrderDefined} .defaultLayerId=${this.defaultLayerId} display=inline-flex .enabledLayerIds=${this._enabledLayerIds} height=50 .isMobile=${this.isMobile} .mapView=${this.mapView} .showOnlyUpdatableLayers=${this.showOnlyUpdatableLayers} .placeholderIcon=${"layers"} scale=l .selectedIds=${this._layer ? [this._layer?.id] : []} show-single-layer-as-label show-tables type=dropdown></map-layer-picker></div>`;
   }
-  _getLayerOption(e) {
-    let t;
-    return this.mapInfo?.layerOptions?.layers.some((i) => i.id === e ? (t = i, !0) : !1), t;
+  _getLayerOption(id) {
+    let layerOption;
+    this.mapInfo?.layerOptions?.layers.some((l) => {
+      if (l.id === id) {
+        layerOption = l;
+        return true;
+      }
+      return false;
+    });
+    return layerOption;
   }
-  _getActionsEnd(e) {
-    const t = this._relatedFeatureTable ? this._relatedFeatureTable.layer : this._layer, i = this._relatedFeatureTable || this._table;
-    let s = this._getLayerOption(t?.id || "");
-    return o`<div class="display-flex" slot=${e ?? c}><field-selection .configExtraFields=${s?.extraFields} .layer=${t} .mapView=${this.mapView} .table=${i} .tableRef=${this.el}></field-selection>${this.enableShare && !this.isMobile ? this._getShare("share") : void 0}</div>`;
+  _getActionsEnd(slot) {
+    const layerOrTable = this._relatedFeatureTable ? this._relatedFeatureTable.layer : this._layer;
+    const table = this._relatedFeatureTable || this._table;
+    let layerOption = this._getLayerOption(layerOrTable?.id || "");
+    return html`<div class="display-flex" slot=${slot ?? nothing}><field-selection .configExtraFields=${layerOption?.extraFields} .layer=${layerOrTable} .mapView=${this.mapView} .table=${table} .tableRef=${this.el}></field-selection>${this.enableShare && !this.isMobile ? this._getShare("share") : void 0}</div>`;
   }
-  _getTableControlRow(e) {
-    return o`<div class=${"height-51-px width-full display-flex"} slot=${e ?? c} ${p(this._toolbar)}>${this._getActionBar()}</div>`;
+  _getTableControlRow(slot) {
+    return html`<div class=${`height-51-px width-full display-flex`} slot=${slot ?? nothing} ${ref(this._toolbar)}>${this._getActionBar()}</div>`;
   }
   _getActionBar() {
-    return o`<calcite-action-bar class=width-full expand-disabled id=${this._getId("bar") ?? c} layout=horizontal><calcite-action-group>${this.isMobile ? void 0 : this._getActions()}</calcite-action-group></calcite-action-bar>`;
+    return html`<calcite-action-bar class=width-full expand-disabled id=${this._getId("bar") ?? nothing} layout=horizontal><calcite-action-group>${!this.isMobile ? this._getActions() : void 0}</calcite-action-group></calcite-action-bar>`;
   }
   _getActions() {
-    return this._toolInfos?.reduce((e, t) => (t && e.push(t.isDanger ? this._getDangerAction(t.icon, t.label, t.func, t.disabled) : this._getAction(t.active, t.icon, t.indicator, t.label, t.func, t.disabled, !!t.loading, t.toolTip)), e), []);
+    return this._toolInfos?.reduce((prev, cur) => {
+      if (cur) {
+        prev.push(cur.isDanger ? this._getDangerAction(cur.icon, cur.label, cur.func, cur.disabled) : this._getAction(cur.active, cur.icon, cur.indicator, cur.label, cur.func, cur.disabled, cur.loading ? true : false, cur.toolTip));
+      }
+      return prev;
+    }, []);
   }
   _validateEnabledActions() {
-    const e = this._getIds().length, t = ["zoom-to-object", "pencil", "trash", "erase", "selected-items-filter"];
-    this._toolInfos?.forEach((i) => {
-      i && t.indexOf(i.icon) > -1 && (i.disabled = i.icon === "pencil" ? e < 2 || e > g : e < 1, i.toolTip = i.icon === "pencil" ? e > g ? this._translations.featureEditLimitNotice : this._translations.editMultiple : i.toolTip);
+    const selectedFeaturesIds = this._getIds().length;
+    const selectionDependant = ["zoom-to-object", "pencil", "trash", "erase", "selected-items-filter"];
+    this._toolInfos?.forEach((ti) => {
+      if (ti && selectionDependant.indexOf(ti.icon) > -1) {
+        ti.disabled = ti.icon === "pencil" ? selectedFeaturesIds < 2 || selectedFeaturesIds > BATCH_EDIT_LIMIT : selectedFeaturesIds < 1;
+        ti.toolTip = ti.icon === "pencil" ? selectedFeaturesIds > BATCH_EDIT_LIMIT ? this._translations.featureEditLimitNotice : this._translations.editMultiple : ti.toolTip;
+      }
     });
   }
   _validateActiveActions() {
-    const e = ["filter", "list-check-all", "selected-items-filter"];
-    this._toolInfos?.forEach((t) => {
-      t && e.indexOf(t.icon) > -1 && (t.icon === "filter" && (t.indicator = this._filterActive), t.icon === "list-check-all" && (t.active = this._selectAllActive), t.icon === "selected-items-filter" && (t.active = this._showOnlySelected, t.label = this._showOnlySelected ? this._translations.showAll : this._translations.showSelected));
+    const activeDependant = ["filter", "list-check-all", "selected-items-filter"];
+    this._toolInfos?.forEach((ti) => {
+      if (ti && activeDependant.indexOf(ti.icon) > -1) {
+        if (ti.icon === "filter") {
+          ti.indicator = this._filterActive;
+        }
+        if (ti.icon === "list-check-all") {
+          ti.active = this._selectAllActive;
+        }
+        if (ti.icon === "selected-items-filter") {
+          ti.active = this._showOnlySelected;
+          ti.label = this._showOnlySelected ? this._translations.showAll : this._translations.showSelected;
+        }
+      }
     });
   }
   async _initToolInfos() {
-    const e = this._getIds().length > 0, t = this._relatedFeatureTable ? this._relatedFeatureTable.layer.isTable : this._layer?.isTable, i = this.featureSelectionMode === "multiple" && this._layer?.capabilities?.operations.supportsUpdate, s = this._getSelectedIds().length < 2 || this._getSelectedIds().length > g, a = !this.mapHidden && !t, l = !this._relatedFeatureTable && (!this._layer?.isTable || this._hasFilterExpressions()), h = this._featuresEmpty(), n = this.featureSelectionMode === "single";
-    let r = this.enableCSV;
+    const featuresSelected = this._getIds().length > 0;
+    const navigatedToRelatedTable = this._relatedFeatureTable ? this._relatedFeatureTable.layer.isTable : this._layer?.isTable;
+    const showMultipleEdits = this.featureSelectionMode === "multiple" && this._layer?.capabilities?.operations.supportsUpdate;
+    const multipleEditsDisabled = this._getSelectedIds().length < 2 || this._getSelectedIds().length > BATCH_EDIT_LIMIT;
+    const showZoom = !this.mapHidden && !navigatedToRelatedTable;
+    const showFilterIcon = !this._relatedFeatureTable && (!this._layer?.isTable || this._hasFilterExpressions());
+    const featuresEmpty = this._featuresEmpty();
+    const singleSelectionMode = this.featureSelectionMode === "single";
+    let showExport = this.enableCSV;
     if (this._relatedFeatureTable) {
-      const f = await this._queryRelatedFeatures();
-      r = f && Object.keys(f).length > 0;
-    }
-    const d = [];
-    l && d.push({
-      active: !1,
-      icon: "filter",
-      indicator: !1,
-      label: this._translations.filters,
-      func: () => this.toggleFilter.emit(),
-      disabled: !1,
-      toolTip: this._translations.filters
-    }), a && d.push({
-      active: !1,
-      icon: "zoom-to-object",
-      indicator: !1,
-      label: this._translations.zoom,
-      func: () => this._zoom(),
-      disabled: !e,
-      toolTip: this._translations.zoom
-    }), i && d.push({
-      active: !1,
-      icon: "pencil",
-      indicator: !1,
-      label: this._translations.editMultiple,
-      func: () => this.editMultipleFeatures.emit(this._getSelectedIds()),
-      disabled: s,
-      toolTip: this._translations.editMultiple
-    }), this._deleteEnabled && d.push({
-      active: !1,
-      icon: "trash",
-      indicator: !1,
-      label: this._translations.delete,
-      func: () => this._showDelete(),
-      disabled: !e,
-      isDanger: !0,
-      toolTip: this._translations.delete
-    }), d.push({
-      active: !1,
+      const features = await this._queryRelatedFeatures();
+      showExport = features && Object.keys(features).length > 0;
+    }
+    const toolInfos = [];
+    if (showFilterIcon) {
+      toolInfos.push({
+        active: false,
+        icon: "filter",
+        indicator: false,
+        label: this._translations.filters,
+        func: () => this.toggleFilter.emit(),
+        disabled: false,
+        toolTip: this._translations.filters
+      });
+    }
+    if (showZoom) {
+      toolInfos.push({
+        active: false,
+        icon: "zoom-to-object",
+        indicator: false,
+        label: this._translations.zoom,
+        func: () => this._zoom(),
+        disabled: !featuresSelected,
+        toolTip: this._translations.zoom
+      });
+    }
+    if (showMultipleEdits) {
+      toolInfos.push({
+        active: false,
+        icon: "pencil",
+        indicator: false,
+        label: this._translations.editMultiple,
+        func: () => this.editMultipleFeatures.emit(this._getSelectedIds()),
+        disabled: multipleEditsDisabled,
+        toolTip: this._translations.editMultiple
+      });
+    }
+    if (this._deleteEnabled) {
+      toolInfos.push({
+        active: false,
+        icon: "trash",
+        indicator: false,
+        label: this._translations.delete,
+        func: () => this._showDelete(),
+        disabled: !featuresSelected,
+        isDanger: true,
+        toolTip: this._translations.delete
+      });
+    }
+    toolInfos.push({
+      active: false,
       icon: "erase",
-      indicator: !1,
+      indicator: false,
       label: this._translations.clearSelection,
-      func: () => {
-        this.clearSelection();
-      },
-      disabled: !e,
+      func: () => void this.clearSelection(),
+      disabled: !featuresSelected,
       toolTip: this._translations.clearSelection
-    }), this._relatedFeatureTable || d.push({
-      active: !1,
-      icon: "selected-items-filter",
-      indicator: !1,
-      label: this._showOnlySelected ? this._translations.showAll : this._translations.showSelected,
-      func: () => this._toggleShowSelected(),
-      disabled: !e,
-      toolTip: this._showOnlySelected ? this._translations.showAll : this._translations.showSelected
-    }), !n && !this._relatedFeatureTable && d.push({
-      active: !1,
-      icon: "list-check-all",
-      indicator: !1,
-      func: async () => await this._selectAll(),
-      label: this._translations.selectAll,
-      disabled: h,
-      toolTip: this._translations.selectAll
-    }), !n && !this._relatedFeatureTable && d.push({
-      active: !1,
-      icon: "compare",
-      indicator: !1,
-      func: async () => await this._switchSelected(),
-      label: this._translations.switchSelected,
-      disabled: h,
-      toolTip: this._translations.switchSelected
-    }), d.push({
-      active: !1,
+    });
+    if (!this._relatedFeatureTable) {
+      toolInfos.push({
+        active: false,
+        icon: "selected-items-filter",
+        indicator: false,
+        label: this._showOnlySelected ? this._translations.showAll : this._translations.showSelected,
+        func: () => this._toggleShowSelected(),
+        disabled: !featuresSelected,
+        toolTip: this._showOnlySelected ? this._translations.showAll : this._translations.showSelected
+      });
+    }
+    if (!singleSelectionMode && !this._relatedFeatureTable) {
+      toolInfos.push({
+        active: false,
+        icon: "list-check-all",
+        indicator: false,
+        func: async () => await this._selectAll(),
+        label: this._translations.selectAll,
+        disabled: featuresEmpty,
+        toolTip: this._translations.selectAll
+      });
+    }
+    if (!singleSelectionMode && !this._relatedFeatureTable) {
+      toolInfos.push({
+        active: false,
+        icon: "compare",
+        indicator: false,
+        func: async () => await this._switchSelected(),
+        label: this._translations.switchSelected,
+        disabled: featuresEmpty,
+        toolTip: this._translations.switchSelected
+      });
+    }
+    toolInfos.push({
+      active: false,
       icon: "refresh",
-      indicator: !1,
-      func: () => {
-        this._refresh();
-      },
+      indicator: false,
+      func: () => void this._refresh(),
       label: this._translations.refresh,
-      disabled: !1,
+      disabled: false,
       toolTip: this._translations.refresh
-    }), r && d.push({
-      active: !1,
-      icon: "export",
-      indicator: !1,
-      func: () => {
-        this._exportToCSV();
-      },
-      label: this._translations.exportCSV,
-      loading: this._csvExporting,
-      disabled: h,
-      toolTip: this._translations.exportCSV
-    }), this._toolInfos = [...d];
+    });
+    if (showExport) {
+      toolInfos.push({
+        active: false,
+        icon: "export",
+        indicator: false,
+        func: () => void this._exportToCSV(),
+        label: this._translations.exportCSV,
+        loading: this._csvExporting,
+        disabled: featuresEmpty,
+        toolTip: this._translations.exportCSV
+      });
+    }
+    this._toolInfos = [...toolInfos];
   }
   _updateFloorDefinitionExpression() {
     if (this._floorField && this._floorLevel) {
-      const e = `${this._floorField} = '${this._floorLevel}'`, t = this._layer?.definitionExpression;
-      this._layer && (this._layer.definitionExpression = t && this._floorExpression && t?.indexOf(this._floorExpression) > -1 ? t.replace(this._floorExpression, e) : t ? `${t} AND (${e})` : e), this._floorExpression = e;
+      const floorExp = `${this._floorField} = '${this._floorLevel}'`;
+      const defExp = this._layer?.definitionExpression;
+      if (this._layer) {
+        this._layer.definitionExpression = defExp && this._floorExpression && defExp?.indexOf(this._floorExpression) > -1 ? defExp.replace(this._floorExpression, floorExp) : defExp ? `${defExp} AND (${floorExp})` : floorExp;
+      }
+      this._floorExpression = floorExp;
     }
   }
   _featuresEmpty() {
     return this._allIds?.length === 0;
   }
   _hasFilterExpressions() {
-    let e = [];
-    const t = this._layer?.id;
-    return this.mapInfo?.filterConfig?.layerExpressions && t !== void 0 && (e = this.mapInfo.filterConfig.layerExpressions.filter((i) => i.id === t)), e.length > 0;
+    let layerExpressions = [];
+    const id = this._layer?.id;
+    if (this.mapInfo?.filterConfig?.layerExpressions && id !== void 0) {
+      layerExpressions = this.mapInfo.filterConfig.layerExpressions.filter((exp) => exp.id === id);
+    }
+    return layerExpressions.length > 0;
   }
-  _getAction(e, t, i, s, a, l, h, n) {
-    const r = this._layer === void 0 ? !0 : l;
-    return o`<calcite-action .active=${e} appearance=solid .disabled=${r} .icon=${t} .id=${`layer-table-${t}`} .indicator=${i} .label=${s} .loading=${h} @click=${a} text text-enabled><div class="display-flex"><span class="label-override padding-start-1-4">${s}</span></div></calcite-action>${this._getToolTip("auto", `layer-table-${t}`, n)}`;
+  _getAction(active, icon, indicator, label, func, disabled, loading, toolTip) {
+    const _disabled = this._layer === void 0 ? true : disabled;
+    return html`<calcite-action .active=${active} appearance=solid .disabled=${_disabled} .icon=${icon} .id=${`layer-table-${icon}`} .indicator=${indicator} .label=${label} .loading=${loading} @click=${func} text text-enabled><div class="display-flex"><span class="label-override padding-start-1-4">${label}</span></div></calcite-action>${this._getToolTip("auto", `layer-table-${icon}`, toolTip)}`;
   }
   _showDelete() {
     this.showDelete.emit({
       ids: this._getIds()
     });
   }
-  _getShare(e) {
-    return o`<div id=${this._getId(e) ?? c}><instant-apps-social-share class="height-51 width-51 display-flex" .embed=${this.shareIncludeEmbed} flip-rtl popover-button-icon-scale=s scale=m share-button-color=neutral share-button-type=action .socialMedia=${this.shareIncludeSocial} .view=${this.mapView} ${p(this._shareNode)}></instant-apps-social-share>${this._getToolTip("bottom", e, this._translations.share)}</div>`;
+  _getShare(icon) {
+    return html`<div id=${this._getId(icon) ?? nothing}><instant-apps-social-share class="height-51 width-51 display-flex" .embed=${this.shareIncludeEmbed} flip-rtl popover-button-icon-scale=s scale=m share-button-color=neutral share-button-type=action .socialMedia=${this.shareIncludeSocial} .view=${this.mapView} ${ref(this._shareNode)}></instant-apps-social-share>${this._getToolTip("bottom", icon, this._translations.share)}</div>`;
   }
   _updateShareUrl() {
-    const e = this._shareNode.value?.shareUrl;
-    if (!e)
+    const url = this._shareNode.value?.shareUrl;
+    if (!url) {
       return;
-    const t = new URL(e);
-    this.mapInfo?.id ? t.searchParams.set("webmap", this.mapInfo.id) : t.searchParams.delete("webmap"), this._layer?.id ? t.searchParams.set("layer", this._layer.id) : t.searchParams.delete("layer"), this.selectedIds?.length > 0 ? t.searchParams.set("oid", this.selectedIds.join(",")) : t.searchParams.delete("oid"), this.appLayout && t.searchParams.set("applayout", this.appLayout), this.selectedRelatedIds?.length > 0 && this._relatedFeatureTable?.layer?.id && (t.searchParams.set("oid", this.selectedRelatedIds.join(",")), t.searchParams.set("layer", this._relatedFeatureTable?.layer?.id.toString())), this._shareNode.value && (this._shareNode.value.autoUpdateShareUrl = !1, this._shareNode.value.shareUrl = t.href);
+    }
+    const urlObj = new URL(url);
+    if (this.mapInfo?.id) {
+      urlObj.searchParams.set("webmap", this.mapInfo.id);
+    } else {
+      urlObj.searchParams.delete("webmap");
+    }
+    if (this._layer?.id) {
+      urlObj.searchParams.set("layer", this._layer.id);
+    } else {
+      urlObj.searchParams.delete("layer");
+    }
+    if (this.selectedIds?.length > 0) {
+      urlObj.searchParams.set("oid", this.selectedIds.join(","));
+    } else {
+      urlObj.searchParams.delete("oid");
+    }
+    if (this.appLayout) {
+      urlObj.searchParams.set("applayout", this.appLayout);
+    }
+    if (this.selectedRelatedIds?.length > 0 && this._relatedFeatureTable?.layer?.id) {
+      urlObj.searchParams.set("oid", this.selectedRelatedIds.join(","));
+      urlObj.searchParams.set("layer", this._relatedFeatureTable?.layer?.id.toString());
+    }
+    if (this._shareNode.value) {
+      this._shareNode.value.autoUpdateShareUrl = false;
+      this._shareNode.value.shareUrl = urlObj.href;
+    }
   }
-  _getToolTip(e, t, i) {
-    return o`<calcite-tooltip .placement=${e} .referenceElement=${t}><span>${i}</span></calcite-tooltip>`;
+  _getToolTip(placement, referenceElement, text) {
+    return html`<calcite-tooltip .placement=${placement} .referenceElement=${referenceElement}><span>${text}</span></calcite-tooltip>`;
   }
-  _getId(e) {
-    return `solutions-action-${e}`;
+  _getId(id) {
+    return `solutions-action-${id}`;
   }
-  _getDangerAction(e, t, i, s) {
-    const a = this._layer === void 0 ? !0 : s;
-    return o`<div class="display-flex" id=${this._getId(e) ?? c}>${o`<calcite-action appearance=solid .disabled=${a} .id=${`layer-table-${e}`} @click=${i} text><calcite-icon class="danger-icon-color" .icon=${e} scale=s></calcite-icon><span class="label-override padding-start-1-4 danger-label-color">${t}</span></calcite-action>`}${this._getToolTip("bottom", `layer-table-${e}`, t)}</div>`;
+  _getDangerAction(icon, label, func, disabled) {
+    const _disabled = this._layer === void 0 ? true : disabled;
+    return html`<div class="display-flex" id=${this._getId(icon) ?? nothing}>${html`<calcite-action appearance=solid .disabled=${_disabled} .id=${`layer-table-${icon}`} @click=${func} text><calcite-icon class="danger-icon-color" .icon=${icon} scale=s></calcite-icon><span class="label-override padding-start-1-4 danger-label-color">${label}</span></calcite-action>`}${this._getToolTip("bottom", `layer-table-${icon}`, label)}</div>`;
   }
   _getIds() {
-    let e = this._relatedFeatureTable ?? this._table;
-    return this._relatedFeatureTable && this._table && this._table.highlightIds.getItemAt(0) !== this.selectedIds[0] && (e = this._table), e?.highlightIds.map((t) => Number.parseInt(t.toString(), 10)).toArray() ?? [];
-  }
-  onTableNodeCreate(e) {
-    this._tableNode = e;
-  }
-  async _getTable(e, t) {
-    this._layer && (await this._layer.when(() => {
-      this._table = new L({
-        autoRefreshEnabled: this.enableAutoRefresh,
-        layer: this._layer,
-        view: this.mapView,
-        columnReorderingEnabled: this.enableColumnReorder,
-        editingEnabled: this._editEnabled && this.enableInlineEdit,
-        relatedRecordsEnabled: !0,
-        attachmentsEnabled: !0,
-        highlightEnabled: !1,
-        multiSortEnabled: !1,
-        visibleElements: {
-          columnDescriptions: !1,
-          header: !1,
-          menu: !1,
-          progress: !1
-        },
-        tableTemplate: {
-          columnTemplates: t
-        },
-        container: e
+    let table = this._relatedFeatureTable ?? this._table;
+    if (this._relatedFeatureTable && this._table && this._table.highlightIds.getItemAt(0) !== this.selectedIds[0]) {
+      table = this._table;
+    }
+    return table?.highlightIds.map((id) => Number.parseInt(id.toString(), 10)).toArray() ?? [];
+  }
+  onTableNodeCreate(node) {
+    this._tableNode = node;
+  }
+  async _getTable(node, columnTemplates) {
+    if (this._layer) {
+      await this._layer.when(() => {
+        this._table = new FeatureTable({
+          autoRefreshEnabled: this.enableAutoRefresh,
+          autoSaveEnabled: this.enableTableAutosave,
+          layer: this._layer,
+          view: this.mapView,
+          columnReorderingEnabled: this.enableColumnReorder,
+          editingEnabled: this._editEnabled && this.enableInlineEdit,
+          relatedRecordsEnabled: true,
+          attachmentsEnabled: true,
+          highlightEnabled: false,
+          multiSortEnabled: false,
+          visibleElements: {
+            columnDescriptions: false,
+            header: false,
+            menu: false,
+            progress: false
+          },
+          tableTemplate: {
+            columnTemplates
+          },
+          container: node
+        });
       });
-    }), await this._table?.when(() => {
-      this._table?.viewModel.addHandles(this._table.highlightIds.on("change", (i) => {
-        this._handleOnChange(i);
-      })), this._table?.viewModel.addHandles(this._table.on("cell-pointerover", this.tempHighlightOnHover.bind(this))), this._table?.viewModel.addHandles(this._table.on("cell-pointerout", this._removeTempHighlight.bind(this))), this._table?.viewModel.addHandles(this._table.on("column-reorder", this._handleColumnReorder.bind(this))), this.listenOn(this._tableNode, "mouseleave", this._removeTempHighlight), this._table?.viewModel.addHandles(u.watch(() => this._table.size, (i) => {
-        this._size = i;
-      })), u?.watch(
-        () => this._table?.relatedTable,
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (i) => {
-          if (i) {
-            if (i.rowHighlightIds.length) {
-              const a = {
-                added: [i.rowHighlightIds.getItemAt(0)],
-                removed: []
-              };
-              this._handleOnChange(a);
-            }
-            const s = i.layer;
-            if (this._layerEditHandle = s.on("edits", async () => {
-              await new Promise((a) => setTimeout(a, 50)), await this._refresh(!0);
-            }), this._checkEditEnabled(s), i.editingEnabled = this._editEnabled && this.enableInlineEdit, this._relatedFeatureTable = i, typeof i.layer?.id == "string" && i.layer?.fields) {
-              const a = i.layer.popupTemplate?.fieldInfos, l = this._getColumnTemplates(i.layer.id, i.layer.fields, a);
-              this._relatedFeatureTable.tableTemplate = new m({
-                columnTemplates: l
+      await this._table?.when(() => {
+        this._table?.viewModel.addHandles(this._table.highlightIds.on("change", (_evt) => {
+          void this._handleOnChange(_evt);
+        }));
+        this._table?.viewModel.addHandles(this._table.on("cell-pointerover", this.tempHighlightOnHover.bind(this)));
+        this._table?.viewModel.addHandles(this._table.on("cell-pointerout", this._removeTempHighlight.bind(this)));
+        this._table?.viewModel.addHandles(this._table.on("column-reorder", this._handleColumnReorder.bind(this)));
+        this.listenOn(this._tableNode, "mouseleave", this._removeTempHighlight);
+        this._table?.viewModel.addHandles(reactiveUtils.watch(() => this._table.size, (size) => {
+          this._size = size;
+        }));
+        reactiveUtils?.watch(
+          () => this._table?.relatedTable,
+          // eslint-disable-next-line @typescript-eslint/no-misused-promises
+          async (table) => {
+            if (table) {
+              if (table.rowHighlightIds.length) {
+                const evt = {
+                  added: [table.rowHighlightIds.getItemAt(0)],
+                  removed: []
+                };
+                void this._handleOnChange(evt);
+              }
+              const layer = table.layer;
+              this._layerEditHandle = layer.on("edits", async () => {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                await this._refresh(true);
               });
+              this._checkEditEnabled(layer);
+              table.editingEnabled = this._editEnabled && this.enableInlineEdit;
+              table.autoSaveEnabled = this.enableTableAutosave;
+              this._relatedFeatureTable = table;
+              if (typeof table.layer?.id === "string" && table.layer?.fields) {
+                const fieldInfos = table.layer.popupTemplate?.fieldInfos;
+                const columnTemplates2 = this._getColumnTemplates(table.layer.id, table.layer.fields, fieldInfos);
+                this._relatedFeatureTable.tableTemplate = new TableTemplate({
+                  columnTemplates: columnTemplates2
+                });
+              }
+              table.highlightIds.on("change", (evt) => {
+                void this._handleRelatedRecordsChange(evt);
+              });
+            } else {
+              this.selectedRelatedIds = [];
+              this._relatedFeatureTable = void 0;
+              if (this._layerEditHandle) {
+                this._layerEditHandle.remove();
+              }
+              const layerOrTable = this._layer;
+              void this._refresh();
+              if (layerOrTable) {
+                this.relatedRecordToggled.emit(layerOrTable);
+              }
+              this._finishOnChange();
             }
-            i.highlightIds.on("change", (a) => {
-              this._handleRelatedRecordsChange(a);
-            });
-          } else {
-            this.selectedRelatedIds = [], this._relatedFeatureTable = void 0, this._layerEditHandle && this._layerEditHandle.remove();
-            const s = this._layer;
-            this._refresh(), s && this.relatedRecordToggled.emit(s), this._finishOnChange();
+            await this._initToolInfos();
           }
-          await this._initToolInfos();
-        }
-      );
-    }));
+        );
+      });
+    }
   }
-  async _handleRelatedRecordsChange(e) {
-    await this._handleOnChange(e), this._updateShareUrl();
+  async _handleRelatedRecordsChange(evt) {
+    await this._handleOnChange(evt);
+    this._updateShareUrl();
   }
-  hasAttachmentsEnabled(e) {
-    if (!e?.capabilities)
-      return !1;
-    const { capabilities: { data: { supportsAttachment: t }, operations: { supportsQueryAttachments: i } } } = e;
-    return t && i;
+  hasAttachmentsEnabled(layer) {
+    if (!layer?.capabilities) {
+      return false;
+    }
+    const { capabilities: { data: { supportsAttachment }, operations: { supportsQueryAttachments } } } = layer;
+    return supportsAttachment && supportsQueryAttachments;
   }
-  async _handleOnChange(e) {
-    if (!await this._validateActiveEdits([...e.added], [...e.removed]))
+  async _handleOnChange(_evt) {
+    const handleOnChange = await this._validateActiveEdits([..._evt.added], [..._evt.removed]);
+    if (!handleOnChange) {
       return;
-    const i = [...this._getIds()];
-    let s = this._getSelectedLayer(i);
-    this._relatedFeatureTable && this._table?.highlightIds.getItemAt(0) !== this.selectedIds[0] && (s = this._layer, await this._initToolInfos()), s && this.relatedRecordToggled.emit(s), this.featureSelectionMode === "single" && (this._relatedFeatureTable && i.length > 1 ? (this._relatedFeatureTable.highlightIds.remove(i[0]), i.shift()) : i.length > 1 && !this._selectAllActive && (this._table?.highlightIds.remove(i[0]), i.shift())), !this._relatedFeatureTable || this._relatedFeatureTable && this._table?.highlightIds.getItemAt(0) !== this.selectedIds[0] ? (this.selectedRelatedIds = [], this.selectedIds = i.reverse(), this._tempSelectedIds = [...this.selectedIds], this._highlightFeatures(this.selectedIds[0])) : this.selectedRelatedIds = i.reverse(), this._finishOnChange();
+    }
+    const ids = [...this._getIds()];
+    let layerOrTable = this._getSelectedLayer(ids);
+    if (this._relatedFeatureTable && this._table?.highlightIds.getItemAt(0) !== this.selectedIds[0]) {
+      layerOrTable = this._layer;
+      await this._initToolInfos();
+    }
+    layerOrTable && this.relatedRecordToggled.emit(layerOrTable);
+    if (this.featureSelectionMode === "single") {
+      if (this._relatedFeatureTable && ids.length > 1) {
+        this._relatedFeatureTable.highlightIds.remove(ids[0]);
+        ids.shift();
+      } else {
+        if (ids.length > 1 && !this._selectAllActive) {
+          this._table?.highlightIds.remove(ids[0]);
+          ids.shift();
+        }
+      }
+    }
+    if (!this._relatedFeatureTable || this._relatedFeatureTable && this._table?.highlightIds.getItemAt(0) !== this.selectedIds[0]) {
+      this.selectedRelatedIds = [];
+      this.selectedIds = ids.reverse();
+      this._tempSelectedIds = [...this.selectedIds];
+      this._highlightFeatures(this.selectedIds[0]);
+    } else {
+      this.selectedRelatedIds = ids.reverse();
+    }
+    this._finishOnChange();
   }
-  async _validateActiveEdits(e, t) {
-    let i = !0;
+  async _validateActiveEdits(added, removed) {
+    let handleOnChange = true;
     if (this._editor && !this._skipEditCheck) {
-      if (this._hasPendingEdits()) {
-        let a = !1;
+      const hasPendingEdits = this._hasPendingEdits();
+      if (hasPendingEdits) {
+        let continueEditing = false;
         try {
           this._editor.viewModel.activeWorkflow && await this._editor.viewModel.activeWorkflow.cancel({
-            force: !1
+            force: false
           });
-        } catch (l) {
-          a = l?.name === "workflow:cancel-denied";
+        } catch (error) {
+          continueEditing = error?.name === "workflow:cancel-denied";
         }
-        if (a) {
-          const l = this._relatedFeatureTable && this._relatedFeatureTable.highlightIds.length > 0 ? this._relatedFeatureTable : this._table;
-          i = !1, this._skipEditCheck = !0, e.length > 0 ? l?.highlightIds.removeMany(e) : t.length > 0 && l?.highlightIds.addMany(t);
+        if (continueEditing) {
+          const table = this._relatedFeatureTable && this._relatedFeatureTable.highlightIds.length > 0 ? this._relatedFeatureTable : this._table;
+          handleOnChange = false;
+          this._skipEditCheck = true;
+          if (added.length > 0) {
+            table?.highlightIds.removeMany(added);
+          } else if (removed.length > 0) {
+            table?.highlightIds.addMany(removed);
+          }
         }
       }
-    } else
-      i = !this._skipEditCheck, this._skipEditCheck = !1;
-    return this._shouldUpdateTableOnExtentChange = i, i;
+    } else {
+      handleOnChange = !this._skipEditCheck;
+      this._skipEditCheck = false;
+    }
+    this._shouldUpdateTableOnExtentChange = handleOnChange;
+    return handleOnChange;
   }
   _hasPendingEdits() {
-    const e = this._editor?.viewModel?.hasPendingEdits, t = this._editor?.activeWorkflow?.activeWorkflow?.hasPendingEdits;
-    return e || t;
+    const vmHasEdits = this._editor?.viewModel?.hasPendingEdits;
+    const awHasEdits = this._editor?.activeWorkflow?.activeWorkflow?.hasPendingEdits;
+    return vmHasEdits || awHasEdits;
   }
   _finishOnChange() {
-    this._showOnlySelected && !this._relatedFeatureTable && (this._table && this._getSelectedIds().length > 0 ? this._table.filterBySelectionEnabled = !0 : this._toggleShowSelected());
-    const e = this._getSelectedIds();
+    if (this._showOnlySelected && !this._relatedFeatureTable) {
+      if (this._table && this._getSelectedIds().length > 0) {
+        this._table.filterBySelectionEnabled = true;
+      } else {
+        this._toggleShowSelected();
+      }
+    }
+    const selectedIds = this._getSelectedIds();
     setTimeout(() => {
-      this.featureSelectionChange.emit(e);
+      this.featureSelectionChange.emit(selectedIds);
     }, 50);
   }
   _handleColumnReorder() {
     this.columnReorder.emit();
   }
   tempHighlightOnHover(e) {
-    if (this._removeTempHighlight(), this._selectedLayerView) {
-      const t = e.feature;
-      this._temporaryFeatureHandle = this._selectedLayerView?.highlight([t], { name: "temporary" });
+    this._removeTempHighlight();
+    if (this._selectedLayerView) {
+      const temporaryFeature = e.feature;
+      this._temporaryFeatureHandle = this._selectedLayerView?.highlight([temporaryFeature], { name: "temporary" });
     }
   }
   _removeTempHighlight() {
-    this._temporaryFeatureHandle && this._temporaryFeatureHandle.remove();
+    if (this._temporaryFeatureHandle) {
+      this._temporaryFeatureHandle.remove();
+    }
   }
-  _highlightFeatures(e) {
-    if (this._clearHighlights(), this.selectedIds.length > 0 && this._selectedLayerView && (this._currentFeatureHighlightHandle = this._selectedLayerView?.highlight([e], { name: "current-selection" }), this.selectedIds.length > 1)) {
-      const t = this.selectedIds.filter((i) => i !== e);
-      this._defaultFeaturesHandle = this._selectedLayerView?.highlight(t, { name: "default" });
+  _highlightFeatures(currentFeatureId) {
+    this._clearHighlights();
+    if (this.selectedIds.length > 0 && this._selectedLayerView) {
+      this._currentFeatureHighlightHandle = this._selectedLayerView?.highlight([currentFeatureId], { name: "current-selection" });
+      if (this.selectedIds.length > 1) {
+        const secondaryFeatures = this.selectedIds.filter((id) => id !== currentFeatureId);
+        this._defaultFeaturesHandle = this._selectedLayerView?.highlight(secondaryFeatures, { name: "default" });
+      }
     }
   }
   _clearHighlights() {
-    this._removeTempHighlight(), this._currentFeatureHighlightHandle && this._currentFeatureHighlightHandle.remove(), this._defaultFeaturesHandle && this._defaultFeaturesHandle.remove();
+    this._removeTempHighlight();
+    if (this._currentFeatureHighlightHandle) {
+      this._currentFeatureHighlightHandle.remove();
+    }
+    if (this._defaultFeaturesHandle) {
+      this._defaultFeaturesHandle.remove();
+    }
   }
   _resetColumnTemplates() {
     if (this._layer) {
-      const e = this._layer.popupTemplate?.fieldInfos, t = this._getColumnTemplates(this._layer.id, this._layer.fields, e);
-      t?.length === 0 ? this._tableNode?.classList.add("display-none") : this._tableNode?.classList.remove("display-none");
-      const i = this._table?.tableTemplate?.columnTemplates, s = i && t && i.length !== t.length || t?.some((a, l) => i && i[l] ? JSON.stringify(i[l]) !== JSON.stringify(a) : !1);
-      if (this._table && t && (s || !this._columnsInfo)) {
-        this._table.tableTemplate = new m({
-          columnTemplates: t
+      const fieldInfos = this._layer.popupTemplate?.fieldInfos;
+      const columnTemplates = this._getColumnTemplates(this._layer.id, this._layer.fields, fieldInfos);
+      if (columnTemplates?.length === 0) {
+        this._tableNode?.classList.add("display-none");
+      } else {
+        this._tableNode?.classList.remove("display-none");
+      }
+      const tableColumnTemplates = this._table?.tableTemplate?.columnTemplates;
+      const hasChange = tableColumnTemplates && columnTemplates && tableColumnTemplates.length !== columnTemplates.length || columnTemplates?.some((ct, i) => {
+        if (tableColumnTemplates && tableColumnTemplates[i]) {
+          return JSON.stringify(tableColumnTemplates[i]) !== JSON.stringify(ct);
+        } else {
+          return false;
+        }
+      });
+      if (this._table && columnTemplates && (hasChange || !this._columnsInfo)) {
+        this._table.tableTemplate = new TableTemplate({
+          columnTemplates
         });
-        const a = t.map((l) => l.fieldName);
-        this._initColumnsInfo(a);
+        const fieldNames = columnTemplates.map((f) => f.fieldName);
+        this._initColumnsInfo(fieldNames);
       }
     }
   }
-  _setColumnTemplates(e) {
-    this._table && e && (this._table.tableTemplate = new m({
-      columnTemplates: e
-    }));
+  _setColumnTemplates(columnTemplates) {
+    if (this._table && columnTemplates) {
+      this._table.tableTemplate = new TableTemplate({
+        columnTemplates
+      });
+    }
   }
   async _resetTable() {
-    if (this._loaded = !1, this._clearSelection(), this._allIds = await this.queryAllIds(), !this._table && this._layer) {
-      const e = this._layer.popupTemplate?.fieldInfos, t = this._getColumnTemplates(this._layer.id, this._layer.fields, e);
-      this._tableNode && await this._getTable(this._tableNode, t);
-    } else this._table && (this._table.view = this.mapView, this._table.layer = this._layer);
-    await this._initLayerRefresh(), this._checkEditEnabled(this._layer), this._table && (this._table.editingEnabled = this._editEnabled && this.enableInlineEdit, await this._table.when(), setTimeout(() => {
-      this._loaded || this.finishLoading();
-    }, 1e3), await u.once(() => this._table?.state === "loaded").then(async () => {
-      await this.finishLoading();
-    }));
+    this._loaded = false;
+    this._clearSelection();
+    this._allIds = await this.queryAllIds();
+    if (!this._table && this._layer) {
+      const fieldInfos = this._layer.popupTemplate?.fieldInfos;
+      const columnTemplates = this._getColumnTemplates(this._layer.id, this._layer.fields, fieldInfos);
+      this._tableNode && await this._getTable(this._tableNode, columnTemplates);
+    } else if (this._table) {
+      this._table.view = this.mapView;
+      this._table.layer = this._layer;
+    }
+    await this._initLayerRefresh();
+    this._checkEditEnabled(this._layer);
+    if (this._table) {
+      this._table.editingEnabled = this._editEnabled && this.enableInlineEdit;
+      this._table.autoSaveEnabled = this.enableTableAutosave;
+      await this._table.when();
+      setTimeout(() => {
+        if (!this._loaded) {
+          void this.finishLoading();
+        }
+      }, 1e3);
+      await reactiveUtils.once(() => this._table?.state === "loaded").then(async () => {
+        await this.finishLoading();
+      });
+    }
   }
   async finishLoading() {
     try {
-      this._loaded = !0, this._table?.highlightIds.removeAll(), this._table.objectIds.removeAll(), this._resetColumnTemplates(), this._showOnlySelected = !1, await this._handleDefaults(), await this._sortTable(), await this._initToolInfos(), ["esri-feature-table", "esri-widget"].forEach((t) => {
-        this._tableNode && !this._tableNode.classList.contains(t) && this._tableNode.classList.add(t);
+      this._loaded = true;
+      this._table?.highlightIds.removeAll();
+      this._table.objectIds.removeAll();
+      this._resetColumnTemplates();
+      this._showOnlySelected = false;
+      await this._handleDefaults();
+      await this._sortTable();
+      await this._initToolInfos();
+      const tableNodeClasses = ["esri-feature-table", "esri-widget"];
+      tableNodeClasses.forEach((c) => {
+        if (this._tableNode && !this._tableNode.classList.contains(c)) {
+          this._tableNode.classList.add(c);
+        }
       });
     } catch (e) {
       console.log(e);
     }
   }
   async _initLayerRefresh() {
-    this._refreshHandle && this._refreshHandle.remove(), this._layer && (this._refreshHandle = this._layer.on("refresh", (e) => {
-      e.dataChanged && this._updateAllIds();
-    }));
+    if (this._refreshHandle) {
+      this._refreshHandle.remove();
+    }
+    if (this._layer) {
+      this._refreshHandle = this._layer.on("refresh", (_evt) => {
+        if (_evt.dataChanged) {
+          void this._updateAllIds();
+        }
+      });
+    }
   }
   async _updateAllIds() {
-    const e = await this.queryAllIds(), t = this.selectedIds.filter((i) => this._allIds.indexOf(i) > -1);
-    (JSON.stringify(e) !== JSON.stringify(this._allIds) || JSON.stringify(this.selectedIds) !== JSON.stringify(t)) && (this._allIds = e, this.selectedIds = t, await this._refresh());
+    const allIds = await this.queryAllIds();
+    const selectedIds = this.selectedIds.filter((id) => this._allIds.indexOf(id) > -1);
+    if (JSON.stringify(allIds) !== JSON.stringify(this._allIds) || JSON.stringify(this.selectedIds) !== JSON.stringify(selectedIds)) {
+      this._allIds = allIds;
+      this.selectedIds = selectedIds;
+      await this._refresh();
+    }
   }
   async _handleDefaults() {
-    if (!this._defaultOidHonored && this.defaultOid?.length > 0 && this.defaultOid[0] > -1 && this._table && (await this._selectDefaultFeature(this.defaultOid), this._defaultOidHonored = !0, this.defaultOid = [], this._showOnlySelected = !1, this._toggleShowSelected()), !this._defaultGlobalIdHonored && this.defaultGlobalId && this.defaultGlobalId?.length > 0 && this._table && this._layer) {
-      const e = await E(this.defaultGlobalId, this._layer), t = e?.length > 0 ? e.map((i) => Number(i.getObjectId())) : void 0;
-      t && await this._selectDefaultFeature(t), this._defaultGlobalIdHonored = !0, this.defaultGlobalId = [], this._showOnlySelected = !1, this._toggleShowSelected();
+    if (!this._defaultOidHonored && this.defaultOid?.length > 0 && this.defaultOid[0] > -1 && this._table) {
+      await this._selectDefaultFeature(this.defaultOid);
+      this._defaultOidHonored = true;
+      this.defaultOid = [];
+      this._showOnlySelected = false;
+      this._toggleShowSelected();
+    }
+    if (!this._defaultGlobalIdHonored && this.defaultGlobalId && this.defaultGlobalId?.length > 0 && this._table && this._layer) {
+      const features = await queryFeaturesByGlobalID(this.defaultGlobalId, this._layer);
+      const oids = features?.length > 0 ? features.map((f) => Number(f.getObjectId())) : void 0;
+      if (oids) {
+        await this._selectDefaultFeature(oids);
+      }
+      this._defaultGlobalIdHonored = true;
+      this.defaultGlobalId = [];
+      this._showOnlySelected = false;
+      this._toggleShowSelected();
     }
   }
-  _initColumnsInfo(e) {
-    const t = this._table?.columns.reduce((a, l) => ((!e || e?.indexOf(l.name) > -1) && (a[l.name] = !l.hidden), a), {}), i = this._table?.columns.map((a) => a.name);
-    (e && i ? e.filter((a) => i.indexOf(a) < 0) : []).forEach((a) => {
-      t[a] = !0;
-    }), this._columnsInfo = e ? e.reduce((a, l) => (a[l] = t[l], a), {}) : t;
-  }
-  async _selectDefaultFeature(e) {
-    e.length > 0 && this._table?.highlightIds.addMany(e);
+  _initColumnsInfo(fieldNames) {
+    const columnsInfo = this._table?.columns.reduce((prev, cur) => {
+      if (!fieldNames || fieldNames?.indexOf(cur.name) > -1) {
+        prev[cur.name] = !cur.hidden;
+      }
+      return prev;
+    }, {});
+    const oldColumnNames = this._table?.columns.map((c) => c.name);
+    const newColumnNames = fieldNames && oldColumnNames ? fieldNames.filter((n) => oldColumnNames.indexOf(n) < 0) : [];
+    newColumnNames.forEach((c) => {
+      columnsInfo[c] = true;
+    });
+    this._columnsInfo = fieldNames ? fieldNames.reduce((prev, cur) => {
+      prev[cur] = columnsInfo[cur];
+      return prev;
+    }, {}) : columnsInfo;
+  }
+  async _selectDefaultFeature(oids) {
+    if (oids.length > 0) {
+      this._table?.highlightIds.addMany(oids);
+    }
   }
-  _checkEditEnabled(e) {
-    this._editEnabled = !!(e?.editingEnabled && e?.capabilities?.operations.supportsUpdate), this._deleteEnabled = !!(e?.editingEnabled && e?.capabilities?.operations.supportsDelete);
+  _checkEditEnabled(layer) {
+    this._editEnabled = layer?.editingEnabled && layer?.capabilities?.operations.supportsUpdate ? true : false;
+    this._deleteEnabled = layer?.editingEnabled && layer?.capabilities?.operations.supportsDelete ? true : false;
   }
   async _sortTable() {
-    let e = this._layer?.objectIdField, t = "desc", i;
-    const s = this.mapInfo?.layerOptions?.layers, a = this._layer?.id;
-    s && s.length > 0 && a !== void 0 && (i = s.filter((l) => l.id === a), i && i.length > 0 && (i = i[0], i.sortField && i.fields?.includes(i.sortField) && (e = i.sortField), t = i?.sortOrder ? i.sortOrder : "desc")), this._table && this._layer && (await this._table.when(), await this._layer.when(() => {
-      e && this._table?.sortColumn(e, t);
-    }));
+    let sortField = this._layer?.objectIdField;
+    let sortOrder = "desc";
+    let configuredLayer;
+    const optionLayers = this.mapInfo?.layerOptions?.layers;
+    const id = this._layer?.id;
+    if (optionLayers && optionLayers.length > 0 && id !== void 0) {
+      configuredLayer = optionLayers.filter((layer) => layer.id === id);
+      if (configuredLayer && configuredLayer.length > 0) {
+        configuredLayer = configuredLayer[0];
+        if (configuredLayer.sortField && configuredLayer.fields?.includes(configuredLayer.sortField)) {
+          sortField = configuredLayer.sortField;
+        }
+        sortOrder = configuredLayer?.sortOrder ? configuredLayer.sortOrder : "desc";
+      }
+    }
+    if (this._table && this._layer) {
+      await this._table.when();
+      await this._layer.when(() => {
+        if (sortField) {
+          this._table?.sortColumn(sortField, sortOrder);
+        }
+      });
+    }
   }
   async _handleFilterListReset() {
-    this._filterActive = !1, this._updateShareUrl(), await this._searchFullText();
+    this._filterActive = false;
+    this._updateShareUrl();
+    await this._searchFullText();
   }
-  async _handleFilterUpdate(e) {
+  async _handleFilterUpdate(active) {
     if (this._floorExpression && this._layer) {
-      const t = this._layer.definitionExpression, i = new RegExp(`${this._floorField} = ['].+[']`, "gm");
-      this._layer.definitionExpression = t && this._floorField && t.indexOf(`${this._floorField} = '`) > -1 ? t.replace(i, this._floorExpression) : t ? `${t} AND (${this._floorExpression})` : this._floorExpression;
+      const defExp = this._layer.definitionExpression;
+      const regEx = new RegExp(`${this._floorField} = ['].+[']`, "gm");
+      this._layer.definitionExpression = defExp && this._floorField && defExp.indexOf(`${this._floorField} = '`) > -1 ? defExp.replace(regEx, this._floorExpression) : defExp ? `${defExp} AND (${this._floorExpression})` : this._floorExpression;
     }
-    this._filterActive = e, this._updateShareUrl(), await this._searchFullText();
+    this._filterActive = active;
+    this._updateShareUrl();
+    await this._searchFullText();
   }
   _handleTableOnMapExtent() {
-    this._table && (this._filterByExtentHandle = u.when(
-      () => this.mapView?.stationary,
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      async () => {
-        if (this._shouldUpdateTableOnExtentChange && this.appLayout === "splitView") {
-          if (await new Promise((e) => setTimeout(e, 800)), this._table && this.mapView) {
-            this._table.filterGeometry = this.mapView.extent;
-            const e = {
-              geometry: this.mapView.extent
-            }, t = this._layer && await this._layer.queryObjectIds(e), i = this.selectedIds.filter((a) => !t?.includes(a)), s = this._outOFExtentOids.filter((a) => t?.includes(a));
-            i.length > 0 && (this._table && this._table?.viewModel?.attachmentsViewOptions?.objectId && this._table.viewModel.hideAttachmentsView(), this._table.highlightIds.removeMany(i), this._outOFExtentOids = [...this._outOFExtentOids, ...i]), s.length > 0 && (this.selectedIds = [.../* @__PURE__ */ new Set([...this.selectedIds, ...s])], this._table.highlightIds.removeAll(), this._table.highlightIds.addMany(this.selectedIds.reverse()), this._outOFExtentOids = this._outOFExtentOids.filter((a) => !s.includes(a)));
+    if (this._table) {
+      this._filterByExtentHandle = reactiveUtils.when(
+        () => this.mapView?.stationary,
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        async () => {
+          if (this._shouldUpdateTableOnExtentChange && this.appLayout === "splitView") {
+            await new Promise((resolve) => setTimeout(resolve, 800));
+            if (this._table && this.mapView) {
+              this._table.filterGeometry = this.mapView.extent;
+              const query = {
+                geometry: this.mapView.extent
+              };
+              const objectIdsInExtent = this._layer && await this._layer.queryObjectIds(query);
+              const outOids = this.selectedIds.filter((id) => !objectIdsInExtent?.includes(id));
+              const restoreOids = this._outOFExtentOids.filter((id) => objectIdsInExtent?.includes(id));
+              if (outOids.length > 0) {
+                if (this._table && this._table?.viewModel?.attachmentsViewOptions?.objectId) {
+                  this._table.viewModel.hideAttachmentsView();
+                }
+                this._table.highlightIds.removeMany(outOids);
+                this._outOFExtentOids = [...this._outOFExtentOids, ...outOids];
+              }
+              if (restoreOids.length > 0) {
+                this.selectedIds = [.../* @__PURE__ */ new Set([...this.selectedIds, ...restoreOids])];
+                this._table.highlightIds.removeAll();
+                this._table.highlightIds.addMany(this.selectedIds.reverse());
+                this._outOFExtentOids = this._outOFExtentOids.filter((oid) => !restoreOids.includes(oid));
+              }
+            }
+            this._allIds = await this.queryAllIds();
           }
-          this._allIds = await this.queryAllIds();
+        },
+        {
+          initial: true
         }
-      },
-      {
-        initial: !0
-      }
-    ));
+      );
+    }
   }
   async _closeFilter() {
     this._allIds = await this.queryAllIds();
   }
   async queryAllIds() {
     if (this._layer) {
-      const e = this._layer.createQuery();
-      return e.geometry = this._filterByExtentHandle && this.mapView ? this.mapView.extent : null, e.where = this._layer.definitionExpression || "1=1", await this._layer.queryObjectIds(e);
-    } else
+      const query = this._layer.createQuery();
+      query.geometry = this._filterByExtentHandle && this.mapView ? this.mapView.extent : null;
+      query.where = this._layer.definitionExpression || "1=1";
+      return await this._layer.queryObjectIds(query);
+    } else {
       return [];
+    }
   }
-  async _mapClicked(e) {
-    const t = {
+  async _mapClicked(_evt) {
+    const opts = {
       include: this._layer
-    }, i = await this.mapView?.hitTest(e.screenPoint, t);
-    if (i && i.results.length > 0) {
-      const s = i.results;
+    };
+    const hitTestResult = await this.mapView?.hitTest(_evt.screenPoint, opts);
+    if (hitTestResult && hitTestResult.results.length > 0) {
+      const result = hitTestResult.results;
       if (this.featureSelectionMode === "single") {
         this._table?.highlightIds.removeAll();
-        const l = s[0].graphic.getObjectId();
-        if (l) {
-          const h = this._table?.highlightIds.indexOf(l);
-          h !== void 0 && h < 0 && this._table?.highlightIds.add(l);
+        const graphic = result[0].graphic;
+        const selectedOID = graphic.getObjectId();
+        if (selectedOID) {
+          const index = this._table?.highlightIds.indexOf(selectedOID);
+          if (index !== void 0 && index < 0) {
+            this._table?.highlightIds.add(selectedOID);
+          }
         }
-      } else
-        s.forEach((a) => {
-          const l = Number(a.graphic.getObjectId()), h = this._table?.highlightIds.indexOf(l);
-          h && h < 0 && l && this._table?.highlightIds.add(l);
+      } else {
+        result.forEach((result2) => {
+          const id = Number(result2.graphic.getObjectId());
+          const index = this._table?.highlightIds.indexOf(id);
+          if (index && index < 0 && id) {
+            this._table?.highlightIds.add(id);
+          }
         });
-      this._showOnlySelected && this._table && (this._table.filterBySelectionEnabled = !0);
-    } else
+      }
+      if (this._showOnlySelected && this._table) {
+        this._table.filterBySelectionEnabled = true;
+      }
+    } else {
       await this.clearSelection();
+    }
   }
   async _selectAll() {
-    const e = this._allIds, t = e.filter((s) => this.selectedIds.indexOf(s) < 0);
-    await this._validateActiveEdits(t, this.selectedIds) && this._table ? (this._table.highlightIds.removeAll(), this._table.highlightIds.addMany(e), this.selectedIds = e, this._finishOnChange(), this._selectAllActive = !0) : this._skipEditCheck = !1;
+    const ids = this._allIds;
+    const addedIds = ids.filter((id) => this.selectedIds.indexOf(id) < 0);
+    const editsDiscarded = await this._validateActiveEdits(addedIds, this.selectedIds);
+    if (editsDiscarded && this._table) {
+      this._table.highlightIds.removeAll();
+      this._table.highlightIds.addMany(ids);
+      this.selectedIds = ids;
+      this._finishOnChange();
+      this._selectAllActive = true;
+    } else {
+      this._skipEditCheck = false;
+    }
   }
   _toggleShowSelected() {
-    this._showOnlySelected = !this._showOnlySelected, this._table && (this._table.filterBySelectionEnabled = this._showOnlySelected);
+    this._showOnlySelected = !this._showOnlySelected;
+    if (this._table) {
+      this._table.filterBySelectionEnabled = this._showOnlySelected;
+    }
   }
   _clearSelection() {
-    this._relatedFeatureTable || (this.selectedIds = [], this._outOFExtentOids = [], this._table && this._table?.viewModel?.attachmentsViewOptions?.objectId && this._table.viewModel.hideAttachmentsView(), this._table?.highlightIds.removeAll(), this._clearHighlights(), this._table?.rowHighlightIds.removeAll()), this._relatedFeatureTable && (this._relatedFeatureTable?.highlightIds.removeAll(), this.selectedRelatedIds = []), this._finishOnChange();
+    if (!this._relatedFeatureTable) {
+      this.selectedIds = [];
+      this._outOFExtentOids = [];
+      if (this._table && this._table?.viewModel?.attachmentsViewOptions?.objectId) {
+        this._table.viewModel.hideAttachmentsView();
+      }
+      this._table?.highlightIds.removeAll();
+      this._clearHighlights();
+      this._table?.rowHighlightIds.removeAll();
+    }
+    if (this._relatedFeatureTable) {
+      this._relatedFeatureTable?.highlightIds.removeAll();
+      this.selectedRelatedIds = [];
+    }
+    this._finishOnChange();
   }
   async _switchSelected() {
-    const e = [...this.selectedIds], t = this._allIds.reduce((s, a) => (e.indexOf(a) < 0 && s.push(a), s), []).sort((s, a) => s - a);
-    await this._validateActiveEdits(t, e) && this._table ? (this._table.highlightIds.removeAll(), this._table.highlightIds.addMany(t), this.selectedIds = t, this._finishOnChange()) : this._skipEditCheck = !1;
+    const currentIndexes = [...this.selectedIds];
+    const ids = this._allIds.reduce((prev, _cur) => {
+      if (currentIndexes.indexOf(_cur) < 0) {
+        prev.push(_cur);
+      }
+      return prev;
+    }, []).sort((a, b) => a - b);
+    const editsDiscarded = await this._validateActiveEdits(ids, currentIndexes);
+    if (editsDiscarded && this._table) {
+      this._table.highlightIds.removeAll();
+      this._table.highlightIds.addMany(ids);
+      this.selectedIds = ids;
+      this._finishOnChange();
+    } else {
+      this._skipEditCheck = false;
+    }
   }
   async _exportToCSV() {
-    const e = this._relatedFeatureTable ? this._relatedFeatureTable.layer : this._layer;
-    if (!e)
+    const layerOrTable = this._relatedFeatureTable ? this._relatedFeatureTable.layer : this._layer;
+    if (!layerOrTable) {
       return;
-    const t = {};
-    let i = this._getIds();
+    }
+    const exportInfos = {};
+    let ids = this._getIds();
     if (this._relatedFeatureTable?.tableParent && this._relatedFeatureTable.highlightIds.length === 0) {
-      const l = this._relatedFeatureTable.tableParent.highlightIds?.getItemAt(0);
-      if (l !== void 0) {
-        const h = await this._queryRelatedFeatures(), n = [];
-        h && h[l]?.features && (h[l].features.forEach((r) => {
-          r.attributes && n.push(r.attributes[e.objectIdField]);
-        }), i = n.length > 0 ? n : []);
-      }
-    }
-    t[e.id] = {
-      selectionSetNames: [e.title || ""],
-      ids: i,
-      layer: e
+      const objectId = this._relatedFeatureTable.tableParent.highlightIds?.getItemAt(0);
+      if (objectId !== void 0) {
+        const result = await this._queryRelatedFeatures();
+        const relatedOIDs = [];
+        if (result && result[objectId]?.features) {
+          result[objectId].features.forEach((feature) => {
+            if (feature.attributes) {
+              relatedOIDs.push(feature.attributes[layerOrTable.objectIdField]);
+            }
+          });
+          ids = relatedOIDs.length > 0 ? relatedOIDs : [];
+        }
+      }
+    }
+    exportInfos[layerOrTable.id] = {
+      selectionSetNames: [layerOrTable.title || ""],
+      ids,
+      layer: layerOrTable
     };
-    const s = this._relatedFeatureTable ?? this._table;
-    if (!s)
+    const table = this._relatedFeatureTable ?? this._table;
+    if (!table) {
       return;
-    const a = s && s.columns.toArray().reduce((l, h) => {
-      if (!h.hidden) {
-        const n = h?.name || h?.fieldName;
-        n && l.push(n.toLocaleLowerCase());
+    }
+    const fields = table && table.columns.toArray().reduce((prev, cur) => {
+      if (!cur.hidden) {
+        const name = cur?.name || cur?.fieldName;
+        if (name) {
+          prev.push(name.toLocaleLowerCase());
+        }
       }
-      return l;
+      return prev;
     }, []);
-    this._updateToolInfoLoading("export", !0), this._csvExporting = !0, this.mapView?.map && await x(
-      this.mapView.map,
-      t,
-      !1,
-      // formatUsingLayerPopup
-      !1,
-      // removeDuplicates
-      !0,
-      // addColumnTitle
-      a,
-      !0,
-      !0
-    ), this._updateToolInfoLoading("export", !1), this._csvExporting = !1;
+    this._updateToolInfoLoading("export", true);
+    this._csvExporting = true;
+    if (this.mapView?.map) {
+      await downloadCSV(
+        this.mapView.map,
+        exportInfos,
+        false,
+        // formatUsingLayerPopup
+        false,
+        // removeDuplicates
+        true,
+        // addColumnTitle
+        fields,
+        true,
+        true
+      );
+    }
+    this._updateToolInfoLoading("export", false);
+    this._csvExporting = false;
   }
   async _queryRelatedFeatures() {
-    const e = this._relatedFeatureTable ? this._relatedFeatureTable ? this._relatedFeatureTable.layer : this._relatedFeatureTable.tableParent?.layer : this._layer, t = this._relatedFeatureTable?.tableParent?.highlightIds?.items[0], i = this._relatedFeatureTable?.tableParent?.layer, s = e?.relationships?.find((h) => i.relationships?.some((n) => n.id === h.id)), a = new $({
-      objectIds: [t],
+    const layerOrTable = !this._relatedFeatureTable ? this._layer : this._relatedFeatureTable ? this._relatedFeatureTable.layer : this._relatedFeatureTable.tableParent?.layer;
+    const objectId = this._relatedFeatureTable?.tableParent?.highlightIds?.items[0];
+    const parentLayer = this._relatedFeatureTable?.tableParent?.layer;
+    const relationship = layerOrTable?.relationships?.find((childReln) => parentLayer.relationships?.some((parentReln) => parentReln.id === childReln.id));
+    const relationshipQuery = new RelationshipQuery({
+      objectIds: [objectId],
       outFields: ["*"],
-      relationshipId: s?.id
+      relationshipId: relationship?.id
     });
-    return t && a && await i.queryRelatedFeatures(a).catch(async (h) => {
-      console.error(h);
+    const result = objectId && relationshipQuery && await parentLayer.queryRelatedFeatures(relationshipQuery).catch(async (e) => {
+      console.error(e);
+    });
+    return result;
+  }
+  _updateToolInfoLoading(name, isLoading) {
+    this._toolInfos.some((tool) => {
+      if (tool?.icon === name) {
+        tool.loading = isLoading;
+        return true;
+      } else {
+        return false;
+      }
     });
   }
-  _updateToolInfoLoading(e, t) {
-    this._toolInfos.some((i) => i?.icon === e ? (i.loading = t, !0) : !1);
-  }
-  async _refresh(e) {
-    if (await this._validateActiveEdits([], this.selectedIds)) {
-      this._table && await this._table.refresh(), this._relatedFeatureTable && await this._relatedFeatureTable.refresh(), this._allIds = await this.queryAllIds();
-      const i = this._getSelectedLayer(this.selectedRelatedIds);
-      if (i && this.relatedRecordToggled.emit(i), !e) {
-        const s = this._getSelectedIds();
-        this.featureSelectionChange.emit(s);
+  async _refresh(skipFeatureSelectionChange) {
+    const editsDiscarded = await this._validateActiveEdits([], this.selectedIds);
+    if (editsDiscarded) {
+      if (this._table) {
+        await this._table.refresh();
+      }
+      if (this._relatedFeatureTable) {
+        await this._relatedFeatureTable.refresh();
+      }
+      this._allIds = await this.queryAllIds();
+      const layerOrTable = this._getSelectedLayer(this.selectedRelatedIds);
+      if (layerOrTable) {
+        this.relatedRecordToggled.emit(layerOrTable);
+      }
+      if (!skipFeatureSelectionChange) {
+        const selectedIds = this._getSelectedIds();
+        this.featureSelectionChange.emit(selectedIds);
       }
     }
   }
   _getSelectedIds() {
-    let e;
-    return this._relatedFeatureTable ? this.selectedRelatedIds.length > 0 ? e = this.selectedRelatedIds : e = this._relatedFeatureTable.tableParent?.highlightIds.toArray() ?? [] : e = this.selectedIds, e;
-  }
-  _getSelectedLayer(e) {
-    let t;
-    return this._relatedFeatureTable ? e.length > 0 ? t = this._relatedFeatureTable.layer : t = this._relatedFeatureTable.tableParent?.layer : t = this._layer, t;
+    let ids;
+    if (!this._relatedFeatureTable) {
+      ids = this.selectedIds;
+    } else if (this.selectedRelatedIds.length > 0) {
+      ids = this.selectedRelatedIds;
+    } else {
+      ids = this._relatedFeatureTable.tableParent?.highlightIds.toArray() ?? [];
+    }
+    return ids;
+  }
+  _getSelectedLayer(ids) {
+    let layerOrTable;
+    if (!this._relatedFeatureTable) {
+      layerOrTable = this._layer;
+    } else if (ids.length > 0) {
+      layerOrTable = this._relatedFeatureTable.layer;
+    } else {
+      layerOrTable = this._relatedFeatureTable.tableParent?.layer;
+    }
+    return layerOrTable;
   }
   async _clearSearchText() {
     if (this._searchNode.value) {
       this._searchNode.value.value = "";
-      const e = {
+      const evt = {
         target: {
           value: ""
         }
       };
-      await this._searchTextChanged(e);
+      await this._searchTextChanged(evt);
     }
   }
   async _zoom() {
-    this._layer && this.mapView && await I(this.selectedIds, this._selectedLayerView, this.mapView, !0, void 0, this.zoomToScale);
-  }
-  async _layerSelectionChanged(e) {
-    const t = e.detail[0];
-    if (t !== this._layer?.id || this._featuresEmpty()) {
-      this._fetchingData = !0, await this._clearSearchText();
-      const i = this.mapView && await T(this.mapView, t);
-      i && await i.when(async () => {
-        this._selectedLayerView = !i.isTable && this.mapView ? await v(this.mapView, i.id) : null, this._table && this._table?.viewModel?.attachmentsViewOptions?.objectId && this._table.viewModel.hideAttachmentsView(), this._shouldUpdateTableOnExtentChange = !0, this._layer = i, await this._initToolInfos(), this._getFullTextSearchInfo();
+    if (this._layer && this.mapView) {
+      await goToSelection(this.selectedIds, this._selectedLayerView, this.mapView, true, void 0, this.zoomToScale);
+    }
+  }
+  async _layerSelectionChanged(_evt) {
+    const id = _evt.detail[0];
+    if (id !== this._layer?.id || this._featuresEmpty()) {
+      this._fetchingData = true;
+      await this._clearSearchText();
+      const layer = this.mapView && await getLayerOrTable(this.mapView, id);
+      layer && await layer.when(async () => {
+        this._selectedLayerView = !layer.isTable && this.mapView ? await getFeatureLayerView(this.mapView, layer.id) : null;
+        if (this._table && this._table?.viewModel?.attachmentsViewOptions?.objectId) {
+          this._table.viewModel.hideAttachmentsView();
+        }
+        this._shouldUpdateTableOnExtentChange = true;
+        this._layer = layer;
+        await this._initToolInfos();
+        this._getFullTextSearchInfo();
       });
     }
-    this._creatingFeature = !1, this._fetchingData = !1;
-  }
-  _getColumnTemplates(e, t, i) {
-    let s = this._getLayerOption(e);
-    const a = this._layer?.attributeTableTemplate?.elements;
-    let l = [];
-    a?.length > 0 && this.honorMapFieldSettings && (l = a.map((r) => r.fieldName));
-    const h = s?.fields && s?.fieldOrder ? s.fieldOrder.filter((r) => s?.fields && s.fields.indexOf(r) > -1) : l.length > 0 ? l : void 0;
-    let n;
-    return t && (n = t.reduce((r, d) => {
-      const f = {
-        type: "field",
-        fieldName: d.name,
-        label: this.getFieldLabel(d, i),
-        menuConfig: this._getMenuConfig(d.name)
-      };
-      return s && s.fields && s?.fields?.length > 0 ? s.fields.indexOf(d.name) > -1 && r.push(f) : l.length > 0 ? l.indexOf(d.name) > -1 && r.push(f) : r.push(f), r;
-    }, [])), n ? h ? n?.sort(this._sortFields.bind(this, h)) : n : [];
+    this._creatingFeature = false;
+    this._fetchingData = false;
+  }
+  _getColumnTemplates(id, fields, fieldInfos) {
+    let layerOption = this._getLayerOption(id);
+    const attributeTableTemplateElements = this._layer?.attributeTableTemplate?.elements;
+    let mapFieldOrder = [];
+    if (attributeTableTemplateElements?.length > 0 && this.honorMapFieldSettings) {
+      mapFieldOrder = attributeTableTemplateElements.map((e) => e.fieldName);
+    }
+    const fieldOrder = layerOption?.fields && layerOption?.fieldOrder ? layerOption.fieldOrder.filter((f) => layerOption?.fields && layerOption.fields.indexOf(f) > -1) : mapFieldOrder.length > 0 ? mapFieldOrder : void 0;
+    let columnTemplates;
+    if (fields) {
+      columnTemplates = fields.reduce((prev, cur) => {
+        const template = {
+          type: "field",
+          fieldName: cur.name,
+          label: this.getFieldLabel(cur, fieldInfos),
+          menuConfig: this._getMenuConfig(cur.name)
+        };
+        if (layerOption && layerOption.fields && layerOption?.fields?.length > 0) {
+          if (layerOption.fields.indexOf(cur.name) > -1) {
+            prev.push(template);
+          }
+        } else {
+          if (mapFieldOrder.length > 0) {
+            if (mapFieldOrder.indexOf(cur.name) > -1) {
+              prev.push(template);
+            }
+          } else {
+            prev.push(template);
+          }
+        }
+        return prev;
+      }, []);
+    }
+    if (columnTemplates) {
+      return fieldOrder ? columnTemplates?.sort(this._sortFields.bind(this, fieldOrder)) : columnTemplates;
+    } else {
+      return [];
+    }
   }
   updateRelatedAttachmentColumns() {
-    let e = this._getLayerOption(this._layer?.id || ""), t = this.hasAttachmentsEnabled(this._layer), i = !0;
-    const s = "attachments", a = (e?.extraFields || []).reduce((h, n) => (n.startsWith("related:") ? h.related.push(n.split("related:")[1]) : h.extra.push(n), h), { related: [], extra: [] }), l = a.extra.some((h) => h.toLowerCase() === s);
-    a && (t = l && t, i = a.related.length > 0, this._table?.columns.forEach((h) => {
-      h.fieldName.startsWith("EsriFeatureTableRelationshipColumn") && (h.hidden = !a.related.includes(h.effectiveLabel)), h.fieldName.startsWith("EsriFeatureTableAttachmentsColumn") && (h.hidden = !a.extra.some((n) => n.toLowerCase() === h.effectiveLabel.toLowerCase()));
-    })), this._table.relatedRecordsEnabled = i, this._table.attachmentsEnabled = t;
-  }
-  getFieldLabel(e, t) {
-    let i = e.alias ? e.alias : e.name;
-    return t?.some((s) => s.fieldName === e.name ? (i = s.label, !0) : !1), i || e.name;
+    let layerOption = this._getLayerOption(this._layer?.id || "");
+    let attachmentsEnabled = this.hasAttachmentsEnabled(this._layer);
+    let relatedRecordEnabled = true;
+    const attachments = "attachments";
+    const extraFields = (layerOption?.extraFields || []).reduce((prev, cur) => {
+      if (cur.startsWith("related:")) {
+        prev.related.push(cur.split("related:")[1]);
+      } else {
+        prev.extra.push(cur);
+      }
+      return prev;
+    }, { related: [], extra: [] });
+    const hasAttachmentsField = extraFields.extra.some((f) => f.toLowerCase() === attachments);
+    if (extraFields) {
+      attachmentsEnabled = hasAttachmentsField && attachmentsEnabled;
+      relatedRecordEnabled = extraFields.related.length > 0;
+      this._table?.columns.forEach((col) => {
+        if (col.fieldName.startsWith("EsriFeatureTableRelationshipColumn")) {
+          col.hidden = extraFields.related.includes(col.effectiveLabel) ? false : true;
+        }
+        if (col.fieldName.startsWith("EsriFeatureTableAttachmentsColumn")) {
+          col.hidden = extraFields.extra.some((f) => f.toLowerCase() === col.effectiveLabel.toLowerCase()) ? false : true;
+        }
+      });
+    }
+    this._table.relatedRecordsEnabled = relatedRecordEnabled;
+    this._table.attachmentsEnabled = attachmentsEnabled;
+  }
+  getFieldLabel(field, fieldInfos) {
+    let label = field.alias ? field.alias : field.name;
+    fieldInfos?.some((fInfo) => {
+      if (fInfo.fieldName === field.name) {
+        label = fInfo.label;
+        return true;
+      } else {
+        return false;
+      }
+    });
+    return label ? label : field.name;
   }
-  _sortFields(e, t, i) {
-    return e?.indexOf(t.fieldName) - e.indexOf(i.fieldName);
+  _sortFields(sorter, a, b) {
+    return sorter?.indexOf(a.fieldName) - sorter.indexOf(b.fieldName);
   }
-  _getMenuConfig(e) {
+  _getMenuConfig(name) {
     return {
       items: [
         {
           label: this._translations.hideField,
           icon: "view-hide",
-          autoCloseMenu: !0,
+          autoCloseMenu: true,
           clickFunction: () => {
-            this._handleHideClick(e);
+            this._handleHideClick(name);
           }
         }
       ]
     };
   }
-  _handleHideClick(e) {
-    this._columnsInfo && this._table && (this._columnsInfo[e] = !1, this._table.hideColumn(e), this._table.tableTemplate && this._table.tableTemplate.columnTemplates.forEach((t) => {
-      t.fieldName === e && (t.visible = !1);
-    }));
+  _handleHideClick(name) {
+    if (this._columnsInfo && this._table) {
+      this._columnsInfo[name] = false;
+      this._table.hideColumn(name);
+      if (this._table.tableTemplate) {
+        this._table.tableTemplate.columnTemplates.forEach((columnTemplate) => {
+          if (columnTemplate.fieldName === name) {
+            columnTemplate.visible = false;
+          }
+        });
+      }
+    }
   }
 }
-w("layer-table", M);
+customElement("layer-table", LayerTable);
 export {
-  M as LayerTable
+  LayerTable
 };