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

package/dist/{packager-tool-3bra2c4j.js → packager-tool-gctpkdzs.js}

@@ -1,6 +1,6 @@
 import {
   Path
-} from "./packager-tool-0d7tcvg1.js";
+} from "./packager-tool-b1xs6aty.js";
 
 // ../packager/packager-tool-flow/src/maestro-automate.ts
 var SENTINEL_FILE_NAME = ".maestro_automate";

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-aa481g36.js → packager-tool-gpwec9sp.js}

@@ -7,10 +7,7 @@ import {
   VARIABLE_PATH_SELECTOR_PATTERN,
   VARS_IDENTIFIER,
   VARS_PREFIX
-} from "./packager-tool-yr3bws42.js";
-import {
-  init_esm_shims
-} from "./packager-tool-6ejqwbw9.js";
+} from "./packager-tool-vqcnvaae.js";
 import {
   FLAT_SEP,
   JS_EXPRESSION_PREFIX,
@@ -21,7 +18,10 @@ import {
   isJobAttachmentRef,
   stripAutoDerivedFieldBindings,
   templateInterpolationBody
-} from "./packager-tool-e8td7b01.js";
+} from "./packager-tool-fvm2dddf.js";
+import {
+  init_esm_shims
+} from "./packager-tool-6ejqwbw9.js";
 
 // ../../node_modules/@uipath/flow-converter/dist/chunk-KX2HWNFV.js
 init_esm_shims();
