@uipath/packager-tool-functions 1.202.0 → 1.203.0-preview.160

package/dist/THIRD-PARTY-NOTICES.md

@@ -5,4 +5,16 @@ compiled into its `dist/` output rather than installed alongside it.
 Their licences and copyright notices are reproduced here in full, as
 those licences require.
 
-No third-party code is bundled into this package.
+1 bundled dependency:
+
+- @uipath/coded-functions-js-packager@0.1.10 — see below
+
+---
+
+## @uipath/coded-functions-js-packager@0.1.10
+
+SPDX: 
+
+The upstream package ships no licence file here; `` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.

package/dist/index.js

@@ -11,34 +11,110 @@ import {
 } from "@uipath/solutionpackager-tool-core";
 
 // ../../../node_modules/@uipath/coded-functions-js-packager/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");
@@ -62,8 +138,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,
@@ -109,9 +193,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);
@@ -124,15 +209,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()) {
@@ -449,4 +535,4 @@ export {
   Languages
 };
 
-//# debugId=79823B003B2CADC564756E2164756E21
+//# debugId=F5FA45901B1BE10264756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-functions",
-    "version": "1.202.0",
+    "version": "1.203.0-preview.160",
     "description": "UiPath Functions tool implementation",
     "type": "module",
     "exports": {
@@ -18,10 +18,10 @@
     "files": [
         "dist"
     ],
-    "author": "",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.202.0"
+        "@uipath/solutionpackager-tool-core": "1.203.0"
     },
-    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
+    "gitHead": "3a42062ba731afca4595ba9aa8a80afc9667528d"
 }