@uipath/case-tool 1.201.0 → 1.202.0-preview.136

package/dist/{ro-RKXZUG7Z-pdztdafr.js → ro-RKXZUG7Z-nndrrsq7.js}

@@ -1,7 +1,7 @@
-import"./packager-tool-jysvpt8p.js";
-import"./packager-tool-wckvcay0.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-1yh8g550.js";
 
-// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/ro-RKXZUG7Z.js
+// ../../node_modules/@uipath/flow-schema/dist/ro-RKXZUG7Z.js
 var agentDuplicateToolNames_duplicateName_message = "Numele instrumentului „{{name}}” este utilizat de mai multe instrumente pe acest agent. Fiecare instrument trebuie să aibă un nume unic.";
 var agentEmptyVar_unwrittenVariable_message = 'Agentul folosește "$vars.{{root}}", dar niciun nod nu atribuie o valoare lui "{{root}}", astfel încât va fi gol în timpul execuției. Asociați-l cu un output al unui nod (de exemplu, output-ul "<node>.output" al unui conector) sau oferiți-i o sursă de valoare.';
 var agentInputRefs_ambiguousUnderscoreRoot_message = "Referința promptului este „$vars.{{ref}}”, dar numele „{{rootSegment}}” conține „__”, care este rezervat ca separator de codificare pentru input-ul agentului și nu poate fi convertit dus-întors. Redenumiți-l pentru a elimina caracterul de subliniere dublu.";
@@ -105,57 +105,57 @@ var ro_default = {
   triggerRequired_message
 };
 export {
-  triggerRequired_message,
-  singleConversationTrigger_message,
-  scriptBody_mustache_message,
-  schemaValidator_validation_genericError,
-  schemaValidator_typeMismatch_message,
-  schemaValidator_required_message,
-  schemaValidator_outOfRange_message,
-  schemaValidator_invalidPattern_message,
-  schemaValidator_invalidField_message,
-  schemaValidator_invalidEnum_message,
-  schemaValidator_genericKeyword_message,
-  outputMapping_missing_message,
-  ixpSchemaDraft_invalid_message,
-  ixpSchemaDraft_invalidWithDetail_message,
-  hitlQuickForm_fieldLabelRequired_message,
-  hitlQuickForm_emptySchema_message,
-  governance_temperatureExceeded_message,
-  governance_noAllowedModel_message,
-  governance_modelNotAvailable_message,
-  governance_maxTokensExceeded_message,
-  governance_maxIterationsExceeded_message,
-  governance_hitlRequired_message,
-  escalation_recipientRequired_message,
-  escalation_quickFormDuplicateFieldLabel_message,
-  escalation_nameRequired_message,
-  escalation_appRequired_message,
-  doWhile_limitOutOfRange_message,
-  ro_default as default,
-  dataTransform_noOperations_message,
-  dataTransform_missingCollection_message,
-  dataTransform_mapNoMappings_message,
-  dataTransform_mapMissingField_message,
-  dataTransform_groupByMissingField_message,
-  dataTransform_groupByAggMissingOutputName_message,
-  dataTransform_groupByAggMissingField_message,
-  dataTransform_filterNoConditions_message,
-  dataTransform_filterMissingField_message,
-  dataTransform_customScriptMissing_message,
-  conversationalVoice_callContextRequired_message,
-  conversationalVoice_callContextInvalid_message,
-  conversationalVoiceEndCall_callContextInvalid_message,
-  conditionExpression_required_message,
-  conditionExpression_invalid_message,
-  conditionExpression_incomplete_message,
-  conditionExpression_decisionWrapped_message,
-  agentInputRefs_unresolvedRef_message,
-  agentInputRefs_reservedNamespace_message,
-  agentInputRefs_reservedMetadataRoot_message,
-  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentDuplicateToolNames_duplicateName_message,
   agentEmptyVar_unwrittenVariable_message,
-  agentDuplicateToolNames_duplicateName_message
+  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentInputRefs_reservedMetadataRoot_message,
+  agentInputRefs_reservedNamespace_message,
+  agentInputRefs_unresolvedRef_message,
+  conditionExpression_decisionWrapped_message,
+  conditionExpression_incomplete_message,
+  conditionExpression_invalid_message,
+  conditionExpression_required_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoice_callContextRequired_message,
+  dataTransform_customScriptMissing_message,
+  dataTransform_filterMissingField_message,
+  dataTransform_filterNoConditions_message,
+  dataTransform_groupByAggMissingField_message,
+  dataTransform_groupByAggMissingOutputName_message,
+  dataTransform_groupByMissingField_message,
+  dataTransform_mapMissingField_message,
+  dataTransform_mapNoMappings_message,
+  dataTransform_missingCollection_message,
+  dataTransform_noOperations_message,
+  ro_default as default,
+  doWhile_limitOutOfRange_message,
+  escalation_appRequired_message,
+  escalation_nameRequired_message,
+  escalation_quickFormDuplicateFieldLabel_message,
+  escalation_recipientRequired_message,
+  governance_hitlRequired_message,
+  governance_maxIterationsExceeded_message,
+  governance_maxTokensExceeded_message,
+  governance_modelNotAvailable_message,
+  governance_noAllowedModel_message,
+  governance_temperatureExceeded_message,
+  hitlQuickForm_emptySchema_message,
+  hitlQuickForm_fieldLabelRequired_message,
+  ixpSchemaDraft_invalidWithDetail_message,
+  ixpSchemaDraft_invalid_message,
+  outputMapping_missing_message,
+  schemaValidator_genericKeyword_message,
+  schemaValidator_invalidEnum_message,
+  schemaValidator_invalidField_message,
+  schemaValidator_invalidPattern_message,
+  schemaValidator_outOfRange_message,
+  schemaValidator_required_message,
+  schemaValidator_typeMismatch_message,
+  schemaValidator_validation_genericError,
+  scriptBody_mustache_message,
+  singleConversationTrigger_message,
+  triggerRequired_message
 };
 
