@uipath/api-workflow-tool 1.200.0-preview.120 → 1.201.0-preview.121

package/dist/{browser-xef2n2gy.js → browser-hrvppyg6.js}

@@ -5,7 +5,7 @@ import {
   TelemetryService,
   ToolLogger,
   setGlobalLogHandler
-} from "./packager-tool-9yfnj0t1.js";
+} from "./packager-tool-2zhkjkmy.js";
 import {
   translate
 } from "./packager-tool-h1tyrbff.js";

package/dist/{browser-strategy-d4zm14fb.js → browser-strategy-rkcvc6tn.js}

@@ -3,7 +3,7 @@ import {
 } from "./packager-tool-9qecd4wb.js";
 import {
   AUTH_CANCELLED_ERROR_CODE
-} from "./packager-tool-1ps2qeqg.js";
+} from "./packager-tool-5arsyj36.js";
 import"./packager-tool-wckvcay0.js";
 
 // ../auth/src/strategies/browser-strategy.ts

package/dist/executor-tool.js

@@ -0,0 +1,256 @@
+import {
+  WorkflowRunService
+} from "./packager-tool-bprnbg91.js";
+import"./packager-tool-4pvh3k50.js";
+import"./packager-tool-y7hv8v54.js";
+import"./packager-tool-9qecd4wb.js";
+import"./packager-tool-5arsyj36.js";
+import"./packager-tool-wckvcay0.js";
+// ../executor/project-executor/src/models/run-status.ts
+var TERMINAL_RUN_STATUSES = [
+  "Succeeded" /* Succeeded */,
+  "Faulted" /* Faulted */,
+  "Cancelled" /* Cancelled */
+];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+
+// ../executor/project-executor/src/models/run-result.ts
+class RunResult {
+  status;
+  errorCode;
+  rawStatus;
+  message;
+  jobKey;
+  instanceId;
+  runId;
+  traceId;
+  steps;
+  output;
+  url;
+  details;
+  constructor(status, errorCode = "None" /* None */, message) {
+    this.status = status;
+    this.errorCode = errorCode;
+    this.message = message;
+  }
+  get isSuccess() {
+    return this.status === "Succeeded" /* Succeeded */ && this.errorCode === "None" /* None */;
+  }
+  get isTerminal() {
+    return isTerminalRunStatus(this.status);
+  }
+  static succeeded(init = {}) {
+    return Object.assign(new RunResult("Succeeded" /* Succeeded */, "None" /* None */), init);
+  }
+  static failed(errorCode, message, init = {}) {
+    return Object.assign(new RunResult("Faulted" /* Faulted */, errorCode, message), init);
+  }
+}
+// ../executor/project-executor/src/services/executors-factory-repository.ts
+class ExecutorsFactoryRepository {
+  factoryMap = new Map;
+  onConflict;
+  constructor(onConflict) {
+    this.onConflict = onConflict ?? ((message) => console.warn(message));
+  }
+  registerProjectExecutorFactory(factory) {
+    for (const projectType of factory.supportedTypes) {
+      const existing = this.factoryMap.get(projectType);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          this.onConflict(`Executor factory conflict for project type '${projectType}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.factoryMap.set(projectType, factory);
+    }
+  }
+  canHandleProject(projectType) {
+    return this.factoryMap.has(projectType);
+  }
+  getProjectExecutorFactory(projectType) {
+    const factory = this.factoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`No executor is registered for project type '${projectType}'. ` + `Registered types: ${this.registeredTypes.join(", ") || "none"}.`);
+    }
+    return factory;
+  }
+  get registeredTypes() {
+    return [...this.factoryMap.keys()];
+  }
+  reset() {
+    this.factoryMap.clear();
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/project-executor/executorsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ExecutorsFactoryRepository;
+}
+var executorsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../executor/project-executor/src/services/executor-factory-provider.ts
+var PROVIDER_KEY = Symbol.for("@uipath/project-executor/executorFactoryProvider");
+// ../executor/project-executor/src/services/project-executor.ts
+class ProjectExecutor {
+  fileSystem;
+  logger;
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  runAsync(_options, _cancellationToken) {
+    return Promise.resolve(RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `${this.constructor.name} does not support run.`));
+  }
+  async resolveDefaultEntryPoint(projectPath) {
+    const entryPointsFile = this.fileSystem.path.join(projectPath, ENTRY_POINTS_FILE_NAME);
+    try {
+      const raw = await this.fileSystem.readFile(entryPointsFile, "utf-8");
+      if (!raw) {
+        return;
+      }
+      const declared = JSON.parse(raw).entryPoints;
+      return this.firstDeclaredEntryPoint(declared);
+    } catch (error) {
+      this.logger.warn(`Could not read the default entry point from ${entryPointsFile}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+  }
+  asEntryPoint(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+  }
+  firstDeclaredEntryPoint(entryPoints) {
+    if (!Array.isArray(entryPoints)) {
+      return;
+    }
+    for (const entry of entryPoints) {
+      const filePath = this.asEntryPoint(entry?.filePath);
+      if (filePath) {
+        return filePath;
+      }
+    }
+    return;
+  }
+  dispose() {
+    return Promise.resolve();
+  }
+}
+var ENTRY_POINTS_FILE_NAME = "entry-points.json";
+// src/executor/api-workflow-project-executor.ts
+var FALLBACK_ENTRY_POINT = "Workflow.json";
+var PACKED_CONTENT_PREFIX = "content/";
+var defaultRunnerFactory = (fileSystem) => new WorkflowRunService(fileSystem);
+
+class ApiWorkflowProjectExecutor extends ProjectExecutor {
+  createRunner;
+  constructor(fileSystem, logger, createRunner = defaultRunnerFactory) {
+    super(fileSystem, logger);
+    this.createRunner = createRunner;
+  }
+  async runAsync(options, cancellationToken) {
+    const { project } = options;
+    if (!project.projectPath) {
+      return RunResult.failed("InvalidInput" /* InvalidInput */, "Running an API Workflow requires the project directory.");
+    }
+    if (cancellationToken?.aborted) {
+      return RunResult.failed("Cancelled" /* Cancelled */, "Run cancelled before it started.");
+    }
+    const entryPoint = options.entryPoint ?? await this.resolveDefaultEntryPoint(project.projectPath) ?? FALLBACK_ENTRY_POINT;
+    const workflowPath = this.fileSystem.path.join(project.projectPath, entryPoint);
+    this.logger.info(`Running API Workflow '${project.name}' locally: ${entryPoint}`);
+    options.callbacks?.onStatusChange?.("Running" /* Running */);
+    let outcome;
+    try {
+      outcome = await this.createRunner(this.fileSystem).run({
+        filePath: workflowPath,
+        input: options.inputArguments,
+        auth: Boolean(options.connection?.accessToken),
+        connection: options.connection
+      });
+    } catch (error) {
+      return RunResult.failed("Unknown" /* Unknown */, `Could not run API Workflow '${project.name}': ${messageOf(error)}`, { details: { entryPoint } });
+    }
+    if (cancellationToken?.aborted) {
+      return RunResult.failed("Cancelled" /* Cancelled */, "Run cancelled.");
+    }
+    return toRunResult(outcome, entryPoint);
+  }
+  async resolveDefaultEntryPoint(projectPath) {
+    const declared = await this.mainFileFromProject(projectPath);
+    if (declared) {
+      return declared;
+    }
+    const packed = await super.resolveDefaultEntryPoint(projectPath);
+    return packed?.startsWith(PACKED_CONTENT_PREFIX) ? packed.slice(PACKED_CONTENT_PREFIX.length) : packed;
+  }
+  async mainFileFromProject(projectPath) {
+    const projectFile = this.fileSystem.path.join(projectPath, "project.uiproj");
+    try {
+      const raw = await this.fileSystem.readFile(projectFile, "utf-8");
+      if (!raw) {
+        return;
+      }
+      const mainFile = JSON.parse(raw).MainFile;
+      return typeof mainFile === "string" && mainFile.length > 0 ? mainFile : undefined;
+    } catch (error) {
+      this.logger.warn(`Could not read the entry point from ${projectFile}: ${messageOf(error)}`);
+      return;
+    }
+  }
+}
+function toRunResult(outcome, entryPoint) {
+  const details = {
+    entryPoint,
+    workflowPath: outcome.workflowPath
+  };
+  if (outcome.success) {
+    const result2 = RunResult.succeeded({
+      output: asOutputArguments(outcome.data),
+      details: hasData(outcome.data) ? { ...details, data: outcome.data } : details
+    });
+    result2.rawStatus = outcome.status;
+    return result2;
+  }
+  const result = RunResult.failed(errorCodeFor(outcome.failedStage), outcome.errorMessage ?? "The workflow run did not succeed.", { details });
+  result.rawStatus = outcome.status;
+  return result;
+}
+function errorCodeFor(stage) {
+  switch (stage) {
+    case "load":
+      return "InvalidInput" /* InvalidInput */;
+    case "auth":
+      return "Unauthorized" /* Unauthorized */;
+    default:
+      return "ExecutionFailed" /* ExecutionFailed */;
+  }
+}
+function asOutputArguments(data) {
+  return data !== null && typeof data === "object" && !Array.isArray(data) ? data : undefined;
+}
+function hasData(data) {
+  return data !== undefined && data !== null;
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/executor/api-workflow-executor-factory.ts
+var API_WORKFLOW_PROJECT_TYPES = ["Api"];
+
+class ApiWorkflowExecutorFactory {
+  supportedTypes = API_WORKFLOW_PROJECT_TYPES;
+  createAsync(logger, fileSystem) {
+    return Promise.resolve(new ApiWorkflowProjectExecutor(fileSystem, logger));
+  }
+}
+
+// src/executor-tool.ts
+var createExecutorFactory = () => new ApiWorkflowExecutorFactory;
+export {
+  createExecutorFactory
+};
+
+//# debugId=E512E96D87D7F48D64756E2164756E21

package/dist/{index-8xj2420r.js → index-0wh8evkn.js}

@@ -18,7 +18,7 @@ import {
   resolveProducedNupkgsAsync,
   setGlobalLogHandler,
   signNupkgsAsync
-} from "./packager-tool-9yfnj0t1.js";
+} from "./packager-tool-2zhkjkmy.js";
 import {
   ToolErrorCodes,
   ToolResult,
@@ -287,7 +287,7 @@ function addSdkUserAgentHeader(headers, userAgent) {
 var package_default = {
   name: "@uipath/project-packager",
   license: "MIT",
-  version: "1.200.0-preview.120",
+  version: "1.201.0-preview.121",
   description: "UiPath Project Packager - core library for packing individual UiPath projects",
   type: "module",
   main: "./dist/index.js",
@@ -719,4 +719,4 @@ export {
   BrowserContextStorage
 };
 
-//# debugId=EC190DCB47AC5F3964756E2164756E21
+//# debugId=1FC1AE2280E19D9064756E2164756E21