@uipath/case-tool 1.195.0 → 1.197.0-preview.59

package/dist/packager-tool.js

@@ -1,9 +1,11 @@
 // ../../node_modules/fflate/esm/index.mjs
 import { createRequire } from "module";
 var require2 = createRequire("/");
+var _a;
 var Worker;
+var isMarkedAsUntransferable;
 try {
-  Worker = require2("worker_threads").Worker;
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
 } catch (e) {}
 var u8 = Uint8Array;
 var u16 = Uint16Array;
@@ -489,7 +491,7 @@ var fltn = function(d, p, t, o) {
     var val = d[k], n = p + k, op = o;
     if (Array.isArray(val))
       op = mrg(o, val[1]), val = val[0];
-    if (val instanceof u8)
+    if (ArrayBuffer.isView(val))
       t[n] = [val, op];
     else {
       t[n += "/"] = [new u8(0), op];
@@ -734,7 +736,7 @@ class TemporaryStorageService {
       } catch {
         return;
       }
-      const pathToCleanup = this._tempFolderPath;
+      const _pathToCleanup = this._tempFolderPath;
       await this.fileSystem.rm(this._tempFolderPath);
       this._tempFolderPath = null;
     } catch {}
@@ -1596,6 +1598,138 @@ class ToolResult {
     return new ToolResult(errorCode, message);
   }
 }
