@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{packager-tool-nj4seavy.js → packager-tool-35c9npcy.js}

@@ -4,31 +4,46 @@ var VALID_TASK_ENTRY_RULE_TYPES = [
   "selected-tasks-completed",
   "wait-for-connector",
   "adhoc",
-  "runs-sequentially"
+  "runs-sequentially",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_STAGE_ENTRY_RULE_TYPES = [
   "case-entered",
   "selected-stage-exited",
   "selected-stage-completed",
   "wait-for-connector",
-  "user-selected-stage"
+  "user-selected-stage",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_STAGE_COMPLETION_RULE_TYPES = [
   "required-tasks-completed",
-  "wait-for-connector"
+  "selected-tasks-completed",
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_STAGE_EXIT_RULE_TYPES = [
   "selected-tasks-completed",
-  "wait-for-connector"
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_CASE_COMPLETION_RULE_TYPES = [
   "required-stages-completed",
-  "wait-for-connector"
+  "selected-stage-exited",
+  "selected-stage-completed",
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_CASE_EXIT_RULE_TYPES = [
   "selected-stage-completed",
   "selected-stage-exited",
-  "wait-for-connector"
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 function buildRule(options) {
   const {
@@ -88,6 +103,10 @@ function buildRule(options) {
       return { rule: "user-selected-stage", id, conditionExpression };
     case "runs-sequentially":
       return { rule: "runs-sequentially", id, conditionExpression };
+    case "sla-status-change":
+      return { rule: "sla-status-change", id, conditionExpression };
+    case "api-event":
+      return { rule: "api-event", id, conditionExpression };
   }
 }
 function isStageNode(node) {
@@ -174,4 +193,4 @@ function remapBindingRefs(value, idRemap) {
 
 export { VALID_TASK_ENTRY_RULE_TYPES, VALID_STAGE_ENTRY_RULE_TYPES, VALID_STAGE_COMPLETION_RULE_TYPES, VALID_STAGE_EXIT_RULE_TYPES, VALID_CASE_COMPLETION_RULE_TYPES, VALID_CASE_EXIT_RULE_TYPES, buildRule, isStageNode, requireStageNode, requireTask, DEFAULT_TRIGGER_ID, DEFAULT_TRIGGER_LABEL, isAnyTriggerNode, findTriggerNodes, ensureRootBindings, findOrPushBinding, remapBindingRefs };
 
-//# debugId=E05AE20CC4D952F964756E2164756E21
+//# debugId=A877E69BF91D62B264756E2164756E21

package/dist/{packager-tool-r0x3qh59.js → packager-tool-388vyja1.js}

@@ -1,9 +1,185 @@
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  CASE_APP_VERSIONS_WITH_ROLES,
+  roleActionKeyOf,
+  caseStageLabels,
+  roleResourceKey,
+  CASE_ROLE_FIELDS,
+  caseRoleEntries,
+  readCaseRole,
+  readCaseRoles
+} from "./packager-tool-1wgav5ma.js";
 import {
-  __require
-} from "./packager-tool-1yh8g550.js";
+  resolvePersonas
+} from "./packager-tool-yh8mmj3p.js";
+import {
+  withoutTrailingSlug
+} from "./packager-tool-fcektt1g.js";
+import {
+  indexKey
+} from "./packager-tool-5w0gjcck.js";
+import {
+  prefixedId
+} from "./packager-tool-1h7abxw6.js";
+
+// src/services/sdd-convert/case-roles.ts
+var caseRolesFor = (model, index, unresolved) => {
+  for (const note of model.personaNotes ?? []) {
+    unresolved.push({
+      kind: "case-role",
+      where: "metadata.caseRoles",
+      detail: note
+    });
+  }
+  if (model.personas.length === 0)
+    return [];
+  const { roles, problems } = resolvePersonas(model.personas, (name) => index.stageIds.get(indexKey(withoutTrailingSlug(name))));
+  for (const problem of problems) {
+    unresolved.push({
+      kind: "case-role",
+      where: `metadata.caseRoles[${problem.persona}]`,
+      detail: problem.detail
+    });
+  }
+  return roles.map((role) => ({
+    id: prefixedId("role-", 10),
+    name: role.name,
+    description: role.description,
+    actions: role.actions,
+    scope: role.scope,
+    ...role.scope === "stages" && { stageIds: role.stageIds }
+  }));
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sameSet = (a, b) => a.length === b.length && new Set(a.map((x) => x.toLowerCase())).size === new Set([...a, ...b].map((x) => x.toLowerCase())).size;
+var describeRole = (role, stageLabels) => {
+  const keys = role.actions.map((action) => roleActionKeyOf(action) ?? action);
+  const grants = keys.length > 0 ? keys.join(", ") : "nothing";
+  const where = role.scope === "stages" ? stageLabels.length > 0 ? ` on ${stageLabels.map((label) => `"${label}"`).join(", ")}` : " on no stage this plan has" : "";
+  const description = role.description?.trim();
+  return `${role.scope} scope granting ${grants}${where}${description ? `, "${description}"` : ""}`;
+};
+var carryCaseRoles = (document, previous, unresolved, declaredNames = []) => {
+  if (!isRecord(document) || !isRecord(previous))
+    return 0;
+  const previousMetadata = isRecord(previous.metadata) ? previous.metadata : {};
+  const entries = previousEntries(previous, unresolved);
+  const previousVersion = asString(previousMetadata.caseAppVersion);
+  if (entries.length === 0 && previousVersion === undefined)
+    return 0;
+  const metadata = isRecord(document.metadata) ? document.metadata : {};
+  const stages = {
+    before: caseStageLabels(previous.nodes),
+    now: caseStageLabels(document.nodes)
+  };
+  const { roles, matched } = matchDeclaredRoles(readCaseRoles(document), entries, stages, unresolved);
+  const undeclared = entries.filter((entry) => !matched.has(entry));
+  const declared = new Set(declaredNames.map(roleResourceKey));
+  const carried = carryUndeclaredRoles(undeclared, stages, declared, unresolved);
+  roles.push(...carried);
+  const versions = caseAppVersions(previousMetadata, metadata, roles.length > 0);
+  if (versions.version !== undefined && roles.length > 0 && !CASE_APP_VERSIONS_WITH_ROLES.includes(versions.version)) {
+    unresolved.push({
+      kind: "case-role",
+      where: "metadata.caseAppVersion",
+      detail: `the plan runs the "${versions.version}" case app, which has no roles, so the ${roles.length} role(s) written are not honoured until the case is moved to the V2 app in the Case Designer. Kept as the plan had it`
+    });
+  }
+  const {
+    caseRoles: _roles,
+    caseAppVersion: _version,
+    caseAppCreatedVersion: _created,
+    ...rest
+  } = metadata;
+  document.metadata = {
+    ...rest,
+    ...versions.version !== undefined && {
+      caseAppVersion: versions.version
+    },
+    ...versions.createdVersion !== undefined && {
+      caseAppCreatedVersion: versions.createdVersion
+    },
+    ...roles.length > 0 && { caseRoles: roles }
+  };
+  return carried.length;
+};
+var asString = (value) => typeof value === "string" ? value : undefined;
+var roleItem = (name, detail) => ({
+  kind: "case-role",
+  where: `metadata.caseRoles[${name}]`,
+  detail
+});
+var previousEntries = (previous, unresolved) => caseRoleEntries(previous).flatMap((entry, at) => {
+  const role = readCaseRole(entry);
+  if (role === undefined) {
+    const name = isRecord(entry) && typeof entry.name === "string" && entry.name.trim() !== "" ? `"${entry.name}"` : `entry ${at + 1}`;
+    unresolved.push({
+      kind: "case-role",
+      where: `metadata.caseRoles[${at}]`,
+      detail: `the plan's role ${name} is not carried: it has no name, no scope or no actions list, so the schema does not read it as a role`
+    });
+    return [];
+  }
+  const extras = Object.fromEntries(Object.entries(entry).filter(([key]) => !CASE_ROLE_FIELDS.includes(key)));
+  return [{ role, extras }];
+});
+var labelsOf = (role, from) => (role.stageIds ?? []).flatMap((stageId) => {
+  const label = from.get(stageId);
+  return label === undefined ? [] : [label];
+});
+var sameRole = (before, role, beforeLabels, nowLabels) => before.scope === role.scope && sameSet(before.actions, role.actions) && sameSet(beforeLabels, nowLabels) && (before.description?.trim() ?? "") === (role.description?.trim() ?? "");
+var matchDeclaredRoles = (declared, entries, stages, unresolved) => {
+  const roles = [];
+  const matched = new Set;
+  for (const role of declared) {
+    const entry = entries.find((candidate) => !matched.has(candidate) && roleResourceKey(candidate.role.name) === roleResourceKey(role.name));
+    if (entry === undefined) {
+      roles.push(role);
+      continue;
+    }
+    matched.add(entry);
+    const { role: before, extras } = entry;
+    const beforeLabels = labelsOf(before, stages.before);
+    const nowLabels = labelsOf(role, stages.now);
+    if (!sameRole(before, role, beforeLabels, nowLabels)) {
+      unresolved.push(roleItem(role.name, `the plan had this role as ${describeRole(before, beforeLabels)}; the Personas row writes it as ${describeRole(role, nowLabels)}. The row is written. If the plan's was the one meant, edit the row`));
+    }
+    roles.push({
+      ...extras,
+      ...role,
+      id: before.id,
+      ...before.isDefault !== undefined && {
+        isDefault: before.isDefault
+      }
+    });
+  }
+  return { roles, matched };
+};
+var carryUndeclaredRoles = (undeclared, stages, declared, unresolved) => {
+  const idByLabel = new Map([...stages.now].map(([id, label]) => [label.toLowerCase(), id]));
+  return undeclared.flatMap(({ role: before, extras }) => {
+    const labels = labelsOf(before, stages.before);
+    const kept = labels.filter((label) => idByLabel.has(label.toLowerCase()));
+    if (before.scope === "stages" && kept.length === 0) {
+      unresolved.push(roleItem(before.name, `the plan's role is not carried: none of its stages${labels.length > 0 ? ` (${labels.map((label) => `"${label}"`).join(", ")})` : ""} is in this plan, so it could apply to nothing. Add it back in the Case Designer if it is still wanted`));
+      return [];
+    }
+    const role = {
+      ...extras,
+      ...before,
+      ...before.scope === "stages" && {
+        stageIds: kept.map((label) => idByLabel.get(label.toLowerCase()))
+      }
+    };
+    unresolved.push(roleItem(before.name, declared.has(roleResourceKey(before.name)) ? `kept from the plan as it was, ${describeRole(role, kept)}: its Personas row could not become a role (see the other items for it)` : `kept from the plan, which the Personas table does not declare: ${describeRole(role, kept)}. Add a row for it, or remove the role in the Case Designer`));
+    return [role];
+  });
+};
+var caseAppVersions = (previousMetadata, metadata, hasRoles) => {
+  const previousVersion = asString(previousMetadata.caseAppVersion);
+  const version = previousVersion ?? asString(metadata.caseAppVersion) ?? (hasRoles ? "v2" : undefined);
+  const createdVersion = previousVersion !== undefined ? asString(previousMetadata.caseAppCreatedVersion) : asString(previousMetadata.caseAppCreatedVersion) ?? asString(metadata.caseAppCreatedVersion) ?? (version !== undefined ? "v2" : undefined);
+  return { version, createdVersion };
+};
 
 // src/services/sdd-convert/canvas-note-match.ts
 var SIMILAR = 0.5;
@@ -30,9 +206,9 @@ var similarity = (a, b) => {
 var commonRun = (a, b) => {
   const length = a.map(() => new Array(b.length + 1).fill(0));
   length.push(new Array(b.length + 1).fill(0));
-  for (let i2 = a.length - 1;i2 >= 0; i2 -= 1)
-    for (let j2 = b.length - 1;j2 >= 0; j2 -= 1)
-      length[i2][j2] = a[i2] === b[j2] ? length[i2 + 1][j2 + 1] + 1 : Math.max(length[i2 + 1][j2], length[i2][j2 + 1]);
+  for (let i = a.length - 1;i >= 0; i -= 1)
+    for (let j = b.length - 1;j >= 0; j -= 1)
+      length[i][j] = a[i] === b[j] ? length[i + 1][j + 1] + 1 : Math.max(length[i + 1][j], length[i][j + 1]);
   const pairs = [];
   let i = 0;
   let j = 0;
@@ -281,27 +457,7 @@ var colorText = (note) => {
   const color = dataOf(note).color;
   return typeof color === "string" ? ` (${color})` : ` (${DEFAULT_COLOR}, the default)`;
 };
-var carryCanvasNotesFrom = async (document, out, unresolved) => {
-  const { getFileSystemAsync } = await import("./index-ngs0a2he.js");
-  const fs = await getFileSystemAsync();
-  if (!await fs.exists(out))
-    return 0;
-  const [readError, text] = await catchError(fs.readFile(out, "utf-8"));
-  if (readError || typeof text !== "string")
-    return {
-      error: `Could not read the plan at ${out} to keep its sticky notes: ${readError?.message ?? "it read as empty"}`
-    };
-  if (text.trim() === "")
-    return 0;
-  const json = text.replace(/^\uFEFF/, "");
-  const [parseError, previous] = await catchError(Promise.resolve().then(() => JSON.parse(json)));
-  if (parseError)
-    return {
-      error: `The plan at ${out} is not valid JSON, so its sticky notes cannot be kept: ${parseError.message}`
-    };
-  return carryCanvasNotes(document, previous, unresolved);
-};
 
-export { STICKY_NOTE_TYPE, sddNoteId, emitCanvasNotes, carryCanvasNotes, carryCanvasNotesFrom };
+export { caseRolesFor, carryCaseRoles, emitCanvasNotes, carryCanvasNotes };
 
-//# debugId=FDBC5FC638B6E79B64756E2164756E21
+//# debugId=114C68FEC6CAE42B64756E2164756E21

package/dist/packager-tool-3m8482sw.js

@@ -0,0 +1,78 @@
+import {
+  getAuthContext2
+} from "./packager-tool-dn9d4ywm.js";
+import {
+  logger
+} from "./packager-tool-psmb758n.js";
+
+// ../maestro-sdk/src/studio-catalog.ts
+var catalogPromises = new Map;
+async function typeCacheGet(route, query, what) {
+  const auth = await getAuthContext2({
+    requireOrganizationId: true,
+    requireTenantId: true
+  });
+  const url = `${auth.baseUrl}/${encodeURIComponent(auth.organizationId)}/studio_/typecache/api/${route}?${query}`;
+  logger.debug(`Fetching Studio TypeCache with URL: ${url}`);
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${auth.accessToken}`,
+      "Content-Type": "application/json",
+      "X-Uipath-Tenantid": auth.tenantId,
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.debug(`Error response body: ${errorText}`);
+    throw new Error(`${what} failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  return await response.json();
+}
+function hasCatalogLists(data) {
+  return Array.isArray(data.activities) && Array.isArray(data.triggers);
+}
+async function fetchSearchCatalog(projectType) {
+  const data = await typeCacheGet("Search/Catalog", new URLSearchParams({
+    useLucene: "false",
+    useElastic: "true",
+    projectType
+  }), "catalog search");
+  if (!hasCatalogLists(data)) {
+    throw new Error(`catalog search returned unexpected shape: ${JSON.stringify(data).slice(0, 200)}`);
+  }
+  const packages = Array.isArray(data.packages) ? data.packages : [];
+  const activities = data.activities;
+  const triggers = data.triggers;
+  logger.debug(`Received ${projectType} catalog: ${activities.length} activities, ${triggers.length} triggers, ${packages.length} packages`);
+  return {
+    packages,
+    activities,
+    triggers
+  };
+}
+async function searchCatalog(projectType) {
+  let promise = catalogPromises.get(projectType);
+  if (!promise) {
+    promise = fetchSearchCatalog(projectType);
+    catalogPromises.set(projectType, promise);
+    promise.catch(() => {
+      catalogPromises.delete(projectType);
+    });
+  }
+  return promise;
+}
+async function searchActivities(projectType = "ProcessOrchestration") {
+  return (await searchCatalog(projectType)).activities;
+}
+async function searchTriggers(projectType = "ProcessOrchestration") {
+  return (await searchCatalog(projectType)).triggers;
+}
+async function searchPackages(projectType = "ProcessOrchestration") {
+  return (await searchCatalog(projectType)).packages;
+}
+
+export { searchActivities, searchTriggers, searchPackages };
+
+//# debugId=7B94294781FD29F064756E2164756E21