@esri/solutions-components 5.1.0-next.14 → 5.1.0-next.140

package/dist/chunks/converter.js

@@ -0,0 +1,643 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+function m() {
+  return {
+    renderer: {
+      type: "simple",
+      symbol: {
+        type: "CIMSymbolReference",
+        symbol: {
+          type: "CIMPointSymbol",
+          symbolLayers: [
+            {
+              type: "CIMVectorMarker",
+              enable: !0,
+              colorLocked: !0,
+              anchorPoint: { x: 0, y: -12.600000000000001 },
+              anchorPointUnits: "Absolute",
+              dominantSizeAxis3D: "Y",
+              size: 7.2,
+              billboardMode3D: "FaceNearPlane",
+              frame: { xmin: 0, ymin: 0, xmax: 84.3, ymax: 84.3 },
+              markerGraphics: [
+                {
+                  type: "CIMMarkerGraphic",
+                  geometry: {
+                    rings: [
+                      [
+                        [83.2, 32.5],
+                        [84.3, 40.7],
+                        [83.8, 48.9],
+                        [81.7, 56.9],
+                        [78.1, 64.3],
+                        [73, 70.9],
+                        [66.9, 76.4],
+                        [59.7, 80.5],
+                        [51.9, 83.2],
+                        [43.7, 84.3],
+                        [35.4, 83.8],
+                        [27.4, 81.7],
+                        [20, 78],
+                        [13.4, 73],
+                        [7.9, 66.8],
+                        [3.8, 59.7],
+                        [1.1, 51.9],
+                        [0, 43.7],
+                        [0.5, 35.4],
+                        [2.6, 27.4],
+                        [6.3, 20],
+                        [11.3, 13.4],
+                        [17.5, 7.9],
+                        [24.7, 3.8],
+                        [32.5, 1.1],
+                        [39.8, 0.1],
+                        [47.1, 0.3],
+                        [54.3, 1.8],
+                        [61.1, 4.5],
+                        [67.4, 8.4],
+                        [72.9, 13.3],
+                        [77.4, 19.1],
+                        [80.9, 25.5],
+                        [83.2, 32.5]
+                      ]
+                    ]
+                  },
+                  symbol: {
+                    type: "CIMPolygonSymbol",
+                    symbolLayers: [
+                      {
+                        type: "CIMSolidFill",
+                        enable: !0,
+                        color: [242, 242, 242, 255]
+                      }
+                    ]
+                  }
+                }
+              ],
+              scaleSymbolsProportionally: !0,
+              respectFrame: !0,
+              clippingPath: {
+                type: "CIMClippingPath",
+                clippingType: "Intersect",
+                path: {
+                  rings: [
+                    [
+                      [0, 0],
+                      [84.3, 0],
+                      [84.3, 84.3],
+                      [0, 84.3],
+                      [0, 0]
+                    ]
+                  ]
+                }
+              },
+              rotation: 360
+            },
+            {
+              type: "CIMVectorMarker",
+              enable: !0,
+              anchorPoint: { x: 0, y: -9 },
+              anchorPointUnits: "Absolute",
+              dominantSizeAxis3D: "Y",
+              size: 18,
+              billboardMode3D: "FaceNearPlane",
+              frame: {
+                xmin: 0,
+                ymin: 0,
+                xmax: 197.7,
+                ymax: 294.7
+              },
+              markerGraphics: [
+                {
+                  type: "CIMMarkerGraphic",
+                  geometry: {
+                    rings: [
+                      [
+                        [98.9, 0],
+                        [119.4, 23.2],
+                        [139.4, 49.3],
+                        [156.8, 75.2],
+                        [171.2, 100.8],
+                        [182.4, 125.3],
+                        [190.6, 148.8],
+                        [195.7, 171.4],
+                        [197.7, 192.9],
+                        [197.7, 195.8],
+                        [197.7, 200.3],
+                        [197.6, 202.5],
+                        [197.5, 204.8],
+                        [197.3, 207.1],
+                        [197, 209.4],
+                        [196.7, 211.7],
+                        [196.4, 214.1],
+                        [196, 216.4],
+                        [195.5, 218.7],
+                        [195, 221.1],
+                        [194.4, 223.4],
+                        [193.7, 225.8],
+                        [193, 228.1],
+                        [192.2, 230.5],
+                        [191.4, 232.8],
+                        [190.5, 235.1],
+                        [189.5, 237.5],
+                        [188.5, 239.7],
+                        [187.4, 242],
+                        [186.2, 244.3],
+                        [185, 246.5],
+                        [183.7, 248.7],
+                        [182.4, 250.9],
+                        [181, 253.1],
+                        [179.5, 255.2],
+                        [178, 257.3],
+                        [176.4, 259.4],
+                        [174.7, 261.4],
+                        [173.1, 263.3],
+                        [171.3, 265.3],
+                        [169.5, 267.2],
+                        [167.7, 269],
+                        [165.8, 270.8],
+                        [163.9, 272.5],
+                        [161.9, 274.2],
+                        [159.9, 275.8],
+                        [157.8, 277.4],
+                        [155.7, 278.9],
+                        [153.6, 280.4],
+                        [151.4, 281.7],
+                        [149.2, 283.1],
+                        [147, 284.4],
+                        [144.8, 285.6],
+                        [142.5, 286.7],
+                        [140.3, 287.8],
+                        [138, 288.8],
+                        [135.7, 289.8],
+                        [133.4, 290.7],
+                        [131, 291.5],
+                        [128.7, 292.3],
+                        [126.4, 293],
+                        [124, 293.6],
+                        [121.7, 294.2],
+                        [119.4, 294.7],
+                        [117, 295.2],
+                        [114.7, 295.6],
+                        [112.4, 296],
+                        [110.1, 296.3],
+                        [107.8, 296.5],
+                        [105.5, 296.7],
+                        [103.3, 296.8],
+                        [101.1, 296.9],
+                        [98.8, 296.9],
+                        [83.1, 295.7],
+                        [67.8, 292],
+                        [53.3, 285.9],
+                        [39.9, 277.5],
+                        [28.1, 267.2],
+                        [18, 255.1],
+                        [10, 241.5],
+                        [4.2, 226.9],
+                        [0.9, 211.5],
+                        [0, 195.8],
+                        [0.1, 192.9],
+                        [2.1, 171.4],
+                        [7.2, 148.8],
+                        [15.4, 125.3],
+                        [26.6, 100.8],
+                        [41, 75.2],
+                        [58.4, 49.3],
+                        [78.4, 23.2],
+                        [98.9, 0]
+                      ]
+                    ]
+                  },
+                  symbol: {
+                    type: "CIMPolygonSymbol",
+                    symbolLayers: [
+                      {
+                        type: "CIMSolidFill",
+                        enable: !0,
+                        color: [39, 17, 17, 255]
+                      }
+                    ]
+                  }
+                }
+              ],
+              scaleSymbolsProportionally: !0,
+              respectFrame: !0,
+              clippingPath: {
+                type: "CIMClippingPath",
+                clippingType: "Intersect",
+                path: {
+                  rings: [
+                    [
+                      [0, 0],
+                      [197.7, 0],
+                      [197.7, 294.7],
+                      [0, 294.7],
+                      [0, 0]
+                    ]
+                  ]
+                }
+              },
+              rotation: 360
+            }
+          ],
+          haloSize: 1,
+          scaleX: 1,
+          angleAlignment: "Display",
+          angle: 360
+        }
+      }
+    }
+  };
+}
+function h() {
+  return {
+    renderer: {
+      type: "simple",
+      symbol: {
+        type: "esriSMS",
+        style: "esriSMSCircle",
+        color: [0, 0, 0, 255],
+        size: 10,
+        angle: 0,
+        xoffset: 0,
+        yoffset: 0,
+        outline: { color: [0, 0, 0, 255], width: 0 }
+      }
+    }
+  };
+}
+class u {
+  constructor(e) {
+    this.llmFsLookup = {}, this.structure = e, this.buildSolution = this.structure?.buildSolution;
+  }
+  static {
+    this.typeLookup = {
+      point: "esriGeometryPoint",
+      polyline: "esriGeometryPolyline",
+      polygon: "esriGeometryPolygon"
+    };
+  }
+  static {
+    this.drawingToolLookup = {
+      esriGeometryPoint: "esriFeatureEditToolPoint",
+      esriGeometryPolyline: "esriFeatureEditToolLine",
+      esriGeometryPolygon: "esriFeatureEditToolPolygon",
+      Table: "esriFeatureEditToolNone"
+    };
+  }
+  static {
+    this.fieldTypeToEsri = {
+      string: "esriFieldTypeString",
+      integer: "esriFieldTypeInteger",
+      double: "esriFieldTypeDouble",
+      date: "esriFieldTypeDate",
+      guid: "esriFieldTypeGUID",
+      globalid: "esriFieldTypeGlobalID",
+      oid: "esriFieldTypeOID"
+    };
+  }
+  static {
+    this.fieldTypeToSimple = Object.fromEntries(
+      Object.entries(u.fieldTypeToEsri).map(([e, i]) => [i, e])
+    );
+  }
+  dumpToLlmTemplate() {
+    const e = this.structure?.buildSolution?.solution, i = Object.entries(e?.strings || {}).map(([s, r]) => ({
+      key: s,
+      value: r.value,
+      description: r.description
+    })), t = {
+      title: e?.title,
+      description: e?.description,
+      tags: e?.tags,
+      strings: i
+    }, o = this.structure?.buildSolution?.items, n = Object.entries(o || {}).map(([s, r]) => ({
+      id: s,
+      title: r.title,
+      description: r.description,
+      type: r.type
+    }));
+    let l = null;
+    for (const [s, r] of Object.entries(o || {})) {
+      if (r.type !== "Feature Layer (hosted)")
+        continue;
+      const d = [];
+      for (const p of r.service?.layers || []) {
+        const c = this.getFields(p);
+        d.push({
+          id: p.id,
+          type: "",
+          name: p.name,
+          customFields: [],
+          requiredFields: c,
+          systemFields: []
+        });
+      }
+      for (const p of r.service?.tables || []) {
+        const c = this.getFields(p);
+        d.push({
+          id: p.id,
+          type: "Table",
+          name: p.name,
+          customFields: [],
+          requiredFields: c,
+          systemFields: []
+        });
+      }
+      l = {
+        itemId: s,
+        addLayers: r.addLayers,
+        layers: d
+      };
+      break;
+    }
+    return {
+      solution: t,
+      items: n,
+      featureLayer: l ?? {
+        itemId: "",
+        addLayers: !1,
+        layers: []
+      }
+    };
+  }
+  getFields(e) {
+    const i = [];
+    for (const t of e.fields || [])
+      i.push({
+        name: t.name,
+        type: u.fieldTypeToSimple[t.type] || t.type,
+        alias: t.alias,
+        description: u.getFieldDescription(t.description),
+        choiceList: u.getFieldDomain(t.domain),
+        length: t.length
+      });
+    return i;
+  }
+  static getFieldDescription(e) {
+    if (e)
+      try {
+        return JSON.parse(e).value || e;
+      } catch {
+        return e;
+      }
+  }
+  static getFieldDomain(e) {
+    if (e)
+      return e.codedValues?.map((i) => i.code);
+  }
+  applyLlmTemplate(e) {
+    const i = this.buildSolution.solution;
+    if (this.llmFsLookup = {}, e.featureLayer?.itemId) {
+      this.llmFsLookup[e.featureLayer.itemId] = {};
+      for (const s of e.featureLayer.layers)
+        this.llmFsLookup[e.featureLayer.itemId][s.id] = s;
+    }
+    for (const [s, r] of Object.entries(this.buildSolution.items))
+      r.type === "Feature Layer (hosted, view)" && (this.llmFsLookup[s] = { ...this.llmFsLookup[r.source] });
+    i.title = e.solution.title, i.description = e.solution.description, i.tags = e.solution.tags;
+    const t = i.strings;
+    for (const s of e.solution.strings)
+      t[s.key] && (t[s.key].value = s.value);
+    const o = {}, n = /* @__PURE__ */ new Set(), l = this.buildSolution.items;
+    for (const s of e.items) {
+      const r = l[s.id];
+      if (r)
+        if (r.title = s.title, r.description = s.description, r.type === "Web Map")
+          this.applyWebMap(r);
+        else if (r.type === "Feature Layer (hosted)") {
+          this.applyFeatureService(r, s.id, !1);
+          const d = b(r);
+          r.data = d, o[s.id] = d;
+        } else r.type === "Feature Layer (hosted, view)" && (this.applyFeatureService(r, s.id, !0), n.add(s.id));
+    }
+    for (const s of n) {
+      const r = l[s];
+      r.data = o[r.source];
+    }
+    return this.structure;
+  }
+  applyWebMap(e) {
+    if (!e.layerSources)
+      return;
+    for (const o of [...e.layers || [], ...e.tables || []]) {
+      const [n, l] = this.extractIdAndLayerId(o.url), s = this.llmFsLookup[n]?.[l];
+      s && (o.title = s.name);
+    }
+    if (!(e.layers?.length === 0 && e.tables?.length === 0))
+      return;
+    const t = crypto.randomUUID().replace(/-/gu, "").substring(0, 10);
+    for (const o of e.layerSources) {
+      const n = this.llmFsLookup[o];
+      if (n)
+        for (const [l, s] of Object.entries(n)) {
+          const r = Number(l), d = s.type.toLowerCase() === "table", p = {
+            id: `${t}-layer-${r}`,
+            title: s.name,
+            url: `{{${o}.layer${r}.url}}`,
+            itemId: `{{${o}.layer${r}.itemId}}`
+          };
+          d ? e.tables.push(p) : (p.layerType = "ArcGISFeatureLayer", e.layers.push(p));
+        }
+    }
+  }
+  extractIdAndLayerId(e) {
+    const i = e.replace(/[{}]/gu, "").split("."), t = i[0], o = Number.parseInt(i[1].replace("layer", ""));
+    return [t, o];
+  }
+  applyFeatureService(e, i, t = !1) {
+    const o = e.source || i, n = this.llmFsLookup[o];
+    for (const s of [...e.service.layers, ...e.service.tables])
+      this.applyLayer(s, n, t);
+    e.addLayers && !t && this.addNewLayers(e, n);
+    const l = e.service.layers?.length === 0 && e.service.tables?.length === 0;
+    t && l && this.addNewViewLayers(e, i, n);
+  }
+  addNewLayers(e, i) {
+    for (const [t, o] of Object.entries(i)) {
+      const l = { id: Number(t) };
+      this.applyLayer(l, i), o.type.toLowerCase() === "table" ? e.service.tables.push(l) : e.service.layers.push(l);
+    }
+  }
+  addNewViewLayers(e, i, t) {
+    const o = e.source;
+    for (const [n, l] of Object.entries(t)) {
+      const s = Number(n), r = l.type.toLowerCase() === "table", d = {
+        adminLayerInfo: {
+          geometryField: r ? null : { name: "Shape" },
+          viewLayerDefinition: {
+            sourceServiceName: `{{${o}.name}}`,
+            sourceLayerId: s,
+            sourceLayerFields: "*"
+          }
+        },
+        id: s,
+        name: l.name,
+        extent: `{{${i}.solutionExtent}}`,
+        maxRecordCount: 2e3
+      };
+      r ? e.service.tables.push(d) : e.service.layers.push(d);
+    }
+  }
+  applyLayer(e, i, t = !1) {
+    const o = i[e.id];
+    if (!o || (e.name = o.name, t))
+      return;
+    const n = u.typeLookup[o.type.toLowerCase()] || o.type;
+    n.toLowerCase() === "table" ? e.type = n : e.geometryType = n, e.editFieldsInfo = this.editFieldsInfo(), e.globalIdField = "globalid", e.objectIdField = "objectid", e.uniqueIdField = { name: "objectid", isSystemMaintained: !0 }, e.hasAttachments = !0, this.updateRelationships(e, i), this.updateFields(e, o), this.updateTemplates(e), this.updateDrawingInfo(e);
+  }
+  updateRelationships(e, i) {
+    const t = e.relationships || [];
+    for (const o of t) {
+      const n = i[o.relatedTableId];
+      n && (o.name = n.name);
+    }
+  }
+  updateFields(e, i) {
+    const t = [], o = [
+      [!1, i.customFields],
+      [!0, i.requiredFields],
+      [!0, i.systemFields]
+    ];
+    for (const [n, l] of o)
+      if (Array.isArray(l))
+        for (const s of l) {
+          const r = {
+            name: s.name,
+            alias: s.alias,
+            type: u.fieldTypeToEsri[s.type] || s.type,
+            description: JSON.stringify({ value: s.description, fieldValueType: "" }, null, 0),
+            domain: this.createDomain(s.choiceList, s.name),
+            required: n
+          };
+          s.type?.toLowerCase() === "string" && (r.length = s.length ?? 256), (s.type === "oid" || s.type === "globalid") && (r.editable = !1, r.nullable = !1), t.push(r);
+        }
+    e.fields = t;
+  }
+  updateTemplates(e) {
+    const i = u.drawingToolLookup[e.geometryType || e.type];
+    e.templates ??= [{
+      name: e.name,
+      description: "",
+      prototype: { attributes: {} }
+    }];
+    for (const t of e.templates)
+      t.drawingTool = i;
+  }
+  updateDrawingInfo(e) {
+    if (e.drawingTool === "esriGeometryPoint")
+      e.drawingInfo = h();
+    else
+      return;
+  }
+  createDomain(e, i) {
+    return e ? {
+      type: "codedValue",
+      name: `${i}_${crypto.randomUUID().replace(/-/gu, "")}`,
+      codedValues: e.map((t) => ({ name: t, code: t }))
+    } : null;
+  }
+  editFieldsInfo() {
+    return {
+      creationDateField: "created_date",
+      creatorField: "created_user",
+      editDateField: "last_edited_date",
+      editorField: "last_edited_user"
+    };
+  }
+}
+function b(a) {
+  const e = a.service, i = {
+    layers: [],
+    tables: []
+  };
+  for (const t of e.layers || [])
+    i.layers.push({
+      id: t.id,
+      formInfo: y(t),
+      popupInfo: f(t),
+      layerDefinition: g(t)
+    });
+  for (const t of e.tables || [])
+    i.tables.push({
+      id: t.id,
+      formInfo: y(t),
+      popupInfo: f(t)
+    });
+  return i;
+}
+function y(a) {
+  const e = [];
+  for (const t of a.fields)
+    t.required || e.push({
+      label: t.alias,
+      type: "field",
+      editableExpression: "expr/system/true",
+      fieldName: t.name,
+      inputType: F(t.type, t.domain, t.length)
+    });
+  const i = a.relationships || [];
+  for (const t of i)
+    e.push({
+      description: "",
+      label: t.name,
+      type: "relationship",
+      displayCount: 3,
+      displayType: "list",
+      editableExpression: "expr/system/true",
+      orderByFields: [{ field: "created_date", order: "asc" }],
+      relationshipId: t.id
+    });
+  return {
+    formElements: e,
+    expressionInfos: [
+      { expression: "false", name: "expr/system/false", returnType: "boolean", title: "False" },
+      { expression: "true", name: "expr/system/true", returnType: "boolean", title: "True" }
+    ],
+    title: a.name
+  };
+}
+function f(a) {
+  const e = [], i = [];
+  for (const o of a.fields)
+    o.required || i.push({
+      fieldName: o.name,
+      isEditable: !0,
+      label: o.alias,
+      visible: !0
+    });
+  e.push({
+    type: "fields",
+    description: "",
+    fieldInfos: i
+  });
+  const t = a.relationships || [];
+  if (t.length && a.type !== "Table")
+    for (const o of t)
+      e.push({
+        type: "relationship",
+        description: "",
+        displayCount: 3,
+        displayType: "list",
+        orderByFields: [{ field: "created_date", order: "asc" }],
+        relationshipId: o.id
+      });
+  return e.push({
+    type: "attachments",
+    description: "",
+    displayType: "auto",
+    title: ""
+  }), {
+    popupElements: e,
+    showLastEditInfo: !1,
+    title: a.name
+  };
+}
+function g(a) {
+  return a.geometryType === "esriGeometryPoint" ? { drawingInfo: m() } : { drawingInfo: {} };
+}
+function F(a, e, i) {
+  return a === "esriFieldTypeString" && !e ? { type: "text-box", maxLength: i || 255, minLength: 0 } : a === "esriFieldTypeString" && e ? { type: "combo-box", noValueOptionLabel: "No value", showNoValueOption: !0 } : ["esriFieldTypeInteger", "esriFieldTypeDouble"].includes(a) ? { type: "text-box", minLength: 0 } : a === "esriFieldTypeDate" ? { type: "datetime-picker", includeTime: !1 } : { type: "text-box", maxLength: i || 255, minLength: 0 };
+}
+export {
+  u as C
+};

