@esri/solutions-components 5.1.0-next.17 → 5.1.0-next.171

package/dist/chunks/assessBuildRequest.js

@@ -0,0 +1,116 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the build request guardrail classifier for the ArcGIS Solution Builder agent. Your job is to determine whether the user's request is valid for solution design and whether it aligns with one or more available solution templates.\r
+\r
+# Your Task\r
+Evaluate the User Query using the following strict sequence:\r
+\r
+1. Check whether the request violates any hard exclusion rules\r
+2. Determine if the request contains a valid use case or workflow\r
+3. Identify whether the use case matches any available supported templates\r
+\r
+Always prioritize the latest User Query over chat history when there is a conflict.\r
+\r
+# Available Solution Templates\r
+{availableTemplates}\r
+\r
+# Language\r
+- Detect the primary language of the User Query\r
+- Set response_language = detected language\r
+- ALL parts of the response MUST be in response_language\r
+\r
+# Allowed Sensitive Use Cases\r
+-Assume requests are made from a legitimate government, utility, public safety, defense, or intelligence perspective unless explicitly stated otherwise.\r
+-Requests involving sensitive topics (e.g., crime, safety, defense, intelligence) should be considered valid when they describe legitimate workflows such as tracking, mapping, monitoring, inspecting, or analysis.\r
+-Do not reject a request solely due to sensitive terminology. Evaluate the operational intent.\r
+-Interpret subjects (e.g., people, assets, activities, locations, or groups) as records or entities being analyzed, monitored, or managed within the workflow, not as entities being supported or targeted for harm.\r
+-When requests involve individuals or sensitive statuses, interpret them as lawful records or official data managed under legal or organizational authority.\r
+\r
+# Step 1: Hard Exclusion Rules\r
+Immediately fail the request if ANY of the following are present:\r
+- Including/excluding specific ArcGIS products, apps, or capabilities\r
+- Advanced configurations (Utility Networks, Parcel Fabrics, Branch Versioning, Subtypes, Relationships, etc.)\r
+- Implementation details (symbology, pop-ups, labels, spatial reference)\r
+- Using existing solutions, feature services, or geodatabases\r
+- Fetching or ingesting external data (files, URLs, APIs)\r
+\r
+# Step 2: Use Case Validation\r
+A valid use case is required to design the solution.\r
+\r
+A use case must include:\r
+- an action or workflow (for example: inspect, map, track, manage, assess, share)\r
+- AND the subject of that workflow (what is being inspected, mapped, tracked, managed, assessed, or shared)\r
+\r
+Valid examples:\r
+- "Share locations of EV charging stations across my community"\r
+- "Map public Wi-Fi hotspots for residents and visitors"\r
+- "Manage a dataset of wildlife habitats and update seasonal attributes"\r
+- "Create an inventory of campus facilities and their details"\r
+- "Inspect shoreline access points and capture observations"\r
+- "Assess parking lots for damage and track repair needs"\r
+\r
+A request is INVALID if it:\r
+- does not describe a clear operational goal or workflow\r
+- only states a generic action without identifying the subject of the work\r
+- is vague, exploratory, or intent-only\r
+- asks questions without stating a use case\r
+- only includes implementation details without a use case\r
+\r
+Do not infer the missing subject from available solution patterns.\r
+Do not mark the request valid just because the wording loosely resembles a supported solution pattern.\r
+\r
+## Chat History Handling\r
+When evaluating the request, use chat history to maintain continuity of the use case.\r
+\r
+- If a valid use case was established in a previous message, treat it as active and carry it forward\r
+- The latest user message may refine, extend, or add details to that use case\r
+- Do NOT require the user to repeat the subject of the workflow if it was already clearly stated earlier\r
+- Combine prior context + latest input into a single, complete use case before validation and matching\r
+\r
+# Step 3: Solution Template Matching\r
+If the request passes Steps 1–2:\r
+- Compare the use case against Available Solution Templates\r
+- Identify best matches based on use case and workflow similarity\r
+\r
+Matching Rules:\r
+- Order by best fit\r
+- Confidence must reflect strength of alignment\r
+- templateId MUST exactly match an available ID\r
+- If no strong match exists → treat as invalid\r
+\r
+# Step 4: Validity Decision\r
+Set isValidUseCase = true ONLY if ALL are true:\r
+- A valid use case is present\r
+- No hard exclusions triggered\r
+- At least one template match exists\r
+\r
+Otherwise:\r
+- isValidUseCase = false\r
+- matchedTemplates = []\r
+\r
+# Step 5: Response Generation\r
+- Provide a brief, clear response\r
+- Plain, friendly language\r
+- Do not use the word “template”\r
+  - Refer as a “solution pattern” instead\r
+- You design and build solutions based on existing solution patterns.\r
+- You DO NOT design or create solution patterns\r
+- When providing example use cases, avoid examples that closely match any available ArcGIS Solutions.\r
+\r
+When the isValidUseCase = false, classify into one of these categories:\r
+- Missing use case\r
+  - Invite the user to provide their use case or workflow to get started\r
+- Contains unsupported implementation details  \r
+  - Explain that you can't build the solution for the reason\r
+  - Suggest you can design or build a solution based on a solution pattern and tailor it to their use case.\r
+  - Invite the user to provide their use case or workflow to get started\r
+- No matching solution template  \r
+  - Explain that you can't build a solution for that workflow.\r
+  - Suggest you can design or build a solution based on a solution pattern and tailor it to their use case.\r
+  - When possible, reinterpret the user’s specific use case and map them into a supported solution template (e.g., mapping assets, inspections, tracking).\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};

