@uipath/flow-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/packager-tool-wnfbe9ra.js

@@ -0,0 +1,188 @@
+import {
+  getEvaluatorRef,
+  isRecord,
+  stripJsonExt
+} from "./packager-tool-8j92afwp.js";
+import {
+  ensureDirectory
+} from "./packager-tool-gcy5q3jv.js";
+import {
+  readUipxFile
+} from "./packager-tool-cabxfk33.js";
+import {
+  catchError
+} from "./packager-tool-226mh80j.js";
+
+// src/services/flow-eval-paths.ts
+function readWorkflowId(flowContent) {
+  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+  if (parseError) {
+    return;
+  }
+  if (!isRecord(parsed) || typeof parsed.id !== "string") {
+    return;
+  }
+  if (parsed.id === "" || parsed.id.includes("/") || parsed.id.includes("\\") || parsed.id.includes("..")) {
+    return;
+  }
+  return parsed.id;
+}
+
+class FlowEvalPathResolver {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  async resolveEvalRoot(projectPath, create) {
+    const absoluteProjectPath = await this.resolveFlowProjectPath(projectPath);
+    const scopedRoot = await this.resolveWorkflowScopedEvalRoot(absoluteProjectPath);
+    const candidates = [
+      ...scopedRoot ? [scopedRoot] : [],
+      this.fs.path.join(absoluteProjectPath, "evals", "default"),
+      this.fs.path.join(absoluteProjectPath, "evals")
+    ];
+    for (const candidate of candidates) {
+      const evalSets = this.fs.path.join(candidate, "eval-sets");
+      const evaluators = this.fs.path.join(candidate, "evaluators");
+      if (await this.fs.exists(evalSets) || await this.fs.exists(evaluators)) {
+        return candidate;
+      }
+    }
+    if (!create) {
+      return null;
+    }
+    const root = scopedRoot ?? this.fs.path.join(absoluteProjectPath, "evals", "default");
+    await ensureDirectory(this.fs, this.fs.path.join(root, "eval-sets"));
+    await ensureDirectory(this.fs, this.fs.path.join(root, "evaluators"));
+    return root;
+  }
+  async resolveFlowProjectPath(projectPath) {
+    const absolutePath = this.fs.path.resolve(projectPath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`Path ${absolutePath} does not exist. Provide --path pointing to a Flow project directory or solution directory.`);
+    }
+    const [statError, stat] = await catchError(this.fs.stat(absolutePath));
+    if (statError || !stat?.isDirectory()) {
+      throw new Error(`Path ${absolutePath} is not a directory. Provide --path pointing to a Flow project directory or solution directory.`);
+    }
+    const [flowFileError] = await catchError(this.findFlowFile(absolutePath));
+    if (!flowFileError) {
+      return absolutePath;
+    }
+    const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, absolutePath));
+    if (uipxError || !uipxResult) {
+      return absolutePath;
+    }
+    const flowProjects = uipxResult.uipx.Projects.filter((project) => project.Type === "Flow");
+    if (flowProjects.length === 0) {
+      throw new Error(`No Flow project found in solution directory ${absolutePath}. Provide --path pointing to a Flow project directory.`);
+    }
+    const flowProjectPaths = flowProjects.map((project) => this.fs.path.join(absolutePath, this.fs.path.dirname(project.ProjectRelativePath)));
+    if (flowProjects.length > 1) {
+      throw new Error(`Multiple Flow projects found in solution directory ${absolutePath}. Provide --path pointing to one of: ${flowProjectPaths.join(", ")}`);
+    }
+    return flowProjectPaths[0];
+  }
+  async resolveWorkflowScopedEvalRoot(projectPath) {
+    const [flowFileError, flowFilePath] = await catchError(this.findFlowFile(projectPath));
+    if (flowFileError) {
+      return;
+    }
+    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    if (readError) {
+      return;
+    }
+    const workflowId = readWorkflowId(String(flowContent));
+    return workflowId ? this.fs.path.join(projectPath, "evals", workflowId) : undefined;
+  }
+  async findFlowFile(projectPath) {
+    const candidates = [
+      projectPath,
+      this.fs.path.join(projectPath, "content"),
+      this.fs.path.join(projectPath, "flow_files")
+    ];
+    for (const dir of candidates) {
+      if (!await this.fs.exists(dir)) {
+        continue;
+      }
+      const stat = await this.fs.stat(dir);
+      if (!stat?.isDirectory()) {
+        continue;
+      }
+      const entries = await this.fs.readdir(dir);
+      const flowFile = entries.find((entry) => entry.endsWith(".flow"));
+      if (flowFile) {
+        return this.fs.path.join(dir, flowFile);
+      }
+    }
+    throw new Error(`No .flow file found in ${projectPath}.`);
+  }
+  async readDefaultEntryPointNodeId(projectPath) {
+    const [findError, flowFilePath] = await catchError(this.findFlowFile(projectPath));
+    if (findError || !flowFilePath) {
+      return;
+    }
+    const [readError, content] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    if (readError) {
+      return;
+    }
+    const [parseError, nodeId] = catchError(() => readStartNodeId(String(content)));
+    if (parseError) {
+      return;
+    }
+    return nodeId;
+  }
+}
+function readStartNodeId(flowContent) {
+  const parsed = JSON.parse(flowContent);
+  if (!isRecord(parsed) || !Array.isArray(parsed.nodes)) {
+    return;
+  }
+  const nodes = parsed.nodes.filter(isRecord);
+  const defaultEntry = nodes.find((node) => {
+    const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+    if (inputs?.isDefaultEntryPoint === true) {
+      return true;
+    }
+    const model = isRecord(node.model) ? node.model : undefined;
+    return model?.isDefaultEntryPoint === true;
+  });
+  const startNode = defaultEntry ?? nodes.find((node) => {
+    const model = isRecord(node.model) ? node.model : undefined;
+    return model?.type === "bpmn:StartEvent" || node.type === "core.trigger.manual";
+  }) ?? nodes[0];
+  return typeof startNode?.id === "string" ? startNode.id : undefined;
+}
+
+// src/services/flow-eval-selectors.ts
+function findEvaluator(evaluators, idOrName) {
+  return evaluators.find((ev) => ev.id === idOrName || ev.name === idOrName || getEvaluatorRef(ev) === idOrName) ?? null;
+}
+function findEvalSet(sets, idOrName) {
+  return sets.find((set) => set.id === idOrName || set.name === idOrName || stripJsonExt(set.fileName ?? "") === idOrName) ?? null;
+}
+function getLinkedEvaluators(allEvaluators, evalSet) {
+  const refs = new Set(evalSet.evaluatorRefs.map(stripJsonExt));
+  return allEvaluators.filter((evaluator) => {
+    const candidates = [
+      evaluator.id,
+      evaluator.fileName,
+      getEvaluatorRef(evaluator)
+    ].filter((value) => value !== undefined);
+    return candidates.some((candidate) => refs.has(stripJsonExt(candidate)));
+  });
+}
+function removeEvaluatorRefFromSet(evalSet, evaluator) {
+  const removedRefs = new Set([
+    evaluator.id,
+    getEvaluatorRef(evaluator),
+    evaluator.fileName
+  ]);
+  const before = evalSet.evaluatorRefs.length;
+  evalSet.evaluatorRefs = evalSet.evaluatorRefs.filter((ref) => !removedRefs.has(ref));
+  return evalSet.evaluatorRefs.length !== before;
+}
+
+export { readWorkflowId, FlowEvalPathResolver, readStartNodeId, findEvaluator, findEvalSet, getLinkedEvaluators, removeEvaluatorRefFromSet };
+
+//# debugId=8C8FD74CA22CF5FB64756E2164756E21

package/dist/packager-tool-wzgne1ff.js

@@ -0,0 +1,18 @@
+import {
+  logger
+} from "./packager-tool-226mh80j.js";
+import {
+  inMemoryWorkflowToFileFormat
+} from "./packager-tool-m5qfverj.js";
+
+// src/utils/write-resolved-flow.ts
+async function writeResolvedFlow(fs, dir, name, workflow) {
+  const resolvedFileFormat = inMemoryWorkflowToFileFormat(workflow);
+  const resolvedPath = fs.path.join(dir, `${name}.flow.resolved`);
+  await fs.writeFile(resolvedPath, JSON.stringify(resolvedFileFormat, null, 2));
+  logger.info(`Resolved flow written to ${resolvedPath}`);
+}
+
+export { writeResolvedFlow };
+
+//# debugId=AE0D61ABCE2DA4C364756E2164756E21