@esri/solutions-components 5.0.2 → 5.0.4-next.1

package/dist/chunks/mapViewUtils.js

@@ -1,110 +1,157 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.0/LICENSE.txt */
-import { q as f } from "./queryUtils.js";
-async function g(t, e) {
-  let a;
-  return await t.when(() => {
-    a = t.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, a, t);
+import { q as queryExtent } from "./queryUtils.js";
+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 w(t, e) {
-  let a;
-  return await t.when(() => {
-    a = t.map.allTables.toArray().reduce((s, n) => (s[n.id] = {
-      name: n.title,
-      supportsUpdate: void 0
-    }, s), {});
-  }), l(e, a, t);
+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 l(t, e, a) {
-  const s = {}, n = Object.keys(e);
-  for (const i of n)
+async function _getFinalHash(onlyShowUpdatable, hash, mapView) {
+  const resultHash = {};
+  const keys = Object.keys(hash);
+  for (const id of keys) {
     try {
-      const r = await c(a, i);
-      await r.load(), await r.when();
-      const o = r.editingEnabled && r.capabilities?.operations.supportsUpdate;
-      (!t || t && o) && (s[i] = {
-        name: e[i].name,
-        supportsUpdate: o
-      });
-    } catch (r) {
-      console.log(r);
+      const layer = await getLayerOrTable(mapView, id);
+      await layer.load();
+      await layer.when();
+      const supportsUpdate = layer.editingEnabled && layer.capabilities?.operations.supportsUpdate;
+      if (!onlyShowUpdatable || onlyShowUpdatable && supportsUpdate) {
+        resultHash[id] = {
+          name: hash[id].name,
+          supportsUpdate
+        };
+      }
+    } catch (error) {
+      console.log(error);
       continue;
     }
-  return s;
+  }
+  return resultHash;
 }
-async function b(t, e) {
-  const a = await c(t, e);
-  return a ? await t.whenLayerView(a) : void 0;
+async function getFeatureLayerView(mapView, id) {
+  const layer = await getLayerOrTable(mapView, id);
+  return layer ? await mapView.whenLayerView(layer) : void 0;
 }
-async function c(t, e) {
-  let a = [];
-  return await t?.when(() => {
-    a = [...t.map.allLayers.toArray(), ...t.map.allTables.toArray()].filter((s) => s.id === e);
-  }), a.length > 0 ? a[0] : 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 m(t) {
-  const e = t.map.allLayers.filter((s) => s.type === "feature").toArray().map((s) => s);
-  let a = [];
-  return await t.when(() => {
-    a = e.map((s) => t.whenLayerView(s));
-  }), await Promise.allSettled(a), e;
+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 p(t) {
-  const e = t.map.allTables.toArray();
-  let a = [];
-  return await t.when(() => {
-    a = e.map((s) => s.load());
-  }), await Promise.allSettled(a), 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(t, e, a, s = !1, n = 0) {
-  return s && (await u(t, e, a, !1, void 0, n), await new Promise((i) => setTimeout(i, 1e3))), e.highlight(t);
+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 T(t) {
-  const e = y(t);
-  return Object.keys(e).reduce((a, s) => {
-    const n = e[s];
-    return a.push(n.layerView.highlight(n.ids)), 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;
   }, []);
 }
-function y(t) {
-  return t.reduce((e, a) => {
-    const s = a.layerView, n = s?.layer.id;
-    return n && Object.keys(e).indexOf(n) > -1 ? e[n].ids = [.../* @__PURE__ */ new Set([...a.selectedIds, ...e[n].ids])] : n && (e[n] = {
-      layerView: s,
-      ids: a.selectedIds
-    }), a.workflowType === "REFINE" && Object.keys(a.refineInfos).forEach((i) => {
-      const r = a.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;
+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 === "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;
   }, {});
 }
-async function d(t, e, a) {
-  const s = {
-    objectIds: t
+async function flashSelection(ids, layerView, featureEffect) {
+  const filter = {
+    objectIds: ids
+  };
+  layerView.featureEffect = {
+    ...featureEffect,
+    filter
   };
-  e.featureEffect = {
-    ...a,
-    filter: s
-  }, setTimeout(() => {
-    e.featureEffect = void 0;
+  setTimeout(() => {
+    layerView.featureEffect = void 0;
   }, 1300);
 }
-async function u(t, e, a, s = !0, n, i = 0) {
-  const r = await f(t, e.layer), o = { target: r.extent };
-  r.count === 1 && e.layer.geometryType === "point" && i && (o.scale = i), await a.goTo(o), s && await d(t, e, n);
+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);
+  }
 }
 export {
-  m as a,
-  p as b,
-  b as c,
-  g as d,
-  u as e,
-  w as f,
-  c as g,
-  I as h,
-  y as i,
-  T as j
+  getAllFeatureLayers as a,
+  getAllTables as b,
+  getFeatureLayerView as c,
+  getMapLayerHash as d,
+  goToSelection as e,
+  getMapTableHash as f,
+  getLayerOrTable as g,
+  highlightFeatures as h,
+  getIdSets as i,
+  highlightAllFeatures as j
 };