@esri/solutions-components 5.0.4-next.2 → 5.0.4

package/dist/chunks/mapViewUtils.js

@@ -1,157 +1,110 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.0/LICENSE.txt */
-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);
+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);
 }
-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 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 _getFinalHash(onlyShowUpdatable, hash, mapView) {
-  const resultHash = {};
-  const keys = Object.keys(hash);
-  for (const id of keys) {
+async function l(t, e, a) {
+  const s = {}, n = Object.keys(e);
+  for (const i of n)
     try {
-      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);
+      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);
       continue;
     }
-  }
-  return resultHash;
+  return s;
 }
-async function getFeatureLayerView(mapView, id) {
-  const layer = await getLayerOrTable(mapView, id);
-  return layer ? await mapView.whenLayerView(layer) : void 0;
+async function b(t, e) {
+  const a = await c(t, e);
+  return a ? await t.whenLayerView(a) : 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 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 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 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 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 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 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 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 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 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;
   }, []);
 }
-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;
+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;
   }, {});
 }
-async function flashSelection(ids, layerView, featureEffect) {
-  const filter = {
-    objectIds: ids
-  };
-  layerView.featureEffect = {
-    ...featureEffect,
-    filter
+async function d(t, e, a) {
+  const s = {
+    objectIds: t
   };
-  setTimeout(() => {
-    layerView.featureEffect = void 0;
+  e.featureEffect = {
+    ...a,
+    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 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);
 }
 export {
-  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
+  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
 };