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

package/dist/packager-tool-1nfdj0zm.js

@@ -0,0 +1,425 @@
+import {
+  norm,
+  stripTicks
+} from "./packager-tool-fcektt1g.js";
+import {
+  isExpressionNamespace
+} from "./packager-tool-mk9fmzdy.js";
+import {
+  outputSourceFor
+} from "./packager-tool-0w4fsdzv.js";
+import {
+  stageSpellings,
+  indexKey,
+  modelKey,
+  dedupedId,
+  exactKey,
+  lookupOutput
+} from "./packager-tool-5w0gjcck.js";
+
+// src/services/sdd-convert/xrefs.ts
+var QUOTED = String.raw`(?:'((?:\\.|[^'\\])*)'|"((?:\\.|[^"\\])*)"|` + "`((?:\\\\.|[^`\\\\])*)`" + String.raw`|\u201c([^\u201d]*)\u201d)`;
+var XREF_CALL = new RegExp(String.raw`vars\.\$xref\(\s*${QUOTED}\s*,\s*${QUOTED}\s*,\s*${QUOTED}\s*\)`, "g");
+var argumentOf = (groups) => groups.find((value) => value !== undefined) ?? "";
+var unresolvedXrefDetail = (whole, found) => {
+  if (found === undefined) {
+    return `\`${whole}\` names an output this SDD does not declare, so the marker is left in place rather than pointed at a guess`;
+  }
+  const spellings = new Set(found.names);
+  const listed = [...spellings].map((name) => `\`${name}\``).join(", ");
+  if (spellings.size < found.names.length) {
+    return `\`${whole}\` names a task that ${found.names.length} tasks in that stage answer to (${listed}), so the marker is left in place rather than pointed at one of them. Task names are unique across the case, so rename all but one`;
+  }
+  return `\`${whole}\` names its task in a spelling that ${found.names.length} tasks answer to (${listed}), so the marker is left in place rather than pointed at one of them — write the task's name as its heading spells it`;
+};
+var DOTTED_READ = /^\.[A-Za-z_$]/;
+var deferredOutputs = new WeakMap;
+var markDeferredOutputs = (index, ids) => {
+  deferredOutputs.set(index, ids);
+};
+var expandXrefs = (text, context) => text.replace(XREF_CALL, (whole, ...rest) => {
+  const offset = rest[rest.length - 2];
+  const captured = rest.slice(0, -2);
+  const stage = argumentOf(captured.slice(0, 4));
+  const task = argumentOf(captured.slice(4, 8));
+  const output = argumentOf(captured.slice(8, 12));
+  const found = lookupOutput(context.outputs, `${indexKey(stage)}|${indexKey(task)}|${indexKey(output)}`, task);
+  if (found !== undefined && "id" in found) {
+    if (deferredOutputs.get(context.outputs)?.has(found.id)) {
+      context.unresolved.push({
+        kind: "placeholder",
+        where: context.where,
+        detail: `\`${whole}\` reads an output of a task the resolved file defers, so \`vars.${found.id}\` resolves to nothing until that task is filled`
+      });
+    }
+    const after = text.slice(offset + whole.length);
+    return DOTTED_READ.test(after) ? `vars.${found.id}?` : `vars.${found.id}`;
+  }
+  context.unresolved.push({
+    kind: "producer-reference",
+    where: context.where,
+    detail: unresolvedXrefDetail(whole, found)
+  });
+  return whole;
+});
+var expandOutputMarkers = (output, context) => {
+  const expand = (value) => typeof value === "string" && value.includes("$xref") ? expandXrefs(value, context) : value;
+  const value = expand(output.value);
+  const source = expand(output.source);
+  return value === output.value && source === output.source ? output : { ...output, value, source };
+};
+
+// src/services/sdd-condition-cell.ts
+var STAGE_SELECTOR_RULES = new Set([
+  "selected-stage-completed",
+  "selected-stage-exited"
+]);
+var TASK_SELECTOR_RULES = new Set(["selected-tasks-completed"]);
+var IF_PARTS = new Map([
+  ["conditionexpression", "expression"],
+  ["selected tasks", "tasks"],
+  ["selected task", "tasks"],
+  ["selected stage", "stage"],
+  ["selected stages", "stage"]
+]);
+var splitIfParts = (text) => {
+  const pieces = [];
+  let current = "";
+  let quote;
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (quote !== undefined) {
+      current += char;
+      if (char === "\\") {
+        current += text[index + 1] ?? "";
+        index += 1;
+      } else if (char === quote)
+        quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char !== ";") {
+      current += char;
+      continue;
+    }
+    pieces.push(current);
+    current = "";
+  }
+  pieces.push(current);
+  return pieces;
+};
+var parseIfCell = (cell) => {
+  const text = cell.trim();
+  const found = {
+    expression: ""
+  };
+  const parts = [];
+  let structured = false;
+  const partKey = (text2) => text2.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  for (const piece of splitIfParts(text)) {
+    const at = piece.indexOf(":");
+    const key = at === -1 ? "" : partKey(piece.slice(0, at));
+    const slot = IF_PARTS.get(key);
+    if (slot === undefined) {
+      parts.push(piece);
+      continue;
+    }
+    structured = true;
+    const value = piece.slice(at + 1).trim();
+    if (slot === "expression")
+      found.expression = value;
+    else if (slot === "tasks")
+      found.tasks = value;
+    else
+      found.stage = value;
+  }
+  if (!structured)
+    return { expression: text };
+  return found;
+};
+
+// src/services/output-types.ts
+var OUTPUT_TYPE_LITERALS = new Map([
+  ["string", "string"],
+  ["date", "string"],
+  ["datetime", "string"],
+  ["time", "string"],
+  ["number", "number"],
+  ["float", "number"],
+  ["double", "number"],
+  ["integer", "integer"],
+  ["int", "integer"],
+  ["boolean", "boolean"],
+  ["bool", "boolean"],
+  ["file", "file"],
+  ["any", "any"],
+  ["object", "jsonSchema"],
+  ["array", "jsonSchema"],
+  ["json", "jsonSchema"],
+  ["jsonschema", "jsonSchema"],
+  ["dictionary", "jsonSchema"]
+]);
+var outputTypeKey = (text) => norm(text).replaceAll(" ", "");
+var outputTypeCell = (cell) => {
+  const text = typeof cell === "string" ? stripTicks(cell) : "";
+  if (text === "")
+    return {};
+  const type = OUTPUT_TYPE_LITERALS.get(outputTypeKey(text));
+  return type === undefined ? { unmapped: text } : { type };
+};
+var OUTPUT_TYPE_NAMES = [...new Set(OUTPUT_TYPE_LITERALS.values())];
+
+// src/services/sdd-convert/io.ts
+var taskMatcher = (model, taskName) => {
+  const mine = exactKey(taskName);
+  const folded = indexKey(taskName);
+  const filed = modelKey(taskName);
+  let unique = true;
+  let filedUnique = true;
+  for (const stage of model.stages) {
+    for (const other of stage.tasks) {
+      const name = exactKey(String(other.name ?? ""));
+      if (name === mine)
+        continue;
+      if (indexKey(name) === folded)
+        unique = false;
+      if (modelKey(name) === filed)
+        filedUnique = false;
+    }
+  }
+  return {
+    names: (spelled) => exactKey(spelled) === mine || unique && indexKey(spelled) === folded,
+    unique,
+    filedUnique
+  };
+};
+var declaredOutputs = (model, stageName, position, task) => {
+  const taskName = String(task.name ?? "");
+  const { names: own, slug, ordinal } = stageSpellings(stageName, position);
+  const names = [...own, ...slug === undefined ? [] : [slug], ordinal].map(indexKey);
+  const matcher = taskMatcher(model, taskName);
+  const mine = (producer) => names.includes(indexKey(producer.stage)) && matcher.names(producer.task);
+  const rows = (task.outputRows ?? []).map((row) => ({ row, aliases: [] }));
+  const sameOutput = (a, b) => indexKey(a) === indexKey(b) || (!a.includes(".") || !b.includes(".")) && indexKey(emittedName(a)) === indexKey(emittedName(b));
+  const dotted = (one) => [one.row, ...one.aliases].find((spelling) => spelling.includes("."));
+  const takes = (one, name) => {
+    if (!sameOutput(one.row, name))
+      return false;
+    if (!name.includes("."))
+      return true;
+    const held = dotted(one);
+    return held === undefined || indexKey(held) === indexKey(name);
+  };
+  const add = (name) => {
+    if (name === "")
+      return;
+    const found = rows.find((one) => takes(one, name));
+    if (found === undefined)
+      rows.push({ row: name, aliases: [] });
+    else if (found.row !== name && !found.aliases.includes(name)) {
+      found.aliases.push(name);
+    }
+  };
+  if (matcher.filedUnique) {
+    for (const name of model.resourceOutputs[modelKey(taskName)] ?? []) {
+      add(name);
+    }
+  }
+  for (const producer of model.xrefOutputs) {
+    if (mine(producer))
+      add(producer.output);
+  }
+  for (const stage of model.stages) {
+    for (const other of stage.tasks) {
+      for (const row of other.producerInputs ?? []) {
+        const producer = row.producer;
+        if (producer !== undefined && mine(producer)) {
+          add(producer.output);
+        }
+      }
+    }
+  }
+  return rows;
+};
+var emittedName = (row) => row.split(".").at(-1) ?? row;
+var OUTPUT_TYPES = new Map([
+  ["string", "string"],
+  ["object", "jsonSchema"],
+  ["json", "jsonSchema"],
+  ["jsonschema", "jsonSchema"],
+  ["array", "jsonSchema"]
+]);
+var readsOutput = (reference, row) => indexKey(reference) === indexKey(row) || !reference.includes(".") && indexKey(reference) === indexKey(emittedName(row));
+var outputTypeFor = (model, stageNames, taskName, output) => {
+  const matcher = taskMatcher(model, taskName);
+  for (const stage of model.stages) {
+    for (const task of stage.tasks) {
+      for (const row of task.producerInputs ?? []) {
+        const producer = row.producer;
+        if (producer === undefined || row.direct !== true || typeof row.type !== "string" || !stageNames.includes(indexKey(producer.stage)) || !matcher.names(producer.task) || !readsOutput(producer.output, output)) {
+          continue;
+        }
+        const mapped = OUTPUT_TYPES.get(row.type.trim().toLowerCase().replaceAll(" ", ""));
+        if (mapped !== undefined)
+          return mapped;
+      }
+    }
+  }
+  return;
+};
+var outputIdentity = (leaf, taken) => {
+  const base = leaf === "" ? leaf : `${leaf[0].toLowerCase()}${leaf.slice(1)}`;
+  if (!isExpressionNamespace(base)) {
+    return { id: dedupedId(base, taken), name: leaf };
+  }
+  const id = dedupedId(base, new Set([...taken, base]));
+  taken.add(id);
+  return { id, name: id };
+};
+var outputFor = (row, elementId, taken, type, taskType) => {
+  const leaf = row.split(".").at(-1) ?? row;
+  const { id, name } = outputIdentity(leaf, taken);
+  return {
+    name,
+    ...type !== undefined && { type },
+    id,
+    var: id,
+    value: id,
+    source: outputSourceFor(taskType, row),
+    target: `=${id}`,
+    elementId
+  };
+};
+var variableOutputType = (model, variable) => {
+  const declared = model.variableTypes[modelKey(variable)];
+  if (typeof declared !== "string" || declared.trim() === "") {
+    return;
+  }
+  const key = declared.trim().toLowerCase().replaceAll(" ", "");
+  return OUTPUT_TYPES.get(key) ?? "string";
+};
+var rowOutputType = (cell) => outputTypeCell(cell);
+var unmappedOutputType = (where, cell, fallback) => ({
+  kind: "output-type",
+  where,
+  detail: `the SDD row types this output "${cell}", which names no output type the Case Designer writes (${OUTPUT_TYPE_NAMES.join(", ")}), so ${fallback === undefined ? "the output has no type" : `the output falls back to "${fallback}"`}; correct the row's Type cell to the resource's output-schema type`
+});
+var extractOutputFor = (row, elementId, taken, type, taskType) => {
+  const leaf = row.field.split(".").at(-1) ?? row.field;
+  const { id, name } = outputIdentity(leaf, taken);
+  return {
+    name,
+    ...type !== undefined && { type },
+    id,
+    var: row.variable,
+    value: row.variable,
+    source: outputSourceFor(taskType, row.field),
+    target: `=${id}`,
+    originalVar: id,
+    elementId
+  };
+};
+var customOutputFor = (row, type) => ({
+  name: row.variable,
+  ...type !== undefined && { type },
+  custom: true,
+  var: row.variable,
+  value: canonicalExpression(unquoteLiteral(row.expression)),
+  source: canonicalExpression(unquoteLiteral(row.expression)),
+  target: "",
+  body: "",
+  elementId: "root"
+});
+var canonicalExpression = (value) => value.startsWith("=metadata.") ? `=js:${value.slice(1)}` : value;
+var unquoteLiteral = (cell) => {
+  const text = cell.trim();
+  const quote = text[0];
+  if (quote !== '"' && quote !== "'")
+    return cell;
+  if (text.length < 2 || text[text.length - 1] !== quote)
+    return cell;
+  const inner = text.slice(1, -1);
+  for (let at = 0;at < inner.length; at += 1) {
+    if (inner[at] === "\\") {
+      at += 1;
+      continue;
+    }
+    if (inner[at] === quote)
+      return cell;
+  }
+  return inner.replaceAll(`\\${quote}`, quote);
+};
+var RANK_LITERAL = 1;
+var RANK_PRODUCER = 2;
+var RANK_EXPRESSION = 3;
+var unboundProducerDetail = (target, found) => {
+  if (found === undefined) {
+    return `the Inputs row reads an output (${target}) that no task in this SDD declares`;
+  }
+  const spellings = new Set(found.names);
+  const listed = [...spellings].map((task) => `"${task}"`).join(", ");
+  if (spellings.size < found.names.length) {
+    return `the Inputs row reads an output (${target}) of a task that ${found.names.length} tasks in that stage answer to (${listed}), so it is left unbound rather than pointed at one of them. Task names are unique across the case, so rename all but one`;
+  }
+  return `the Inputs row reads an output (${target}) whose task spelling ${found.names.length} tasks answer to (${listed}), so it is left unbound rather than pointed at one of them`;
+};
+var inputsFor = (task, elementId, where, unresolved, outputs) => {
+  const ranked = new Map;
+  const offer = (name, rank, input) => {
+    const existing = ranked.get(name);
+    if (existing === undefined || rank > existing.rank) {
+      ranked.set(name, { rank, input });
+    }
+  };
+  for (const row of task.literalInputs ?? []) {
+    offer(String(row.name ?? ""), RANK_LITERAL, {
+      name: String(row.name ?? ""),
+      value: unquoteLiteral(String(row.value ?? "")),
+      elementId
+    });
+  }
+  for (const row of task.expressionInputs ?? []) {
+    offer(String(row.name ?? ""), RANK_EXPRESSION, {
+      name: String(row.name ?? ""),
+      value: canonicalExpression(expandXrefs(String(row.expression ?? row.value ?? ""), {
+        outputs,
+        where,
+        unresolved
+      })),
+      elementId
+    });
+  }
+  for (const row of task.producerInputs ?? []) {
+    const name = String(row.name ?? "");
+    const producer = row.producer;
+    const found = producer === undefined ? undefined : lookupOutput(outputs, `${indexKey(producer.stage)}|${indexKey(producer.task)}|${indexKey(producer.output)}`, producer.task);
+    if (found === undefined || !("id" in found)) {
+      const target = producer === undefined ? "unnamed producer" : `"${producer.stage}"."${producer.task}".${producer.output}`;
+      unresolved.push({
+        kind: "producer-reference",
+        where: `${where}.inputs[${name}]`,
+        detail: unboundProducerDetail(target, found)
+      });
+      continue;
+    }
+    const id = found.id;
+    offer(name, RANK_PRODUCER, {
+      name,
+      value: row.direct === false ? expandXrefs(String(row.value ?? `=js:vars.${id}`), {
+        outputs,
+        where,
+        unresolved
+      }) : `=vars.${id}`,
+      elementId
+    });
+  }
+  return [...ranked.values()].map((entry) => entry.input);
+};
+
+export { STAGE_SELECTOR_RULES, TASK_SELECTOR_RULES, parseIfCell, outputTypeCell, markDeferredOutputs, expandXrefs, expandOutputMarkers, declaredOutputs, outputTypeFor, outputFor, variableOutputType, rowOutputType, unmappedOutputType, extractOutputFor, customOutputFor, canonicalExpression, unquoteLiteral, inputsFor };
+
+//# debugId=6333C5A436172EF864756E2164756E21

