@uipath/solution-tool 1.201.0 → 1.202.0-preview.136

package/dist/{packager-tool-129wn232.js → packager-tool-dfrk01gn.js}

@@ -4,9 +4,40 @@ var require2 = createRequire("/");
 var _a;
 var Worker;
 var isMarkedAsUntransferable;
+var workerAdd = ";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global";
 try {
   _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
 } catch (e) {}
+var wk = Worker ? function(c, _, msg, transfer, cb) {
+  var done = false;
+  var w = new Worker(c + workerAdd, { eval: true }).on("error", function(e) {
+    return cb(e, null);
+  }).on("message", function(m) {
+    return cb(null, m);
+  }).on("exit", function(c2) {
+    if (c2 && !done)
+      cb(new Error("exited with code " + c2), null);
+  });
+  if (isMarkedAsUntransferable)
+    transfer = transfer.filter(function(t) {
+      return !isMarkedAsUntransferable(t);
+    });
+  w.postMessage(msg, transfer);
+  w.terminate = function() {
+    done = true;
+    return Worker.prototype.terminate.call(w);
+  };
+  return w;
+} : function(_, __, ___, ____, cb) {
+  setImmediate(function() {
+    return cb(new Error("async operations unsupported - update to Node 12+ (or Node 10-11 with the --experimental-worker CLI flag)"), null);
+  });
+  var NOP = function() {};
+  return {
+    terminate: NOP,
+    postMessage: NOP
+  };
+};
 var u8 = Uint8Array;
 var u16 = Uint16Array;
 var i32 = Int32Array;
@@ -638,6 +669,73 @@ var mrg = function(a, b) {
     o[k] = b[k];
   return o;
 };
+var wcln = function(fn, fnStr, td) {
+  var dt = fn();
+  var st = fn.toString();
+  var ks = st.slice(st.indexOf("[") + 1, st.lastIndexOf("]")).replace(/\s+/g, "").split(",");
+  for (var i2 = 0;i2 < dt.length; ++i2) {
+    var v = dt[i2], k = ks[i2];
+    if (typeof v == "function") {
+      fnStr += ";" + k + "=";
+      var st_1 = v.toString();
+      if (v.prototype) {
+        if (st_1.indexOf("[native code]") != -1) {
+          var spInd = st_1.indexOf(" ", 8) + 1;
+          fnStr += st_1.slice(spInd, st_1.indexOf("(", spInd));
+        } else {
+          fnStr += st_1;
+          for (var t in v.prototype)
+            fnStr += ";" + k + ".prototype." + t + "=" + v.prototype[t].toString();
+        }
+      } else
+        fnStr += st_1;
+    } else
+      td[k] = v;
+  }
+  return fnStr;
+};
+var ch = [];
+var cbfs = function(v) {
+  var tl = [];
+  for (var k in v) {
+    if (v[k].buffer) {
+      tl.push((v[k] = new v[k].constructor(v[k])).buffer);
+    }
+  }
+  return tl;
+};
+var wrkr = function(fns, init, id, cb) {
+  if (!ch[id]) {
+    var fnStr = "", td_1 = {}, m = fns.length - 1;
+    for (var i2 = 0;i2 < m; ++i2)
+      fnStr = wcln(fns[i2], fnStr, td_1);
+    ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
+  }
+  var td = mrg({}, ch[id].e);
+  return wk(ch[id].c + ";onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=" + init.toString() + "}", id, td, cbfs(td), cb);
+};
+var bInflt = function() {
+  return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt];
+};
+var pbf = function(msg) {
+  return postMessage(msg, [msg.buffer]);
+};
+var gopt = function(o) {
+  return o && {
+    out: o.size && new u8(o.size),
+    dictionary: o.dictionary
+  };
+};
+var cbify = function(dat, opts, fns, init, id, cb) {
+  var w = wrkr(fns, init, id, function(err2, dat2) {
+    w.terminate();
+    cb(err2, dat2);
+  });
+  w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);
+  return function() {
+    w.terminate();
+  };
+};
 var b2 = function(d, b) {
   return d[b] | d[b + 1] << 8;
 };
