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

package/dist/packager-tool-s12392rd.js

@@ -0,0 +1,80 @@
+import {
+  catchError,
+  hashContent,
+  logger
+} from "./packager-tool-5ax2ywcg.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+
+// src/utils/resourcesStorage.ts
+async function resolveResourcesStorageDir() {
+  const fs = getFileSystem();
+  return fs.path.join(fs.env.homedir(), ".uip", "case-resources");
+}
+async function saveResourceIndex(resources, resourceType) {
+  const fs = getFileSystem();
+  const dir = await resolveResourcesStorageDir();
+  await fs.mkdir(dir);
+  const indexPath = fs.path.join(dir, `${resourceType}-index.json`);
+  const content = JSON.stringify(resources, null, 2);
+  await fs.writeFile(indexPath, content);
+  logger.debug(`Saved ${resources.length} ${resourceType} resources to index. Updating metadata...`);
+  const hash = await hashContent(content);
+  await saveIndexMetadata({
+    lastSync: Date.now(),
+    count: resources.length,
+    hash
+  }, resourceType);
+  return resources.length;
+}
+async function loadResourceIndex(resourceType) {
+  const fs = getFileSystem();
+  const dir = await resolveResourcesStorageDir();
+  const indexPath = fs.path.join(dir, `${resourceType}-index.json`);
+  if (!await fs.exists(indexPath)) {
+    throw new Error("No resource index found. Please run 'uip maestro case registry pull' to sync resources first.");
+  }
+  const [readError, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  if (readError) {
+    throw new Error(`Failed to load resource index: ${readError instanceof Error ? readError.message : String(readError)}`);
+  }
+  if (content === null || content.trim() === "") {
+    throw new Error("No resource index found. Please run 'uip maestro case registry pull' to sync resources first.");
+  }
+  const [parseError, parsed] = await catchError(Promise.resolve().then(() => JSON.parse(content)));
+  if (parseError) {
+    throw new Error("No resource index found. Please run 'uip maestro case registry pull' to sync resources first.");
+  }
+  return parsed;
+}
+async function saveIndexMetadata(metadata, resourceType) {
+  const fs = getFileSystem();
+  const dir = await resolveResourcesStorageDir();
+  await fs.mkdir(dir);
+  const metaPath = fs.path.join(dir, `${resourceType}-index.meta.json`);
+  await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2));
+}
+async function loadIndexMetadata(resourceType) {
+  const fs = getFileSystem();
+  const dir = await resolveResourcesStorageDir();
+  const metaPath = fs.path.join(dir, `${resourceType}-index.meta.json`);
+  if (!await fs.exists(metaPath)) {
+    return null;
+  }
+  const [error, metadata] = await catchError((async () => {
+    const content = await fs.readFile(metaPath, "utf-8");
+    if (content === null) {
+      return null;
+    }
+    return JSON.parse(content);
+  })());
+  if (error) {
+    return null;
+  }
+  return metadata;
+}
+
+export { saveResourceIndex, loadResourceIndex, saveIndexMetadata, loadIndexMetadata };
+
+//# debugId=5B29295616C3417264756E2164756E21

package/dist/packager-tool-sv0d6wb6.js