-//# debugId=56D73E4D01E32FEC64756E2164756E21
+//# debugId=BF10298C1139774564756E2164756E21

package/dist/{ru-GSCT4ARZ-qj8dm4dp.js → ru-GSCT4ARZ-1sa9wbr8.js}

@@ -1,5 +1,5 @@
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-wckvcay0.js";
+import"./packager-tool-1yh8g550.js";
 
 // ../../node_modules/@uipath/flow-core/dist/ru-GSCT4ARZ.js
 var ru_default = {};

package/dist/ru-WBLQ5B2U-8r3c7v6d.js

@@ -0,0 +1,10 @@
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-schema/dist/ru-WBLQ5B2U.js
+var ru_default = {};
+export {
+  ru_default as default
+};
+
+//# debugId=18200F1245D66B3E64756E2164756E21

package/dist/strict-case-rules-303vjvas.js

@@ -0,0 +1,377 @@
+import {
+  contextEntry,
+  missingContextKeys,
+  readActivityTypeId
+} from "./packager-tool-ty1t2byf.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/strict-case-rules.ts
+import { Script } from "node:vm";
+var FORMAL_ARG_ID = /^v[A-Za-z0-9]{8}$/;
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var nodeType = (node) => typeof node.type === "string" ? node.type : "";
+var isStage = (node) => nodeType(node).startsWith("case-management:Stage") || nodeType(node) === "case-management:Stage";
+var checkStagesHaveTasks = (nodes) => {
+  const issues = [];
+  for (const node of nodes) {
+    if (!isStage(node))
+      continue;
+    const data = asRecord(node.data);
+    const lanes = asArray(data?.tasks);
+    const taskCount = lanes.reduce((total, lane) => total + asArray(lane).length, 0);
+    if (taskCount > 0)
+      continue;
+    const id = typeof node.id === "string" ? node.id : "?";
+    issues.push({
+      code: "STRICT_STAGE_NO_TASKS",
+      path: `nodes[${id}].data.tasks`,
+      severity: "error",
+      message: `Stage "${id}" declares no tasks. A stage with empty task ` + "lanes deploys and then has nothing to run, so the case " + "enters it and stops."
+    });
+  }
+  return issues;
+};
+var checkNoUnresolvedXrefs = (value, path, issues) => {
+  if (typeof value === "string") {
+    if (value.includes("$xref(")) {
+      issues.push({
+        code: "STRICT_XREF_UNRESOLVED",
+        path,
+        severity: "error",
+        message: `Unresolved authoring marker in "${value}". "$xref(...)" ` + "is a placeholder the converter does not expand — resolve " + "it to the real id before packing."
+      });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      checkNoUnresolvedXrefs(entry, `${path}[${index}]`, issues);
+    });
+    return;
+  }
+  const record = asRecord(value);
+  if (!record)
+    return;
+  for (const [key, entry] of Object.entries(record)) {
+    checkNoUnresolvedXrefs(entry, `${path}.${key}`, issues);
+  }
+};
+var jsSyntaxError = (source) => {
+  try {
+    new Script(source);
+    return null;
+  } catch (error) {
+    return error instanceof SyntaxError ? error.message : null;
+  }
+};
+var checkJsExpressionsParse = (value, path, issues) => {
+  if (typeof value === "string") {
+    if (!value.startsWith("=js:"))
+      return;
+    const source = value.slice(4);
+    const failure = jsSyntaxError(source);
+    if (failure === null)
+      return;
+    const escaped = source.replace(/\r\n|\r|\n/g, String.raw`\n`);
+    const rawLineBreak = escaped !== source && jsSyntaxError(escaped) === null;
+    issues.push({
+      code: "STRICT_JS_EXPRESSION_INVALID",
+      path,
+      severity: "error",
+      message: `This \`=js:\` expression does not parse: ${failure}. The ` + "runtime evaluates it as JavaScript, so the element faults on " + "its first evaluation." + (rawLineBreak ? " It carries a raw line break: write `\\\\n` in the JSON " + "so the JavaScript source carries `\\n`." : "") + ` Offending text: ${JSON.stringify(value.slice(0, 70))}`
+    });
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      checkJsExpressionsParse(entry, `${path}[${index}]`, issues);
+    });
+    return;
+  }
+  const record = asRecord(value);
+  if (!record)
+    return;
+  for (const [key, entry] of Object.entries(record)) {
+    checkJsExpressionsParse(entry, `${path}.${key}`, issues);
+  }
+};
+var checkConditionExpressionPlacement = (conditions, path) => {
+  const issues = [];
+  asArray(conditions).forEach((condition, index) => {
+    const record = asRecord(condition);
+    if (!record)
+      return;
+    if (typeof record.conditionExpression !== "string")
+      return;
+    issues.push({
+      code: "STRICT_CONDITION_EXPR_HOISTED",
+      path: `${path}[${index}].conditionExpression`,
+      severity: "error",
+      message: '"conditionExpression" sits on the condition object. The ' + "scheduler reads it from a rule inside rules[][], so here it " + "is ignored and the condition fires ungated — move it onto " + "the rule it is meant to guard."
+    });
+  });
+  return issues;
+};
+var collectConditionIssues = (nodes, metadata) => {
+  const issues = [];
+  for (const node of nodes) {
+    const id = typeof node.id === "string" ? node.id : "?";
+    const data = asRecord(node.data);
+    issues.push(...checkConditionExpressionPlacement(data?.entryConditions, `nodes[${id}].data.entryConditions`), ...checkConditionExpressionPlacement(data?.exitConditions, `nodes[${id}].data.exitConditions`));
+    for (const lane of asArray(data?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord(task);
+        if (!taskRecord)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        issues.push(...checkConditionExpressionPlacement(taskRecord.entryConditions, `nodes[${id}].data.tasks[${taskId}].entryConditions`));
+      }
+    }
+  }
+  issues.push(...checkConditionExpressionPlacement(metadata?.caseExitRules, "metadata.caseExitRules"));
+  return issues;
+};
+var checkVariableContract = (variables) => {
+  const issues = [];
+  for (const slot of ["inputs", "outputs", "inputOutputs"]) {
+    asArray(variables?.[slot]).forEach((entry, index) => {
+      const variable = asRecord(entry);
+      if (!variable)
+        return;
+      const name = typeof variable.name === "string" ? variable.name : `#${index}`;
+      const path = `variables.${slot}[${name}]`;
+      const id = variable.id;
+      if (slot !== "inputOutputs") {
+        if (typeof id !== "string" || !FORMAL_ARG_ID.test(id)) {
+          issues.push({
+            code: "STRICT_FORMAL_ARG_ID",
+            path: `${path}.id`,
+            severity: "error",
+            message: `Formal argument "${name}" has id ` + `"${String(id)}", which is not the generated ` + 'form "v" + 8 characters. An id copied from the ' + "name collides across renames and does not match " + "what the converter emits."
+          });
+        }
+      }
+      if (variable.default !== undefined && typeof variable.default !== "string") {
+        issues.push({
+          code: "STRICT_DEFAULT_NOT_STRING",
+          path: `${path}.default`,
+          severity: "error",
+          message: `Default for "${name}" is a ` + `${Array.isArray(variable.default) ? "array" : typeof variable.default} ` + "and must be a JSON string. The converter drops " + "non-string defaults without saying so, so the value " + "silently disappears from entry-points.json."
+        });
+      }
+    });
+  }
+  return issues;
+};
+var checkInputOutputCompanions = (variables, nodes) => {
+  const issues = [];
+  const companions = new Set(asArray(variables?.inputOutputs).map((entry) => asRecord(entry)?.name).filter((name) => typeof name === "string"));
+  const unbound = (name) => !companions.has(name);
+  asArray(variables?.inputs).forEach((entry) => {
+    const variable = asRecord(entry);
+    const name = variable?.name;
+    if (typeof name !== "string" || !unbound(name))
+      return;
+    issues.push({
+      code: "STRICT_INPUTOUTPUTS_COMPANION",
+      path: `variables.inputs[${name}]`,
+      severity: "error",
+      message: `In-argument "${name}" has no entry of the same name in ` + "variables.inputOutputs[]. The companion is what carries the " + "binding, so without it the argument is declared and never " + "bound."
+    });
+  });
+  for (const node of nodes) {
+    const nodeId = typeof node.id === "string" ? node.id : "?";
+    const data = asRecord(node.data);
+    for (const lane of asArray(data?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord(task);
+        if (!taskRecord)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        for (const output of asArray(asRecord(taskRecord.data)?.outputs)) {
+          const record = asRecord(output);
+          if (record?.custom !== true)
+            continue;
+          const variableName = record.var;
+          if (typeof variableName !== "string" || !unbound(variableName)) {
+            continue;
+          }
+          const label = typeof record.name === "string" ? record.name : variableName;
+          issues.push({
+            code: "STRICT_INPUTOUTPUTS_COMPANION",
+            path: `nodes[${nodeId}].data.tasks[${taskId}].data.outputs[${label}]`,
+            severity: "error",
+            message: `Custom output "${label}" writes to ` + `"${variableName}", which has no entry in ` + "variables.inputOutputs[]. Without the companion " + "the value has nowhere to land."
+          });
+        }
+      }
+    }
+  }
+  return issues;
+};
+var checkOutputIdUniqueness = (nodes) => {
+  const issues = [];
+  const seen = new Map;
+  const reported = new Set;
+  for (const node of nodes) {
+    const nodeId = typeof node.id === "string" ? node.id : "?";
+    const data = asRecord(node.data);
+    for (const lane of asArray(data?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord(task);
+        if (!taskRecord)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        const taskData = asRecord(taskRecord.data);
+        for (const output of asArray(taskData?.outputs)) {
+          const id = asRecord(output)?.id;
+          if (typeof id !== "string" || id === "")
+            continue;
+          const owner = `${nodeId}/${taskId}`;
+          const previous = seen.get(id);
+          if (previous !== undefined && !reported.has(id)) {
+            reported.add(id);
+            issues.push({
+              code: "STRICT_OUTPUT_ID_DUPLICATE",
+              path: `nodes[${nodeId}].data.tasks[${taskId}].data.outputs[${id}]`,
+              severity: "error",
+              message: `Output id "${id}" is used by two tasks ` + `(${previous} and ${owner}). Output ids are ` + "the write target, so the second write lands " + "on the first task's variable."
+            });
+          }
+          if (previous === undefined)
+            seen.set(id, owner);
+        }
+      }
+    }
+  }
+  return issues;
+};
+var checkConnectorRuleContext = (nodes) => {
+  const issues = [];
+  const visitRule = (rule, path) => {
+    if (rule.rule !== "wait-for-connector")
+      return;
+    const context = asRecord(rule.uipath)?.context;
+    const missing = missingContextKeys(context);
+    if (missing.length > 0) {
+      issues.push({
+        code: "STRICT_CONNECTOR_CONTEXT_INCOMPLETE",
+        path: `${path}.uipath.context`,
+        severity: "error",
+        message: `Connector rule "${String(rule.id ?? "?")}" is missing ` + `context entries: ${missing.join(", ")}. A rule carrying ` + "the connection but not the activity metadata deploys and " + "then has no event to wait for."
+      });
+    }
+    if (contextEntry(context, "metadata") === undefined)
+      return;
+    if (readActivityTypeId(context) === undefined) {
+      issues.push({
+        code: "STRICT_CONNECTOR_ACTIVITY_TYPE_ID",
+        path: `${path}.uipath.context[metadata].body.activityPropertyConfiguration.UiPathActivityTypeId`,
+        severity: "error",
+        message: `Connector rule "${String(rule.id ?? "?")}" has metadata ` + "with no UiPathActivityTypeId. The connection id alone " + "does not identify the event to wait for."
+      });
+    }
+  };
+  const visitConditions = (conditions, path) => {
+    asArray(conditions).forEach((condition, conditionIndex) => {
+      const record = asRecord(condition);
+      if (!record)
+        return;
+      asArray(record.rules).forEach((group, groupIndex) => {
+        asArray(group).forEach((rule, ruleIndex) => {
+          const ruleRecord = asRecord(rule);
+          if (!ruleRecord)
+            return;
+          visitRule(ruleRecord, `${path}[${conditionIndex}].rules[${groupIndex}][${ruleIndex}]`);
+        });
+      });
+    });
+  };
+  for (const node of nodes) {
+    const id = typeof node.id === "string" ? node.id : "?";
+    const data = asRecord(node.data);
+    visitConditions(data?.entryConditions, `nodes[${id}].data.entryConditions`);
+    visitConditions(data?.exitConditions, `nodes[${id}].data.exitConditions`);
+    for (const lane of asArray(data?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord(task);
+        if (!taskRecord)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        visitConditions(taskRecord.entryConditions, `nodes[${id}].data.tasks[${taskId}].entryConditions`);
+      }
+    }
+  }
+  return issues;
+};
+var RECIPIENT_PREFIXES = [
+  "User:",
+  "UserGroup:",
+  "Role:",
+  "Email:",
+  "Expression:"
+];
+var recipientIssues = (recipient, path) => {
+  const value = recipient.Value;
+  if (typeof value !== "string")
+    return [];
+  const prefix = RECIPIENT_PREFIXES.find((candidate) => value.startsWith(candidate));
+  if (prefix !== undefined) {
+    return [
+      {
+        code: "STRICT_RECIPIENT_PREFIX_LEFT",
+        path: `${path}.Value`,
+        severity: "error",
+        message: `Recipient value "${value}" still carries the ` + `"${prefix}" marker. That marker picks the Type and is ` + "removed on the way in, so the assignment looks up a " + "name nobody has and the task ships assigned to no one."
+      }
+    ];
+  }
+  if (!value.startsWith("=vars.") || recipient.Type === 3)
+    return [];
+  return [
+    {
+      code: "STRICT_RECIPIENT_EXPRESSION_TYPE",
+      path: `${path}.Type`,
+      severity: "error",
+      message: `Recipient value "${value}" is an expression but carries ` + `Type ${String(recipient.Type)}. Type 0 sends it to a user ` + "lookup, Type 1 to a group lookup and Type 2 to an email " + "lookup, all on the literal text. An expression recipient " + "is Type 3."
+    }
+  ];
+};
+var checkActionRecipientShape = (nodes) => nodes.flatMap((node) => {
+  const nodeId = typeof node.id === "string" ? node.id : "?";
+  const lanes = asArray(asRecord(node.data)?.tasks);
+  return lanes.flatMap((lane) => asArray(lane).flatMap((task) => {
+    const taskRecord = asRecord(task);
+    const recipient = asRecord(asRecord(taskRecord?.data)?.recipient);
+    if (!taskRecord || !recipient)
+      return [];
+    const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+    return recipientIssues(recipient, `nodes[${nodeId}].data.tasks[${taskId}].data.recipient`);
+  }));
+});
+var runStrictCaseRules = (parsed) => {
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const variables = asRecord(parsed.variables);
+  const metadata = asRecord(parsed.metadata);
+  const xrefIssues = [];
+  checkNoUnresolvedXrefs(parsed, "(root)", xrefIssues);
+  const jsSyntaxIssues = [];
+  checkJsExpressionsParse(parsed, "(root)", jsSyntaxIssues);
+  return [
+    ...checkStagesHaveTasks(nodes),
+    ...xrefIssues,
+    ...jsSyntaxIssues,
+    ...collectConditionIssues(nodes, metadata),
+    ...checkVariableContract(variables),
+    ...checkInputOutputCompanions(variables, nodes),
+    ...checkOutputIdUniqueness(nodes),
+    ...checkConnectorRuleContext(nodes),
+    ...checkActionRecipientShape(nodes)
+  ];
+};
+export {
+  runStrictCaseRules
+};
+
+//# debugId=A26096E08E3DBD7464756E2164756E21