@uipath/maestro-tool 1.202.2 → 1.203.0-preview.180

package/dist/packager-tool-gdtpsdn7.js

@@ -0,0 +1,342 @@
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-names.js
+var JsonSerializerNames = {
+  DefaultCaseInsensitive: "DefaultCaseInsensitive",
+  CaseInsensitive: "CaseInsensitive",
+  Indented: "Indented",
+  CamelCase: "CamelCase",
+  CaseInsensitiveIndented: "CaseInsensitiveIndented",
+  IndentedIgnoreNull: "IndentedIgnoreNull",
+  PreservePropertyNames: "PreservePropertyNames",
+  CamelCaseIndented: "CamelCaseIndented",
+  AllNames: [
+    "DefaultCaseInsensitive",
+    "CaseInsensitive",
+    "Indented",
+    "CamelCase",
+    "CaseInsensitiveIndented",
+    "IndentedIgnoreNull",
+    "PreservePropertyNames",
+    "CamelCaseIndented"
+  ]
+};
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer.js
+class JsonSerializer {
+  serialize(value) {
+    if (value == null)
+      return null;
+    let toSerialize = value;
+    if (this.options.ignoreNull)
+      toSerialize = this.removeNullValues(value);
+    if (this.options.camelCase && !this.options.preservePropertyNames)
+      toSerialize = this.toCamelCase(toSerialize);
+    if (this.options.enumCamelCase !== false)
+      toSerialize = this.convertEnumValuesToCamelCase(toSerialize);
+    const json = JSON.stringify(toSerialize, null, this.options.indented ? 2 : undefined);
+    return json;
+  }
+  async serializeAsync(stream, value, cancellationToken) {
+    cancellationToken?.throwIfAborted?.();
+    const json = this.serialize(value);
+    if (json === null)
+      return;
+    const writer = stream.getWriter();
+    try {
+      const bytes = this.encoder.encode(json);
+      await writer.write(bytes);
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  serializeToUtf8Bytes(value) {
+    const json = this.serialize(value);
+    if (json === null)
+      return new Uint8Array(0);
+    return this.encoder.encode(json);
+  }
+  deserialize(value) {
+    if (value == null || value === "")
+      return null;
+    try {
+      let cleanValue = value.charCodeAt(0) === 65279 ? value.slice(1) : value;
+      if (cleanValue.charCodeAt(cleanValue.length - 1) === 26)
+        cleanValue = cleanValue.slice(0, -1);
+      const parsed = JSON.parse(cleanValue);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  deserializeAsType(value, _type) {
+    return this.deserialize(value);
+  }
+  removeNullValues(obj) {
+    if (obj == null)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((item) => this.removeNullValues(item));
+    if (typeof obj == "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(obj))
+        if (val != null)
+          result[key] = this.removeNullValues(val);
+      return result;
+    }
+    return obj;
+  }
+  toCamelCase(obj) {
+    if (obj == null)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((item) => this.toCamelCase(item));
+    if (typeof obj == "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(obj)) {
+        const camelKey = key.charAt(0).toLowerCase() + key.slice(1);
+        result[camelKey] = this.toCamelCase(val);
+      }
+      return result;
+    }
+    return obj;
+  }
+  convertEnumValuesToCamelCase(obj, className) {
+    if (obj == null)
+      return obj;
+    if (typeof obj == "string")
+      return this.tryConvertEnumStringToCamelCase(obj, undefined, undefined);
+    if (Array.isArray(obj))
+      return obj.map((item) => this.convertEnumValuesToCamelCase(item, className));
+    if (typeof obj == "object") {
+      const result = {};
+      const currentClassName = obj.constructor?.name !== "Object" ? obj.constructor.name : className;
+      for (const [key, val] of Object.entries(obj))
+        if (typeof val == "string")
+          result[key] = this.tryConvertEnumStringToCamelCase(val, currentClassName, key);
+        else if (Array.isArray(val))
+          result[key] = val.map((item) => {
+            if (typeof item == "string")
+              return this.tryConvertEnumStringToCamelCase(item, currentClassName, key);
+            return this.convertEnumValuesToCamelCase(item, currentClassName);
+          });
+        else
+          result[key] = this.convertEnumValuesToCamelCase(val, currentClassName);
+      return result;
+    }
+    return obj;
+  }
+  tryConvertEnumStringToCamelCase(value, className, propertyName) {
+    if (this.camelCaseEnumProperties.size > 0) {
+      if (!propertyName || !this.isKnownCamelCaseEnum(className, propertyName))
+        return value;
+    } else if (propertyName && this.isInPropertySet(this.pascalCaseEnumProperties, className, propertyName))
+      return value;
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(value))
+      return value.charAt(0).toLowerCase() + value.slice(1);
+    return value;
+  }
+  isKnownCamelCaseEnum(className, propertyName) {
+    if (this.isInPropertySet(this.pascalCaseEnumProperties, className, propertyName))
+      return false;
+    return this.isInPropertySet(this.camelCaseEnumProperties, className, propertyName);
+  }
+  isInPropertySet(propertySet, className, propertyName) {
+    if (className && propertySet.has(`${className}.${propertyName}`))
+      return true;
+    return propertySet.has(propertyName);
+  }
+  constructor(options = {}) {
+    this.isContextBased = false;
+    this.encoder = new TextEncoder;
+    this.options = options;
+    this.camelCaseEnumProperties = new Set(options.camelCaseEnumProperties ?? []);
+    this.pascalCaseEnumProperties = new Set(options.pascalCaseEnumProperties ?? []);
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/pascal-case-enum-properties.js
+var CAMEL_CASE_ENUM_PROPERTIES = [
+  "scope",
+  "replaceOption",
+  "lookupStrategy",
+  "folderType"
+];
+var SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES = [
+  "propertyCategory"
+];
+var RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES = [
+  "ValidationState.errorSeverity",
+  "ValidationState.errorType",
+  "AddOrUpdateResourceToSolutionResponse.status",
+  "Overwrite.type",
+  "OverwriteValidationError.severity",
+  "ProjectResourceDescriptor.provisionType"
+];
+var PASCAL_CASE_ENUM_PROPERTIES = [
+  ...SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES,
+  ...RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES
+];
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-factory.js
+class JsonSerializerFactory {
+  get() {
+    return this.defaultSerializer;
+  }
+  getByName(name) {
+    if (!name)
+      return this.defaultSerializer;
+    let serializer = this.namedSerializers.get(name);
+    if (!serializer) {
+      serializer = this.createNamedSerializer(name);
+      this.namedSerializers.set(name, serializer);
+    }
+    return serializer;
+  }
+  initializePredefinedSerializers() {
+    for (const name of JsonSerializerNames.AllNames)
+      this.namedSerializers.set(name, this.createNamedSerializer(name));
+  }
+  createNamedSerializer(name) {
+    const options = this.createOptionsForName(name);
+    return new JsonSerializer(options);
+  }
+  createOptionsForName(name) {
+    const options = {
+      ...this.baseOptions
+    };
+    switch (name) {
+      case JsonSerializerNames.DefaultCaseInsensitive:
+        return {
+          caseInsensitive: true
+        };
+      case JsonSerializerNames.CaseInsensitive:
+        options.caseInsensitive = true;
+        break;
+      case JsonSerializerNames.Indented:
+        options.indented = true;
+        break;
+      case JsonSerializerNames.CamelCase:
+        options.camelCase = true;
+        break;
+      case JsonSerializerNames.CaseInsensitiveIndented:
+        options.caseInsensitive = true;
+        options.indented = true;
+        break;
+      case JsonSerializerNames.IndentedIgnoreNull:
+        options.indented = true;
+        options.ignoreNull = true;
+        break;
+      case JsonSerializerNames.PreservePropertyNames:
+        options.preservePropertyNames = true;
+        options.camelCase = false;
+        break;
+      case JsonSerializerNames.CamelCaseIndented:
+        options.indented = true;
+        options.camelCase = true;
+        options.ignoreNull = true;
+        break;
+      default:
+        break;
+    }
+    return options;
+  }
+  constructor(options) {
+    const defaults = {
+      camelCase: true,
+      enumCamelCase: true,
+      camelCaseEnumProperties: CAMEL_CASE_ENUM_PROPERTIES,
+      pascalCaseEnumProperties: PASCAL_CASE_ENUM_PROPERTIES
+    };
+    this.baseOptions = options ? {
+      ...defaults,
+      ...options
+    } : defaults;
+    this.defaultSerializer = new JsonSerializer(this.baseOptions);
+    this.namedSerializers = new Map;
+    this.initializePredefinedSerializers();
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/serializer-proxy.js
+class JsonSerializerProxy {
+  serialize(value) {
+    return this.jsonSerializer.serialize(value);
+  }
+  serializeAsync(stream, value, cancellationToken) {
+    return this.jsonSerializer.serializeAsync(stream, value, cancellationToken);
+  }
+  serializeToUtf8Bytes(value) {
+    return this.jsonSerializer.serializeToUtf8Bytes(value);
+  }
+  deserialize(value) {
+    return this.jsonSerializer.deserialize(value);
+  }
+  tryDeserializeObject(json) {
+    if (!json || json.trim() === "")
+      return null;
+    try {
+      return this.jsonSerializer.isContextBased ? this.jsonSerializer.deserialize(json) : this.caseInsensitiveSerializer.deserialize(json);
+    } catch (ex) {
+      this.logger.info("Deserialization failed with exception.", ex);
+      return null;
+    }
+  }
+  tryDeserialize(value) {
+    if (!value || value.trim() === "")
+      return [
+        false,
+        null
+      ];
+    try {
+      const result = this.jsonSerializer.deserialize(value);
+      return [
+        true,
+        result
+      ];
+    } catch (ex) {
+      this.logger.info("Deserialization failed with exception.", ex);
+      return [
+        false,
+        null
+      ];
+    }
+  }
+  constructor(jsonSerializerFactory, loggerFactory) {
+    this.jsonSerializer = jsonSerializerFactory.get();
+    this.caseInsensitiveSerializer = jsonSerializerFactory.getByName(JsonSerializerNames.CaseInsensitive);
+    this.logger = loggerFactory.create("JsonSerializerProxy");
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/stream-serializer.js
+class StreamSerializer {
+  async serializeAsync(data, cancellationToken) {
+    cancellationToken?.throwIfAborted?.();
+    const serializer = this.jsonSerializerFactory.getByName(JsonSerializerNames.PreservePropertyNames);
+    const serializedContent = serializer.serialize(data);
+    const encoder = new TextEncoder;
+    const bytes = serializedContent ? encoder.encode(serializedContent) : new Uint8Array(0);
+    let streamClosed = false;
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(bytes);
+        controller.close();
+        streamClosed = true;
+      }
+    });
+    const disposeStream = this.disposeStream;
+    return {
+      stream,
+      dispose() {
+        if (disposeStream && !streamClosed)
+          stream.cancel().catch(() => {});
+      }
+    };
+  }
+  constructor(jsonSerializerFactory, disposeStream = true) {
+    this.jsonSerializerFactory = jsonSerializerFactory;
+    this.disposeStream = disposeStream;
+  }
+}
+export { JsonSerializerNames, JsonSerializer, CAMEL_CASE_ENUM_PROPERTIES, SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES, RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES, PASCAL_CASE_ENUM_PROPERTIES, JsonSerializerFactory, JsonSerializerProxy, StreamSerializer };
+
+//# debugId=B9E68BD7718EF2DB64756E2164756E21

package/dist/{packager-tool-ejyeka5x.js → packager-tool-gpwec9sp.js}

@@ -7,7 +7,7 @@ import {
   VARIABLE_PATH_SELECTOR_PATTERN,
   VARS_IDENTIFIER,
   VARS_PREFIX
-} from "./packager-tool-nxw5yzs7.js";
+} from "./packager-tool-vqcnvaae.js";
 import {
   FLAT_SEP,
   JS_EXPRESSION_PREFIX,
@@ -18,7 +18,7 @@ import {
   isJobAttachmentRef,
   stripAutoDerivedFieldBindings,
   templateInterpolationBody
-} from "./packager-tool-e8td7b01.js";
+} from "./packager-tool-fvm2dddf.js";
 import {
   init_esm_shims
 } from "./packager-tool-6ejqwbw9.js";

package/dist/{packager-tool-pap09zfh.js → packager-tool-h8x54cvx.js}

@@ -1,6 +1,6 @@
 import {
   catchError
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";

package/dist/{packager-tool-9vh3df76.js → packager-tool-hdmhxdch.js}

@@ -1,9 +1,9 @@
 import {
   package_default
-} from "./packager-tool-8dgxmjzx.js";
+} from "./packager-tool-30ky51ca.js";
 import {
   isPreviewBuild
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
@@ -24,26 +24,26 @@ var shouldHydrateBranch = (branchName) => {
 };
 var registerCommands = async (program) => {
   if (isPreviewBuild()) {
-    const { registerMaestroRegistryCommands } = await import("./authoring-6r3wx3fa.js");
+    const { registerMaestroRegistryCommands } = await import("./authoring-sh284a0x.js");
     registerMaestroRegistryCommands(program);
   }
   const bpmnCommand = program.command("bpmn").description("Create, debug, and run BPMN Maestro projects and jobs.");
   if (shouldHydrateBranch("bpmn")) {
-    const { registerBpmnCommands } = await import("./bpmn-branch-y1m9f10n.js");
+    const { registerBpmnCommands } = await import("./bpmn-branch-t12a7jvf.js");
     registerBpmnCommands(bpmnCommand);
     if (isPreviewBuild()) {
-      const { registerBpmnAuthoringCommands } = await import("./authoring-6r3wx3fa.js");
+      const { registerBpmnAuthoringCommands } = await import("./authoring-sh284a0x.js");
       registerBpmnAuthoringCommands(bpmnCommand);
     }
   }
   const flowCommand = program.command("flow").description("Create, debug, and run UiPath Flow projects and jobs.");
   if (shouldHydrateBranch("flow")) {
-    const { registerCommands: registerFlowCommands } = await import("./tool-td30zmyt.js");
+    const { registerCommands: registerFlowCommands } = await import("./tool-v0r5qzcc.js");
     await registerFlowCommands(flowCommand);
   }
   const caseCommand = program.command("case").description("Manage Case Management instances, processes, and incidents.");
   if (shouldHydrateBranch("case")) {
-    const { registerCommands: registerCaseCommands } = await import("./tool-pxfafj3m.js");
+    const { registerCommands: registerCaseCommands } = await import("./tool-dejjyv8m.js");
     await registerCaseCommands(caseCommand);
   }
 };

package/dist/packager-tool-hnyecbk6.js

@@ -0,0 +1,88 @@
+// ../case-tool/src/services/strict-connector-context.ts
+var REQUIRED_CONNECTOR_CONTEXT_KEYS = [
+  "connectorKey",
+  "connection",
+  "resourceKey",
+  "folderKey",
+  "objectName",
+  "metadata"
+];
+var REQUIRED_TRIGGER_CONTEXT_KEYS = [
+  ...REQUIRED_CONNECTOR_CONTEXT_KEYS,
+  "operation"
+];
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var contextEntries = (context) => (Array.isArray(context) ? context : []).map((entry) => asRecord(entry)).filter((entry) => entry !== undefined);
+var contextEntry = (context, name) => contextEntries(context).find((entry) => entry.name === name);
+var missingContextKeys = (context, waitsForEvent) => {
+  const present = new Set(contextEntries(context).map((entry) => entry.name).filter((name) => typeof name === "string"));
+  const required = waitsForEvent ? REQUIRED_TRIGGER_CONTEXT_KEYS : REQUIRED_CONNECTOR_CONTEXT_KEYS;
+  return required.filter((key) => !present.has(key));
+};
+var readActivityTypeId = (context) => {
+  const metadata = contextEntry(context, "metadata");
+  const configuration = asRecord(asRecord(metadata?.body)?.activityPropertyConfiguration);
+  const activityTypeId = configuration?.uiPathActivityTypeId;
+  return typeof activityTypeId === "string" && activityTypeId.trim() !== "" ? activityTypeId : undefined;
+};
+var ACTIVITY_TYPE_ID_PATH = "body.activityPropertyConfiguration.uiPathActivityTypeId";
+var ACTIVITY_TYPE_ID_KEY = "uiPathActivityTypeId";
+var MISCASED_ACTIVITY_TYPE_ID_KEY = "UiPathActivityTypeId";
+var findActivityTypeIdPath = (context) => {
+  const metadata = contextEntry(context, "metadata");
+  if (metadata === undefined)
+    return;
+  const search = (value, path) => {
+    const record = asRecord(value);
+    if (record === undefined) {
+      if (!Array.isArray(value))
+        return;
+      for (const [index, entry] of value.entries()) {
+        const found = search(entry, `${path}[${index}]`);
+        if (found !== undefined)
+          return found;
+      }
+      return;
+    }
+    for (const [key, entry] of Object.entries(record)) {
+      const here = path === "" ? key : `${path}.${key}`;
+      if ((key === ACTIVITY_TYPE_ID_KEY || key === MISCASED_ACTIVITY_TYPE_ID_KEY) && typeof entry === "string" && entry.trim() !== "") {
+        return here;
+      }
+      const found = search(entry, here);
+      if (found !== undefined)
+        return found;
+    }
+    return;
+  };
+  const { name: _name, type: _type, ...payload } = metadata;
+  return search(payload, "");
+};
+var activityTypeIdMessage = (subject, context, consequence) => {
+  const foundAt = findActivityTypeIdPath(context);
+  if (foundAt !== undefined && foundAt !== ACTIVITY_TYPE_ID_PATH) {
+    return `Connector ${subject} carries an activity type id at ` + `context[metadata].${foundAt}, but the runtime reads it from ` + `context[metadata].${ACTIVITY_TYPE_ID_PATH}. Write it at that ` + "path instead, with that exact spelling. Both keys start " + 'lower-case: "activityPropertyConfiguration" directly under ' + `"body", then "${ACTIVITY_TYPE_ID_KEY}". The id itself is ` + "already correct.";
+  }
+  return `Connector ${subject} has a metadata configuration with no ` + `${ACTIVITY_TYPE_ID_KEY} at context[metadata].` + `${ACTIVITY_TYPE_ID_PATH}. ${consequence}`;
+};
+
+// ../case-tool/src/services/resource-task-binding.ts
+var NAME_BOUND_TASK_TYPES = new Set([
+  "action",
+  "agent",
+  "api-workflow",
+  "case-management",
+  "process",
+  "rpa"
+]);
+var RESOLVED_IDENTITY_KEYS = [
+  "resourceId",
+  "typeId",
+  "actionAppId",
+  "actionDefinitionId"
+];
+var BINDING_REFERENCE_PREFIX = "=bindings.";
+
+export { contextEntries, contextEntry, missingContextKeys, readActivityTypeId, ACTIVITY_TYPE_ID_PATH, activityTypeIdMessage, NAME_BOUND_TASK_TYPES, RESOLVED_IDENTITY_KEYS, BINDING_REFERENCE_PREFIX };
+
+//# debugId=446801D5A70E1A1364756E2164756E21

package/dist/{packager-tool-mtbak8t4.js → packager-tool-j00gcgbs.js}

@@ -5,10 +5,10 @@ import {
   registerFlowMigrationsI18n,
   runtimeMigrations,
   runtimeVersion
-} from "./packager-tool-54b4v7wp.js";
+} from "./packager-tool-te6rrpsz.js";
 import {
   instance
-} from "./packager-tool-e8td7b01.js";
+} from "./packager-tool-vdc8r21p.js";
 
 // ../flow-tool/src/services/flow-migration-check.ts
 if (!instance.isInitialized) {

package/dist/packager-tool-j78fwwhq.js

@@ -0,0 +1,16 @@
+// ../../node_modules/@uipath/flow-expression-model/node_modules/@uipath/flow-core/dist/chunk-EVM6BVMO.js
+var __defProp = Object.defineProperty;
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn)
+    return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __glob, __export };
+
+//# debugId=3A2F5FBC7A6C56F364756E2164756E21

package/dist/packager-tool-jysvpt8p.js

@@ -0,0 +1,11 @@
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/chunk-QKQ47GQZ.js
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn)
+    return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+
+export { __glob };
+
+//# debugId=CD595A1AF45EBB3464756E2164756E21