@uipath/case-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/packager-tool-13kkvf2n.js

@@ -0,0 +1,356 @@
+import {
+  catchError
+} from "./packager-tool-ygwa3sc0.js";
+
+// src/services/schema-utils.ts
+function getMutatedType(variable) {
+  if (variable["x-uipath-resource-kind"] === "JobAttachment") {
+    return "file";
+  }
+  return typeof variable.type === "string" ? variable.type : "unknown";
+}
+function createNestedRefResolver(definitions) {
+  const resolveRef = (ref) => {
+    const definitionName = ref?.replace("#/definitions/", "") ?? "";
+    const definition = definitions[definitionName];
+    return definition && typeof definition === "object" ? { ...definition } : {};
+  };
+  const resolvePropertyWithRef = (propValue) => {
+    const refResolved = resolveRef(propValue.$ref);
+    const excludedKeys = new Set([
+      "type",
+      "properties",
+      "required",
+      "$ref"
+    ]);
+    const nested = refResolved.properties && typeof refResolved.properties === "object" ? {
+      properties: resolveNestedRefs(refResolved.properties)
+    } : {};
+    const extras = Object.fromEntries(Object.entries(refResolved).filter(([k]) => !excludedKeys.has(k)));
+    return {
+      type: refResolved.type,
+      required: false,
+      ...nested,
+      ...extras
+    };
+  };
+  const resolvePropertiesObject = (properties) => {
+    const resolvedProps = {};
+    for (const [propKey, propValue] of Object.entries(properties)) {
+      if (typeof propValue === "object" && propValue !== null && "$ref" in propValue) {
+        resolvedProps[propKey] = resolvePropertyWithRef(propValue);
+      } else {
+        resolvedProps[propKey] = resolveNestedRefs(propValue);
+      }
+    }
+    return resolvedProps;
+  };
+  const resolveNestedRefs = (obj) => {
+    if (!obj || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => resolveNestedRefs(item));
+    }
+    const record = obj;
+    const resolved = {};
+    for (const [key, value] of Object.entries(record)) {
+      if (key === "$ref" || key === "required" && Array.isArray(value)) {
+        continue;
+      }
+      if (key === "properties" && typeof value === "object") {
+        resolved[key] = resolvePropertiesObject(value);
+        continue;
+      }
+      resolved[key] = resolveNestedRefs(value);
+    }
+    return resolved;
+  };
+  return { resolveRef, resolveNestedRefs };
+}
+function transformSchemaToVariables(schemaInput, options) {
+  if (!schemaInput) {
+    return {};
+  }
+  let schema;
+  if (typeof schemaInput === "string") {
+    const [parseError, parsed] = catchError(() => JSON.parse(schemaInput));
+    if (parseError) {
+      throw new Error(`Failed to parse schema JSON: ${schemaInput.slice(0, 80)}`);
+    }
+    schema = parsed;
+  } else {
+    schema = schemaInput;
+  }
+  if (!schema || typeof schema !== "object" || !("properties" in schema) || !schema.properties) {
+    return {};
+  }
+  const properties = schema.properties;
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  const definitions = typeof schema.definitions === "object" && schema.definitions !== null ? schema.definitions : {};
+  const { resolveRef, resolveNestedRefs } = createNestedRefResolver(definitions);
+  const result = {};
+  for (const [name, prop] of Object.entries(properties)) {
+    const propObj = prop;
+    const merged = {
+      ...propObj,
+      ...resolveRef(propObj.$ref ?? "")
+    };
+    const resolved = resolveNestedRefs(merged);
+    const type = getMutatedType(resolved);
+    const innerRequired = Array.isArray(merged.required) ? merged.required : required;
+    result[name] = {
+      ...resolved,
+      required: options?.includeRequired ? innerRequired.includes(name) : undefined,
+      type
+    };
+  }
+  return result;
+}
+function getArgumentType(rawType, collectionDataType) {
+  const type = rawType.split(",")[0];
+  if (type.startsWith("System.Int32[]") || type.startsWith("System.Int64[]") || type.startsWith("System.Double[]") || type.startsWith("System.Decimal[]")) {
+    return "array{number}";
+  }
+  if (type.startsWith("System.String[]")) {
+    return "array{string}";
+  }
+  if (type.startsWith("System.Boolean[]")) {
+    return "array{boolean}";
+  }
+  if (type.startsWith("System.Collections.Generic.List") || type.startsWith("System.Collections.Generic.IList") || type.startsWith("System.Collections.Generic.IEnumerable") || type.startsWith("System.Collections.IEnumerable") || type.startsWith("System.Data.DataTable") || type.startsWith("Newtonsoft.Json.Linq.JArray") || collectionDataType?.startsWith("List") || collectionDataType?.startsWith("Array")) {
+    return "array";
+  }
+  if (type.startsWith("System.Collections.Generic.Dictionary")) {
+    return "json";
+  }
+  if (type.startsWith("System.Collections.Generic") || type.startsWith("System.Object")) {
+    return "json";
+  }
+  if (type.startsWith("System.String")) {
+    return "string";
+  }
+  if (type.startsWith("System.Int32") || type.startsWith("System.Int64") || type.startsWith("System.Double") || type.startsWith("System.Decimal")) {
+    return "number";
+  }
+  if (type.startsWith("System.Boolean")) {
+    return "boolean";
+  }
+  return "any";
+}
+var ERROR_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    code: { type: "string" },
+    message: { type: "string" },
+    detail: { type: "string" },
+    category: { type: "string" },
+    status: { type: "number" },
+    element: { type: "string" }
+  }
+};
+function convertActionArgsToVariables(args) {
+  const result = {};
+  for (const arg of args) {
+    const variable = {
+      type: getArgumentType(arg.type, arg.collectionDataType)
+    };
+    if (arg.required) {
+      variable.required = true;
+    }
+    result[arg.name] = variable;
+  }
+  return result;
+}
+
+// src/services/input-output-utils.ts
+var JOB_ATTACHMENT_PREFIX = "=orchestrator.JobAttachments";
+var JSON_SCHEMA_DRAFT_7 = "http://json-schema.org/draft-07/schema#";
+var FILE_TYPE_JSON_SCHEMA = {
+  $schema: JSON_SCHEMA_DRAFT_7,
+  type: "object",
+  properties: {
+    ID: {
+      type: "string",
+      description: "Orchestrator attachment key"
+    },
+    FullName: {
+      type: "string",
+      description: "File name"
+    },
+    MimeType: {
+      type: "string",
+      description: "The MIME type of the content, such as application/json or image/png"
+    },
+    Metadata: {
+      type: "object",
+      description: "Dictionary<string, string> of metadata",
+      additionalProperties: {
+        type: "string"
+      }
+    }
+  },
+  required: ["ID"],
+  "x-uipath-resource-kind": "JobAttachment"
+};
+var DATA_FABRIC_PREFIX = "=datafabric.";
+var DATA_FABRIC_TYPE_JSON_SCHEMA = {
+  $schema: JSON_SCHEMA_DRAFT_7,
+  type: "object",
+  properties: {}
+};
+function parseTypeAndSubtype(typeString) {
+  const match = /^(\w+)\{(.+)\}$/.exec(typeString);
+  if (match) {
+    return { type: match[1], subType: match[2] };
+  }
+  return { type: typeString };
+}
+function isFileType(type) {
+  return type === "file" || type === "octet-stream";
+}
+function getJsonSchema(props) {
+  if (props.type === "object" || props.type === "array") {
+    return { ...props, $schema: JSON_SCHEMA_DRAFT_7 };
+  }
+  return null;
+}
+function camelizeDisplayName(displayName) {
+  const sanitized = displayName.replace(/[^a-zA-Z0-9_ ]/g, "");
+  const words = sanitized.split(/[\s_]+/).filter(Boolean);
+  if (words.length === 0) {
+    return "";
+  }
+  return words.map((w, i) => i === 0 ? w.charAt(0).toLowerCase() + w.slice(1) : w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function toUniqueCamelCase(input, existingNames) {
+  let candidate = camelizeDisplayName(input);
+  if (!candidate) {
+    candidate = "variable";
+  }
+  const nameSet = new Set(existingNames);
+  if (!nameSet.has(candidate)) {
+    return candidate;
+  }
+  let counter = 1;
+  while (nameSet.has(`${candidate}${counter}`)) {
+    counter++;
+  }
+  return `${candidate}${counter}`;
+}
+var ALPHANUMERIC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function generateRandomId(length) {
+  let result = "";
+  for (let i = 0;i < length; i++) {
+    result += ALPHANUMERIC.charAt(Math.floor(Math.random() * ALPHANUMERIC.length));
+  }
+  return result;
+}
+function generateNextId(prefix, count) {
+  return prefix + generateRandomId(count);
+}
+function generateNewVariableId(existingIds, variableName) {
+  return toUniqueCamelCase(variableName, existingIds);
+}
+function resolveFileBodyFromTarget(target) {
+  if (!target) {
+    return;
+  }
+  if (target.startsWith(JOB_ATTACHMENT_PREFIX)) {
+    return FILE_TYPE_JSON_SCHEMA;
+  }
+  if (target.startsWith(DATA_FABRIC_PREFIX)) {
+    return DATA_FABRIC_TYPE_JSON_SCHEMA;
+  }
+  return;
+}
+function generateBodyForVariable(variable) {
+  if (variable.type !== "jsonSchema" && !isFileType(variable.type)) {
+    return;
+  }
+  return variable._jsonSchema ?? resolveFileBodyFromTarget(variable.target) ?? undefined;
+}
+function mapVariablesToInputOutput(variables, getTypeFromVar, isOutput, existingInputOutputs, additionalProps) {
+  const existingNames = new Set(existingInputOutputs.map((io) => io.name));
+  const result = [...existingInputOutputs];
+  for (const [name, variable] of Object.entries(variables)) {
+    if (existingNames.has(name)) {
+      continue;
+    }
+    const rawType = getTypeFromVar(variable);
+    const { type: parsedType, subType: parsedSubType } = parseTypeAndSubtype(rawType);
+    const props = additionalProps ? additionalProps(variable) : {};
+    const jsonSchema = getJsonSchema(props);
+    const item = {
+      name,
+      displayName: name,
+      value: "",
+      ...!jsonSchema ? props : {},
+      type: jsonSchema && isOutput && rawType !== "file" ? "jsonSchema" : parsedType,
+      ...jsonSchema ? { _jsonSchema: jsonSchema } : {},
+      subType: parsedSubType ?? props.items?.type,
+      ...isOutput ? { source: `=${name}` } : {},
+      ...rawType === "file" && isOutput ? { target: JOB_ATTACHMENT_PREFIX } : {},
+      ...isFileType(rawType) ? {
+        properties: FILE_TYPE_JSON_SCHEMA.properties,
+        "x-uipath-resource-kind": FILE_TYPE_JSON_SCHEMA["x-uipath-resource-kind"]
+      } : {}
+    };
+    result.push(item);
+  }
+  return result;
+}
+function mapEntryPointVariablesToInputOutput(entryPointVariables, isOutput, existingInputOutputs = []) {
+  return mapVariablesToInputOutput(entryPointVariables, (v) => v.type, isOutput, existingInputOutputs, (v) => v);
+}
+function buildErrorOutput() {
+  return {
+    name: "Error",
+    displayName: "Error",
+    value: "",
+    type: "jsonSchema",
+    _jsonSchema: ERROR_OUTPUT_SCHEMA,
+    source: "=Error"
+  };
+}
+function addVarIdsToInputsOutputs(params) {
+  const {
+    inputs,
+    outputs,
+    elementId = "",
+    existingVariableIds = []
+  } = params;
+  const collectedIds = [...existingVariableIds];
+  const inputsWithVars = inputs.map((input) => {
+    const id = generateNextId("v", 8);
+    collectedIds.push(id);
+    return {
+      ...input,
+      var: id,
+      id,
+      elementId
+    };
+  });
+  const outputsWithVars = outputs.map((output) => {
+    let id = output.value;
+    if (!id?.length) {
+      id = generateNewVariableId(collectedIds, output.name);
+    }
+    collectedIds.push(id);
+    const body = generateBodyForVariable(output);
+    return {
+      ...output,
+      var: id,
+      id,
+      value: id,
+      target: output.target ?? `=${id}`,
+      elementId,
+      ...body ? { body } : {}
+    };
+  });
+  return { inputsWithVars, outputsWithVars };
+}
+
+export { transformSchemaToVariables, convertActionArgsToVariables, mapEntryPointVariablesToInputOutput, buildErrorOutput, addVarIdsToInputsOutputs };
+
+//# debugId=F4923EB769649F2664756E2164756E21