@uipath/flow-tool 1.205.0-preview.277 → 1.206.0-preview.279

package/dist/{packager-tool-nhrc54tz.js → packager-tool-bbkkxbyq.js}

@@ -1,9 +1,10 @@
 import {
-  validateIntSvcNode
-} from "./packager-tool-mgwzjh8c.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+  stripJsonStringGuard,
+  validateIntSvcNode
+} from "./packager-tool-kz3t4raw.js";
 
 // src/services/connector-node-types.ts
 function isConnectorTriggerType(nodeType) {
@@ -17,7 +18,7 @@ function isEventDrivenConnectorType(nodeType) {
 }
 
 // src/services/node-validators/connector-validator.ts
-var connectorNodeValidator = {
+var connectorNodeValidator2 = {
   id: "uipath-connector",
   appliesTo: (node) => node.type?.startsWith("uipath.connector") ?? false,
   validate: (node) => {
@@ -76,7 +77,7 @@ function readEssentialConfiguration(detail) {
   const configuration = detail.configuration;
   if (typeof configuration !== "string")
     return;
-  const [, parsed] = catchError(() => JSON.parse(configuration.replace(/^=jsonString:/, "")));
+  const [, parsed] = catchError2(() => JSON.parse(stripJsonStringGuard(configuration)));
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     return;
   }
@@ -256,6 +257,6 @@ var crossNodeBindingValidator = {
   }
 };
 
-export { isConnectorTriggerType, isConnectorWaitForEventType, isEventDrivenConnectorType, connectorNodeValidator, readEssentialConfiguration, scanDetailForCrossNodeBindings, crossNodeBindingValidator };
+export { isConnectorTriggerType, isConnectorWaitForEventType, isEventDrivenConnectorType, connectorNodeValidator2, readEssentialConfiguration, scanDetailForCrossNodeBindings, crossNodeBindingValidator };
 
-//# debugId=EFF28D07D245963864756E2164756E21
+//# debugId=887FCC1A025427FB64756E2164756E21

package/dist/{packager-tool-409n51pv.js → packager-tool-d07g2kpn.js}

@@ -1,8 +1,8 @@
 import {
-  buildExtractDocumentBuilderNode,
+  ootbNodes,
   inlineAgentNodes,
-  ootbNodes
-} from "./packager-tool-9rmaeaww.js";
+  buildExtractDocumentBuilderNode
+} from "./packager-tool-gdpw0daf.js";
 
 // ../maestro-sdk/src/registry/known-types.ts
 var KNOWN_SDK_NODES = [
@@ -11,15 +11,15 @@ var KNOWN_SDK_NODES = [
   buildExtractDocumentBuilderNode()
 ];
 var KNOWN_SDK_NODE_TYPES = new Set(KNOWN_SDK_NODES.map((n) => n.nodeType.toLowerCase()).filter((t) => typeof t === "string" && t.length > 0));
-function isKnownSdkNodeType(nodeType) {
+function isKnownSdkNodeType2(nodeType) {
   if (typeof nodeType !== "string" || nodeType.length === 0)
     return false;
   return KNOWN_SDK_NODE_TYPES.has(nodeType.toLowerCase());
 }
-function listKnownSdkNodes() {
+function listKnownSdkNodes2() {
   return KNOWN_SDK_NODES.slice();
 }
 
-export { isKnownSdkNodeType, listKnownSdkNodes };
+export { isKnownSdkNodeType2, listKnownSdkNodes2 };
 
-//# debugId=901A5E5E6810517E64756E2164756E21
+//# debugId=AA44820AC8C7293D64756E2164756E21

package/dist/{packager-tool-8zzmg2f3.js → packager-tool-dx6sjbkd.js}

@@ -1,20 +1,20 @@
 import {
-  resolveEntryPointNodeId
-} from "./packager-tool-j95w4fj3.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
-  ensureDirectory,
-  isRecord
-} from "./packager-tool-xk78j7dz.js";
+  isRecord,
+  ensureDirectory
+} from "./packager-tool-ac6rvny7.js";
 import {
-  readUipxFile
-} from "./packager-tool-8g5931fz.js";
+  resolveEntryPointNodeId
+} from "./packager-tool-q0f1dvtd.js";
 import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+  readUipxFile2
+} from "./packager-tool-em4ppegs.js";
 
 // src/services/flow-eval-paths.ts
 function readWorkflowId(flowContent) {
-  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+  const [parseError, parsed] = catchError2(() => JSON.parse(flowContent));
   if (parseError) {
     return;
   }
@@ -60,15 +60,15 @@ class FlowEvalPathResolver {
     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));
+    const [statError, stat] = await catchError2(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));
+    const [flowFileError] = await catchError2(this.findFlowFile(absolutePath));
     if (!flowFileError) {
       return absolutePath;
     }
