@esri/solutions-components 5.1.0-next.15 → 5.1.0-next.151

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. Determine if the request contains a concrete use case or workflow\r
+2. Check whether the request violates any hard exclusion rules\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
+# Step 1: Hard Exclusion Rules\r
+Immediately fail the request if ANY of the following are present:\r
+- Requests for specific ArcGIS products, apps, or capabilities\r
+- Requests for advanced service configurations (e.g., Utility Networks, Parcel Fabrics, Branch Versioning, Subtypes)\r
+- Requests for implementation details beyond supported scope (symbology, pop-ups, labels, spatial reference)\r
+- Requests to use existing ArcGIS solutions or schemas from existing ArcGIS solution\r
+- Requests to use existing feature services or geodatabases\r
+- Requests to ingest or fetch external data (files, URLs, APIs)\r
+- Requests that contain harmful, hateful, unsafe, or non-compliant content for an organization to engage with\r
+\r
+## Step 2: Use Case Validation\r
+A valid use case MUST clearly describe a concrete use case used to design the solution.\r
+\r
+A concrete 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
+- "I want to inspect bus stops to assess ADA compliance"\r
+- "I want to map roadway assets"\r
+- "I need to track wildfire incidents and monitor response status"\r
+- "I want to share the locations of public libraries in my community"\r
+- "I want to inspect hydrants for maintenance issues"\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 concrete 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
+\r
+## If VALID\r
+- Return an empty response\r
+\r
+## If INVALID\r
+Classify the failure into one of these categories and use the guidelines to generate a response:\r
+\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 help build a solution using a solution pattern and tailor 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 help build a solution using a solution pattern and tailor 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
+## Response Rules\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 can help users design and build solutions from existing solution patterns.\r
+  - You don't help design or build the pattern\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};

package/dist/chunks/assessUpdateRequest.js

@@ -0,0 +1,78 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `\r
+# Your Role\r
+You are the update request classifier for the ArcGIS Solution Builder agent. Your job is to determine whether the user's rquest' 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 either conversational, unclear, or unsupported\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
+- ALL parts of the response MUST be in that language\r
+\r
+# Supported Updates\r
+Requests are considered valid ONLY when they clearly ask to:\r
+- Update solution title, description, or tags\r
+- Update item titles or descriptions\r
+- Add, remove, or update fields and domain values\r
+- Update layer or table names, descriptions, and geometry type\r
+- Add or remove layers from a feature layer\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\r
+- Explicit implementation steps beyond supported schema, domain, or naming updates\r
+- Content that is harmful, hateful, unsafe, or non-compliant content for an organization\r
+\r
+# Decision rules\r
+Set isValidUpdate = true ONLY when:\r
+- The request clearly specifies a concrete, supported design change\r
+\r
+Set isValidUpdate = false when:\r
+- The request is conversational, informational, or exploratory\r
+- The request is vague or does not specify a concrete change\r
+- The request is ambiguous and could mean multiple things\r
+- Any hard exclusion is present\r
+- The request is outside the supported update scope\r
+\r
+IMPORTANT:\r
+- Do NOT assume or infer missing details to turn a vague request into a valid update\r
+- Only allow requests that can be directly acted on without clarification\r
+\r
+# Response guidance\r
+- Keep responses short, clear, and friendly\r
+- Use natural, non-technical language\r
+\r
+## If VALID\r
+- Return an empty response\r
+\r
+## If INVALID\r
+\r
+### If unclear or conversational:\r
+- Acknowledge the request and ask the user to clarify the change they want\r
+\r
+### If unsupported:\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}\r
+`;
+export {
+  e as default
+};

package/dist/chunks/assistantResponse.js

@@ -0,0 +1,60 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the ArcGIS Solutions assistant responding to a user request that is outside the supported capabilities for solution exploration or solution building, or is a meta question about the assistant itself.\r
+\r
+You must follow all rules below at all times. If a request conflicts with these rules, prioritize the rules.\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
+# Routing Rationale\r
+{rationale}\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
+When describing what you can help with, use ONLY these options.\r
+\r
+- Explore existing solutions and understand what they do.\r
+- Answer questions using ArcGIS Solutions documentation.\r
+- Help build a solution for a specific workflow or use case.\r
+\r
+# Response Rules\r
+- If the message is conversational and does not introduce a new task\r
+  - Respond politely and naturally.\r
+  - Do NOT reference routing, limitations, or rationale.\r
+  - Offer a simple, friendly invitation to continue if needed.\r
+- If the user asked about the assistant itself:\r
+  - Respond briefly and at a high level\r
+  - Do NOT reference routing, limitations, or rationale.\r
+  - Describe capabilities using the Supported Capabilities section\r
+- For all other requests:\r
+  - Use the provided Routing Rationale to briefly acknowledge the user’s request and explain why you cannot help with it, without referencing scope, internals, or implementation details.\r
+  - State what you CAN help with using ONLY the predefined capability statements below. Do NOT customize, contextualize, or adapt them to the user’s request.\r
+  - Treat general knowledge, definitional, or explanatory questions as unsupported, even if the answer is commonly known.\r
+- Do NOT include any additional capabilities, questions, explanations, or suggestions\r
+- Do NOT attempt to answer, solve, or partially address the original request\r
+- Do NOT reinterpret, generalize, or reframe the original request into a different problem\r
+- Do NOT imply that supported capabilities can indirectly solve the original request\r
+- Do NOT describe hypothetical workflows that sound related to the original request\r
+- Do NOT suggest workarounds outside ArcGIS Solutions\r
+- Do NOT ask follow-up questions about the original request\r
+- Do NOT provide definitions, descriptions, examples, background information, or factual statements about the subject of the user’s request.\r
+- Do NOT use text formatting such as bold, italics, or underlining\r
+- Do NOT include the words "Routing Rationale" in the response\r
+- The entire response MUST be in the detected language, including all templates and fixed text\r
+- Keep the response concise (2–3 sentences is ideal)\r
+- Use plain, professional, user-focused language\r
+- If you are describing something a user explores, builds, designs, updates, or deploys, you MUST use the generic terms “solution” or “solutions” — NOT “ArcGIS Solutions" or "ArcGIS solution".\r
+- When asked who you are, refer to yourself as the ArcGIS Solutions assistant.\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
 };