@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/packager-tool-e15kqpyh.js

@@ -1,266 +0,0 @@
-import {
-  NugetConstants,
-  NugetPackager,
-  Path,
-  ProjectTool,
-  TemporaryStorageService,
-  ToolResult,
-  ensureContentOperateFile,
-  toolsFactoryRepository
-} from "./packager-tool-yn7r7zq2.js";
-
-// ../packager/packager-tool-case/src/case-bpmn-compiler.ts
-var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
-var _global = globalThis;
-function registerCaseBpmnCompiler(caseBpmnCompiler) {
-  _global[COMPILER_KEY] = caseBpmnCompiler;
-}
-function getCaseBpmnCompiler() {
-  return _global[COMPILER_KEY];
-}
-
-// ../packager/packager-tool-case/src/case-plan-file.ts
-var CasePlanFileNames = [
-  "caseplan.case",
-  "caseplan.json",
-  "case.stage.json",
-  "default.stage.json"
-];
-var casePlanSidecarName = (casePlanFileName) => `${casePlanFileName}.bpmn`;
-var findCasePlanFileName = (entries) => {
-  const present = new Set(entries);
-  return CasePlanFileNames.find((candidate) => present.has(candidate));
-};
-var stripDeclaredFilePathPrefix = (filePath) => {
-  const withoutLeadingSlash = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  return withoutLeadingSlash.startsWith("content/") ? withoutLeadingSlash.slice("content/".length) : withoutLeadingSlash;
-};
-var resolveDeclaredFileName = (filePath) => {
-  const stripped = stripDeclaredFilePathPrefix(filePath.split("#")[0]);
-  return stripped.includes("/") ? "" : stripped;
-};
-var normalizeEntryPointPath = (filePath) => `/${stripDeclaredFilePathPrefix(filePath)}`;
-var entryPointBpmnNames = (entryPointsJson) => {
-  try {
-    const parsed = JSON.parse(entryPointsJson);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error("document is not an object");
-    }
-    if (parsed.entryPoints !== undefined && !Array.isArray(parsed.entryPoints)) {
-      throw new Error("entryPoints is not a list");
-    }
-    const resolvedNames = (parsed.entryPoints ?? []).map((entry) => typeof entry.filePath === "string" ? resolveDeclaredFileName(entry.filePath) : "");
-    if (resolvedNames.includes("")) {
-      throw new Error("an entry point has no usable filePath");
-    }
-    const names = resolvedNames.filter((name) => name.endsWith(".bpmn"));
-    return [...new Set(names)];
-  } catch {
-    return null;
-  }
-};
-var misnamedEntryPointBpmn = (declared, casePlanFileName) => {
-  const own = casePlanSidecarName(casePlanFileName);
-  const otherPlans = new Set(CasePlanFileNames.filter((name) => name !== casePlanFileName).map(casePlanSidecarName));
-  return declared.find((file) => file !== own && otherPlans.has(file));
-};
-var buildCasePackageDescriptor = (contentFileNames) => ({
-  $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-  files: {
-    [NugetConstants.OperateFileName]: `${NugetConstants.ContentFolderName}/${NugetConstants.OperateFileName}`,
-    [NugetConstants.EntryPointsFileName]: `${NugetConstants.ContentFolderName}/${NugetConstants.EntryPointsFileName}`,
-    [NugetConstants.BindingsFileId]: `${NugetConstants.ContentFolderName}/${NugetConstants.BindingsV2FileName}`,
-    ...Object.fromEntries(contentFileNames.filter((name) => name.endsWith(".bpmn") || CasePlanFileNames.includes(name)).map((name) => [
-      name,
-      `${NugetConstants.ContentFolderName}/${name}`
-    ]))
-  }
-});
-
-// ../packager/packager-tool-case/src/case-tool.ts
-var CaseConstants = {
-  EntryPointsFileName: "entry-points.json"
-};
-
-class CaseTool extends ProjectTool {
-  _temporaryStorage;
-  constructor(fileSystem, logger) {
-    super(fileSystem, logger);
-    this._temporaryStorage = new TemporaryStorageService(fileSystem);
-  }
-  async restoreAsync(_options, _cancellationToken) {
-    this.logger.info("Restore operation is not required for Case Management projects");
-    return ToolResult.success();
-  }
-  async validateAsync(_options, _cancellationToken) {
-    this.logger.info("Validate operation is not required for Case Management projects");
-    return ToolResult.success();
-  }
-  async buildAsync(options, _cancellationToken) {
-    const tempFolder = await this._temporaryStorage.getTempFolderPath();
-    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
-    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
-    try {
-      this.logger.progress("Copying files...");
-      await this.copyFiles(options.projectPath, contentFolder);
-      this.logger.progress("Compiling case plan to BPMN...");
-      const compileResult = await this.compileCasePlan(options.projectPath, contentFolder);
-      if (!compileResult.isSuccess) {
-        return compileResult;
-      }
-      this.logger.progress("Creating operate.json file...");
-      await this.createOperateFile(options, contentFolder);
-      this.logger.progress("Creating package-descriptor.json file...");
-      await this.createPackageDescriptor(localBuildFolder, contentFolder);
-      return new ToolResult("SUCCESS" /* Success */, "done", [
-        localBuildFolder
-      ]);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.toString() : String(error);
-      this.logger.error(errorMessage);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while building Case Management project files");
-    }
-  }
-  async packAsync(options, cancellationToken) {
-    const buildResult = await this.buildAsync(options, cancellationToken);
-    if (!buildResult.isSuccess) {
-      return buildResult;
-    }
-    const localBuildFolder = buildResult.packages[0];
-    try {
-      this.logger.progress("Creating NuGet package...");
-      const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
-      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
-      const packager = new NugetPackager(this.fileSystem);
-      const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
-      this.logger.progress("Package created successfully");
-      return new ToolResult("SUCCESS" /* Success */, "done", [
-        result.outputPath
-      ]);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.toString() : String(error);
-      this.logger.error(errorMessage);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while packing Case Management project");
-    }
-  }
-  async dispose() {
-    this.logger.info("Disposing Case Management Tool");
-    try {
-      await this._temporaryStorage.cleanup();
-    } catch {}
-  }
-  async copyFiles(sourcePath, contentFolder) {
-    await this.fileSystem.mkdir(contentFolder);
-    const files = await this.fileSystem.readdir(sourcePath);
-    for (const file of files) {
-      const sourceFile = Path.join(sourcePath, file);
-      const stat = await this.fileSystem.stat(sourceFile);
-      if (stat?.isFile()) {
-        const content = await this.fileSystem.readFile(sourceFile);
-        if (content) {
-          const destinationFile = Path.join(contentFolder, file);
-          await this.fileSystem.writeFile(destinationFile, content);
-        }
-      }
-    }
-  }
-  async compileCasePlan(projectPath, contentFolder) {
-    const compile = getCaseBpmnCompiler();
-    const casePlanFileName = findCasePlanFileName(await this.fileSystem.readdir(projectPath));
-    if (!compile || !casePlanFileName) {
-      return this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
-    }
-    const sidecarFileName = casePlanSidecarName(casePlanFileName);
-    const casePlanPath = Path.join(projectPath, casePlanFileName);
-    const casePlan = await this.fileSystem.readFile(casePlanPath);
-    if (!casePlan || casePlan.length === 0) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${casePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${sidecarFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
-    }
-    try {
-      const bpmnXml = await compile(new TextDecoder().decode(casePlan));
-      await this.fileSystem.writeFile(Path.join(contentFolder, sidecarFileName), bpmnXml);
-      return await this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(message);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Failed to compile '${casePlanFileName}' into '${sidecarFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
-    }
-  }
-  async checkEntryPointBpmnPresent(contentFolder, casePlanFileName) {
-    const referenced = await this.readEntryPointBpmnFiles(contentFolder);
-    if (referenced === null) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`);
-    }
-    const own = casePlanFileName ? casePlanSidecarName(casePlanFileName) : undefined;
-    const fix = own ?? `Author a case plan (${CasePlanFileNames.join(", ")}) so pack can compile it (see 'uip maestro case init'), then pack again.`;
-    const firstEntry = await this.firstEntryPointFileName(contentFolder);
-    if (firstEntry && !referenced.includes(firstEntry)) {
-      const firstEntryFix = own ? `Point the first entry point at '${own}', then pack again.` : fix;
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' first entry point resolves to '${firstEntry}', which is not a declared .bpmn file this project ships, so operate.json's main would name a file pack cannot produce. ${firstEntryFix}`);
-    }
-    if (referenced.length === 0) {
-      return ToolResult.success();
-    }
-    const contentFiles = await this.fileSystem.readdir(contentFolder);
-    const missing = referenced.filter((file) => !contentFiles.includes(file));
-    if (missing.length === 0) {
-      if (casePlanFileName) {
-        const misnamed = misnamedEntryPointBpmn(referenced, casePlanFileName);
-        if (misnamed) {
-          return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' points at 'content/${misnamed}', the sidecar of a case plan this project does not carry. '${casePlanFileName}' compiles to '${own}', so the entry point would resolve to a BPMN pack did not produce. Point it at '${own}', then pack again.`);
-        }
-      }
-      return ToolResult.success();
-    }
-    const missingFix = casePlanFileName ? `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.` : fix;
-    const missingList = missing.map((f) => `'content/${f}'`).join(", ");
-    return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' points at ${missingList}, which the package does not contain, so it would deploy and activate and then fault every job. ${missingFix}`);
-  }
-  async readEntryPointBpmnFiles(contentFolder) {
-    const entryPointsPath = Path.join(contentFolder, CaseConstants.EntryPointsFileName);
-    if (!await this.fileSystem.exists(entryPointsPath)) {
-      return [];
-    }
-    const raw = await this.fileSystem.readFile(entryPointsPath);
-    if (!raw || raw.length === 0) {
-      return null;
-    }
-    return entryPointBpmnNames(new TextDecoder().decode(raw));
-  }
-  async firstEntryPointFileName(contentFolder) {
-    const raw = await this.fileSystem.readFile(Path.join(contentFolder, CaseConstants.EntryPointsFileName));
-    const parsed = JSON.parse(raw ? new TextDecoder().decode(raw) : "{}");
-    const filePath = parsed.entryPoints?.[0]?.filePath ?? "";
-    return resolveDeclaredFileName(filePath);
-  }
-  async createOperateFile(options, contentFolder) {
-    await ensureContentOperateFile(this.fileSystem, {
-      contentFolder,
-      projectPath: options.projectPath,
-      projectStorageId: options.projectStorageId,
-      contentType: "CaseManagement" /* CaseManagement */
-    });
-  }
-  async createPackageDescriptor(localBuildFolder, contentFolder) {
-    const contentFiles = await this.fileSystem.readdir(contentFolder);
-    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
-    const packageDescriptorJson = JSON.stringify(buildCasePackageDescriptor(contentFiles), null, 2);
-    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
-  }
-}
-
-// ../packager/packager-tool-case/src/case-tool-factory.ts
-class CaseToolFactory {
-  supportedTypes = [
-    "CaseManagement" /* CaseManagement */
-  ];
-  async createAsync(logger, fileSystem) {
-    return new CaseTool(fileSystem, logger);
-  }
-}
-
-// ../packager/packager-tool-case/src/index.ts
-toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
-export { registerCaseBpmnCompiler, CasePlanFileNames, casePlanSidecarName, findCasePlanFileName, resolveDeclaredFileName, normalizeEntryPointPath, entryPointBpmnNames, misnamedEntryPointBpmn, buildCasePackageDescriptor, CaseToolFactory };
-
-//# debugId=008D294270E95A4364756E2164756E21