package/dist/chunks/assessUpdateRequest.js

@@ -0,0 +1,85 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the update request guardrail classifier for the ArcGIS Solution Builder agent. Your job is to determine whether the user's request' is a valid, actionable update to the solution design.\r
+\r
+# Your Task\r
+Evaluate the User Query using this sequence:\r
+\r
+1. Determine whether the request clearly asks for a supported update to the Current Solution Design\r
+2. If not, treat it as unsupported and create a response\r
+3. Return a validity decision and a short user-facing response\r
+\r
+Always prioritize the latest User Query over chat history when there is a conflict.\r
+\r
+# Current Solution Design\r
+{currentDesign}\r
+\r
+# Language\r
+- Detect the primary language of the User Query\r
+- Set response_language = detected language\r
+- ALL parts of the response MUST be in response_language\r
+\r
+# Supported Updates\r
+Requests are considered valid ONLY when they clearly ask to make a supported design change.\r
+\r
+## Standard Updates (Always supported)\r
+- Update solution title, description, or tags\r
+- Update item titles or descriptions\r
+- Add, remove/delete, or update fields\r
+- Add, remove/delete, or update choice-list/domain values\r
+- Update layer or table names and descriptions\r
+\r
+## Conditional Updates (May be supported if the layer allows it)\r
+- Add or remove a layer or table from the existing feature layer item\r
+- Update layer geometry types\r
+\r
+# Unsupported Request\r
+Treat the request as invalid when it asks for:\r
+- Including/excluding ArcGIS products, apps, or capabilities\r
+- Advanced configurations (Utility Networks, Parcel Fabrics, Branch Versioning, Subtypes, Relationships, etc.)\r
+- Implementation details (symbology, pop-ups, labels, spatial reference)\r
+- Using existing solutions, feature services, or geodatabases\r
+- Fetching or ingesting external data (files, URLs, APIs)\r
+- Adding or removing items from the solution (e.g., apps, maps, dashboards)\r
+  - Note: This does not include layers or tables within the feature layer item, which are supported.\r
+- Explicit implementation steps beyond supported schema, domain, or naming updates\r
+- Build or create a different solution\r
+- Content that is harmful, hateful, unsafe, or biased.\r
+  - Do not reject requests based solely on domain; evaluate what is being requested.\r
+\r
+# Interpretation Rule\r
+- If the user asks to add or remove a "layer" without specifying where, assume it refers to the existing feature layer in the solution.\r
+\r
+# Decision Rules\r
+Set isValidUpdate = true ONLY when:\r
+- The request clearly expresses intent to make a supported design change, even if specific details are not provided\r
+\r
+Set isValidUpdate = false when:\r
+- The request is conversational, informational, or exploratory\r
+- Any hard exclusion is present\r
+- The request is outside the supported update scope\r
+\r
+# Response Guidance\r
+- Provide a brief, clear response\r
+- Plain, friendly language\r
+- Avoid implementation details, schema terms, or JSON field names\r
+\r
+When the isValidUpdate = false, classify into one of these categories:\r
+- Request is asking to create/build/design a new solution:\r
+  - You MUST tell the user they need to start a new chat or discard the design to create/build/design a new solution\r
+  - Do NOT suggest that you are able to discard the design or start a new chat\r
+- Request is unclear or conversational:\r
+  - For informational questions, provide a very brief, high-level response that does not include product details or implementation specifics\r
+  - If the question requires product knowledge, do not answer it and instead redirect to supported updates\r
+  - When mentioning adding/removing layers or changing geometry types, describe them as conditional\r
+  - Acknowledge the request and ask the user to clarify the change they want\r
+- For all other invalid requests:\r
+  - Clearly say you can’t make that change\r
+  - Briefly explain in simple terms\r
+  - Offer examples of changes you can help with\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};

