@uipath/case-tool 1.204.0-preview.254 → 1.205.0-preview.256

package/dist/{packager-tool-xdxr3ync.js → packager-tool-hdxtgckw.js}

@@ -182,6 +182,16 @@ class NodeFileSystem {
   async rename(oldPath, newPath) {
     await fs.rename(oldPath, newPath);
   }
+  async isSymbolicLink(filePath) {
+    try {
+      return (await fs.lstat(filePath)).isSymbolicLink();
+    } catch (error) {
+      if (this.isEnoent(error) || this.hasErrnoCode(error, "ENOTDIR")) {
+        return false;
+      }
+      throw error;
+    }
+  }
   async realpath(filePath) {
     try {
       return await fs.realpath(filePath);
@@ -236,4 +246,4 @@ var getFileSystemAsync = async () => fsInstance;
 
 export { NodeFileSystem, setFileSystem, getFileSystem, getFileSystemAsync };
 
-//# debugId=3E49815A855BD0ED64756E2164756E21
+//# debugId=1DD0126610F78D8964756E2164756E21

package/dist/packager-tool-k6jbedyc.js

@@ -0,0 +1,69 @@
+// src/services/gate-key.ts
+var gateKey = (expression) => {
+  const text = expression.trim();
+  let out = "";
+  let quote;
+  let pendingSpace = false;
+  const word = (ch) => ch !== undefined && /[\w$]/.test(ch);
+  for (let at = 0;at < text.length; at++) {
+    const ch = text[at];
+    if (quote !== undefined) {
+      out += ch;
+      if (ch === "\\" && at + 1 < text.length) {
+        out += text[at + 1];
+        at++;
+      } else if (ch === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (ch === "/")
+      return text;
+    if (/\s/.test(ch)) {
+      pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace && word(out.at(-1)) && word(ch))
+      out += " ";
+    pendingSpace = false;
+    if (ch === '"' || ch === "'" || ch === "`")
+      quote = ch;
+    out += ch;
+  }
+  return out;
+};
+
+// src/services/variable-types.ts
+var VARIABLE_TYPES = new Set([
+  "string",
+  "integer",
+  "float",
+  "double",
+  "boolean",
+  "datetime",
+  "date",
+  "time",
+  "object",
+  "file",
+  "array",
+  "jsonSchema"
+]);
+var ALIASES = new Map([
+  ["number", "double"],
+  ["int", "integer"],
+  ["bool", "boolean"],
+  ["json", "object"],
+  ["dictionary", "object"]
+]);
+var BY_FOLDED = new Map([...VARIABLE_TYPES].map((type) => [type.toLowerCase(), type]));
+var canonicalVariableType = (declared) => {
+  if (VARIABLE_TYPES.has(declared))
+    return { type: declared, alias: false };
+  const folded = declared.toLowerCase();
+  const type = BY_FOLDED.get(folded) ?? ALIASES.get(folded);
+  return type === undefined ? undefined : { type, alias: true };
+};
+
+export { gateKey, canonicalVariableType };
+
+//# debugId=C2C5641D599E11AF64756E2164756E21

package/dist/packager-tool-kdhey8gz.js

@@ -0,0 +1,153 @@
+import {
+  catchError
+} from "./packager-tool-83v804p7.js";
+import {
+  getFileSystem
+} from "./packager-tool-hdxtgckw.js";
+
+// src/services/localSolutionDiscovery.ts
+var LOCAL_RESOURCE_TYPES = new Set([
+  "agent",
+  "process",
+  "api",
+  "processOrchestration",
+  "caseManagement",
+  "function",
+  "businessRule"
+]);
+var PROJECT_TYPE_TO_RESOURCE = {
+  Agent: "agent",
+  Process: "process",
+  Api: "api",
+  ProcessOrchestration: "processOrchestration",
+  CaseManagement: "caseManagement",
+  Function: "function",
+  BusinessRules: "businessRule"
+};
+var PROJECT_TYPE_TO_RESOURCE_LC = Object.fromEntries(Object.entries(PROJECT_TYPE_TO_RESOURCE).map(([k, v]) => [
+  k.toLowerCase(),
+  v
+]));
+var PROCESS_SUBDIR = ["resources", "solution_folder", "process"];
+function isUnder(parent, child) {
+  if (child === parent)
+    return true;
+  const fs = getFileSystem();
+  const rel = fs.path.relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !fs.path.isAbsolute(rel);
+}
+async function parseEnrichmentFile(filePath) {
+  const fs = getFileSystem();
+  const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+  if (readErr || !content)
+    return null;
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr || !parsed.resource?.projectKey)
+    return null;
+  const r = parsed.resource;
+  return [
+    r.projectKey,
+    {
+      key: r.key,
+      name: r.name,
+      folders: r.folders && r.folders.length > 0 ? r.folders.map((f) => ({
+        fullyQualifiedName: f.fullyQualifiedName ?? "solution_folder"
+      })) : undefined,
+      packageName: r.spec?.packageName
+    }
+  ];
+}
+async function loadResourceEnrichmentMap(solutionDir) {
+  const fs = getFileSystem();
+  const map = new Map;
+  const processDir = fs.path.join(solutionDir, ...PROCESS_SUBDIR);
+  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
+  if (dirErr || !Array.isArray(typeDirs))
+    return map;
+  for (const typeDir of typeDirs) {
+    const typePath = fs.path.join(processDir, typeDir);
+    const [filesErr, files] = await catchError(fs.readdir(typePath));
+    if (filesErr || !Array.isArray(files))
+      continue;
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      const entry = await parseEnrichmentFile(fs.path.join(typePath, file));
+      if (entry)
+        map.set(entry[0], entry[1]);
+    }
+  }
+  return map;
+}
+async function readProjectName(projectDir) {
+  const fs = getFileSystem();
+  const [err, content] = await catchError(fs.readFile(fs.path.join(projectDir, "project.uiproj"), "utf-8"));
+  if (!err && content) {
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (!parseErr && parsed.Name)
+      return parsed.Name;
+  }
+  return fs.path.basename(projectDir);
+}
+async function readEntryPointIO(projectDir) {
+  const fs = getFileSystem();
+  const candidates = [
+    fs.path.join(projectDir, "entry-points.json"),
+    fs.path.join(projectDir, "content", "entry-points.json")
+  ];
+  for (const filePath of candidates) {
+    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+    if (err || !content)
+      continue;
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (parseErr || !parsed.entryPoints?.length)
+      continue;
+    const ep = parsed.entryPoints[0];
+    return {
+      inputs: ep.input ?? ep.InputArguments,
+      outputs: ep.output ?? ep.OutputArguments
+    };
+  }
+  return {};
+}
+async function readLocalResourcesForType(ctx, resourceType, enrichment) {
+  if (!LOCAL_RESOURCE_TYPES.has(resourceType))
+    return [];
+  const fs = getFileSystem();
+  const enrichmentMap = enrichment ?? await loadResourceEnrichmentMap(ctx.solutionDir);
+  const entries = [];
+  for (const project of ctx.projects) {
+    if (!project.Id || !project.Type)
+      continue;
+    if (ctx.currentProjectId && project.Id === ctx.currentProjectId)
+      continue;
+    if (PROJECT_TYPE_TO_RESOURCE_LC[project.Type.toLowerCase()] !== resourceType)
+      continue;
+    const projectDir = fs.path.resolve(ctx.solutionDir, fs.path.dirname(project.ProjectRelativePath ?? ""));
+    if (!isUnder(ctx.solutionDir, projectDir))
+      continue;
+    const enriched = enrichmentMap.get(project.Id);
+    const [name, io] = await Promise.all([
+      enriched?.name ? Promise.resolve(enriched.name) : readProjectName(projectDir),
+      readEntryPointIO(projectDir)
+    ]);
+    entries.push({
+      entityKey: enriched?.key ?? project.Id,
+      name,
+      category: resourceType,
+      folders: enriched?.folders ?? [
+        { fullyQualifiedName: "solution_folder" }
+      ],
+      packageName: enriched?.packageName,
+      projectKey: project.Id,
+      inputs: io.inputs,
+      outputs: io.outputs,
+      source: "local"
+    });
+  }
+  return entries;
+}
+
+export { loadResourceEnrichmentMap, readLocalResourcesForType };
+
+//# debugId=44DA57B437646B6C64756E2164756E21