+var OPERATE_FILE = "operate.json";
+var PROJECT_FILE = "project.json";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+async function readJsonObject(fs, filePath) {
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  if (content === null) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed === null || typeof parsed !== "object") {
+      return;
+    }
+    return parsed;
+  } catch {
+    return;
+  }
+}
+async function writeJsonObject(fs, filePath, data) {
+  await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+async function ensureProjectId(projectPath, fs) {
+  const operatePath = Path.join(projectPath, OPERATE_FILE);
+  const operateExists = await fs.exists(operatePath);
+  if (operateExists) {
+    const operate = await readJsonObject(fs, operatePath);
+    if (operate && isNonEmptyString(operate.projectId)) {
+      return operate.projectId;
+    }
+    if (operate) {
+      const id = crypto.randomUUID();
+      await writeJsonObject(fs, operatePath, {
+        ...operate,
+        projectId: id
+      });
+      return id;
+    }
+    return crypto.randomUUID();
+  }
+  const projectFilePath = Path.join(projectPath, PROJECT_FILE);
+  const projectFileExists = await fs.exists(projectFilePath);
+  if (projectFileExists) {
+    const projectFile = await readJsonObject(fs, projectFilePath);
+    if (projectFile && isNonEmptyString(projectFile.projectId)) {
+      return projectFile.projectId;
+    }
+    if (projectFile) {
+      const id = crypto.randomUUID();
+      await writeJsonObject(fs, projectFilePath, {
+        ...projectFile,
+        projectId: id
+      });
+      return id;
+    }
+    return crypto.randomUUID();
+  }
+  return crypto.randomUUID();
+}
+async function ensureProjectIdInOperateFile(operateFilePath, fallbackProjectId, fs) {
+  if (!await fs.exists(operateFilePath)) {
+    return;
+  }
+  const parsed = await readJsonObject(fs, operateFilePath);
+  if (!parsed) {
+    return;
+  }
+  if (isNonEmptyString(parsed.projectId)) {
+    return;
+  }
+  await writeJsonObject(fs, operateFilePath, {
+    ...parsed,
+    projectId: fallbackProjectId
+  });
+}
+async function writeOrBackfillOperateProjectId(operateFilePath, projectId, fs, createIfMissing) {
+  if (await fs.exists(operateFilePath)) {
+    await ensureProjectIdInOperateFile(operateFilePath, projectId, fs);
+    return;
+  }
+  await createIfMissing();
+}
+var OPERATE_SCHEMA = "https://cloud.uipath.com/draft/2024-12/operate";
+async function resolveEntryPointMain(fs, sourceFolder) {
+  const entryPointsFilePath = Path.join(sourceFolder, NugetConstants.EntryPointsFileName);
+  if (!await fs.exists(entryPointsFilePath)) {
+    return "";
+  }
+  const content = await fs.readFile(entryPointsFilePath);
+  if (!content) {
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(content));
+    return parsed.entryPoints?.[0]?.filePath ?? "";
+  } catch {
+    return "";
+  }
+}
+async function writeContentOperateFile(fs, params) {
+  const operateFilePath = Path.join(params.contentFolder, NugetConstants.OperateFileName);
+  await writeOrBackfillOperateProjectId(operateFilePath, params.projectId, fs, async () => {
+    const main = await resolveEntryPointMain(fs, params.contentFolder);
+    const operateFileModel = {
+      $schema: OPERATE_SCHEMA,
+      contentType: params.contentType,
+      projectId: params.projectId,
+      main,
+      targetFramework: "Portable",
+      runtimeOptions: {
+        isAttended: false,
+        requiresUserInteraction: false
+      }
+    };
+    await fs.writeFile(operateFilePath, JSON.stringify(operateFileModel, null, 2));
+  });
+}
+async function ensureContentOperateFile(fs, params) {
+  const projectId = params.projectStorageId ?? await ensureProjectId(params.projectPath, fs);
+  await writeContentOperateFile(fs, {
+    contentFolder: params.contentFolder,
+    projectId,
+    contentType: params.contentType
+  });
+}
 function escapeXml(str) {
   if (str === null || str === undefined) {
     return "";
@@ -1758,8 +1892,11 @@ class ToolsFactoryRepository {
   solutionFactory = null;
   registerProjectToolFactory(factory) {
     for (const type of factory.supportedTypes) {
-      if (this.projectFactoryMap.has(type)) {
-        console.warn(`Tool factory already registered for project type '${type}', skipping.`);
+      const existing = this.projectFactoryMap.get(type);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          console.warn(`Tool factory conflict for project type '${type}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
         continue;
       }
       this.projectFactoryMap.set(type, factory);
@@ -1880,39 +2017,12 @@ class CaseTool extends ProjectTool {
     }
   }
   async createOperateFile(options, contentFolder) {
-    const operateJsonFilePath = Path.join(contentFolder, NugetConstants.OperateFileName);
-    const exists = await this.fileSystem.exists(operateJsonFilePath);
-    if (!exists) {
-      await this.createOperateJsonFile(contentFolder, options.projectStorageId ?? "", operateJsonFilePath);
-    }
-  }
-  async createOperateJsonFile(projectPath, projectId, filePath) {
-    const entryPointsFilePath = Path.join(projectPath, CaseConstants.EntryPointsFileName);
-    let mainPath = "";
-    const entryPointsExists = await this.fileSystem.exists(entryPointsFilePath);
-    if (entryPointsExists) {
-      const entryPointsContent = await this.fileSystem.readFile(entryPointsFilePath);
-      if (entryPointsContent) {
-        try {
-          const entryPointsText = new TextDecoder().decode(entryPointsContent);
-          const entryPoints = JSON.parse(entryPointsText);
-          mainPath = entryPoints.entryPoints?.[0]?.filePath ?? "";
-        } catch {}
-      }
-    }
-    const operateFileModel = {
-      $schema: "https://cloud.uipath.com/draft/2024-12/operate",
-      contentType: ProjectTypes.CaseManagement,
-      projectId,
-      main: mainPath,
-      targetFramework: "Portable",
-      runtimeOptions: {
-        isAttended: false,
-        requiresUserInteraction: false
-      }
-    };
-    const operateJsonString = JSON.stringify(operateFileModel, null, 2);
-    await this.fileSystem.writeFile(filePath, operateJsonString);
+    await ensureContentOperateFile(this.fileSystem, {
+      contentFolder,
+      projectPath: options.projectPath,
+      projectStorageId: options.projectStorageId,
+      contentType: ProjectTypes.CaseManagement
+    });
   }
   async createPackageDescriptor(localBuildFolder, contentFolder) {
     const descriptorFiles = {};
@@ -1946,3 +2056,876 @@ class CaseToolFactory {
 
 // ../packager/packager-tool-case/src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
+// ../packager/packager-core/src/i18n/types.ts
+function isPluralForm2(value) {
+  return typeof value === "object" && value !== null && "other" in value;
+}
+function selectPluralForm2(forms, count) {
+  if (count === 0 && forms.zero !== undefined) {
+    return forms.zero;
+  }
+  if (count === 1 && forms.one !== undefined) {
+    return forms.one;
+  }
+  if (count === 2 && forms.two !== undefined) {
+    return forms.two;
+  }
+  if (forms.few !== undefined) {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) {
+      return forms.few;
+    }
+  }
+  if (forms.many !== undefined) {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (count === 0 || mod10 === 0 && mod100 !== 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14) {
+      return forms.many;
+    }
+  }
+  return forms.other;
+}
+
+// ../packager/packager-core/src/i18n/i18n-manager.ts
+class I18nManager2 {
+  static translations = {};
+  static currentLocale = "en";
+  static fallbackLocale = "en";
+  static registerTranslations(locale, catalog) {
+    if (!I18nManager2.translations[locale]) {
+      I18nManager2.translations[locale] = {};
+    }
+    I18nManager2.translations[locale] = I18nManager2.deepMerge(I18nManager2.translations[locale], catalog);
+  }
+  static setLocale(locale) {
+    const normalized = I18nManager2.normalizeLocale(locale);
+    if (I18nManager2.translations[normalized]) {
+      I18nManager2.currentLocale = normalized;
+      return normalized;
+    }
+    const baseLocale = normalized.split("-")[0];
+    if (baseLocale !== normalized && I18nManager2.translations[baseLocale]) {
+      I18nManager2.currentLocale = baseLocale;
+      return baseLocale;
+    }
+    return I18nManager2.currentLocale;
+  }
+  static getLocale() {
+    return I18nManager2.currentLocale;
+  }
+  static setFallbackLocale(locale) {
+    I18nManager2.fallbackLocale = I18nManager2.normalizeLocale(locale);
+  }
+  static t(key, params, locale) {
+    const targetLocale = locale ? I18nManager2.normalizeLocale(locale) : I18nManager2.currentLocale;
+    let value = I18nManager2.getTranslationValue(key, targetLocale);
+    if (value === undefined && targetLocale !== I18nManager2.fallbackLocale) {
+      value = I18nManager2.getTranslationValue(key, I18nManager2.fallbackLocale);
+    }
+    if (value === undefined) {
+      return key;
+    }
+    if (isPluralForm2(value) && params && "count" in params) {
+      const count = typeof params.count === "number" ? params.count : Number(params.count);
+      value = selectPluralForm2(value, count);
+    } else if (isPluralForm2(value)) {
+      value = value.other;
+    }
+    if (typeof value !== "string") {
+      return key;
+    }
+    return params ? I18nManager2.interpolate(value, params) : value;
+  }
+  static has(key, locale) {
+    const targetLocale = locale ? I18nManager2.normalizeLocale(locale) : I18nManager2.currentLocale;
+    const value = I18nManager2.getTranslationValue(key, targetLocale);
+    if (value !== undefined) {
+      return true;
+    }
+    if (targetLocale !== I18nManager2.fallbackLocale) {
+      return I18nManager2.getTranslationValue(key, I18nManager2.fallbackLocale) !== undefined;
+    }
+    return false;
+  }
+  static getAvailableLocales() {
+    return Object.keys(I18nManager2.translations);
+  }
+  static clearTranslations() {
+    I18nManager2.translations = {};
+    I18nManager2.currentLocale = "en";
+  }
+  static getTranslationValue(key, locale) {
+    const catalog = I18nManager2.translations[locale];
+    if (!catalog) {
+      return;
+    }
+    const keys = key.split(".");
+    let value = catalog;
+    for (const k of keys) {
+      if (value && typeof value === "object" && k in value) {
+        value = value[k];
+      } else {
+        return;
+      }
+    }
+    return value;
+  }
+  static interpolate(template, params) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+      const value = params[key];
+      return value !== undefined ? String(value) : `{${key}}`;
+    });
+  }
+  static normalizeLocale(locale) {
+    const normalized = locale.toLowerCase().replace(/_/g, "-");
+    const specialLocales = ["es-mx", "pt-br", "zh-cn", "zh-tw"];
+    if (specialLocales.includes(normalized)) {
+      return normalized;
+    }
+    return normalized.split("-")[0];
+  }
+  static deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = I18nManager2.deepMerge(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+    return result;
+  }
+}
+
+// ../packager/packager-core/src/i18n/locales/de.ts
+var de2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/en.ts
+var en2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/es.ts
+var es2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/es-MX.ts
+var es_MX2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/fr.ts
+var fr2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ja.ts
+var ja2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ko.ts
+var ko2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/pt.ts
+var pt2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/pt-BR.ts
+var pt_BR2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ro.ts
+var ro2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ru.ts
+var ru2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/tr.ts
+var tr2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/zh-CN.ts
+var zh_CN2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/zh-TW.ts
+var zh_TW2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/zu.ts
+var zu2 = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/translation-service.ts
+class TranslationService2 {
+  static instance;
+  currentLocale = "en";
+  constructor() {}
+  static getInstance() {
+    if (!TranslationService2.instance) {
+      TranslationService2.instance = new TranslationService2;
+    }
+    return TranslationService2.instance;
+  }
+  setLocale(locale) {
+    this.currentLocale = I18nManager2.setLocale(locale);
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  t(key, params) {
+    return I18nManager2.t(key, params, this.currentLocale);
+  }
+  tLocale(key, locale, params) {
+    return I18nManager2.t(key, params, locale);
+  }
+  has(key) {
+    return I18nManager2.has(key, this.currentLocale);
+  }
+  getAvailableLocales() {
+    return I18nManager2.getAvailableLocales();
+  }
+}
+var translate2 = TranslationService2.getInstance();
+
+// ../packager/packager-core/src/i18n/index.ts
+I18nManager2.registerTranslations("en", en2);
+I18nManager2.registerTranslations("de", de2);
+I18nManager2.registerTranslations("es", es2);
+I18nManager2.registerTranslations("es-mx", es_MX2);
+I18nManager2.registerTranslations("fr", fr2);
+I18nManager2.registerTranslations("ja", ja2);
+I18nManager2.registerTranslations("ko", ko2);
+I18nManager2.registerTranslations("pt", pt2);
+I18nManager2.registerTranslations("pt-br", pt_BR2);
+I18nManager2.registerTranslations("ro", ro2);
+I18nManager2.registerTranslations("ru", ru2);
+I18nManager2.registerTranslations("tr", tr2);
+I18nManager2.registerTranslations("zh-cn", zh_CN2);
+I18nManager2.registerTranslations("zh-tw", zh_TW2);
+I18nManager2.registerTranslations("zu", zu2);
+I18nManager2.setLocale("en");
+// ../packager/packager-core/src/services/tools-factory-repository.ts
+class ToolsFactoryRepository2 {
+  projectFactoryMap = new Map;
+  solutionFactory = null;
+  registerProjectToolFactory(factory) {
+    for (const type of factory.supportedTypes) {
+      const existing = this.projectFactoryMap.get(type);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          console.warn(`Tool factory conflict for project type '${type}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.projectFactoryMap.set(type, factory);
+    }
+  }
+  registerSolutionToolFactory(factory) {
+    this.solutionFactory = factory;
+  }
+  getSolutionToolFactory() {
+    if (!this.solutionFactory) {
+      throw new Error("No solution tool factory is registered");
+    }
+    return this.solutionFactory;
+  }
+  canHandleProject(projectType) {
+    return this.projectFactoryMap.has(projectType);
+  }
+  getProjectToolFactory(projectType) {
+    const factory = this.projectFactoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`No tool factory found for project type '${projectType}'`);
+    }
+    return factory;
+  }
+  reset() {
+    this.projectFactoryMap.clear();
+    this.solutionFactory = null;
+  }
+}
+var REGISTRY_KEY2 = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
+var _global2 = globalThis;
+if (!_global2[REGISTRY_KEY2]) {
+  _global2[REGISTRY_KEY2] = new ToolsFactoryRepository2;
+}
+var toolsFactoryRepository2 = _global2[REGISTRY_KEY2];
+// src/packager-tool.ts
+toolsFactoryRepository2.registerProjectToolFactory(new CaseToolFactory);
+
+//# debugId=68E4F5A39F4EC1A864756E2164756E21