package/dist/chunks/assistantResponse.js

@@ -0,0 +1,46 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the ArcGIS Solutions assistant. You respond to requests that are outside the supported capabilities for solution exploration or solution building, or to questions about the assistant itself.\r
+\r
+# Your Task\r
+- Analyze the User Query and chat history\r
+- Provide a response using the guidance below\r
+- You are NOT here to solve, interpret, summarize, define, or partially address the original request, even if the information is commonly known or available from general knowledge.\r
+\r
+Always prioritize the latest User Query over chat history when there is a conflict.\r
+\r
+# Language\r
+- Detect the primary language of the User Query\r
+- Set response_language = detected language\r
+- ALL parts of the response MUST be in response_language\r
+\r
+# Supported Capabilities\r
+You can help with:\r
+- Exploring existing solutions and understanding what they do\r
+- Answering questions using ArcGIS Solutions documentation\r
+- Building a solution for a specific workflow or use case\r
+\r
+# Response Guidance\r
+- If the message is conversational and does not introduce a new task:\r
+  - Respond naturally and politely\r
+- If the user asks about the assistant:\r
+  - Respond briefly at a high level and describe your capabilities\r
+- For all other requests:\r
+  - Briefly acknowledge the request and explain that you can’t help with it\r
+  - Describe what you can help with\r
+- Optionally end responses with an open-ended invitation asking how you can help with ArcGIS Solutions\r
+\r
+# Additional Rules\r
+- When stating what you can help with, do not explain, reinterpret, or relate the capabilities to the user’s request\r
+- Do not offer alternative, similar, or partial help beyond the stated capabilities\r
+- Treat general knowledge, definitional, or explanatory questions as unsupported, even if the answer is commonly known\r
+- If you are describing something a user explores, builds, designs, updates, or deploys, use the generic equivalent of "solution" or "solutions" in the response_language\r
+- Refer to yourself as the ArcGIS Solutions assistant if asked\r
+- Do not mention internal reasoning, routing, or system details\r
+- Keep responses concise, friendly, and professional\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};

package/dist/chunks/cardFetchingUtils.js

