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

package/dist/chunks/mapViewUtils.js

@@ -1,8 +1,8 @@
+import { q as c } from "./queryUtils.js";
+import { d as y } from "./interfaces.js";
 /*! 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 { q as queryExtent } from "./queryUtils.js";
-import { d as EWorkflowType } from "./interfaces.js";
+v1.2.0-next.92 */
 /**
  * @license
  * Copyright 2025 Esri
@@ -19,160 +19,112 @@ import { d as EWorkflowType } from "./interfaces.js";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-async function getMapLayerHash(mapView, showOnlyUpdatableLayers) {
-  let layerHash;
-  await mapView.when(() => {
-    layerHash = mapView.map.allLayers.toArray().reduce((prev, cur) => {
-      if (cur.type === "feature" || cur?.type === "subtype-group") {
-        prev[cur.id] = {
-          name: cur.title,
-          supportsUpdate: void 0
-        };
-      }
-      return prev;
-    }, {});
-  });
-  return _getFinalHash(showOnlyUpdatableLayers, layerHash, mapView);
+async function b(a, e) {
+  let t;
+  return await a.when(() => {
+    t = a.map.allLayers.toArray().reduce((s, n) => ((n.type === "feature" || n?.type === "subtype-group") && (s[n.id] = {
+      name: n.title,
+      supportsUpdate: void 0
+    }), s), {});
+  }), l(e, t, a);
 }
-async function getMapTableHash(mapView, onlyShowUpdatableTables) {
-  let tableHash;
-  await mapView.when(() => {
-    tableHash = mapView.map.allTables.toArray().reduce((prev, cur) => {
-      prev[cur.id] = {
-        name: cur.title,
-        supportsUpdate: void 0
-      };
-      return prev;
-    }, {});
-  });
-  return _getFinalHash(onlyShowUpdatableTables, tableHash, mapView);
+async function m(a, e) {
+  let t;
+  return await a.when(() => {
+    t = a.map.allTables.toArray().reduce((s, n) => (s[n.id] = {
+      name: n.title,
+      supportsUpdate: void 0
+    }, s), {});
+  }), l(e, t, a);
 }
-async function _getFinalHash(onlyShowUpdatable, hash, mapView) {
-  if (onlyShowUpdatable) {
-    const editableHash = {};
-    const keys = Object.keys(hash);
-    for (let i = 0; i < keys.length; i++) {
+async function l(a, e, t) {
+  if (a) {
+    const s = {}, n = Object.keys(e);
+    for (let i = 0; i < n.length; i++)
       try {
-        const id = keys[i];
-        const layer = await getLayerOrTable(mapView, id);
-        await layer.load();
-        await layer.when();
-        editableHash[id] = {
-          name: hash[id].name,
-          supportsUpdate: layer.editingEnabled && layer.capabilities?.operations.supportsUpdate
+        const r = n[i], o = await f(t, r);
+        await o.load(), await o.when(), s[r] = {
+          name: e[r].name,
+          supportsUpdate: o.editingEnabled && o.capabilities?.operations.supportsUpdate
         };
-      } catch (error) {
-        console.log(error);
+      } catch (r) {
+        console.log(r);
         continue;
       }
-    }
-    return editableHash;
-  } else {
-    return hash;
-  }
+    return s;
+  } else
+    return e;
 }
-async function getFeatureLayerView(mapView, id) {
-  const layer = await getLayerOrTable(mapView, id);
-  return layer ? await mapView.whenLayerView(layer) : void 0;
+async function p(a, e) {
+  const t = await f(a, e);
+  return t ? await a.whenLayerView(t) : void 0;
 }
-async function getLayerOrTable(mapView, id) {
-  let layers = [];
-  await mapView?.when(() => {
-    layers = [...mapView.map.allLayers.toArray(), ...mapView.map.allTables.toArray()].filter((l) => {
-      return l.id === id;
-    });
-  });
-  return layers.length > 0 ? layers[0] : void 0;
+async function f(a, e) {
+  let t = [];
+  return await a?.when(() => {
+    t = [...a.map.allLayers.toArray(), ...a.map.allTables.toArray()].filter((s) => s.id === e);
+  }), t.length > 0 ? t[0] : void 0;
 }
-async function getAllFeatureLayers(mapView) {
-  const layers = mapView.map.allLayers.filter((l) => l.type === "feature").toArray().map((l) => l);
-  let layerViewPromises = [];
-  await mapView.when(() => {
-    layerViewPromises = layers.map((l) => mapView.whenLayerView(l));
-  });
-  await Promise.allSettled(layerViewPromises);
-  return layers;
+async function T(a) {
+  const e = a.map.allLayers.filter((s) => s.type === "feature").toArray().map((s) => s);
+  let t = [];
+  return await a.when(() => {
+    t = e.map((s) => a.whenLayerView(s));
+  }), await Promise.allSettled(t), e;
 }
-async function getAllTables(mapView) {
-  const tables = mapView.map.allTables.toArray();
-  let layerViewPromises = [];
-  await mapView.when(() => {
-    layerViewPromises = tables.map((t) => t.load());
-  });
-  await Promise.allSettled(layerViewPromises);
-  return tables;
+async function I(a) {
+  const e = a.map.allTables.toArray();
+  let t = [];
+  return await a.when(() => {
+    t = e.map((s) => s.load());
+  }), await Promise.allSettled(t), e;
 }
-async function highlightFeatures(ids, layerView, mapView, updateExtent = false, zoomToScale = 0) {
-  if (updateExtent) {
-    await goToSelection(ids, layerView, mapView, false, void 0, zoomToScale);
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-  }
-  return layerView.highlight(ids);
+async function A(a, e, t, s = !1, n = 0) {
+  return s && (await h(a, e, t, !1, void 0, n), await new Promise((i) => setTimeout(i, 1e3))), e.highlight(a);
 }
-async function highlightAllFeatures(selectionSets) {
-  const highlightInfos = getIdSets(selectionSets);
-  return Object.keys(highlightInfos).reduce((prev, cur) => {
-    const highlightInfo = highlightInfos[cur];
-    prev.push(highlightInfo.layerView.highlight(highlightInfo.ids));
-    return prev;
+async function L(a) {
+  const e = d(a);
+  return Object.keys(e).reduce((t, s) => {
+    const n = e[s];
+    return t.push(n.layerView.highlight(n.ids)), t;
   }, []);
 }
-function getIdSets(selectionSets) {
-  return selectionSets.reduce((prev, cur) => {
-    const lv = cur.layerView;
-    const id = lv?.layer.id;
-    if (id && Object.keys(prev).indexOf(id) > -1) {
-      prev[id].ids = [.../* @__PURE__ */ new Set([...cur.selectedIds, ...prev[id].ids])];
-    } else if (id) {
-      prev[id] = {
-        layerView: lv,
-        ids: cur.selectedIds
-      };
-    }
-    if (cur.workflowType === EWorkflowType.REFINE) {
-      Object.keys(cur.refineInfos).forEach((k) => {
-        const refineInfo = cur.refineInfos[k];
-        if (Object.keys(prev).indexOf(k) > -1) {
-          prev[k].ids = [.../* @__PURE__ */ new Set([...refineInfo.addIds, ...prev[k].ids])];
-          prev[k].ids = prev[k].ids.filter((_id) => refineInfo.removeIds.indexOf(_id) < 0);
-        }
-      });
-    }
-    return prev;
+function d(a) {
+  return a.reduce((e, t) => {
+    const s = t.layerView, n = s?.layer.id;
+    return n && Object.keys(e).indexOf(n) > -1 ? e[n].ids = [.../* @__PURE__ */ new Set([...t.selectedIds, ...e[n].ids])] : n && (e[n] = {
+      layerView: s,
+      ids: t.selectedIds
+    }), t.workflowType === y.REFINE && Object.keys(t.refineInfos).forEach((i) => {
+      const r = t.refineInfos[i];
+      Object.keys(e).indexOf(i) > -1 && (e[i].ids = [.../* @__PURE__ */ new Set([...r.addIds, ...e[i].ids])], e[i].ids = e[i].ids.filter((o) => r.removeIds.indexOf(o) < 0));
+    }), e;
   }, {});
 }
