@uipath/function-tool 1.202.0-preview.155 → 1.202.0-preview.157

package/dist/packager-tool.js

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./packager-tool-1bx83sw4.js";
+} from "./packager-tool-1de529jm.js";
 
 // ../../node_modules/fflate/esm/index.mjs
 import { createRequire } from "module";
@@ -1884,34 +1884,110 @@ if (!_global[REGISTRY_KEY]) {
 var toolsFactoryRepository = _global[REGISTRY_KEY];
 
 // ../packager/packager-tool-functions/dist/index.js
-var EXCLUDED_NAMES = new Set([
-  "node_modules",
-  ".git",
-  ".env",
-  ".deno",
-  "dist",
-  ".uipath"
-]);
-var EXCLUDED_EXTENSIONS = [".nupkg"];
-var NPMRC = ".npmrc";
-var UIPATH_SCOPE = "@uipath:";
+var npm = { name: "npm", lockFile: "package-lock.json", installHint: "npm install" };
+var bun = { name: "bun", lockFile: "bun.lock", installHint: "bun install" };
+var SUPPORTED_MANAGERS = [npm, bun];
+var RECOGNIZED_UNSUPPORTED_LOCK_FILES = ["yarn.lock", "pnpm-lock.yaml", "bun.lockb"];
+function detectPackageManager(present) {
+  const supported = SUPPORTED_MANAGERS.filter((manager) => present.has(manager.lockFile));
+  if (supported.length > 1)
+    return { kind: "ambiguous", managers: supported };
+  if (supported.length === 1)
+    return { kind: "found", manager: supported[0] };
+  const unsupported = RECOGNIZED_UNSUPPORTED_LOCK_FILES.filter((name) => present.has(name));
+  return unsupported.length > 0 ? { kind: "unsupported", fileNames: unsupported } : { kind: "none" };
+}
+var CANDIDATE_LOCK_FILES = [
+  ...SUPPORTED_MANAGERS.map((manager) => manager.lockFile),
+  ...RECOGNIZED_UNSUPPORTED_LOCK_FILES
+];
+async function probeLockFiles(reader) {
+  const present = new Set;
+  for (const fileName of CANDIDATE_LOCK_FILES) {
+    if (await reader.fileExists(fileName))
+      present.add(fileName);
+  }
+  return present;
+}
+function supportedLockFilesLabel() {
+  return SUPPORTED_MANAGERS.map((manager) => `${manager.lockFile} (${manager.name})`).join(" or ");
+}
+function describeDependencyProblem(detection) {
+  const defaultHint = SUPPORTED_MANAGERS[0].installHint;
+  switch (detection.kind) {
+    case "none":
+      return {
+        problem: `No dependency lock file found; expected ${supportedLockFilesLabel()}.`,
+        remedyCommand: defaultHint
+      };
+    case "unsupported": {
+      const names = detection.fileNames.join(" and ");
+      return {
+        problem: `Found ${names}, which cannot be installed from; expected ${supportedLockFilesLabel()}. ` + `Create a supported lock file, then delete ${names}.`,
+        remedyCommand: defaultHint
+      };
+    }
+    case "ambiguous":
+      return {
+        problem: `Found ${detection.managers.map((manager) => manager.lockFile).join(" and ")}. Keep exactly one: ` + `with two lock files the installer that runs on the pod picks one and the other's resolution ` + `is silently ignored.`,
+        remedyCommand: null
+      };
+  }
+}
+var REGISTRY_CONFIG_FILE = ".npmrc";
+function isRegistryConfigFile(fileName) {
+  return fileName === REGISTRY_CONFIG_FILE;
+}
 var CREDENTIAL_KEYS = ["_authtoken", "_auth", "_password"];
 function isComment(line) {
   return line === "" || line.startsWith("#") || line.startsWith(";");
 }
-function isOurs(line) {
+function settingKey(line) {
   const trimmed = line.trim();
   if (isComment(trimmed))
-    return false;
-  const key = (trimmed.split("=")[0] ?? "").trim().toLowerCase();
-  return key.startsWith(UIPATH_SCOPE) || CREDENTIAL_KEYS.some((c) => key.endsWith(c));
+    return null;
+  return (trimmed.split("=")[0] ?? "").trim().toLowerCase();
 }
-function sanitizeNpmrc(content) {
-  const kept = content.split(/\r?\n/).filter((line) => !isOurs(line));
+function sanitizeRegistryConfig(content, stripScopes) {
+  const stripped = stripScopes.map((scope) => `${scope.replace(/:$/, "")}:`.toLowerCase());
+  const kept = content.split(/\r?\n/).filter((line) => {
+    const key = settingKey(line);
+    if (key === null)
+      return true;
+    if (stripped.some((scope) => key.startsWith(scope)))
+      return false;
+    return !CREDENTIAL_KEYS.some((credential) => key.endsWith(credential));
+  });
   return kept.some((line) => !isComment(line.trim())) ? kept.join(`
 `) : null;
 }
-var LOCK_FILES = new Set(["bun.lock", "package-lock.json", "deno.lock", "yarn.lock"]);
+function ifsProjectFileReader(fs, projectPath) {
+  return {
+    async fileExists(fileName) {
+      try {
+        return await fs.exists(fs.path.join(projectPath, fileName));
+      } catch {
+        return false;
+      }
+    },
+    async readFile(fileName) {
+      const content = await fs.readFile(fs.path.join(projectPath, fileName), "utf-8");
+      if (content === null)
+        throw new Error(`${fileName} not found in ${projectPath}.`);
+      return content;
+    }
+  };
+}
+var EXCLUDED_NAMES = new Set([
+  "node_modules",
+  ".git",
+  ".env",
+  ".deno",
+  "dist",
+  ".uipath"
+]);
+var EXCLUDED_EXTENSIONS = [".nupkg"];
+var SCOPES_NOT_PACKAGED = ["@uipath"];
 async function buildFunctionsPackage(fs, options) {
   const { projectPath, outputPath, projectStorageId } = options;
   const contentPath = fs.path.join(outputPath, "content");
@@ -1935,8 +2011,16 @@ async function buildFunctionsPackage(fs, options) {
   const packageJsonRaw = await fs.readFile(fs.path.join(projectPath, "package.json"), "utf-8");
   const packageDependencies = packageJsonRaw ? JSON.parse(packageJsonRaw).dependencies ?? {} : {};
   const targetRuntime = detectRuntime(uipathJson.functions);
-  const includeLockFile = options.excludeLockFile ? false : uipathJson.packOptions?.includeLockFile ?? true;
-  await copyProjectFiles(fs, projectPath, contentPath, includeLockFile, uipathJson.packOptions);
+  const detection = detectPackageManager(await probeLockFiles(ifsProjectFileReader(fs, projectPath)));
+  if (detection.kind !== "found") {
+    const { problem, remedyCommand } = describeDependencyProblem(detection);
+    throw new Error(remedyCommand !== null ? `${problem} Run '${remedyCommand}' in the project, then pack again.` : `${problem} Then pack again.`);
+  }
+  const lockFile = detection.manager.lockFile;
+  if (uipathJson.packOptions?.includeLockFile === false) {
+    console.warn(`uipath.json packOptions.includeLockFile is ignored: ${lockFile} is always packaged.`);
+  }
+  await copyProjectFiles(fs, projectPath, contentPath, lockFile, uipathJson.packOptions);
   const operateJson = {
     $schema: "https://cloud.uipath.com/draft/2024-12/operate",
     projectId: projectStorageId,
@@ -1982,9 +2066,10 @@ function detectRuntime(functions) {
     return "python";
   return "javascript";
 }
-async function copyProjectFiles(fs, sourcePath, destPath, includeLockFile, packOptions) {
+async function copyProjectFiles(fs, sourcePath, destPath, lockFile, packOptions) {
   const extraExcludedDirs = new Set(packOptions?.directoriesExcluded ?? []);
   const extraExcludedFiles = new Set(packOptions?.filesExcluded ?? []);
+  const otherLockFiles = new Set(CANDIDATE_LOCK_FILES.filter((name) => name !== lockFile));
   async function walk(src, dest) {
     await fs.mkdir(dest);
     const entries = await fs.readdir(src);
@@ -1997,15 +2082,16 @@ async function copyProjectFiles(fs, sourcePath, destPath, includeLockFile, packO
         continue;
       if (EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext)))
         continue;
-      if (!includeLockFile && LOCK_FILES.has(name))
+      if (otherLockFiles.has(name))
         continue;
       const srcEntry = fs.path.join(src, name);
       const destEntry = fs.path.join(dest, name);
       const stat = await fs.stat(srcEntry);
       if (stat?.isDirectory()) {
         await walk(srcEntry, destEntry);
-      } else if (name === NPMRC) {
-        const sanitized = sanitizeNpmrc(await fs.readFile(srcEntry, "utf-8") ?? "");
+      } else if (isRegistryConfigFile(name)) {
+        const raw = await fs.readFile(srcEntry, "utf-8") ?? "";
+        const sanitized = sanitizeRegistryConfig(raw, SCOPES_NOT_PACKAGED);
         if (sanitized !== null)
           await fs.writeFile(destEntry, sanitized);
       } else if (stat?.isFile()) {
@@ -2312,7 +2398,7 @@ function createManifestGeneratingFunctionsToolFactory() {
       if (language === Languages.JavaScript) {
         this.logger.progress("Generating Functions manifests...");
         try {
-          const { generateManifests } = await import("./cliRunner-gtb0dftd.js");
+          const { generateManifests } = await import("./cliRunner-bxxtxqc3.js");
           await generateManifests(options.projectPath);
         } catch (error) {
           const errorMessage = error instanceof Error ? error.toString() : String(error);
@@ -2340,4 +2426,4 @@ export {
   registerPackagerFactories
 };
 
-//# debugId=F1DD9E77602436F664756E2164756E21
+//# debugId=EFD595DCE5DAE45864756E2164756E21