testplane 8.20.0-alpha.0 → 8.20.0

package/build/src/browser-pool/utils.js

@@ -1,3 +1,6 @@
 "use strict";
-exports.buildCompositeBrowserId = (browserId, version) => (version ? `${browserId}.${version}` : browserId);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCompositeBrowserId = void 0;
+const buildCompositeBrowserId = (browserId, version) => version ? `${browserId}.${version}` : browserId;
+exports.buildCompositeBrowserId = buildCompositeBrowserId;
 //# sourceMappingURL=utils.js.map

package/build/src/browser-pool/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/browser-pool/utils.js"],"names":[],"mappings":";AAAA,OAAO,CAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/browser-pool/utils.ts"],"names":[],"mappings":";;;AAAO,MAAM,uBAAuB,GAAG,CAAC,SAAiB,EAAE,OAAgB,EAAU,EAAE,CACnF,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AADvC,QAAA,uBAAuB,2BACgB"}

package/build/src/bundle/index.js

@@ -18959,6 +18959,41 @@ var require_sourcemap_codec_umd = __commonJS({
         intToChar[i] = c;
         charToInt[c] = i;
       }
+      function decodeInteger(reader, relative) {
+        let value2 = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+          const c = reader.next();
+          integer = charToInt[c];
+          value2 |= (integer & 31) << shift;
+          shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value2 & 1;
+        value2 >>>= 1;
+        if (shouldNegate) {
+          value2 = -2147483648 | -value2;
+        }
+        return relative + value2;
+      }
+      function encodeInteger(builder, num, relative) {
+        let delta = num - relative;
+        delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+        do {
+          let clamped = delta & 31;
+          delta >>>= 5;
+          if (delta > 0)
+            clamped |= 32;
+          builder.write(intToChar[clamped]);
+        } while (delta > 0);
+        return num;
+      }
+      function hasMoreVlq(reader, max) {
+        if (reader.pos >= max)
+          return false;
+        return reader.peek() !== comma;
+      }
+      const bufLength = 1024 * 16;
       const td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
         decode(buf) {
           const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
@@ -18973,72 +19008,317 @@ var require_sourcemap_codec_umd = __commonJS({
           return out;
         }
       };
+      class StringWriter {
+        constructor() {
+          this.pos = 0;
+          this.out = "";
+          this.buffer = new Uint8Array(bufLength);
+        }
+        write(v) {
+          const { buffer } = this;
+          buffer[this.pos++] = v;
+          if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+          }
+        }
+        flush() {
+          const { buffer, out, pos } = this;
+          return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+        }
+      }
+      class StringReader {
+        constructor(buffer) {
+          this.pos = 0;
+          this.buffer = buffer;
+        }
+        next() {
+          return this.buffer.charCodeAt(this.pos++);
+        }
+        peek() {
+          return this.buffer.charCodeAt(this.pos);
+        }
+        indexOf(char) {
+          const { buffer, pos } = this;
+          const idx = buffer.indexOf(char, pos);
+          return idx === -1 ? buffer.length : idx;
+        }
+      }
+      const EMPTY = [];
+      function decodeOriginalScopes(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const scopes = [];
+        const stack = [];
+        let line = 0;
+        for (; reader.pos < length; reader.pos++) {
+          line = decodeInteger(reader, line);
+          const column = decodeInteger(reader, 0);
+          if (!hasMoreVlq(reader, length)) {
+            const last = stack.pop();
+            last[2] = line;
+            last[3] = column;
+            continue;
+          }
+          const kind = decodeInteger(reader, 0);
+          const fields = decodeInteger(reader, 0);
+          const hasName = fields & 1;
+          const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];
+          let vars = EMPTY;
+          if (hasMoreVlq(reader, length)) {
+            vars = [];
+            do {
+              const varsIndex = decodeInteger(reader, 0);
+              vars.push(varsIndex);
+            } while (hasMoreVlq(reader, length));
+          }
+          scope.vars = vars;
+          scopes.push(scope);
+          stack.push(scope);
+        }
+        return scopes;
+      }
+      function encodeOriginalScopes(scopes) {
+        const writer = new StringWriter();
+        for (let i = 0; i < scopes.length; ) {
+          i = _encodeOriginalScopes(scopes, i, writer, [0]);
+        }
+        return writer.flush();
+      }
+      function _encodeOriginalScopes(scopes, index, writer, state) {
+        const scope = scopes[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+        if (index > 0)
+          writer.write(comma);
+        state[0] = encodeInteger(writer, startLine, state[0]);
+        encodeInteger(writer, startColumn, 0);
+        encodeInteger(writer, kind, 0);
+        const fields = scope.length === 6 ? 1 : 0;
+        encodeInteger(writer, fields, 0);
+        if (scope.length === 6)
+          encodeInteger(writer, scope[5], 0);
+        for (const v of vars) {
+          encodeInteger(writer, v, 0);
+        }
+        for (index++; index < scopes.length; ) {
+          const next = scopes[index];
+          const { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn) {
+            break;
+          }
+          index = _encodeOriginalScopes(scopes, index, writer, state);
+        }
+        writer.write(comma);
+        state[0] = encodeInteger(writer, endLine, state[0]);
+        encodeInteger(writer, endColumn, 0);
+        return index;
+      }
+      function decodeGeneratedRanges(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const ranges = [];
+        const stack = [];
+        let genLine = 0;
+        let definitionSourcesIndex = 0;
+        let definitionScopeIndex = 0;
+        let callsiteSourcesIndex = 0;
+        let callsiteLine = 0;
+        let callsiteColumn = 0;
+        let bindingLine = 0;
+        let bindingColumn = 0;
+        do {
+          const semi = reader.indexOf(";");
+          let genColumn = 0;
+          for (; reader.pos < semi; reader.pos++) {
+            genColumn = decodeInteger(reader, genColumn);
+            if (!hasMoreVlq(reader, semi)) {
+              const last = stack.pop();
+              last[2] = genLine;
+              last[3] = genColumn;
+              continue;
+            }
+            const fields = decodeInteger(reader, 0);
+            const hasDefinition = fields & 1;
+            const hasCallsite = fields & 2;
+            const hasScope = fields & 4;
+            let callsite = null;
+            let bindings = EMPTY;
+            let range;
+            if (hasDefinition) {
+              const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+              definitionScopeIndex = decodeInteger(reader, definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0);
+              definitionSourcesIndex = defSourcesIndex;
+              range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+            } else {
+              range = [genLine, genColumn, 0, 0];
+            }
+            range.isScope = !!hasScope;
+            if (hasCallsite) {
+              const prevCsi = callsiteSourcesIndex;
+              const prevLine = callsiteLine;
+              callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+              const sameSource = prevCsi === callsiteSourcesIndex;
+              callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+              callsiteColumn = decodeInteger(reader, sameSource && prevLine === callsiteLine ? callsiteColumn : 0);
+              callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+            }
+            range.callsite = callsite;
+            if (hasMoreVlq(reader, semi)) {
+              bindings = [];
+              do {
+                bindingLine = genLine;
+                bindingColumn = genColumn;
+                const expressionsCount = decodeInteger(reader, 0);
+                let expressionRanges;
+                if (expressionsCount < -1) {
+                  expressionRanges = [[decodeInteger(reader, 0)]];
+                  for (let i = -1; i > expressionsCount; i--) {
+                    const prevBl = bindingLine;
+                    bindingLine = decodeInteger(reader, bindingLine);
+                    bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+                    const expression = decodeInteger(reader, 0);
+                    expressionRanges.push([expression, bindingLine, bindingColumn]);
+                  }
+                } else {
+                  expressionRanges = [[expressionsCount]];
+                }
+                bindings.push(expressionRanges);
+              } while (hasMoreVlq(reader, semi));
+            }
+            range.bindings = bindings;
+            ranges.push(range);
+            stack.push(range);
+          }
+          genLine++;
+          reader.pos = semi + 1;
+        } while (reader.pos < length);
+        return ranges;
+      }
+      function encodeGeneratedRanges(ranges) {
+        if (ranges.length === 0)
+          return "";
+        const writer = new StringWriter();
+        for (let i = 0; i < ranges.length; ) {
+          i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+        }
+        return writer.flush();
+      }
+      function _encodeGeneratedRanges(ranges, index, writer, state) {
+        const range = ranges[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings } = range;
+        if (state[0] < startLine) {
+          catchupLine(writer, state[0], startLine);
+          state[0] = startLine;
+          state[1] = 0;
+        } else if (index > 0) {
+          writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, range[1], state[1]);
+        const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
+        encodeInteger(writer, fields, 0);
+        if (range.length === 6) {
+          const { 4: sourcesIndex, 5: scopesIndex } = range;
+          if (sourcesIndex !== state[2]) {
+            state[3] = 0;
+          }
+          state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+          state[3] = encodeInteger(writer, scopesIndex, state[3]);
+        }
+        if (callsite) {
+          const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+          if (sourcesIndex !== state[4]) {
+            state[5] = 0;
+            state[6] = 0;
+          } else if (callLine !== state[5]) {
+            state[6] = 0;
+          }
+          state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+          state[5] = encodeInteger(writer, callLine, state[5]);
+          state[6] = encodeInteger(writer, callColumn, state[6]);
+        }
+        if (bindings) {
+          for (const binding of bindings) {
+            if (binding.length > 1)
+              encodeInteger(writer, -binding.length, 0);
+            const expression = binding[0][0];
+            encodeInteger(writer, expression, 0);
+            let bindingStartLine = startLine;
+            let bindingStartColumn = startColumn;
+            for (let i = 1; i < binding.length; i++) {
+              const expRange = binding[i];
+              bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+              bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+              encodeInteger(writer, expRange[0], 0);
+            }
+          }
+        }
+        for (index++; index < ranges.length; ) {
+          const next = ranges[index];
+          const { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn) {
+            break;
+          }
+          index = _encodeGeneratedRanges(ranges, index, writer, state);
+        }
+        if (state[0] < endLine) {
+          catchupLine(writer, state[0], endLine);
+          state[0] = endLine;
+          state[1] = 0;
+        } else {
+          writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, endColumn, state[1]);
+        return index;
+      }
+      function catchupLine(writer, lastLine, line) {
+        do {
+          writer.write(semicolon);
+        } while (++lastLine < line);
+      }
       function decode(mappings) {
-        const state = new Int32Array(5);
+        const { length } = mappings;
+        const reader = new StringReader(mappings);
         const decoded = [];
-        let index = 0;
+        let genColumn = 0;
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
         do {
-          const semi = indexOf(mappings, index);
+          const semi = reader.indexOf(";");
           const line = [];
           let sorted = true;
           let lastCol = 0;
-          state[0] = 0;
-          for (let i = index; i < semi; i++) {
+          genColumn = 0;
+          while (reader.pos < semi) {
             let seg;
-            i = decodeInteger(mappings, i, state, 0);
-            const col = state[0];
-            if (col < lastCol)
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
               sorted = false;
-            lastCol = col;
-            if (hasMoreVlq(mappings, i, semi)) {
-              i = decodeInteger(mappings, i, state, 1);
-              i = decodeInteger(mappings, i, state, 2);
-              i = decodeInteger(mappings, i, state, 3);
-              if (hasMoreVlq(mappings, i, semi)) {
-                i = decodeInteger(mappings, i, state, 4);
-                seg = [col, state[1], state[2], state[3], state[4]];
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+              sourcesIndex = decodeInteger(reader, sourcesIndex);
+              sourceLine = decodeInteger(reader, sourceLine);
+              sourceColumn = decodeInteger(reader, sourceColumn);
+              if (hasMoreVlq(reader, semi)) {
+                namesIndex = decodeInteger(reader, namesIndex);
+                seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
               } else {
-                seg = [col, state[1], state[2], state[3]];
+                seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
               }
             } else {
-              seg = [col];
+              seg = [genColumn];
             }
             line.push(seg);
+            reader.pos++;
           }
           if (!sorted)
             sort(line);
           decoded.push(line);
-          index = semi + 1;
-        } while (index <= mappings.length);
+          reader.pos = semi + 1;
+        } while (reader.pos <= length);
         return decoded;
       }
-      function indexOf(mappings, index) {
-        const idx = mappings.indexOf(";", index);
-        return idx === -1 ? mappings.length : idx;
-      }
-      function decodeInteger(mappings, pos, state, j) {
-        let value2 = 0;
-        let shift = 0;
-        let integer = 0;
-        do {
-          const c = mappings.charCodeAt(pos++);
-          integer = charToInt[c];
-          value2 |= (integer & 31) << shift;
-          shift += 5;
-        } while (integer & 32);
-        const shouldNegate = value2 & 1;
-        value2 >>>= 1;
-        if (shouldNegate) {
-          value2 = -2147483648 | -value2;
-        }
-        state[j] += value2;
-        return pos;
-      }
-      function hasMoreVlq(mappings, i, length) {
-        if (i >= length)
-          return false;
-        return mappings.charCodeAt(i) !== comma;
-      }
       function sort(line) {
         line.sort(sortComparator);
       }
@@ -19046,63 +19326,41 @@ var require_sourcemap_codec_umd = __commonJS({
         return a[0] - b[0];
       }
       function encode(decoded) {
-        const state = new Int32Array(5);
-        const bufLength = 1024 * 16;
-        const subLength = bufLength - 36;
-        const buf = new Uint8Array(bufLength);
-        const sub = buf.subarray(0, subLength);
-        let pos = 0;
-        let out = "";
+        const writer = new StringWriter();
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
         for (let i = 0; i < decoded.length; i++) {
           const line = decoded[i];
-          if (i > 0) {
-            if (pos === bufLength) {
-              out += td.decode(buf);
-              pos = 0;
-            }
-            buf[pos++] = semicolon;
-          }
+          if (i > 0)
+            writer.write(semicolon);
           if (line.length === 0)
             continue;
-          state[0] = 0;
+          let genColumn = 0;
           for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            if (pos > subLength) {
-              out += td.decode(sub);
-              buf.copyWithin(0, subLength, pos);
-              pos -= subLength;
-            }
             if (j > 0)
-              buf[pos++] = comma;
-            pos = encodeInteger(buf, pos, state, segment, 0);
+              writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
               continue;
-            pos = encodeInteger(buf, pos, state, segment, 1);
-            pos = encodeInteger(buf, pos, state, segment, 2);
-            pos = encodeInteger(buf, pos, state, segment, 3);
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
               continue;
-            pos = encodeInteger(buf, pos, state, segment, 4);
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
           }
         }
-        return out + td.decode(buf.subarray(0, pos));
-      }
-      function encodeInteger(buf, pos, state, segment, j) {
-        const next = segment[j];
-        let num = next - state[j];
-        state[j] = next;
-        num = num < 0 ? -num << 1 | 1 : num << 1;
-        do {
-          let clamped = num & 31;
-          num >>>= 5;
-          if (num > 0)
-            clamped |= 32;
-          buf[pos++] = intToChar[clamped];
-        } while (num > 0);
-        return pos;
+        return writer.flush();
       }
       exports2.decode = decode;
+      exports2.decodeGeneratedRanges = decodeGeneratedRanges;
+      exports2.decodeOriginalScopes = decodeOriginalScopes;
       exports2.encode = encode;
+      exports2.encodeGeneratedRanges = encodeGeneratedRanges;
+      exports2.encodeOriginalScopes = encodeOriginalScopes;
       Object.defineProperty(exports2, "__esModule", { value: true });
     });
   }