-async function flashSelection(ids, layerView, featureEffect) {
-  const filter = {
-    objectIds: ids
-  };
-  layerView.featureEffect = {
-    ...featureEffect,
-    filter
+async function u(a, e, t) {
+  const s = {
+    objectIds: a
   };
-  setTimeout(() => {
-    layerView.featureEffect = void 0;
+  e.featureEffect = {
+    ...t,
+    filter: s
+  }, setTimeout(() => {
+    e.featureEffect = void 0;
   }, 1300);
 }
-async function goToSelection(ids, layerView, mapView, flashFeatures = true, featureEffect, zoomToScale = 0) {
-  const result = await queryExtent(ids, layerView.layer);
-  const goToParams = { target: result.extent };
-  if (result.count === 1 && layerView.layer.geometryType === "point" && zoomToScale) {
-    goToParams.scale = zoomToScale;
-  }
-  await mapView.goTo(goToParams);
-  if (flashFeatures) {
-    await flashSelection(ids, layerView, featureEffect);
-  }
+async function h(a, e, t, s = !0, n, i = 0) {
+  const r = await c(a, e.layer), o = { target: r.extent };
+  r.count === 1 && e.layer.geometryType === "point" && i && (o.scale = i), await t.goTo(o), s && await u(a, e, n);
 }
 export {
-  goToSelection as a,
-  getIdSets as b,
-  highlightAllFeatures as c,
-  getLayerOrTable as d,
-  getMapLayerHash as e,
-  getMapTableHash as f,
-  getFeatureLayerView as g,
-  highlightFeatures as h,
-  getAllTables as i,
-  getAllFeatureLayers as j
+  h as a,
+  d as b,
+  L as c,
+  f as d,
+  b as e,
+  m as f,
+  p as g,
+  A as h,
+  I as i,
+  T as j
 };