@@ -1080,4 +1080,4 @@ function rewriteStringsDeep(value, fn) {
 
 export { ITERATOR_FIELDS, SCRIPT_TASK_NODE_TYPES, DATA_TRANSFORM_NODE_TYPES, unwrapScriptBody, serializeTemplateInterpolations, transformExpression, serializeExpressionValueAsMappingSource, serializeExpressionValue, transformNodeExpressions, transformEdgeExpression, DEFAULT_AGENT_INPUT_ENCODING, SCHEMA_CONTAINER_MARKER, getContainerChildProps, CONNECTOR_PARAM_BUCKET_KEYS, extractAgentInputName, isCompositeConnectorValue, compositeConnectorInputKey, isSyntheticAgentInputId, collectCompositeConnectorInputs, encodeFlatName, decodeFlatName, rewriteInputTokensToSource, UnresolvedAgentInputTypeError, AmbiguousAgentInputRootError, detectAmbiguousAgentInputRoot, buildAgentInputTypeResolver, canPruneAgentInputs, deriveAgentInputVariables, scanSourceRefsDeep, collectInlineAgentClusterInputs, collectInlineAgentInputsFromAgent, collectArtifactDescendants, mergeCompositeConnectorInputs, deriveMergedAgentInputVariables, preDeriveAgentInputDefinitions, buildDerivedInputDefinition, rewriteStringsDeep };
 
-//# debugId=3F34FC97A81EFC8764756E2164756E21
+//# debugId=678BEB3000A25CC964756E2164756E21

package/dist/{packager-tool-a1hbfmws.js → packager-tool-gzpvdcnw.js}

@@ -1,3 +1,13 @@
+import {
+  findNodeDefinition
+} from "./packager-tool-w5a1hhyj.js";
+import {
+  catchError
+} from "./packager-tool-6k8s7pt9.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
 // src/services/flow-eval-schema/prompts.ts
 var DEFAULT_EVALUATOR_PROMPT = `As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
 ----
@@ -393,7 +403,119 @@ function evaluatorTypeHasConfigField(typeId, fieldKey) {
 function evaluatorCanUseSharedExpectedOutput(typeId) {
   return getEvaluatorTypeDefinition(typeId)?.criteriaFields.some((field) => field.key === "expectedOutput" && field.type === "object") ?? false;
 }
+// src/services/flow-eval-utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+  return UUID_RE.test(value);
+}
+function stripJsonExt(name) {
+  return name.endsWith(".json") ? name.slice(0, -".json".length) : name;
+}
+function slugify(text) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return slug || "untitled";
+}
+function getEvaluatorRef(evaluator) {
+  return stripJsonExt(evaluator.fileName ?? `${evaluator.id}.json`);
+}
+function buildEvaluatorConfig(typeId, options) {
+  const evaluatorConfig = {
+    name: options.name,
+    ...getDefaultConfigForEvaluatorType(typeId)
+  };
+  if (evaluatorTypeHasConfigField(typeId, "targetOutputKey")) {
+    evaluatorConfig.targetOutputKey = options.targetOutputKey ?? "*";
+  }
+  if (options.model !== undefined) {
+    evaluatorConfig.model = options.model;
+  }
+  if (options.prompt !== undefined) {
+    evaluatorConfig.prompt = options.prompt;
+  }
+  return evaluatorConfig;
+}
+async function validateLoginFields() {
+  const { getLoginStatusAsync } = await import("./index-3ts7y9d3.js");
+  const [loginError, login] = await catchError(getLoginStatusAsync());
+  if (loginError) {
+    throw new Error(loginError.message);
+  }
+  if (login.loginStatus !== "Logged in" || !login.baseUrl) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  if (!login.organizationId) {
+    throw new Error("Organization ID not available from login.");
+  }
+  if (!login.tenantId) {
+    throw new Error("Tenant ID not available from login.");
+  }
+  if (!login.tenantName) {
+    throw new Error("Tenant name not available from login.");
+  }
+  if (!login.accessToken) {
+    throw new Error("Access token not available from login.");
+  }
+  return {
+    baseUrl: login.baseUrl,
+    organizationId: login.organizationId,
+    tenantId: login.tenantId,
+    tenantName: login.tenantName,
+    accessToken: login.accessToken,
+    organizationName: login.organizationName || undefined
+  };
+}
+async function resolveLoginConfig() {
+  const fields = await validateLoginFields();
+  if (!fields.organizationName) {
+    throw new Error("Organization name not available from login. Required for Studio Web evaluation.");
+  }
+  return {
+    baseUrl: fields.baseUrl,
+    organizationId: fields.organizationId,
+    tenantId: fields.tenantId,
+    tenantName: fields.tenantName,
+    authToken: fields.accessToken,
+    organizationName: fields.organizationName
+  };
+}
+async function resolveEvalApiConfig() {
+  const fields = await validateLoginFields();
+  return {
+    baseUrl: fields.baseUrl,
+    organizationId: fields.organizationId,
+    tenantName: fields.tenantName,
+    tenantId: fields.tenantId,
+    authToken: fields.accessToken
+  };
+}
+function findMatchingDefinition(nodeType, typeVersion, definitions) {
+  const strict = findNodeDefinition(definitions, {
+    type: nodeType,
+    typeVersion
+  });
+  if (strict)
+    return strict;
+  return definitions.find((d) => d.nodeType === nodeType);
+}
+function buildDefaultCriteria(evaluators, expectedOutput, searchText) {
+  const criterias = {};
+  for (const evaluator of evaluators) {
+    const key = evaluator.id;
+    if (expectedOutput !== undefined && evaluatorCanUseSharedExpectedOutput(evaluator.evaluatorTypeId)) {
+      criterias[key] = { expectedOutput };
+    } else if (searchText !== undefined && evaluator.evaluatorTypeId === "uipath-contains") {
+      criterias[key] = { searchText };
+    } else {
+      const defaultCriteria = evaluator.evaluatorConfig.defaultEvaluationCriteria;
+      criterias[key] = isRecord(defaultCriteria) ? defaultCriteria : null;
+    }
+  }
+  return criterias;
+}
 
-export { evaluatorTypeAliases, resolveEvaluatorType, getDefaultConfigForEvaluatorType, evaluatorTypeHasConfigField, evaluatorCanUseSharedExpectedOutput };
+export { evaluatorTypeAliases, resolveEvaluatorType, isRecord, isUUID, stripJsonExt, slugify, getEvaluatorRef, buildEvaluatorConfig, resolveLoginConfig, resolveEvalApiConfig, findMatchingDefinition, buildDefaultCriteria };
 
-//# debugId=25565E7CDA9B5A3664756E2164756E21
+//# debugId=6033C3040704269E64756E2164756E21

package/dist/{packager-tool-03hjxcd7.js → packager-tool-h9d8c9rf.js}

@@ -1,6 +1,6 @@
 import {
   readStdin
-} from "./packager-tool-rew0hp2h.js";
+} from "./packager-tool-6k8s7pt9.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";

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

package/dist/{packager-tool-5kd7msdf.js → packager-tool-nsmy7aap.js}

@@ -1,9 +1,9 @@
-import {
-  logger
-} from "./packager-tool-rew0hp2h.js";
 import {
   inMemoryWorkflowToFileFormat
-} from "./packager-tool-e8td7b01.js";
+} from "./packager-tool-fvm2dddf.js";
+import {
+  logger
+} from "./packager-tool-6k8s7pt9.js";
 
 // src/utils/write-resolved-flow.ts
 async function writeResolvedFlow(fs, dir, name, workflow) {
@@ -15,4 +15,4 @@ async function writeResolvedFlow(fs, dir, name, workflow) {
 
 export { writeResolvedFlow };
 
-//# debugId=AE0D61ABCE2DA4C364756E2164756E21
+//# debugId=6009258457D2C62464756E2164756E21