-    const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, absolutePath));
+    const [uipxError, uipxResult] = await catchError2(readUipxFile2(this.fs, absolutePath));
     if (uipxError || !uipxResult) {
       return absolutePath;
     }
@@ -83,11 +83,11 @@ class FlowEvalPathResolver {
     return flowProjectPaths[0];
   }
   async resolveWorkflowScopedEvalRoot(projectPath) {
-    const [flowFileError, flowFilePath] = await catchError(this.findFlowFile(projectPath));
+    const [flowFileError, flowFilePath] = await catchError2(this.findFlowFile(projectPath));
     if (flowFileError) {
       return;
     }
-    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    const [readError, flowContent] = await catchError2(this.fs.readFile(flowFilePath, "utf-8"));
     if (readError) {
       return;
     }
@@ -117,15 +117,15 @@ class FlowEvalPathResolver {
     throw new Error(`No .flow file found in ${projectPath}.`);
   }
   async readDefaultEntryPointNodeId(projectPath) {
-    const [findError, flowFilePath] = await catchError(this.findFlowFile(projectPath));
+    const [findError, flowFilePath] = await catchError2(this.findFlowFile(projectPath));
     if (findError || !flowFilePath) {
       return;
     }
-    const [readError, content] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    const [readError, content] = await catchError2(this.fs.readFile(flowFilePath, "utf-8"));
     if (readError) {
       return;
     }
-    const [parseError, nodeId] = catchError(() => readStartNodeId(String(content)));
+    const [parseError, nodeId] = catchError2(() => readStartNodeId(String(content)));
     if (parseError) {
       return;
     }
@@ -141,4 +141,4 @@ function readStartNodeId(flowContent) {
 }
 export { readWorkflowId, FlowEvalPathResolver, readStartNodeId };
 
-//# debugId=BC5FF472DF67E93A64756E2164756E21
+//# debugId=8608CE51B14B95F364756E2164756E21

package/dist/{packager-tool-8g5931fz.js → packager-tool-em4ppegs.js}

@@ -1,11 +1,11 @@
+import {
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
   logger,
   quoteForShell,
   unsupportedSolutionProjectType
-} from "./packager-tool-apawc11t.js";
-import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+} from "./packager-tool-8ed52y5r.js";
 
 // ../solution-sdk/src/solution-file.ts
 var STUDIO_WEB_PROJECT_TYPE_OVERRIDES = {
@@ -17,7 +17,7 @@ function normalizeProjectType(projectType) {
 function toPortableRelativePath(relativePath) {
   return relativePath.replace(/\\/g, "/");
 }
-async function readUipxFile(fs, solutionDir) {
+async function readUipxFile2(fs, solutionDir) {
   const dirEntries = await fs.readdir(solutionDir);
   const uipxFileName = dirEntries.find((f) => f.endsWith(".uipx"));
   if (!uipxFileName) {
@@ -27,7 +27,7 @@ async function readUipxFile(fs, solutionDir) {
   if (!uipxContent) {
     throw new Error(`Could not read .uipx file: ${uipxFileName} is empty or missing.`);
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(uipxContent));
+  const [parseError, parsed] = catchError2(() => JSON.parse(uipxContent));
   if (parseError) {
     throw new Error(`Invalid .uipx file: could not parse JSON in ${uipxFileName}.`);
   }
@@ -98,12 +98,12 @@ async function autoScaffoldSolution(fs, baseDir, projectName) {
     SolutionFile: solutionFile
   };
 }
-async function prepareProjectLocation(fs, candidateProjectDir, projectName, options = {}) {
+async function prepareProjectLocation2(fs, candidateProjectDir, projectName, options = {}) {
   const resolved = fs.path.resolve(candidateProjectDir);
   if (options.skipRegistration) {
     return { projectDir: resolved };
   }
-  const discovery = await findNearestParentUipxFile(fs, resolved);
+  const discovery = await findNearestParentUipxFile2(fs, resolved);
   if (discovery.status !== "notFound") {
     return { projectDir: resolved };
   }
@@ -114,45 +114,38 @@ async function prepareProjectLocation(fs, candidateProjectDir, projectName, opti
   return { projectDir, autoCreatedSolution };
 }
 async function warnIfCandidateDirShadowed(fs, candidateDir, projectDir) {
-  const [, exists] = await catchError(fs.exists(candidateDir));
+  const [, exists] = await catchError2(fs.exists(candidateDir));
   if (!exists) {
     return;
   }
-  const [, entries] = await catchError(fs.readdir(candidateDir));
+  const [, entries] = await catchError2(fs.readdir(candidateDir));
   if (!entries || entries.length === 0) {
     return;
   }
   logger.warn(`An existing directory "${candidateDir}" was left untouched. ` + `The project was created inside the auto-created solution at "${projectDir}". ` + "Run init from inside an existing solution, or pass --skip-solution-registration, if you meant to use the existing directory.");
 }
-function resolveSolutionDir(fs, inputPath) {
-  const resolved = fs.path.resolve(inputPath);
-  if (resolved.endsWith(".uipx")) {
-    return fs.path.dirname(resolved);
-  }
-  return resolved;
-}
 async function updateUipxSolutionId(fs, uipxPath, newSolutionId) {
-  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(uipxPath, "utf-8"));
   if (readError || !content) {
     logger.error(`Could not read .uipx file for update: ${readError?.message ?? "empty file"}`);
     return;
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  const [parseError, parsed] = catchError2(() => JSON.parse(content));
   if (parseError) {
     logger.error(`Could not parse .uipx file for update: ${parseError.message}`);
     return;
   }
   parsed.SolutionId = newSolutionId;
-  const [writeError] = await catchError(fs.writeFile(uipxPath, JSON.stringify(parsed, null, 4)));
+  const [writeError] = await catchError2(fs.writeFile(uipxPath, JSON.stringify(parsed, null, 4)));
   if (writeError) {
     logger.error(`Could not update .uipx with new SolutionId: ${writeError.message}`);
   } else {
     logger.info(`Updated .uipx with Studio Web SolutionId: ${newSolutionId}`);
   }
 }
-async function findSolutionFile(fs, projectPath) {
+async function findSolutionFile2(fs, projectPath) {
   const parentDir = fs.path.resolve(projectPath, "..");
-  const [dirError, entries] = await catchError(fs.readdir(parentDir));
+  const [dirError, entries] = await catchError2(fs.readdir(parentDir));
   if (dirError) {
     logger.error(`Could not read parent directory for .uipx file: ${dirError.message}`);
     return;
@@ -163,12 +156,12 @@ async function findSolutionFile(fs, projectPath) {
     return;
   }
   const uipxPath = fs.path.join(parentDir, uipxFile);
-  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(uipxPath, "utf-8"));
   if (readError || content === null) {
     logger.error(`Could not read .uipx file: ${readError?.message ?? "file returned null"}`);
     return;
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  const [parseError, parsed] = catchError2(() => JSON.parse(content));
   if (parseError) {
     logger.error(`Could not parse .uipx file: ${parseError.message}`);
     return;
@@ -185,9 +178,9 @@ async function findSolutionFile(fs, projectPath) {
     projectId: projectId ?? crypto.randomUUID()
   };
 }
-async function updateSolutionFile(fs, projectPath, newSolutionId) {
+async function updateSolutionFile2(fs, projectPath, newSolutionId) {
   const parentDir = fs.path.resolve(projectPath, "..");
-  const [dirError, entries] = await catchError(fs.readdir(parentDir));
+  const [dirError, entries] = await catchError2(fs.readdir(parentDir));
   if (dirError)
     return;
   const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
@@ -196,7 +189,7 @@ async function updateSolutionFile(fs, projectPath, newSolutionId) {
   const uipxPath = fs.path.join(parentDir, uipxFile);
   await updateUipxSolutionId(fs, uipxPath, newSolutionId);
 }
-async function tryRegisterProjectInParentSolution(fs, projectDir, options) {
+async function tryRegisterProjectInParentSolution2(fs, projectDir, options) {
   if (options?.skipRegistration) {
     return {
       Status: "OptedOut",
@@ -204,7 +197,7 @@ async function tryRegisterProjectInParentSolution(fs, projectDir, options) {
       Instructions: buildOptedOutInstructions(fs.path.resolve(projectDir))
     };
   }
-  const [registrationError, registration] = await catchError(registerProjectInParentSolution(fs, projectDir));
+  const [registrationError, registration] = await catchError2(registerProjectInParentSolution(fs, projectDir));
   if (registrationError) {
     return {
       Status: "Failed",
@@ -216,7 +209,7 @@ async function tryRegisterProjectInParentSolution(fs, projectDir, options) {
 }
 async function registerProjectInParentSolution(fs, projectDir) {
   const resolvedProjectDir = fs.path.resolve(projectDir);
-  const discovery = await findNearestParentUipxFile(fs, resolvedProjectDir);
+  const discovery = await findNearestParentUipxFile2(fs, resolvedProjectDir);
   if (discovery.status === "notFound") {
     return {
       Status: "NotInSolution",
@@ -268,7 +261,7 @@ async function registerProjectInParentSolution(fs, projectDir) {
     };
   }
   const projectRelativePath = toPortableRelativePath(fs.path.join(relativeProjectDir, projectFile.fileName));
-  const [solutionError, solution] = await readSolutionManifest(fs, solutionFile);
+  const [solutionError, solution] = await readSolutionManifest2(fs, solutionFile);
   if (solutionError) {
     return {
       Status: "Failed",
@@ -296,7 +289,7 @@ async function registerProjectInParentSolution(fs, projectDir) {
     Id: projectId
   });
   solution.content.Projects = solution.projects;
-  const [writeError] = await catchError(fs.writeFile(solutionFile, `${JSON.stringify(solution.content, null, 2)}
+  const [writeError] = await catchError2(fs.writeFile(solutionFile, `${JSON.stringify(solution.content, null, 2)}
 `));
   if (writeError) {
     return {
@@ -316,10 +309,10 @@ async function registerProjectInParentSolution(fs, projectDir) {
     Instructions: buildRegistrationSuccessInstructions(solutionDir)
   };
 }
-async function findNearestParentUipxFile(fs, projectDir) {
+async function findNearestParentUipxFile2(fs, projectDir) {
   let currentDir = fs.path.dirname(fs.path.resolve(projectDir));
   while (true) {
-    const [readDirError, entries] = await catchError(fs.readdir(currentDir));
+    const [readDirError, entries] = await catchError2(fs.readdir(currentDir));
     if (readDirError) {
       return {
         status: "skipped",
@@ -384,11 +377,11 @@ async function findProjectFile(fs, projectDir) {
   ];
 }
 async function readProjectManifest(fs, filePath, useProjectJson) {
-  const [readError, rawContent] = await catchError(fs.readFile(filePath, "utf-8"));
+  const [readError, rawContent] = await catchError2(fs.readFile(filePath, "utf-8"));
   if (readError || !rawContent) {
     return [readError ?? new Error(`Unable to read ${filePath}.`), null];
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(rawContent));
+  const [parseError, parsed] = catchError2(() => JSON.parse(rawContent));
   if (parseError) {
     return [
       new Error(`Invalid JSON in project file: ${parseError.message}`),
@@ -411,15 +404,15 @@ async function readProjectManifest(fs, filePath, useProjectJson) {
     }
   ];
 }
-async function readSolutionManifest(fs, solutionFile) {
-  const [readError, rawContent] = await catchError(fs.readFile(solutionFile, "utf-8"));
+async function readSolutionManifest2(fs, solutionFile) {
+  const [readError, rawContent] = await catchError2(fs.readFile(solutionFile, "utf-8"));
   if (readError || !rawContent) {
     return [
       readError ?? new Error(`Unable to read solution file: ${solutionFile}`),
       null
     ];
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(rawContent));
+  const [parseError, parsed] = catchError2(() => JSON.parse(rawContent));
   if (parseError) {
     return [
       new Error(`Invalid JSON in solution file: ${parseError.message}`),
@@ -496,8 +489,8 @@ function buildOptedOutInstructions(projectDir) {
   ].join(`
 `);
 }
-async function isProjectRegisteredInSolution(fs, projectDir, solutionFile) {
-  const [readErr, manifest] = await readSolutionManifest(fs, solutionFile);
+async function isProjectRegisteredInSolution2(fs, projectDir, solutionFile) {
+  const [readErr, manifest] = await readSolutionManifest2(fs, solutionFile);
   if (readErr) {
     throw readErr;
   }
@@ -516,7 +509,7 @@ async function isProjectRegisteredInSolution(fs, projectDir, solutionFile) {
   return false;
 }
 async function canonicalizePath(fs, p) {
-  const [err, real] = await catchError(fs.realpath(p));
+  const [err, real] = await catchError2(fs.realpath(p));
   return err || !real ? p : real;
 }
 async function findSolutionFileUpward(fs, startDir) {
@@ -538,6 +531,6 @@ async function findSolutionFileUpward(fs, startDir) {
   }
 }
 
-export { normalizeProjectType, toPortableRelativePath, readUipxFile, createSolutionManifest, autoScaffoldSolution, prepareProjectLocation, resolveSolutionDir, updateUipxSolutionId, findSolutionFile, updateSolutionFile, tryRegisterProjectInParentSolution, findNearestParentUipxFile, readSolutionManifest, isProjectRegisteredInSolution, findSolutionFileUpward };
+export { normalizeProjectType, toPortableRelativePath, readUipxFile2, prepareProjectLocation2, findSolutionFile2, updateSolutionFile2, tryRegisterProjectInParentSolution2, findNearestParentUipxFile2, readSolutionManifest2, isProjectRegisteredInSolution2, findSolutionFileUpward };
 
-//# debugId=B912693656C764E064756E2164756E21
+//# debugId=82B61A0F512E804464756E2164756E21

package/dist/{packager-tool-zgsvggdr.js → packager-tool-f7rk9xhv.js}

@@ -1,12 +1,12 @@
 import {
-  UI_ONLY_NODE_TYPES
-} from "./packager-tool-e5hj89zm.js";
+  UI_ONLY_NODE_TYPES2
+} from "./packager-tool-9217bxm2.js";
 
 // src/services/preview-id-rule.ts
 function previewIdIssues(graph) {
   const issues = [];
   for (const node of graph.nodes ?? []) {
-    if (UI_ONLY_NODE_TYPES.has(node.type ?? ""))
+    if (UI_ONLY_NODE_TYPES2.has(node.type ?? ""))
       continue;
     if (node.id.startsWith("preview")) {
       issues.push({
@@ -47,4 +47,4 @@ function assertNoPreviewIds(workflow) {
 
 export { previewIdIssues, assertNoPreviewIds };
 
-//# debugId=68C64DCF11797BEA64756E2164756E21
+//# debugId=34B980A977180DF664756E2164756E21