@@ -654,6 +752,17 @@ var wbytes = function(d, b, v) {
 function deflateSync(data, opts) {
   return dopt(data, opts || {}, 0, 0);
 }
+function inflate(data, opts, cb) {
+  if (!cb)
+    cb = opts, opts = {};
+  if (typeof cb != "function")
+    err(7);
+  return cbify(data, opts, [
+    bInflt
+  ], function(ev) {
+    return pbf(inflateSync(ev.data[0], gopt(ev.data[1])));
+  }, 1, cb);
+}
 function inflateSync(data, opts) {
   return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
 }
@@ -869,6 +978,93 @@ function zipSync(data, opts) {
   wzf(out, o, files.length, cdl, oe);
   return out;
 }
+var mt = typeof queueMicrotask == "function" ? queueMicrotask : typeof setTimeout == "function" ? setTimeout : function(fn) {
+  fn();
+};
+function unzip(data, opts, cb) {
+  if (!cb)
+    cb = opts, opts = {};
+  if (typeof cb != "function")
+    err(7);
+  var term = [];
+  var tAll = function() {
+    for (var i3 = 0;i3 < term.length; ++i3)
+      term[i3]();
+  };
+  var files = {};
+  var cbd = function(a, b) {
+    mt(function() {
+      cb(a, b);
+    });
+  };
+  mt(function() {
+    cbd = cb;
+  });
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558) {
+      cbd(err(13, 0, 1), null);
+      return tAll;
+    }
+  }
+  var lft = b2(data, e + 8);
+  if (lft) {
+    var c = lft;
+    var o = b4(data, e + 16);
+    var z = b4(data, e - 20) == 117853008;
+    if (z) {
+      var ze = b4(data, e - 12);
+      z = b4(data, ze) == 101075792;
+      if (z) {
+        c = lft = b4(data, ze + 32);
+        o = b4(data, ze + 48);
+      }
+    }
+    var fltr = opts && opts.filter;
+    var _loop_3 = function(i3) {
+      var _a2 = zh(data, o, z), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+      o = no;
+      var cbl = function(e2, d) {
+        if (e2) {
+          tAll();
+          cbd(e2, null);
+        } else {
+          if (d)
+            files[fn] = d;
+          if (!--lft)
+            cbd(null, files);
+        }
+      };
+      if (!fltr || fltr({
+        name: fn,
+        size: sc,
+        originalSize: su,
+        compression: c_1
+      })) {
+        if (!c_1)
+          cbl(null, slc(data, b, b + sc));
+        else if (c_1 == 8) {
+          var infl = data.subarray(b, b + sc);
+          if (su < 524288 || sc > 0.8 * su) {
+            try {
+              cbl(null, inflateSync(infl, { out: new u8(su) }));
+            } catch (e2) {
+              cbl(e2, null);
+            }
+          } else
+            term.push(inflate(infl, { size: su }, cbl));
+        } else
+          cbl(err(14, "unknown compression type " + c_1, 1), null);
+      } else
+        cbl(null, null);
+    };
+    for (var i2 = 0;i2 < c; ++i2) {
+      _loop_3(i2);
+    }
+  } else
+    cbd(null, {});
+  return tAll;
+}
 function unzipSync(data, opts) {
   var files = {};
   var e = data.length - 22;
@@ -910,6 +1106,6 @@ function unzipSync(data, opts) {
   return files;
 }
 
-export { strToU8, strFromU8, zipSync, unzipSync };
+export { strToU8, strFromU8, zipSync, unzip, unzipSync };
 
-//# debugId=4FB81DC4940FE35C64756E2164756E21
+//# debugId=3A48AB12A966C5FC64756E2164756E21

package/dist/{packager-tool-rhpy5cp2.js → packager-tool-gkvmps31.js}

@@ -1,32 +1,31 @@
 import {
   Configuration,
   PipelinesApi,
+  feedScopeInitOverride,
   resolveFeedScope
-} from "./packager-tool-9zd0epj7.js";
+} from "./packager-tool-74ceetd5.js";
 import {
   Configuration as Configuration2,
   PackagesApi
-} from "./packager-tool-v92sp27p.js";
+} from "./packager-tool-6jnn8mcn.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-fzwxq48d.js";
+} from "./packager-tool-0rnx15s1.js";
 import {
   PollOutcome,
   catchError,
   extractErrorDetails,
+  getFileSystem,
   logger,
   mapPollFailure,
   pollUntil
-} from "./packager-tool-bcpknnr8.js";
-import {
-  getFileSystem
-} from "./packager-tool-7eva0peq.js";
+} from "./packager-tool-axz0e8h0.js";
 import {
   strFromU8,
   strToU8,
   unzipSync,
   zipSync
-} from "./packager-tool-129wn232.js";
+} from "./packager-tool-dfrk01gn.js";
 
 // src/services/package-metadata-rewrite.ts
 import { randomUUID } from "node:crypto";
@@ -176,6 +175,14 @@ async function publishSolutionAsync(packagePath, options = {}) {
     };
   }
   if (!resolvedPath.endsWith(".zip")) {
+    if (resolvedPath.toLowerCase().endsWith(".nupkg")) {
+      return {
+        ok: false,
+        reason: "project_package",
+        message: `'${packagePath}' is a project package (.nupkg), not a solution package. 'publish' uploads the solution-level .zip produced by 'solution pack'.`,
+        details: resolvedPath
+      };
+    }
     const stats = await fs.stat(resolvedPath);
     const isSolutionSource = stats?.isDirectory() === true || resolvedPath.endsWith(".uis") || resolvedPath.endsWith(".uipx");
     if (isSolutionSource) {
@@ -310,14 +317,15 @@ async function publishToFeed(auth, fileBuffer, scope, options) {
   if (uploadError) {
     return mapUploadError(uploadError);
   }
-  const [getError, initialInfo] = await catchError(api.packagesGetVersion({ packageVersionKey }));
+  const feedScope = feedScopeInitOverride(scope);
+  const [getError, initialInfo] = await catchError(api.packagesGetVersion({ packageVersionKey }, feedScope));
   if (getError) {
     logger.warn(`Package uploaded (key ${packageVersionKey}) but its metadata was not yet retrievable; PackageName/PackageVersion/State will be absent from output: ${getError.message}`);
   }
   let packageVersionInfo = getError ? undefined : initialInfo;
   if (options.wait) {
     const pollResult = await pollUntil({
-      fn: () => api.packagesGetVersion({ packageVersionKey }),
+      fn: () => api.packagesGetVersion({ packageVersionKey }, feedScope),
       until: (result) => TERMINAL_STATES.has(result.state),
       getStatus: (result) => result.state,
       label: `publish ${packageVersionInfo ? `${packageVersionInfo.packageName}:${packageVersionInfo.packageVersion}` : packageVersionKey}`,
@@ -384,4 +392,4 @@ async function mapUploadError(uploadError) {
 
 export { publishSolutionAsync };
 
-//# debugId=F5A8606772C19F7264756E2164756E21
+//# debugId=A863118C75768F1764756E2164756E21