@uipath/agent-tool 1.202.1 → 1.203.0-preview.180

package/dist/packager-tool-53w8skv5.js

@@ -0,0 +1,262 @@
+// ../../node_modules/@uipath/resource-builder-sdk/dist/clients/generated/first-party-service.js
+var first_party_service_DeploymentAction = /* @__PURE__ */ function(DeploymentAction) {
+  DeploymentAction["Install"] = "Install";
+  DeploymentAction["Link"] = "Link";
+  DeploymentAction["Uninstall"] = "Uninstall";
+  DeploymentAction["Unlink"] = "Unlink";
+  DeploymentAction["Merge"] = "Merge";
+  DeploymentAction["UseExisting"] = "UseExisting";
+  DeploymentAction["Activate"] = "Activate";
+  return DeploymentAction;
+}({});
+var first_party_service_SolutionDeploymentAction = /* @__PURE__ */ function(SolutionDeploymentAction) {
+  SolutionDeploymentAction["Install"] = "Install";
+  SolutionDeploymentAction["Uninstall"] = "Uninstall";
+  SolutionDeploymentAction["Upgrade"] = "Upgrade";
+  SolutionDeploymentAction["Rollback"] = "Rollback";
+  SolutionDeploymentAction["Activate"] = "Activate";
+  return SolutionDeploymentAction;
+}({});
+var first_party_service_SolutionStatus = /* @__PURE__ */ function(SolutionStatus) {
+  SolutionStatus["Installed"] = "Installed";
+  SolutionStatus["Uninstalled"] = "Uninstalled";
+  SolutionStatus["Installing"] = "Installing";
+  SolutionStatus["Uninstalling"] = "Uninstalling";
+  SolutionStatus["InstallError"] = "InstallError";
+  SolutionStatus["UninstallError"] = "UninstallError";
+  SolutionStatus["Unknown"] = "Unknown";
+  return SolutionStatus;
+}({});
+var first_party_service_QueryOptions = /* @__PURE__ */ function(QueryOptions) {
+  QueryOptions["Contains"] = "Contains";
+  QueryOptions["Equals"] = "Equals";
+  return QueryOptions;
+}({});
+var first_party_service_DeploymentResourceValidationErrorLevel = /* @__PURE__ */ function(DeploymentResourceValidationErrorLevel) {
+  DeploymentResourceValidationErrorLevel["Error"] = "Error";
+  DeploymentResourceValidationErrorLevel["Warning"] = "Warning";
+  DeploymentResourceValidationErrorLevel["Info"] = "Info";
+  return DeploymentResourceValidationErrorLevel;
+}({});
+var first_party_service_DeploymentResourceValidationErrorKind = /* @__PURE__ */ function(DeploymentResourceValidationErrorKind) {
+  DeploymentResourceValidationErrorKind["Conflict"] = "Conflict";
+  DeploymentResourceValidationErrorKind["ConfigurationError"] = "ConfigurationError";
+  return DeploymentResourceValidationErrorKind;
+}({});
+var first_party_service_DeploymentResourceValidationAction = /* @__PURE__ */ function(DeploymentResourceValidationAction) {
+  DeploymentResourceValidationAction["RenameExisting"] = "RenameExisting";
+  DeploymentResourceValidationAction["RenameInSolution"] = "RenameInSolution";
+  DeploymentResourceValidationAction["UseExisting"] = "UseExisting";
+  DeploymentResourceValidationAction["FixConfiguration"] = "FixConfiguration";
+  DeploymentResourceValidationAction["Delete"] = "Delete";
+  DeploymentResourceValidationAction["SkipDelete"] = "SkipDelete";
+  DeploymentResourceValidationAction["MergeConfiguration"] = "MergeConfiguration";
+  DeploymentResourceValidationAction["Replace"] = "Replace";
+  return DeploymentResourceValidationAction;
+}({});
+var first_party_service_ContentType = /* @__PURE__ */ function(ContentType) {
+  ContentType["Json"] = "application/json";
+  ContentType["JsonApi"] = "application/vnd.api+json";
+  ContentType["FormData"] = "multipart/form-data";
+  ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+  ContentType["Text"] = "text/plain";
+  return ContentType;
+}({});
+
+class HttpClient {
+  encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    return `${encodedKey}=${encodeURIComponent(typeof value == "number" ? value : `${value}`)}`;
+  }
+  addQueryParam(query, key) {
+    return this.encodeQueryParam(key, query[key]);
+  }
+  addArrayQueryParam(query, key) {
+    const value = query[key];
+    return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+  }
+  toQueryString(rawQuery) {
+    const query = rawQuery || {};
+    const keys = Object.keys(query).filter((key) => query[key] !== undefined);
+    return keys.map((key) => Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)).join("&");
+  }
+  addQueryParams(rawQuery) {
+    const queryString = this.toQueryString(rawQuery);
+    return queryString ? `?${queryString}` : "";
+  }
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...this.baseApiParams.headers || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  constructor(apiConfig = {}) {
+    this.baseUrl = "https://localhost:7008";
+    this.securityData = null;
+    this.abortControllers = new Map;
+    this.customFetch = (...fetchParams) => fetch(...fetchParams);
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.contentFormatters = {
+      ["application/json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["application/vnd.api+json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["text/plain"]: (input) => input !== null && typeof input != "string" ? JSON.stringify(input) : input,
+      ["multipart/form-data"]: (input) => {
+        if (input instanceof FormData)
+          return input;
+        return Object.keys(input || {}).reduce((formData, key) => {
+          const property = input[key];
+          formData.append(key, property instanceof Blob ? property : typeof property == "object" && property !== null ? JSON.stringify(property) : `${property}`);
+          return formData;
+        }, new FormData);
+      },
+      ["application/x-www-form-urlencoded"]: (input) => this.toQueryString(input)
+    };
+    this.createAbortSignal = (cancelToken) => {
+      if (this.abortControllers.has(cancelToken)) {
+        const abortController2 = this.abortControllers.get(cancelToken);
+        if (abortController2)
+          return abortController2.signal;
+        return;
+      }
+      const abortController = new AbortController;
+      this.abortControllers.set(cancelToken, abortController);
+      return abortController.signal;
+    };
+    this.abortRequest = (cancelToken) => {
+      const abortController = this.abortControllers.get(cancelToken);
+      if (abortController) {
+        abortController.abort();
+        this.abortControllers.delete(cancelToken);
+      }
+    };
+    this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+      const secureParams = (typeof secure == "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const queryString = query && this.toQueryString(query);
+      const payloadFormatter = this.contentFormatters[type || "application/json"];
+      const responseFormat = format || requestParams.format;
+      return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+        ...requestParams,
+        headers: {
+          ...requestParams.headers || {},
+          ...type && type !== "multipart/form-data" ? {
+            "Content-Type": type
+          } : {}
+        },
+        signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+        body: body == null ? null : payloadFormatter(body)
+      }).then(async (response) => {
+        const r = response;
+        r.data = null;
+        r.error = null;
+        const responseToParse = responseFormat ? response.clone() : response;
+        const data = responseFormat ? await responseToParse[responseFormat]().then((data2) => {
+          if (r.ok)
+            r.data = data2;
+          else
+            r.error = data2;
+          return r;
+        }).catch((e) => {
+          r.error = e;
+          return r;
+        }) : r;
+        if (cancelToken)
+          this.abortControllers.delete(cancelToken);
+        if (!response.ok)
+          throw data;
+        return data.data;
+      });
+    };
+    Object.assign(this, apiConfig);
+  }
+}
+
+class FirstPartyServiceApi extends HttpClient {
+  constructor(...args) {
+    super(...args), this.v2 = {
+      automationSolutionsGetMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "GET",
+        ...params
+      }),
+      automationSolutionsHeadMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "HEAD",
+        ...params
+      }),
+      automationSolutionsSetState: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PATCH",
+        query,
+        body: data,
+        type: "application/json",
+        ...params
+      }),
+      automationSolutionsInstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PUT",
+        query,
+        body: data,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsUninstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "DELETE",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsExport: (data, params = {}) => this.request({
+        path: "/v2/automationsolutions/export",
+        method: "POST",
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsGetTranslations: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/translations",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsValidate: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions/validate",
+        method: "POST",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsLookup: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/lookup",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      })
+    };
+  }
+}
+export { first_party_service_DeploymentAction, first_party_service_SolutionDeploymentAction, first_party_service_SolutionStatus, first_party_service_QueryOptions, first_party_service_DeploymentResourceValidationErrorLevel, first_party_service_DeploymentResourceValidationErrorKind, first_party_service_DeploymentResourceValidationAction, first_party_service_ContentType, HttpClient, FirstPartyServiceApi };
+
+//# debugId=AC88CC622210E15664756E2164756E21

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