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

package/dist/chunks/getItemIcon.js

@@ -1,43 +1,98 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.0/LICENSE.txt */
-import { g as c } from "./runtime.js";
-function l(a, t) {
-  const r = i(a, t), e = c("assets/item-icons/");
-  return r === "group" ? `${e}/${r}16.png` : `${e}/${r}16.svg`;
+import { g as getAssetPath } from "./runtime.js";
+function getIconUrl(type, typeKeywords) {
+  const icon = _getItemIcon(type, typeKeywords);
+  const baseUrl = getAssetPath("assets/item-icons/");
+  return icon === "group" ? `${baseUrl}/${icon}16.png` : `${baseUrl}/${icon}16.svg`;
 }
-function i(a, t) {
-  const r = a.toLowerCase(), e = t || [], s = e.includes("Hosted Service");
-  switch (r.trim()) {
+function _getItemIcon(type, typeKeywords) {
+  const _type = type.toLowerCase();
+  const keywords = typeKeywords || [];
+  const hosted = keywords.includes("Hosted Service");
+  switch (_type.trim()) {
     case "360 vr experience":
       return "360vr";
     case "3dtiles package":
       return "3dtileslayerpackage";
     case "3dtiles service":
-      return e.includes("3DObject") ? "3dobjecttileslayer" : e.includes("IntegratedMesh") ? "integratedmeshtileslayer" : "3dobjecttileslayer";
+      return keywords.includes("3DObject") ? "3dobjecttileslayer" : keywords.includes("IntegratedMesh") ? "integratedmeshtileslayer" : "3dobjecttileslayer";
     case "feature service":
     case "feature collection":
     case "kml":
     case "wfs":
-      if (e.includes("IndoorPositioningDataService"))
+      if (keywords.includes("IndoorPositioningDataService")) {
         return "indoorpositioningdataservice";
-      const n = e.includes("Spatiotemporal");
-      return e.includes("Table") ? n ? "spatiotemporaltable" : "table" : e.includes("Route Layer") ? "routelayer" : e.includes("Markup") ? "markup" : n ? "spatiotemporal" : e.includes("UtilityNetwork") ? "utilitynetwork" : s ? "featureshosted" : "features";
+      }
+      const isSpatiotemporal = keywords.includes("Spatiotemporal");
+      if (keywords.includes("Table")) {
+        return isSpatiotemporal ? "spatiotemporaltable" : "table";
+      }
+      if (keywords.includes("Route Layer")) {
+        return "routelayer";
+      }
+      if (keywords.includes("Markup")) {
+        return "markup";
+      }
+      if (isSpatiotemporal) {
+        return "spatiotemporal";
+      }
+      if (keywords.includes("UtilityNetwork")) {
+        return "utilitynetwork";
+      }
+      return hosted ? "featureshosted" : "features";
     case "group":
       return "group";
     case "group layer":
-      return e.includes("Map") ? "layergroup2d" : e.includes("Scene") ? "layergroup3d" : "layergroup";
+      if (keywords.includes("Map")) {
+        return "layergroup2d";
+      }
+      if (keywords.includes("Scene")) {
+        return "layergroup3d";
+      }
+      return "layergroup";
     case "wmts":
       return "maptiles";
     case "map service":
     case "wms":
-      return s || e.includes("Tiled") ? "maptiles" : "mapimages";
+      return hosted || keywords.includes("Tiled") ? "maptiles" : "mapimages";
     case "scene service":
-      return e.includes("Line") ? "sceneweblayerline" : e.includes("3DObject") ? "sceneweblayermultipatch" : e.includes("Point") ? "sceneweblayerpoint" : e.includes("IntegratedMesh") ? "sceneweblayermesh" : e.includes("PointCloud") ? "sceneweblayerpointcloud" : e.includes("Polygon") ? "sceneweblayerpolygon" : e.includes("Building") ? "sceneweblayerbuilding" : e.includes("Voxel") ? "sceneweblayervoxel" : "sceneweblayer";
+      if (keywords.includes("Line")) {
+        return "sceneweblayerline";
+      }
+      if (keywords.includes("3DObject")) {
+        return "sceneweblayermultipatch";
+      }
+      if (keywords.includes("Point")) {
+        return "sceneweblayerpoint";
+      }
+      if (keywords.includes("IntegratedMesh")) {
+        return "sceneweblayermesh";
+      }
+      if (keywords.includes("PointCloud")) {
+        return "sceneweblayerpointcloud";
+      }
+      if (keywords.includes("Polygon")) {
+        return "sceneweblayerpolygon";
+      }
+      if (keywords.includes("Building")) {
+        return "sceneweblayerbuilding";
+      }
+      if (keywords.includes("Voxel")) {
+        return "sceneweblayervoxel";
+      }
+      return "sceneweblayer";
     case "image service":
-      return e.includes("Elevation 3D Layer") ? "elevationlayer" : e.includes("Tiled Imagery") ? "tiledimagerylayer" : "imagery";
+      if (keywords.includes("Elevation 3D Layer")) {
+        return "elevationlayer";
+      }
+      if (keywords.includes("Tiled Imagery")) {
+        return "tiledimagerylayer";
+      }
+      return "imagery";
     case "stream service":
       return "streamlayer";
     case "video service":
-      return e.includes("Live Stream") ? "livestreamvideolayer" : "mediaservice";
+      return keywords.includes("Live Stream") ? "livestreamvideolayer" : "mediaservice";
     case "vector tile service":
       return "vectortile";
     case "datastore catalog service":
@@ -45,20 +100,20 @@ function i(a, t) {
     case "geocoding service":
       return "geocodeservice";
     case "geoprocessing service":
-      return e.includes("Web Tool") ? "tool" : "layers";
+      return keywords.includes("Web Tool") ? "tool" : "layers";
     case "geodata service":
       return "geodataservice";
     case "web map":
     case "cityengine web scene":
       return "maps";
     case "web scene":
-      return e.includes("ViewingMode-Local") ? "webscenelocal" : "websceneglobal";
+      return keywords.includes("ViewingMode-Local") ? "webscenelocal" : "websceneglobal";
     case "application":
     case "web mapping application":
     case "mobile application":
     case "operation view":
     case "desktop application":
-      return e.includes("configurableApp") ? "instantapps" : "apps";
+      return keywords.includes("configurableApp") ? "instantapps" : "apps";
     case "map document":
     case "map package":
     case "published map":
@@ -73,9 +128,18 @@ function i(a, t) {
     case "layout":
       return "mapsgray";
     case "layer":
-      return e.includes("ArcGIS Pro") ? "mapsgray" : "layersgray";
+      if (keywords.includes("ArcGIS Pro")) {
+        return "mapsgray";
+      }
+      return "layersgray";
     case "explorer map":
-      return e.indexOf("Explorer Document") ? "mapsgray" : e.includes("Explorer Mapping Application") ? "datafilesgray" : "mapsgray";
+      if (keywords.indexOf("Explorer Document")) {
+        return "mapsgray";
+      }
+      if (keywords.includes("Explorer Mapping Application")) {
+        return "datafilesgray";
+      }
+      return "mapsgray";
     case "pro presentation":
       return "propresentation";
     case "api key":
@@ -132,7 +196,10 @@ function i(a, t) {
     case "workflow manager package":
       return "datafilesgray";
     case "form":
-      return e.includes("Survey123") ? "survey" : "datafilesgray";
+      if (keywords.includes("Survey123")) {
+        return "survey";
+      }
+      return "datafilesgray";
     case "network analysis service":
     case "geometry service":
     case "geoprocessing package":
@@ -181,7 +248,10 @@ function i(a, t) {
     case "image collection":
       return "imagecollection";
     case "style":
-      return e.includes("Dictionary") ? "dictionarystyle" : "style";
+      if (keywords.includes("Dictionary")) {
+        return "dictionarystyle";
+      }
+      return "style";
     case "desktop style":
       return "desktopstyle";
     case "dashboard":
@@ -213,7 +283,16 @@ function i(a, t) {
     case "reality mapping project":
       return "realitymappingproject";
     case "storymap":
-      return e.includes("storymaptemplate") ? "storymapstemplate" : e.includes("storymapcollection") ? "storymapcollection" : e.includes("storymapbriefing") ? "storymapbriefing" : "storymap";
+      if (keywords.includes("storymaptemplate")) {
+        return "storymapstemplate";
+      }
+      if (keywords.includes("storymapcollection")) {
+        return "storymapcollection";
+      }
+      if (keywords.includes("storymapbriefing")) {
+        return "storymapbriefing";
+      }
+      return "storymap";
     case "survey123 add in":
       return "survey123addin";
     case "mission":
@@ -288,9 +367,12 @@ function i(a, t) {
     case "data pipeline":
       return "datapipeline";
     default:
-      return e.includes("Document") ? "datafilesgray" : r.includes("service") ? "layers" : "maps";
+      if (keywords.includes("Document")) {
+        return "datafilesgray";
+      }
+      return _type.includes("service") ? "layers" : "maps";
   }
 }
 export {
-  l as g
+  getIconUrl as g
 };

package/dist/chunks/getRelatedInfos.js

@@ -1,54 +1,69 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.0/LICENSE.txt */
-import { x as D } from "./interfaces.js";
-import { getItemRelatedItems as g } from "@esri/solution-common";
-async function R(o, r) {
-  const s = await h(r, o);
-  let l = [], a = [], d = [];
-  const c = s.map(async (e) => {
-    const m = await S(e.id, "reverse", "Solution2Item", o);
-    return { template: e, relatedItems: m };
-  }), p = await Promise.all(c);
-  for (const { template: e, relatedItems: m } of p)
-    for (const f of m) {
-      const I = [];
-      for (const t of f.relatedItemIds)
-        I.push({
-          controlItemId: e.id,
-          dependencyItemId: t
+import { x as prepareDataForSolutionDisplay } from "./interfaces.js";
+import { getItemRelatedItems } from "@esri/solution-common";
+async function getRelatedSolutionsInfos(userSession, card) {
+  const templateInfos = await processTemplates(card, userSession);
+  let uniqueIitemIds = [];
+  let _nonSolutionDependencyItems = [];
+  let multiSolutionDependencies = [];
+  const dependencyFetches = templateInfos.map(async (template) => {
+    const relatedItems = await _getRelatedDependency(template.id, "reverse", "Solution2Item", userSession);
+    return { template, relatedItems };
+  });
+  const resolvedDependencies = await Promise.all(dependencyFetches);
+  for (const { template, relatedItems } of resolvedDependencies) {
+    for (const relatedItem of relatedItems) {
+      const solutionItemDeps = [];
+      for (const itemId of relatedItem.relatedItemIds) {
+        solutionItemDeps.push({
+          controlItemId: template.id,
+          dependencyItemId: itemId
         });
-      const y = I.reduce((t, n) => (t[n.controlItemId] || (t[n.controlItemId] = /* @__PURE__ */ new Set()), t[n.controlItemId].add(n.dependencyItemId), t), {}), i = Object.entries(y).filter(([t, n]) => n.size > 1).flatMap(
-        ([t, n]) => Array.from(n).map((w) => ({
-          controlItemId: t,
-          dependencyItemId: w
+      }
+      const grouped = solutionItemDeps.reduce((acc, dep) => {
+        if (!acc[dep.controlItemId]) {
+          acc[dep.controlItemId] = /* @__PURE__ */ new Set();
+        }
+        acc[dep.controlItemId].add(dep.dependencyItemId);
+        return acc;
+      }, {});
+      const uniqueFiltered = Object.entries(grouped).filter(([_, depSet]) => depSet.size > 1).flatMap(
+        ([controlItemId, depSet]) => Array.from(depSet).map((dependencyItemId) => ({
+          controlItemId,
+          dependencyItemId
         }))
       );
-      i.length > 0 && (d = d.concat(i));
+      if (uniqueFiltered.length > 0) {
+        multiSolutionDependencies = multiSolutionDependencies.concat(uniqueFiltered);
+      }
     }
-  a = Array.from(
+  }
+  _nonSolutionDependencyItems = Array.from(
     new Map(
       [
-        ...d
-      ].map((e) => [`${e.controlItemId}:${e.dependencyItemId}`, e])
+        ...multiSolutionDependencies
+      ].map((dep) => [`${dep.controlItemId}:${dep.dependencyItemId}`, dep])
     ).values()
   );
-  const u = a.map((e) => e.controlItemId);
-  return l = [...new Set(u)], {
-    uniqueIitemIds: l,
-    _nonSolutionDependencyItems: a,
-    templateInfos: s
+  const controlItems = _nonSolutionDependencyItems.map((dep) => dep.controlItemId);
+  uniqueIitemIds = [...new Set(controlItems)];
+  return {
+    uniqueIitemIds,
+    _nonSolutionDependencyItems,
+    templateInfos
   };
 }
-async function S(o, r, s, l) {
-  const a = await g(o, s, r, l);
+async function _getRelatedDependency(itemId, direction, type, userSession) {
+  const relatedItems = await getItemRelatedItems(itemId, type, direction, userSession);
   return [{
-    relationshipType: s,
-    relatedItemIds: a.relatedItems.map((d) => d.id)
+    relationshipType: type,
+    relatedItemIds: relatedItems.relatedItems.map((item) => item.id)
   }];
 }
-async function h(o, r) {
-  return await D(o.id, r);
+async function processTemplates(card, userSession) {
+  return await prepareDataForSolutionDisplay(card.id, userSession);
 }
 export {
-  R as g,
-  h as p
+  getRelatedSolutionsInfos as g,
+  processTemplates as p
 };