@@ -0,0 +1,173 @@
+// src/utils/schema-helpers.ts
+var VALID_TASK_ENTRY_RULE_TYPES = [
+  "current-stage-entered",
+  "selected-tasks-completed",
+  "wait-for-connector",
+  "adhoc",
+  "runs-sequentially"
+];
+var VALID_STAGE_ENTRY_RULE_TYPES = [
+  "case-entered",
+  "selected-stage-exited",
+  "selected-stage-completed",
+  "wait-for-connector",
+  "user-selected-stage"
+];
+var VALID_STAGE_COMPLETION_RULE_TYPES = [
+  "required-tasks-completed",
+  "wait-for-connector"
+];
+var VALID_STAGE_EXIT_RULE_TYPES = [
+  "selected-tasks-completed",
+  "wait-for-connector"
+];
+var VALID_CASE_COMPLETION_RULE_TYPES = [
+  "required-stages-completed",
+  "wait-for-connector"
+];
+var VALID_CASE_EXIT_RULE_TYPES = [
+  "selected-stage-completed",
+  "selected-stage-exited",
+  "wait-for-connector"
+];
+function buildRule(options) {
+  const {
+    id,
+    ruleType,
+    conditionExpression,
+    selectedStageId,
+    selectedTasksIds
+  } = options;
+  switch (ruleType) {
+    case "wait-for-connector":
+      return { rule: "wait-for-connector", id, conditionExpression };
+    case "case-entered":
+      return { rule: "case-entered", id, conditionExpression };
+    case "selected-stage-completed":
+      return {
+        rule: "selected-stage-completed",
+        id,
+        selectedStageId,
+        conditionExpression
+      };
+    case "selected-stage-exited":
+      return {
+        rule: "selected-stage-exited",
+        id,
+        selectedStageId,
+        conditionExpression
+      };
+    case "selected-tasks-completed":
+      return {
+        rule: "selected-tasks-completed",
+        id,
+        selectedTasksIds,
+        conditionExpression
+      };
+    case "current-stage-entered":
+      return { rule: "current-stage-entered", id, conditionExpression };
+    case "adhoc":
+      return { rule: "adhoc", id, conditionExpression };
+    case "required-stages-completed":
+      return {
+        rule: "required-stages-completed",
+        id,
+        conditionExpression
+      };
+    case "required-tasks-completed":
+      return {
+        rule: "required-tasks-completed",
+        id,
+        conditionExpression
+      };
+    case "user-selected-stage":
+      return { rule: "user-selected-stage", id, conditionExpression };
+    case "runs-sequentially":
+      return { rule: "runs-sequentially", id, conditionExpression };
+  }
+}
+function isStageNode(node) {
+  return node.type === "case-management:Stage" || node.type === "case-management:ExceptionStage";
+}
+function requireStageNode(schema, stageId) {
+  const node = schema.nodes.find((n) => n.id === stageId);
+  if (!node) {
+    throw new Error(`Stage not found with id: ${stageId}`);
+  }
+  if (!isStageNode(node)) {
+    throw new Error(`Node ${stageId} is not a stage (type: ${node.type})`);
+  }
+  return node;
+}
+function findTask(tasks, taskId) {
+  for (let lane = 0;lane < tasks.length; lane++) {
+    const index = tasks[lane].findIndex((t) => t.id === taskId);
+    if (index !== -1) {
+      return { task: tasks[lane][index], lane, index };
+    }
+  }
+  return;
+}
+function requireTask(tasks, taskId, stageId) {
+  const found = findTask(tasks, taskId);
+  if (!found) {
+    throw new Error(`Task not found with id: ${taskId} in stage: ${stageId}`);
+  }
+  return found;
+}
+var DEFAULT_TRIGGER_ID = "trigger_1";
+var DEFAULT_TRIGGER_LABEL = "Trigger 1";
+function isTriggerNode(node) {
+  return node.type === "case-management:Trigger";
+}
+function isAnyTriggerNode(node) {
+  return isTriggerNode(node) || node.type === "uipath.case.trigger";
+}
+function findTriggerNodes(schema) {
+  return schema.nodes.filter(isTriggerNode);
+}
+function ensureRootBindings(schema) {
+  schema.bindings ??= [];
+  schema.variables ??= { inputOutputs: [] };
+  return schema;
+}
+function findOrPushBinding(schema, binding) {
+  ensureRootBindings(schema);
+  const bindings = schema.bindings;
+  if (!bindings) {
+    throw new Error("Bindings array missing after ensureRootBindings");
+  }
+  const existing = bindings.find((b) => b.propertyAttribute === binding.propertyAttribute && b.resource === binding.resource && b.resourceKey === binding.resourceKey && b.default === binding.default);
+  if (existing)
+    return existing;
+  bindings.push(binding);
+  return binding;
+}
+function remapBindingRefs(value, idRemap) {
+  if (idRemap.size === 0)
+    return value;
+  if (Array.isArray(value)) {
+    for (let i = 0;i < value.length; i++) {
+      value[i] = remapBindingRefs(value[i], idRemap);
+    }
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+      obj[key] = remapBindingRefs(obj[key], idRemap);
+    }
+    return obj;
+  }
+  if (typeof value === "string") {
+    for (const [from, to] of idRemap) {
+      if (value === `=bindings.${from}`)
+        return `=bindings.${to}`;
+    }
+  }
+  return value;
+}
+
+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=6BD6876D991554EF64756E2164756E21

package/dist/packager-tool-ty1t2byf.js

@@ -0,0 +1,27 @@
+// src/services/strict-connector-context.ts
+var REQUIRED_CONNECTOR_CONTEXT_KEYS = [
+  "connectorKey",
+  "connection",
+  "resourceKey",
+  "folderKey",
+  "objectName",
+  "operation",
+  "metadata"
+];
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var contextEntries = (context) => (Array.isArray(context) ? context : []).map((entry) => asRecord(entry)).filter((entry) => entry !== undefined);
+var contextEntry = (context, name) => contextEntries(context).find((entry) => entry.name === name);
+var missingContextKeys = (context) => {
+  const present = new Set(contextEntries(context).map((entry) => entry.name).filter((name) => typeof name === "string"));
+  return REQUIRED_CONNECTOR_CONTEXT_KEYS.filter((key) => !present.has(key));
+};
+var readActivityTypeId = (context) => {
+  const metadata = contextEntry(context, "metadata");
+  const configuration = asRecord(asRecord(metadata?.body)?.activityPropertyConfiguration);
+  const activityTypeId = configuration?.UiPathActivityTypeId;
+  return typeof activityTypeId === "string" && activityTypeId.trim() !== "" ? activityTypeId : undefined;
+};
+
+export { contextEntry, missingContextKeys, readActivityTypeId };
+
+//# debugId=05A016EFC31CA34E64756E2164756E21

package/dist/packager-tool-vepqrsse.js

@@ -0,0 +1,23 @@
+// ../maestro-sdk/src/shared-utils.ts
+var VALID_PROJECT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+var VALID_PACKAGE_NAME_REGEX = /^[a-zA-Z0-9._-]+$/;
+function formatTraceStatus(status) {
+  if (status === "Completed")
+    return "✓";
+  if (status === "Failed" || status === "Faulted")
+    return "✗";
+  if (status === "Running" || status === "InProgress")
+    return "⏳";
+  return "•";
+}
+function formatTraceLine(trace) {
+  const time = new Date(trace.timestamp).toLocaleTimeString();
+  const statusIcon = formatTraceStatus(trace.status);
+  const duration = trace.duration ? ` ${trace.duration}ms` : "";
+  const name = trace.name.length > 60 ? `${trace.name.substring(0, 57)}...` : trace.name;
+  return `[${time}] ${statusIcon} ${name} (${trace.status})${duration}`;
+}
+
+export { VALID_PROJECT_NAME_REGEX, VALID_PACKAGE_NAME_REGEX, formatTraceLine };
+
+//# debugId=3FEAF014449A0BAE64756E2164756E21