@@ -73885,6 +74143,7 @@ var setupTransformHook = (opts = {}) => {
     configFile: false,
     compact: false,
     presets: [require_lib32()],
+    sourceMaps: "inline",
     plugins: [
       [
         require_lib35(),

package/build/src/cli/commands/list-tests/index.d.ts

@@ -0,0 +1,4 @@
+import { Testplane } from "../../../testplane";
+import { type CommonCmdOpts } from "../../../utils/cli";
+export type ListTestsCmd = typeof commander & CommonCmdOpts;
+export declare const registerCmd: (cliTool: ListTestsCmd, testplane: Testplane) => void;

package/build/src/cli/commands/list-tests/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCmd = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const test_collection_1 = require("../../../test-collection");
+const constants_1 = require("../../constants");
+const cli_1 = require("../../../utils/cli");
+const logger_1 = __importDefault(require("../../../utils/logger"));
+const { LIST_TESTS: commandName } = constants_1.CliCommands;
+const registerCmd = (cliTool, testplane) => {
+    (0, cli_1.withCommonCliOptions)({ cmd: cliTool.command(`${commandName}`), actionName: "list" })
+        .description("Lists all tests info in one of available formats")
+        .option("--ignore <file-path>", "exclude paths from tests read", cli_1.collectCliValues)
+        .option("--silent [type]", "flag to disable events emitting while reading tests", Boolean, false)
+        .option("--output-file <file-path>", "save results to specified file")
+        .option("--formatter [name]", "return tests in specified format", String, test_collection_1.Formatters.LIST)
+        .arguments("[paths...]")
+        .action(async (paths, options) => {
+        const { grep, browser: browsers, set: sets, require: requireModules } = cliTool;
+        const { ignore, silent, outputFile, formatter } = options;
+        try {
+            (0, test_collection_1.validateFormatter)(formatter);
+            (0, cli_1.handleRequires)(requireModules);
+            const testCollection = await testplane.readTests(paths, {
+                browsers,
+                sets,
+                grep,
+                ignore,
+                silent,
+                runnableOpts: {
+                    saveLocations: formatter === test_collection_1.Formatters.TREE,
+                },
+            });
+            const result = testCollection.format(formatter);
+            if (outputFile) {
+                await fs_extra_1.default.ensureDir(node_path_1.default.dirname(outputFile));
+                await fs_extra_1.default.writeJson(outputFile, result);
+            }
+            else {
+                console.info(JSON.stringify(result));
+            }
+            process.exit(0);
+        }
+        catch (err) {
+            logger_1.default.error(err.stack || err);
+            process.exit(1);
+        }
+    });
+};
+exports.registerCmd = registerCmd;
+//# sourceMappingURL=index.js.map

package/build/src/cli/commands/list-tests/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/cli/commands/list-tests/index.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAC7B,wDAA0B;AAG1B,8DAAyE;AACzE,+CAA8C;AAC9C,4CAAgH;AAChH,mEAA2C;AAI3C,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,uBAAW,CAAC;AAWzC,MAAM,WAAW,GAAG,CAAC,OAAqB,EAAE,SAAoB,EAAQ,EAAE;IAC7E,IAAA,0BAAoB,EAAC,EAAE,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;SAC/E,WAAW,CAAC,kDAAkD,CAAC;SAC/D,MAAM,CAAC,sBAAsB,EAAE,+BAA+B,EAAE,sBAAgB,CAAC;SACjF,MAAM,CAAC,iBAAiB,EAAE,qDAAqD,EAAE,OAAO,EAAE,KAAK,CAAC;SAChG,MAAM,CAAC,2BAA2B,EAAE,gCAAgC,CAAC;SACrE,MAAM,CAAC,oBAAoB,EAAE,kCAAkC,EAAE,MAAM,EAAE,4BAAU,CAAC,IAAI,CAAC;SACzF,SAAS,CAAC,YAAY,CAAC;SACvB,MAAM,CAAC,KAAK,EAAE,KAAe,EAAE,OAAyB,EAAE,EAAE;QACzD,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAChF,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QAE1D,IAAI,CAAC;YACD,IAAA,mCAAiB,EAAC,SAAS,CAAC,CAAC;YAC7B,IAAA,oBAAc,EAAC,cAAc,CAAC,CAAC;YAE/B,MAAM,cAAc,GAAG,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE;gBACpD,QAAQ;gBACR,IAAI;gBACJ,IAAI;gBACJ,MAAM;gBACN,MAAM;gBACN,YAAY,EAAE;oBACV,aAAa,EAAE,SAAS,KAAK,4BAAU,CAAC,IAAI;iBAC/C;aACJ,CAAC,CAAC;YAEH,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAEhD,IAAI,UAAU,EAAE,CAAC;gBACb,MAAM,kBAAE,CAAC,SAAS,CAAC,mBAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC7C,MAAM,kBAAE,CAAC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YAC3C,CAAC;iBAAM,CAAC;gBACJ,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;YACzC,CAAC;YAED,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACX,gBAAM,CAAC,KAAK,CAAE,GAAa,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC;YAC1C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;IACL,CAAC,CAAC,CAAC;AACX,CAAC,CAAC;AA1CW,QAAA,WAAW,eA0CtB"}

package/build/src/cli/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const CliCommands: {
+    readonly LIST_TESTS: "list-tests";
+};

package/build/src/cli/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliCommands = void 0;
+exports.CliCommands = {
+    LIST_TESTS: "list-tests",
+};
+//# sourceMappingURL=constants.js.map

package/build/src/cli/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/cli/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG;IACvB,UAAU,EAAE,YAAY;CAClB,CAAC"}

package/build/src/cli/index.d.ts

@@ -1 +1,4 @@
-export function run(opts?: {}): void;
+export type TestplaneRunOpts = {
+    cliName?: string;
+};
+export declare const run: (opts?: TestplaneRunOpts) => void;