@uipath/case-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/{packager-tool-sfkyb4kz.js → packager-tool-4rqd21wc.js}

@@ -125,6 +125,29 @@ async function ensureProjectId(projectPath, fs) {
   }
   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();
+}
 
 // ../packager/packager-core/src/services/nuget-packager.ts
 function escapeXml(str) {
@@ -292,6 +315,175 @@ if (!_global[REGISTRY_KEY]) {
   _global[REGISTRY_KEY] = new ToolsFactoryRepository;
 }
 var toolsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../packager/packager-core/src/models/nuget-constants.ts
+var NugetConstants = {
+  OutputFolderName: "bundle",
+  ContentFolderName: "content",
+  OperateFileName: "operate.json",
+  EntryPointsFileName: "entry-points.json",
+  PackageDescriptorFileName: "package-descriptor.json",
+  BindingsV2FileName: "bindings_v2.json",
+  BindingsFileId: "bindings.json"
+};
+
+// ../packager/packager-core/src/services/content-operate-file.ts
+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
+  });
+}
+// ../packager/packager-core/src/models/tool-result.ts
+class ToolResult {
+  errorCode;
+  message;
+  packages;
+  details;
+  instructions;
+  constructor(errorCode, message, packages = [], instructions) {
+    this.errorCode = errorCode;
+    this.message = message;
+    this.packages = packages;
+    this.instructions = instructions;
+  }
+  get isSuccess() {
+    return this.errorCode === "SUCCESS" /* Success */;
+  }
+  static success() {
+    return new ToolResult("SUCCESS" /* Success */);
+  }
+  static error(errorCode, message, instructions) {
+    return new ToolResult(errorCode, message, [], instructions);
+  }
+}
+
+// ../packager/packager-core/src/services/project-tool.ts
+class ProjectTool {
+  fileSystem;
+  logger;
+  static ProjectFileName = "project.uiproj";
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is a noop");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is a noop");
+    return ToolResult.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation is a noop");
+    return ToolResult.success();
+  }
+  async packAsync(_options, _cancellationToken) {
+    this.logger.info("Pack operation is a noop");
+    return ToolResult.success();
+  }
+  async cleanupAsync(_options, _cancellationToken) {
+    this.logger.info("Cleanup operation is a noop");
+    return ToolResult.success();
+  }
+  async getUiProjectAsync(projectPath) {
+    const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
+    if (!await this.fileSystem.exists(filePath)) {
+      return;
+    }
+    const raw = await this.fileSystem.readFile(filePath);
+    if (!raw) {
+      return;
+    }
+    const json = typeof raw === "string" ? raw : new TextDecoder("utf-8").decode(raw);
+    return JSON.parse(json);
+  }
+  async dispose() {}
+}
+// ../packager/packager-core/src/filesystem/temporary-storage-service.ts
+class TemporaryStorageService {
+  fileSystem;
+  _tempFolderPath = null;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async getTempFolderPath() {
+    if (!this._tempFolderPath) {
+      const systemTempDir = await this.fileSystem.getTempDir();
+      const uniqueFolderName = this.generateUniqueFolderName();
+      this._tempFolderPath = Path.join(systemTempDir, uniqueFolderName);
+      await this.fileSystem.mkdir(this._tempFolderPath);
+    }
+    return this._tempFolderPath;
+  }
+  generateUniqueFolderName() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `tool-temp-${timestamp}-${random}`;
+  }
+  async getTempSubfolderPathAsync(subfolder) {
+    const tempFolderPath = await this.getTempFolderPath();
+    const inputPath = Path.join(tempFolderPath, subfolder);
+    await this.fileSystem.mkdir(inputPath);
+    return inputPath;
+  }
+  async cleanup() {
+    try {
+      if (!this._tempFolderPath) {
+        return;
+      }
+      try {
+        const stats = await this.fileSystem.stat(this._tempFolderPath);
+        if (!stats) {
+          return;
+        }
+      } catch {
+        return;
+      }
+      const _pathToCleanup = this._tempFolderPath;
+      await this.fileSystem.rm(this._tempFolderPath);
+      this._tempFolderPath = null;
+    } catch {}
+  }
+}
 // ../packager/packager-core/src/i18n/types.ts
 function isPluralForm(value) {
   return typeof value === "object" && value !== null && "other" in value;
@@ -1115,6 +1307,6 @@ I18nManager.registerTranslations("zh-cn", zh_CN);
 I18nManager.registerTranslations("zh-tw", zh_TW);
 I18nManager.registerTranslations("zu", zu);
 I18nManager.setLocale("en");
-export { ensureProjectId, NugetPackager, toolsFactoryRepository };
+export { Path, TemporaryStorageService, NugetConstants, ToolResult, ensureProjectId, ensureContentOperateFile, NugetPackager, ProjectTool, toolsFactoryRepository };
 
-//# debugId=D3514638EC5C638064756E2164756E21
+//# debugId=D78B926691074C7664756E2164756E21

package/dist/packager-tool-57pzrd0g.js

@@ -0,0 +1,32 @@
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-cmwets3m.js";
+
+// src/services/case-schema-version.ts
+var MIN_SUPPORTED_MAJOR = 20;
+async function resolveCaseSchemaVersion() {
+  const { LATEST_CASE_SCHEMA_VERSION } = await loadCaseSchemaAsync();
+  if (parseCaseSchemaVersion(LATEST_CASE_SCHEMA_VERSION) === null) {
+    throw new Error(`@uipath/case-schema exports a LATEST_CASE_SCHEMA_VERSION that is not "<major>.<minor>.<patch>": ${String(LATEST_CASE_SCHEMA_VERSION)}`);
+  }
+  return LATEST_CASE_SCHEMA_VERSION;
+}
+function parseCaseSchemaVersion(version) {
+  if (typeof version !== "string")
+    return null;
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  if (!match)
+    return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10)
+  };
+}
+function compareCaseSchemaVersions(a, b) {
+  return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+
+export { MIN_SUPPORTED_MAJOR, resolveCaseSchemaVersion, parseCaseSchemaVersion, compareCaseSchemaVersions };
+
+//# debugId=11DAE5CFC88DAB2564756E2164756E21