@esri/solutions-components 1.2.0-next.92 → 1.2.0-next.93

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

@@ -1,24 +1,21 @@
+import { c as y } from "../../chunks/runtime.js";
+import { e as d, j as p, g as m } from "../../chunks/mapViewUtils.js";
+import * as l from "@arcgis/core/intl";
+import { u as L } from "../../chunks/useT9n.js";
+import { css as f, html as a } from "lit";
+import { LitElement as u, createEvent as h, noShadowRoot as w } from "@arcgis/lumina";
+import * as g from "@arcgis/core/core/reactiveUtils";
 /*! 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.91 */
-import { c as customElement } from "../../chunks/runtime.js";
-import { e as getMapLayerHash, j as getAllFeatureLayers, g as getFeatureLayerView } from "../../chunks/mapViewUtils.js";
-import * as intl from "@arcgis/core/intl";
-import { u as useT9n } from "../../chunks/useT9n.js";
-import { css, html } from "lit";
-import { LitElement, createEvent, noShadowRoot } from "@arcgis/lumina";
-import * as reactiveUtils from "@arcgis/core/core/reactiveUtils";
-async function formatNumber(number, options) {
-  const { style = "decimal", places = 2 } = options || {};
-  const numberFormatIntlOptions = intl.convertNumberFormatToIntlOptions({
-    places,
-    digitSeparator: true
+v1.2.0-next.92 */
+async function _(n, e) {
+  const { style: s = "decimal", places: t = 2 } = e || {}, i = l.convertNumberFormatToIntlOptions({
+    places: t,
+    digitSeparator: !0
   });
-  numberFormatIntlOptions.style = style;
-  return intl.formatNumber(number, numberFormatIntlOptions);
+  return i.style = s, l.formatNumber(n, i);
 }
-const styles = css`@layer{
-/** @license
+const I = f`@layer{/** @license
  * Copyright 2025 Esri
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,178 +29,111 @@ const styles = css`@layer{
  * 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;
-}
-
-.notice-msg {
-  width: calc(100% - 20px);
-  padding: 10px;
-}
-
-.layer-name {
-  font-weight: 500;
-  word-break: break-word;
-}
-
-.feature-count {
-  padding: 0 10px;
-}
-}`;
-class LayerList extends LitElement {
+ */:host{display:block}.notice-msg{width:calc(100% - 20px);padding:10px}.layer-name{font-weight:500;word-break:break-word}.feature-count{padding:0 10px}}`;
+class x extends u {
   constructor() {
-    super();
-    this.layers = [];
-    this.showFeatureCount = true;
-    this.showNextIcon = false;
-    this.applyLayerViewFilter = false;
-    this.filterByMapExtent = false;
-    this._noLayersToDisplay = false;
-    this._mapLayerIds = [];
-    this._isLoading = false;
-    this._translations = useT9n({ name: "layer-list", blocking: true });
-    this.layerSelect = createEvent();
-    this.layersListLoaded = createEvent();
-    this.listenOn(window, "selectedLanguageUpdated", this.selectedLanguageUpdated);
+    super(), this.layers = [], this.showFeatureCount = !0, this.showNextIcon = !1, this.applyLayerViewFilter = !1, this.filterByMapExtent = !1, this._noLayersToDisplay = !1, this._mapLayerIds = [], this._isLoading = !1, this._translations = L({ name: "layer-list", blocking: !0 }), this.layerSelect = h(), this.layersListLoaded = h(), this.listenOn(window, "selectedLanguageUpdated", this.selectedLanguageUpdated);
   }
   static {
-    this.properties = { mapView: [0, {}, { attribute: false }], layers: [0, {}, { attribute: false }], showFeatureCount: [5, {}, { type: Boolean }], showNextIcon: [5, {}, { type: Boolean }], applyLayerViewFilter: [5, {}, { type: Boolean }], filterByMapExtent: [5, {}, { type: Boolean }], _noLayersToDisplay: [16, {}, { state: true }], _mapLayerIds: [16, {}, { state: true }], _isLoading: [16, {}, { state: true }], _translations: [16, {}, { state: true }] };
+    this.properties = { mapView: 0, layers: 0, showFeatureCount: 5, showNextIcon: 5, applyLayerViewFilter: 5, filterByMapExtent: 5, _noLayersToDisplay: 16, _mapLayerIds: 16, _isLoading: 16, _translations: 16 };
   }
   static {
-    this.styles = styles;
+    this.styles = I;
   }
   static {
-    this.shadowRootOptions = noShadowRoot;
+    this.shadowRootOptions = w;
   }
-  willUpdate(changes) {
-    if (changes.has("filterByMapExtent") && this.hasUpdated) {
-      this.filterByMapExtentWatchHandler(this.filterByMapExtent);
-    }
+  willUpdate(e) {
+    e.has("filterByMapExtent") && this.hasUpdated && this.filterByMapExtentWatchHandler(this.filterByMapExtent);
   }
-  filterByMapExtentWatchHandler(enabled) {
-    if (enabled) {
-      this.initializeMapExtentFilter();
-    } else if (this._filterByMapExtentHandle) {
-      this._filterByMapExtentHandle.remove();
-    }
+  filterByMapExtentWatchHandler(e) {
+    e ? this.initializeMapExtentFilter() : this._filterByMapExtentHandle && this._filterByMapExtentHandle.remove();
   }
   async refresh() {
     await this.setLayers();
   }
-  async selectedLanguageUpdated(_evt) {
+  async selectedLanguageUpdated(e) {
     await this.setLayers();
   }
   async load() {
-    if (this.filterByMapExtent) {
-      this.initializeMapExtentFilter();
-    }
+    this.filterByMapExtent && this.initializeMapExtentFilter();
   }
   async loaded() {
     await this.setLayers();
   }
   render() {
-    return html`${this._isLoading && html`<calcite-loader label scale=m></calcite-loader>` || ""}${!this._isLoading && this.mapView && this._noLayersToDisplay && html`<calcite-notice class="notice-msg" icon=layers-reference kind=danger open><div slot=title>${this._translations.error}</div><div slot=message>${this._translations.noLayerToDisplayErrorMsg}</div></calcite-notice>` || ""}${!this._isLoading && this.mapView && html`<calcite-list label selection-appearance=border selection-mode=none>${this.filterByMapExtent && this._mapLayerIds.length > 0 && this.getExtentNotice() || ""}${this.renderLayerList()}</calcite-list>` || ""}`;
+    return a`${this._isLoading && a`<calcite-loader label scale=m></calcite-loader>` || ""}${!this._isLoading && this.mapView && this._noLayersToDisplay && a`<calcite-notice class="notice-msg" icon=layers-reference kind=danger open><div slot=title>${this._translations.error}</div><div slot=message>${this._translations.noLayerToDisplayErrorMsg}</div></calcite-notice>` || ""}${!this._isLoading && this.mapView && a`<calcite-list label selection-appearance=border selection-mode=none>${this.filterByMapExtent && this._mapLayerIds.length > 0 && this.getExtentNotice() || ""}${this.renderLayerList()}</calcite-list>` || ""}`;
   }
   initializeMapExtentFilter() {
-    this._filterByMapExtentHandle = reactiveUtils.when(() => this.mapView?.stationary, () => {
-      void this.setLayers();
+    this._filterByMapExtentHandle = g.when(() => this.mapView?.stationary, () => {
+      this.setLayers();
     }, {
-      initial: true
+      initial: !0
     });
   }
   async setLayers() {
-    if (this.mapView) {
-      this._isLoading = true;
-      await this.initLayerHash();
-      this._isLoading = false;
-    }
+    this.mapView && (this._isLoading = !0, await this.initLayerHash(), this._isLoading = !1);
   }
   async initLayerHash() {
-    const def = [];
+    const e = [];
     if (this.mapView) {
-      this._layerItemsHash = await getMapLayerHash(this.mapView, true);
-      const allMapLayers = await getAllFeatureLayers(this.mapView);
-      for (const eachLayer of allMapLayers) {
-        if (eachLayer?.type === "feature") {
-          if (this.showFeatureCount) {
-            const q = eachLayer.createQuery();
-            if (eachLayer?.definitionExpression) {
-              q.where = q.where + " AND " + eachLayer.definitionExpression;
-            }
-            if (this.applyLayerViewFilter) {
-              const featureLayerView = await getFeatureLayerView(this.mapView, eachLayer.id);
-              if (featureLayerView?.filter?.where) {
-                q.where = q.where ? q.where + " AND " + featureLayerView.filter.where : featureLayerView.filter.where;
-              }
-            }
-            q.geometry = this.filterByMapExtent ? this.mapView.extent : null;
-            const result = eachLayer.queryFeatureCount(q);
-            def.push(result);
-            void result.then(async (resCount) => {
-              const formattedCount = !Number.isNaN(resCount) ? await formatNumber(resCount, {
-                places: 0,
-                style: "decimal"
-              }) : "";
-              if (this._layerItemsHash) {
-                this._layerItemsHash[eachLayer.id].formattedFeatureCount = formattedCount;
-              }
-            });
+      this._layerItemsHash = await d(this.mapView, !0);
+      const s = await p(this.mapView);
+      for (const t of s)
+        if (t?.type === "feature" && this.showFeatureCount) {
+          const i = t.createQuery();
+          if (t?.definitionExpression && (i.where = i.where + " AND " + t.definitionExpression), this.applyLayerViewFilter) {
+            const r = await m(this.mapView, t.id);
+            r?.filter?.where && (i.where = i.where ? i.where + " AND " + r.filter.where : r.filter.where);
           }
+          i.geometry = this.filterByMapExtent ? this.mapView.extent : null;
+          const o = t.queryFeatureCount(i);
+          e.push(o), o.then(async (r) => {
+            const c = Number.isNaN(r) ? "" : await _(r, {
+              places: 0,
+              style: "decimal"
+            });
+            this._layerItemsHash && (this._layerItemsHash[t.id].formattedFeatureCount = c);
+          });
         }
-      }
-      await Promise.all(def).then(() => {
-        const editableLayerIds = this._layerItemsHash && this.getLayersToBeShownInList(this._layerItemsHash);
-        this._mapLayerIds = editableLayerIds?.reverse() || [];
-        this.handleNoLayersToDisplay();
+      await Promise.all(e).then(() => {
+        const t = this._layerItemsHash && this.getLayersToBeShownInList(this._layerItemsHash);
+        this._mapLayerIds = t?.reverse() || [], this.handleNoLayersToDisplay();
       }, () => {
-        this._mapLayerIds = [];
-        this.handleNoLayersToDisplay();
+        this._mapLayerIds = [], this.handleNoLayersToDisplay();
       });
     }
   }
   handleNoLayersToDisplay() {
-    this._noLayersToDisplay = !(this._mapLayerIds.length > 0);
-    this.layersListLoaded.emit(this._mapLayerIds);
-  }
-  getLayersToBeShownInList(hash) {
-    const configuredLayers = this.layers?.length > 0 ? this.layers : [];
-    return Object.keys(hash).reduce((prev, cur) => {
-      if (configuredLayers.indexOf(cur) > -1) {
-        prev.push(cur);
-      }
-      return prev;
-    }, []);
+    this._noLayersToDisplay = !(this._mapLayerIds.length > 0), this.layersListLoaded.emit(this._mapLayerIds);
+  }
+  getLayersToBeShownInList(e) {
+    const s = this.layers?.length > 0 ? this.layers : [];
+    return Object.keys(e).reduce((t, i) => (s.indexOf(i) > -1 && t.push(i), t), []);
   }
   renderLayerList() {
-    return this._mapLayerIds.length > 0 ? this._mapLayerIds.reduce((prev, layerId) => {
-      if (this._layerItemsHash && this._layerItemsHash[layerId]) {
-        const li = this.getLayerListItem(layerId);
-        if (li) {
-          prev.push(li);
-        }
+    return this._mapLayerIds.length > 0 ? this._mapLayerIds.reduce((e, s) => {
+      if (this._layerItemsHash && this._layerItemsHash[s]) {
+        const t = this.getLayerListItem(s);
+        t && e.push(t);
       }
-      return prev;
+      return e;
     }, []) : void 0;
   }
-  getLayerListItem(layerId) {
-    const layerName = this._layerItemsHash && this._layerItemsHash[layerId].name;
-    const featureCount = this._layerItemsHash && this._layerItemsHash[layerId].formattedFeatureCount;
-    return html`<calcite-list-item @calciteListItemSelect=${() => {
-      this.onLayerItemSelected(layerId);
-    }}><div class="layer-name" slot=content-start>${layerName}</div>${this.showFeatureCount && featureCount !== void 0 && featureCount !== "" && html`<div class="feature-count" slot=content-end>${`(${featureCount})`}</div>` || ""}${this.showNextIcon && html`<calcite-icon flip-rtl icon=chevron-right scale=s slot=content-end></calcite-icon>` || ""}</calcite-list-item>`;
+  getLayerListItem(e) {
+    const s = this._layerItemsHash && this._layerItemsHash[e].name, t = this._layerItemsHash && this._layerItemsHash[e].formattedFeatureCount;
+    return a`<calcite-list-item @calciteListItemSelect=${() => {
+      this.onLayerItemSelected(e);
+    }}><div class="layer-name" slot=content-start>${s}</div>${this.showFeatureCount && t !== void 0 && t !== "" && a`<div class="feature-count" slot=content-end>${`(${t})`}</div>` || ""}${this.showNextIcon && a`<calcite-icon flip-rtl icon=chevron-right scale=s slot=content-end></calcite-icon>` || ""}</calcite-list-item>`;
   }
   getExtentNotice() {
-    return html`<calcite-notice class="notice-msg" icon=extent-filter kind=brand open scale=s><div slot=message>${this._translations.extentFilterMsg}</div></calcite-notice>`;
+    return a`<calcite-notice class="notice-msg" icon=extent-filter kind=brand open scale=s><div slot=message>${this._translations.extentFilterMsg}</div></calcite-notice>`;
   }
-  onLayerItemSelected(layerId) {
-    if (this._layerItemsHash) {
-      this.layerSelect.emit({ layerId, layerName: this._layerItemsHash[layerId]?.name });
-    }
+  onLayerItemSelected(e) {
+    this._layerItemsHash && this.layerSelect.emit({ layerId: e, layerName: this._layerItemsHash[e]?.name });
   }
 }
-customElement("layer-list", LayerList);
+y("layer-list", x);
 export {
-  LayerList
+  x as LayerList
 };

package/dist/components/layer-table/customElement.d.ts

@@ -79,7 +79,7 @@ export declare class LayerTable extends LitElement {
     mapHidden: boolean;
     /** IMapInfo: key configuration details about the current map */
     mapInfo: IMapInfo | undefined;
-    /** esri/views/View: https://next.gha.afd.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html */
+    /** esri/views/View: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html */
     mapView: __esri.MapView | undefined;
     /**
      * boolean: When true only editable layers that support the update capability will be available