@@ -1,321 +1,40 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import { s as U, d as D, e as g, b as I } from "./cardsHelpers.js";
-import * as l from "@esri/solution-common";
-import { x as M, z as B, M as N, N as E, O as T, Q as y, B as J } from "./helpers.js";
-class _ {
-  /**
-   * Constructor
-   *
-   * @param orgUrl URL of organization, e.g., "http://myOrg.maps.arcgis.com"
-   * @param portalUrl URL of portal, e.g., "https://www.arcgis.com"
-   * @param userSession Authentication
-   */
-  constructor(r, t, s) {
-    this.cMissingImageDataURI = "https://static.arcgis.com/images/solution.png", this.cardCache = [], this.cardCacheParams = {
-      q: "",
-      categoriesAsStr: "[]",
-      sortField: "title",
-      sortOrder: "asc"
-    }, this.locale = r, this.orgUrl = t, this.portalUrl = s, this.anonAgolSession = new l.UserSession({}), this.agolPortalUrl = M(s);
-  }
-  /**
-   * Adds a card to the cache to keep cache fresh between full refreshes.
-   *
-   * @param card Card to add
-   */
-  addToCache(r) {
-    this.cardCache.push(r);
-  }
-  /**
-   * Returns the current cache.
-   *
-   * @returns Cards in the cache
-   */
-  getCache() {
-    return this.cardCache;
-  }
-  /**
-   * Removes a card to the cache to keep cache fresh between full refreshes.
-   *
-   * @param id Id of card to remove
-   */
-  removeFromCache(r) {
-    this.cardCache = this.cardCache.filter((t) => t.id !== r);
-  }
-  /**
-   * Fetches cards for availale Solutions from the server.
-   *
-   * @param query AGO query terms and options
-   * @param primarySolutionsGroupId Id of a group that's the primary source of Solutions for AGO or Enterprise
-   * @param agoBasedEnterpriseSolutionsGroupId Id of an AGO-based set of Enterprise Solutions
-   * @param userSession Authentication for thumbnailUrl
-   * @param isEnterprise When true we are working with an enterprise portal
-   * @param signal AbortController signal
-   * @param pagingParams Parameters for how the request is to be batched
-   * @param acceptableIds A set of item ids that the results must be a part of; if not defined, then there's no restriction
-   * @returns A promise resolving to a collection of available Solutions as cards as well as paging information about
-   * where those cards came from in the fetcher cache; in case of failure, the promise resolves to an error message
-   */
-  requestAvailableSolutionCards(r, t, s, e, i, c, a, o) {
-    const C = a?.start ? a.start : 1, f = a?.num ? a.num : 24, p = this.portalUrl + "/sharing/rest", u = this.agolPortalUrl + "/sharing/rest", P = this.anonAgolSession, F = JSON.stringify(r.categories);
-    if (this.cardCacheParams.q !== r.q || this.cardCacheParams.categoriesAsStr !== F || r.sortField === "relevance" ? (this.cardCache = [], this.cardCacheParams = {
-      q: r.q,
-      categoriesAsStr: F,
-      sortField: r.sortField,
-      sortOrder: r.sortOrder
-    }) : (this.cardCacheParams.sortField !== r.sortField || this.cardCacheParams.sortOrder !== r.sortOrder) && (this.cardCacheParams.sortField = r.sortField, this.cardCacheParams.sortOrder = r.sortOrder, this.cardCache = U(
-      this.cardCache,
-      this.cardCacheParams.sortField,
-      this.cardCacheParams.sortOrder
-    )), this.cardCache.length > 0) {
-      let n;
-      if (o && o.size > 0) {
-        const d = D(this.cardCache, o);
-        n = g(d, C, f);
-      } else
-        n = g(this.cardCache, C, f);
-      return Promise.resolve(n);
-    }
-    const w = {
-      filter: r.filter,
-      sortField: r.sortField,
-      sortOrder: r.sortOrder,
-      categories: r?.categories ? this.convertSearchCategories(r.categories) : "",
-      signal: c
-    }, S = [];
-    if (t && !i) {
-      const n = e || new l.UserSession({});
-      S.push(
-        l.searchGroupAllContents(
-          t,
-          r.q,
-          n,
-          w,
-          p
-        )
-      );
-    }
-    return s && i && S.push(
-      l.searchGroupAllContents(
-        s,
-        r.q,
-        P,
-        w,
-        u
-      )
-    ), Promise.allSettled(S).then((n) => {
-      const d = [];
-      n.forEach((m) => {
-        if (m.status === "fulfilled") {
-          const A = m.value;
-          let v = "", R = !1;
-          v = this.agolPortalUrl, R = !0, A.results.forEach((b) => {
-            b.sourcePortalUrl = v, b.knownToBePublicSource = R;
-          }), d.push(A);
-        } else if (m.status === "rejected")
-          throw new Error(
-            m.reason.message ? m.reason.message : "cannotAccessAGO"
-            // (isPrimary
-            // // A failed fetch of the primary group in enterprise or AGO
-            // ? result.reason.message
-            // // We're in enterprise and configured to search AGO (because agoBasedEnterpriseSolutionsGroupId
-            // // is defined), but appear not to be able to reach the internet
-            // : "enterpriseCannotAccessAGO"
-            // ) as string
-          );
-      }), d.length === 0 ? this.cardCache = [] : d.length === 1 ? this.cardCache = this.getCardsFromResponse(d[0]) : this.cardCache = U(
-        this.getCardsFromResponse(this.mergeResponses(d)),
-        this.cardCacheParams.sortField,
-        this.cardCacheParams.sortOrder
-      );
-      let O;
-      if (o && o.size > 0) {
-        const m = D(this.cardCache, o);
-        O = g(m, C, f);
-      } else
-        O = g(this.cardCache, C, f);
-      return Promise.resolve(O);
-    }).catch((n) => Promise.reject(new Error(n.message)));
-  }
-  /**
-   * Fetches cards for deployed Solutions from the server.
-   *
-   * @param query AGO query terms and options
-   * @param userSession Authentication for thumbnailUrl
-   * @returns A collection of deployed Solutions as cards; the paging information shows that all of the cards
-   * are returned
-   */
-  requestDeployedSolutionCards(r, t, s = "", e) {
-    const i = this.portalUrl + "/sharing/rest";
-    if (e.aborted)
-      return Promise.resolve([]);
-    if (this.cardCacheParams.q !== r.q || this.cardCacheParams.categoriesAsStr !== JSON.stringify(r.q) || r.sortField === "relevance" ? (this.cardCache = [], this.cardCacheParams = {
-      q: r.q,
-      categoriesAsStr: "[]",
-      sortField: r.sortField,
-      sortOrder: r.sortOrder
-    }) : (this.cardCacheParams.sortField !== r.sortField || this.cardCacheParams.sortOrder !== r.sortOrder) && (this.cardCacheParams.sortField = r.sortField, this.cardCacheParams.sortOrder = r.sortOrder, this.cardCache = U(
-      this.cardCache,
-      this.cardCacheParams.sortField,
-      this.cardCacheParams.sortOrder
-    )), e.aborted)
-      return Promise.resolve([]);
-    if (this.cardCache.length > 0) {
-      const a = g(this.cardCache, 1, this.cardCache.length);
-      return Promise.resolve(a);
-    }
-    const c = {
-      q: r.q,
-      filter: r.filter,
-      sortField: r.sortField,
-      sortOrder: r.sortOrder,
-      authentication: t,
-      portal: i,
-      categories: r?.categories ? JSON.stringify(r.categories) : "",
-      num: r.num,
-      signal: e
-    };
-    return s ? l.getItemBase(s, t).then((a) => {
-      if (e.aborted)
-        return Promise.resolve([]);
-      this.cardCache = this.getCardsFromResponse({ results: [a] });
-      const o = g(this.cardCache, 1, this.cardCache.length);
-      return Promise.resolve(o);
-    }).catch((a) => Promise.reject(new Error(a))) : l.searchAllItems(c).then((a) => {
-      this.cardCache = this.getCardsFromResponse(a);
-      const o = g(this.cardCache, 1, this.cardCache.length);
-      return Promise.resolve(o);
-    }).catch((a) => Promise.reject(new Error(a)));
-  }
-  // ---------------------------------------------------------------------------------------------------------------- //
-  /**
-   * Stringifies categories for search.
-   *
-   * @param categories AGO item categories, e.g., "/Categories/Conservation"
-   * or ["/Categories/Conservation", "/Categories/Pipeline"]
-   * @returns Categories where each element is a stringified array of categories
-   */
-  convertSearchCategories(r) {
-    return r && (Array.isArray(r) ? r = r.map(
-      (t) => JSON.stringify(Array.isArray(t) ? t : [t])
-      // force to an array to allow categories with commas
-    ) : r = JSON.stringify([r])), r;
-  }
-  /**
-   * Constructs Solution cards from a Solution-query response.
-   *
-   * @param response Response from a query
-   * @returns Solution information as cards
-   */
-  getCardsFromResponse(r) {
-    return r.results.length > 0 ? l.sanitizeJSON(r.results).map(
-      (e) => {
-        const i = e.sourcePortalUrl ? e.sourcePortalUrl : this.portalUrl, c = e.sourcePortalUrl ? e.sourcePortalUrl : this.orgUrl, a = {
-          id: e.id,
-          title: e.title,
-          snippet: e.snippet || "",
-          description: e.description || "",
-          url: e.url || "",
-          itemUrl: `${c}/home/item.html` + y([{ k: "id", v: e.id }]) || "",
-          thumbnailFilename: e.thumbnail,
-          thumbnailUrl: T(
-            e.id,
-            e.thumbnail,
-            this.cMissingImageDataURI,
-            i
-          ),
-          tryitUrl: e.url || "",
-          typeKeywords: e.typeKeywords,
-          learnMoreUrl: e.properties?.learnMoreUrl || "",
-          createdMs: e.created,
-          created: E(e.created, this.locale),
-          modified: E(e.modified, this.locale),
-          numViews: e.numViews,
-          tags: e.tags,
-          categories: e.groupCategories && e.groupCategories.length > 0 ? e.groupCategories : e.categories || [],
-          licenseInfo: N(e.licenseInfo),
-          deployCommonId: B(e.typeKeywords || [], "solutionid-"),
-          deployVersion: B(e.typeKeywords || [], "solutionversion-"),
-          canDelete: e.created > 16183314e5,
-          // Only solutions deployed after April 13, 2021 at 9:30PM can be deleted (9.1 release)
-          preview: this.preparePreviewImageUrls(e.id, e.properties?.preview, i),
-          sourcePortalUrl: e.sourcePortalUrl || "",
-          knownToBePublicSource: e.knownToBePublicSource || !1,
-          waitId: "",
-          relatedSolutions: l.getProp(e, "properties.relatedSolutions") || [],
-          owner: e.owner
-        };
-        return a.deployCommonId !== "" && a.deployVersion !== "" ? a : null;
-      }
-    ).filter((e) => e != null) : [];
-  }
-  /**
-   * Merge a set of search responses into a single response item.
-   *
-   * @param responseSet Array of search results
-   * @returns A response item that takes its query from the first item in the set and sets the other properties
-   * as if all of the responses are the result of one, large query that's independent of AGO's 100-item limit.
-   */
-  mergeResponses(r) {
-    let t = 0;
-    r.forEach((e) => t += e.total);
-    let s = [];
-    return r.forEach((e) => s = s.concat(e.results)), {
-      query: r[0].query,
-      start: 1,
-      num: t,
-      nextStart: -1,
-      total: t,
-      results: s
-    };
-  }
-  /**
-   * Converts image preview information into a URL pointing to that image; returns non-image previews unchanged.
-   *
-   * @param id Item id to insert into URL
-   * @param preview List of previews to modify
-   * @returns Copy of previews with iamge previews modified
-   */
-  preparePreviewImageUrls(r, t, s) {
-    return t ? t.map(
-      (e) => (e.format === "image" && (e.name = s + "/sharing/rest/content/items/" + r + "/resources/" + e.name), e)
-    ) : [];
-  }
-}
-async function j(h, r, t, s, e = J, i = "created", c = "desc", a = !1, o = [], C = [], f, p, u) {
-  if (!h?.IsSignedIn)
+import "@esri/solution-common";
+import { g as p } from "./cardsHelpers.js";
+import { B as y } from "./interfaces.js";
+async function _(e, n, r, o, t = y, i = "created", s = "desc", a = !1, l = [], u = [], c, f, g) {
+  if (!e?.IsSignedIn)
     return;
-  const P = {
-    q: e,
+  const d = {
+    q: t,
     filter: "type:Solution",
     sortField: i,
-    sortOrder: c,
+    sortOrder: s,
     delay: a,
-    categories: o,
+    categories: l,
     num: 100
   };
-  return P.q += k(h, p), await x(
-    r,
-    P,
-    s,
-    C,
+  return d.q += S(e, f), await m(
+    n,
+    d,
+    o,
     u,
-    f
+    g,
+    c
   );
 }
-function k(h, r) {
-  let t = "";
-  const s = h.PortalUserOrg, e = h.PortalUserName;
-  return s && (t += " orgid:" + s), r !== "My organization's solutions" && e && (t += " owner:" + e), t;
+function S(e, n) {
+  let r = "";
+  const o = e.PortalUserOrg, t = e.PortalUserName;
+  return o && (r += " orgid:" + o), n !== "My organization's solutions" && t && (r += " owner:" + t), r;
 }
-async function x(h, r, t, s, e = "", i) {
-  const c = await t.requestDeployedSolutionCards(r, h, e, i), a = I(c.cards, s);
+async function m(e, n, r, o, t = "", i) {
+  const s = await r.requestDeployedSolutionCards(n, e, t, i), a = p(s.cards, o);
   return {
-    cards: c.cards,
+    cards: s.cards,
     relatedSolutions: a
   };
 }
 export {
-  _ as C,
-  j as g
+  _ as g
 };

package/dist/chunks/cardsHelpers.js

@@ -1,13 +1,13 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
 import "@esri/solution-common";
-import { z as a } from "./helpers.js";
-function p(o, t) {
+import { g as a } from "./helpers.js";
+function g(o, t) {
   const n = [];
   return o.forEach((e) => {
     t.has(e.id) && n.push(e);
   }), n;
 }
-function y(o, t, n) {
+function p(o, t, n) {
   if (t < 1 || o.length < t)
     return {
       cards: [],
@@ -29,7 +29,7 @@ function y(o, t, n) {
     }
   };
 }
-function g(o, t) {
+function y(o, t) {
   const n = c(o);
   return d(n, t);
 }
@@ -96,13 +96,13 @@ function b(o, t) {
   return u(n.title);
 }
 export {
-  b as a,
-  g as b,
-  u as c,
-  p as d,
-  y as e,
-  I as f,
-  m as g,
+  I as a,
+  m as b,
+  g as c,
+  u as d,
+  p as e,
+  b as f,
+  y as g,
   h,
   w as s
 };