package/dist/chunks/deployAppContexts.js

@@ -1,9 +1,10 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
 import { createContext as o } from "@lit/context";
-const e = o("isMobile");
+const t = o("isMobile");
 o("localDebug");
-const i = o("config");
+const i = o("config"), n = o("builderDesign");
 export {
+  n as b,
   i as c,
-  e as i
+  t as i
 };

package/dist/chunks/description.js

@@ -0,0 +1,12 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const t = `The Solutions Assistant Agent is the single entry point for ArcGIS Solutions assistant requests.\r
+\r
+It classifies each incoming request and routes it to the most appropriate specialist flow:\r
+- Explorer flow for discovery, documentation, and general ArcGIS Solutions questions.\r
+- Builder flow for creating, designing, or updating a solution design.\r
+- Other flow for unsupported, unclear, or off-topic requests.\r
+\r
+Always select this agent`;
+export {
+  t as default
+};

package/dist/chunks/description2.js

@@ -0,0 +1,36 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `The Solution Builder Agent **guides, creates, and updates custom solutions** based on explicit user intent.\r
+\r
+**Use this agent when the user:**\r
+- Asks how to build a solution or what kinds of solutions they can build\r
+- Asks to create, build, or design a solution\r
+- Asks to update or modify an existing solution design\r
+\r
+**Scenario 1: Build guidance**\r
+When the user asks questions such as:\r
+- “How do I build a solution?”\r
+- “What kinds of solutions can I build?”\r
+\r
+The agent explains solution-building capabilities, patterns, and options.\r
+This response **fully completes the user’s request for that turn**.\r
+\r
+**Scenario 2: Create a solution**\r
+When the user asks to build, create, or design a solution, the agent produces a **complete, ready-to-use solution design** including layers, maps, apps.\r
+This **fully completes the user’s request for that turn**.\r
+\r
+**Scenario 3: Update a solution**\r
+When the user asks to update or refine a solution design, the agent applies the **specific requested change** (for example: add, remove or update a field, update a title, modify a domain).\r
+Each update request is handled as a **single, complete modification**\r
+\r
+**Context-aware behavior**\r
+When a prior user message or assistant response has established intent to build a solution, the agent treats subsequent user messages that describe a use case or workflow as the input to the solution being created.\r
+\r
+In this context:\r
+- Workflow descriptions are considered build requirements, not exploratory questions\r
+- The agent remains the correct handler for the request\r
+\r
+**Important behavior**\r
+- When selecting this agent **'requiresFollowUp' should always be false**`;
+export {
+  e as default
+};