package/dist/packager-tool-1wgav5ma.js

@@ -0,0 +1,139 @@
+// ../packager/packager-tool-case/src/case-roles.ts
+var CASE_APP_ROLE_ACTIONS = {
+  View: "CaseManagement.Cases.View",
+  Create: "CaseManagement.Cases.Create",
+  Edit: "CaseManagement.Cases.Edit",
+  Close: "CaseManagement.Cases.Close",
+  Reopen: "CaseManagement.Cases.Reopen",
+  Assign: "CaseManagement.Cases.Assign",
+  ManageSLA: "CaseManagement.Cases.ManageSLA",
+  RunAdhocTasks: "CaseManagement.Cases.RunAdhocTasks",
+  SelectStage: "CaseManagement.Cases.SelectStage",
+  ViewSummary: "CaseManagement.Cases.ViewSummary",
+  LogsView: "Orchestrator.Logs.View",
+  TasksView: "Orchestrator.Tasks.View",
+  TasksCreate: "Orchestrator.Tasks.Create",
+  TasksEdit: "Orchestrator.Tasks.Edit",
+  TasksDelete: "Orchestrator.Tasks.Delete",
+  TaskAssignmentView: "Orchestrator.TaskAssignment.View",
+  TaskAssignmentCreate: "Orchestrator.TaskAssignment.Create",
+  TaskAssignmentEdit: "Orchestrator.TaskAssignment.Edit",
+  TaskAssignmentDelete: "Orchestrator.TaskAssignment.Delete",
+  TaskSelfAssignmentCreate: "Orchestrator.TaskSelfAssignment.Create",
+  TaskSelfAssignmentEdit: "Orchestrator.TaskSelfAssignment.Edit",
+  TaskSelfAssignmentDelete: "Orchestrator.TaskSelfAssignment.Delete"
+};
+var LEGACY_CASE_APP_ROLE_ACTIONS = [
+  "CaseManagement.Cases.Manage"
+];
+var CASE_APP_ROLE_ACTION_KEYS = Object.keys(CASE_APP_ROLE_ACTIONS);
+var STAGE_ALLOWED_ROLE_ACTION_KEYS = [
+  "View",
+  "Assign",
+  "ManageSLA",
+  "RunAdhocTasks"
+];
+var TENANT_GATED_ROLE_ACTIONS = [
+  { flag: "panel-enableCaseRoleAssign", keys: ["Assign"] },
+  {
+    flag: "panel-enableCaseRoleTaskPermissions",
+    keys: [
+      "TasksView",
+      "TasksCreate",
+      "TasksEdit",
+      "TasksDelete",
+      "TaskAssignmentView",
+      "TaskAssignmentCreate",
+      "TaskAssignmentEdit",
+      "TaskAssignmentDelete",
+      "TaskSelfAssignmentCreate",
+      "TaskSelfAssignmentEdit",
+      "TaskSelfAssignmentDelete"
+    ]
+  }
+];
+var roleActionGateOf = (key) => TENANT_GATED_ROLE_ACTIONS.find((gate) => gate.keys.includes(key))?.flag;
+var CASE_ROLE_NAME_MAX_LENGTH = 64;
+var CASE_ROLE_DESCRIPTION_MAX_LENGTH = 500;
+var CASE_ROLE_NAME_FORBIDDEN = /[<>"%;&']/;
+var CASE_APP_VERSIONS_WITH_ROLES = ["v2", "custom"];
+var ACTION_KEY_BY_LITERAL = new Map(CASE_APP_ROLE_ACTION_KEYS.map((key) => [CASE_APP_ROLE_ACTIONS[key], key]));
+var ACTION_KEY_BY_FOLDED = new Map(CASE_APP_ROLE_ACTION_KEYS.map((key) => [key.toLowerCase(), key]));
+var isLegacyRoleAction = (literal) => LEGACY_CASE_APP_ROLE_ACTIONS.includes(literal);
+var roleActionKeyOf = (literal) => ACTION_KEY_BY_LITERAL.get(literal);
+var roleActionKeyFor = (text) => {
+  const trimmed = text.trim();
+  return ACTION_KEY_BY_LITERAL.get(trimmed) ?? ACTION_KEY_BY_FOLDED.get(trimmed.toLowerCase());
+};
+var roleDescriptionOf = (role) => role.description?.trim() || role.name;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var STAGE_NODE_TYPE = "case-management:Stage";
+var caseStageLabels = (nodes) => {
+  const labels = new Map;
+  for (const node of Array.isArray(nodes) ? nodes : []) {
+    if (!isRecord(node))
+      continue;
+    const { id, type, data } = node;
+    if (type !== STAGE_NODE_TYPE || typeof id !== "string")
+      continue;
+    const label = isRecord(data) ? data.label : undefined;
+    if (typeof label === "string" && label.trim() !== "") {
+      labels.set(id, label);
+    }
+  }
+  return labels;
+};
+var liveStageIdsOf = (role, stages) => (role.stageIds ?? []).filter((stageId) => stages.has(stageId));
+var publishedRoleActions = (role) => role.actions.filter((action) => {
+  const key = roleActionKeyOf(action);
+  if (key === undefined)
+    return false;
+  return role.scope !== "stages" || STAGE_ALLOWED_ROLE_ACTION_KEYS.includes(key);
+});
+var roleDeploys = (role, stages) => publishedRoleActions(role).length > 0 && (role.scope !== "stages" || liveStageIdsOf(role, stages).length > 0);
+var roleResourceKey = (name) => name.trim().toLowerCase();
+var CASE_ROLE_FIELDS = [
+  "id",
+  "name",
+  "description",
+  "isDefault",
+  "actions",
+  "scope",
+  "stageIds"
+];
+var caseRoleEntries = (plan) => {
+  if (!isRecord(plan) || !isRecord(plan.metadata))
+    return [];
+  const entries = plan.metadata.caseRoles;
+  return Array.isArray(entries) ? entries : [];
+};
+var readCaseRole = (entry) => {
+  if (!isRecord(entry))
+    return;
+  const { id, name, description, isDefault, actions, scope, stageIds } = entry;
+  if (typeof name !== "string" || name.trim() === "")
+    return;
+  if (scope !== "case" && scope !== "stages")
+    return;
+  if (!Array.isArray(actions))
+    return;
+  return {
+    id: typeof id === "string" ? id : name,
+    name,
+    ...typeof description === "string" && { description },
+    ...typeof isDefault === "boolean" && { isDefault },
+    actions: actions.filter((action) => typeof action === "string" && (roleActionKeyOf(action) !== undefined || isLegacyRoleAction(action))),
+    scope,
+    ...Array.isArray(stageIds) && {
+      stageIds: stageIds.filter((stageId) => typeof stageId === "string")
+    }
+  };
+};
+var readCaseRoles = (plan) => caseRoleEntries(plan).flatMap((entry) => {
+  const role = readCaseRole(entry);
+  return role === undefined ? [] : [role];
+});
+
+export { CASE_APP_ROLE_ACTIONS, CASE_APP_ROLE_ACTION_KEYS, STAGE_ALLOWED_ROLE_ACTION_KEYS, roleActionGateOf, CASE_ROLE_NAME_MAX_LENGTH, CASE_ROLE_DESCRIPTION_MAX_LENGTH, CASE_ROLE_NAME_FORBIDDEN, CASE_APP_VERSIONS_WITH_ROLES, roleActionKeyOf, roleActionKeyFor, roleDescriptionOf, caseStageLabels, liveStageIdsOf, publishedRoleActions, roleDeploys, roleResourceKey, CASE_ROLE_FIELDS, caseRoleEntries, readCaseRole, readCaseRoles };
+
+//# debugId=975EE435E70BFF6A64756E2164756E21