@zohodesk/testinglibrary 0.0.9 → 0.0.10-n20-experimental

package/build/core/playwright/setup/config-utils.js

@@ -4,15 +4,27 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getBrowsersList = getBrowsersList;
+exports.getModulePathForFeatureFiles = getModulePathForFeatureFiles;
+exports.getPathsForFeatureFiles = getPathsForFeatureFiles;
 exports.getProjects = getProjects;
 exports.getTestDir = getTestDir;
 var _test = require("@playwright/test");
 var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
-var _bddFramework = require("../../../bdd-framework");
+var _playwrightBdd = require("playwright-bdd");
+var _logger = require("../../../utils/logger");
+var _browserTypes = require("../constants/browserTypes");
+var _fileUtils = require("../../../utils/fileUtils");
+/**
+ ** Playwright project configuration
+ * @returns {import('@playwright/test').Project}
+ */
+
 function getBrowserConfig({
   browserName,
   isAuthMode,
+  isSmokeTest,
   authFilePath,
   expectTimeout,
   testTimeout,
@@ -23,10 +35,12 @@ function getBrowserConfig({
     viewport,
     storageState: isAuthMode ? (0, _readConfigFile.getAuthFilePath)(_path.default.resolve(process.cwd(), authFilePath)) : {}
   };
-  const dependencies = isAuthMode ? ['setup'] : [];
+  // Determine dependencies based on the mode and smoke test status
+  let dependencies = isAuthMode ? ['setup'] : [];
+  dependencies = isSmokeTest ? [...dependencies, 'smokeTest'] : dependencies;
   if (browser === 'chrome') {
     return {
-      name: 'chromium',
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.CHROME,
       use: {
         ..._test.devices['Desktop Chrome'],
         ...commonConfig
@@ -39,7 +53,7 @@ function getBrowserConfig({
     };
   } else if (browser === 'edge') {
     return {
-      name: 'Microsoft Edge',
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.EDGE,
       timeout: testTimeout,
       expect: {
         timeout: expectTimeout
@@ -53,7 +67,7 @@ function getBrowserConfig({
     };
   } else if (browser === 'firefox') {
     return {
-      name: 'firefox',
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.FIREFOX,
       timeout: 2 * testTimeout,
       expect: {
         timeout: 2 * expectTimeout
@@ -66,7 +80,7 @@ function getBrowserConfig({
     };
   } else if (browser === 'safari') {
     return {
-      name: 'webkit',
+      name: _browserTypes.BROWSER_PROJECT_MAPPING.SAFARI,
       timeout: 4 * testTimeout,
       expect: {
         timeout: 4 * expectTimeout
@@ -81,9 +95,16 @@ function getBrowserConfig({
     return false;
   }
 }
+
+/**
+ *
+ * @param {*} param0
+ * @returns {import('@playwright/test').Project[]}
+ */
 function getProjects({
   browsers,
   isAuthMode,
+  isSmokeTest,
   authFilePath,
   expectTimeout,
   testTimeout,
@@ -92,18 +113,76 @@ function getProjects({
   return browsers.map(browserName => getBrowserConfig({
     browserName,
     isAuthMode,
+    isSmokeTest,
     authFilePath,
     expectTimeout,
     testTimeout,
     viewport
   })).filter(Boolean);
 }
-function getTestDir(bddMode, cwd) {
-  return bddMode ? (0, _bddFramework.defineBddConfig)({
-    paths: [_path.default.join(cwd, 'uat', '**', '*.feature')],
-    import: [_path.default.join(cwd, 'uat', '**', 'steps', '*.spec.js')],
-    featuresRoot: _path.default.join(cwd, 'uat'),
-    outputDir: _path.default.join(cwd, 'uat', '.features-gen'),
+function getBrowsersList(browserFromArgs) {
+  if (browserFromArgs) {
+    if (typeof browserFromArgs === 'string') {
+      let listOfbrowsers = browserFromArgs.split(',').map(browser => browser.trim().toLowerCase());
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Using browsers from command line args');
+      return listOfbrowsers;
+    }
+  }
+  return [];
+}
+function getPathsForFeatureFiles(cwd) {
+  if (process.env.isRerunFailedCases) {
+    let {
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    let filePathFromArgs = process.env.filePath;
+    let filePath = filePathFromArgs ? filePathFromArgs : reportPath;
+    const testSummary = (0, _fileUtils.readFileContents)(filePath);
+    if (testSummary !== null) {
+      const {
+        failed = []
+      } = JSON.parse(testSummary);
+      const casesToRun = failed.map(filePath => _path.default.join(cwd, 'uat', filePath.replace(/\.spec\.js$|\.js$/, '')));
+      return casesToRun;
+    } else {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Unable to read test summary from the ${reportPath}. Verify If File Exists in the path`);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Going to run all test cases');
+    }
+  } else if (process.env.modules !== 'undefined' && process.env.modules.length > 0) {
+    let modules = process.env.modules;
+    let moduleList = modules.split(',');
+    return getModulePathForFeatureFiles(moduleList);
+  }
+  return [_path.default.join(cwd, 'uat', 'modules', '**', '*.feature')];
+}
+function getModulePathForFeatureFiles(moduleList) {
+  let validModuleList = [];
+  moduleList.forEach(moduleName => {
+    let modulePath = _path.default.join(process.cwd(), 'uat', 'modules', '**', `${moduleName}`);
+    if ((0, _fileUtils.checkIfFolderExistsWithPattern)(modulePath)) {
+      validModuleList.push(_path.default.join(modulePath, '**', '*.feature'));
+    } else {
+      validModuleList = [];
+      throw new Error(`Module ${moduleName} does not exist. We have not triggered the execution for this module`);
+    }
+  });
+  return validModuleList;
+}
+function getTestDir(bddMode, {
+  featureFilesFolder,
+  stepDefinitionsFolder,
+  outputDir,
+  uatPath
+}) {
+  return bddMode ? (0, _playwrightBdd.defineBddConfig)({
+    features: featureFilesFolder,
+    steps: [stepDefinitionsFolder, require.resolve('../fixtures.js')],
+    importTestFrom: require.resolve('../fixtures.js'),
+    featuresRoot: uatPath,
+    outputDir: outputDir,
+    disableWarnings: {
+      importTestFrom: true
+    },
     publish: true
-  }) : _path.default.join(cwd, 'uat');
+  }) : uatPath;
 }

package/build/core/playwright/setup/custom-reporter.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _readline = _interopRequireDefault(require("readline"));
+var _fileUtils = require("../../../utils/fileUtils");
+var _readConfigFile = require("../readConfigFile");
+var _logger = require("../../../utils/logger");
+var _configFileNameProvider = require("../helpers/configFileNameProvider");
+class JSONSummaryReporter {
+  constructor() {
+    this.durationInMS = -1;
+    this.passed = [];
+    this.skipped = [];
+    this.failed = [];
+    this.warned = [];
+    this.errored = [];
+    this.interrupted = [];
+    this.timedOut = [];
+    this.flakey = [];
+    this.failedSteps = [];
+    this.status = 'unknown';
+    this.startedAt = 0;
+    this._open = (0, _readConfigFile.generateConfigFromFile)().openReportOn;
+  }
+  onBegin() {
+    this.startedAt = Date.now();
+  }
+  getTitle(test) {
+    const title = [];
+    const fileName = [];
+    let clean = true;
+    for (const s of test.titlePath()) {
+      if (s === '' && clean) {
+        continue;
+      }
+      clean = false;
+      title.push(s);
+      if (s.endsWith('.ts') || s.endsWith('.js')) {
+        fileName.push(s);
+      }
+    }
+
+    //Using the fullTitle variable in the push will push a full test name + test description
+
+    return {
+      fullTitle: title.join(' > '),
+      fileName: fileName[0] || ''
+    };
+  }
+  onTestEnd(test, result) {
+    const {
+      fullTitle,
+      fileName
+    } = this.getTitle(test);
+
+    // Set the status
+    const stepTitleList = result.steps.filter(step => step.error).map(step => ({
+      title: step.title,
+      error: step.error,
+      testTitle: fullTitle
+    }));
+    if (stepTitleList.length > 0) {
+      this.failedSteps = [...this.failedSteps, ...stepTitleList];
+    }
+    const status = !['passed', 'skipped'].includes(result.status) && fullTitle.includes('@warn') ? 'warned' : result.status;
+    // Logic to push the results into the correct array
+    if (result.status === 'passed' && result.retry >= 1) {
+      this.flakey.push(fileName);
+    } else {
+      this[status].push(fileName);
+    }
+    this[status].push(fileName);
+  }
+  onError(error) {
+    this.errored.push({
+      error: error.message,
+      stack: error.stack
+    });
+  }
+  onEnd(result) {
+    this.durationInMS = Date.now() - this.startedAt;
+    this.status = result.status;
+
+    // removing duplicate tests from passed array
+    this.passed = this.passed.filter((element, index) => {
+      return this.passed.indexOf(element) === index;
+    });
+    // removing duplicate tests from the failed array
+    this.failed = this.failed.filter((element, index) => {
+      if (!this.passed.includes(element)) {
+        return this.failed.indexOf(element) === index;
+      }
+    });
+    // removing duplicate tests from the skipped array
+    this.skipped = this.skipped.filter((element, index) => {
+      return this.skipped.indexOf(element) === index;
+    });
+    // removing duplicate tests from the timedOut array
+    this.timedOut = this.timedOut.filter((element, index) => {
+      return this.timedOut.indexOf(element) === index;
+    });
+    // removing duplicate tests from the interrupted array
+    this.interrupted = this.interrupted.filter((element, index) => {
+      return this.interrupted.indexOf(element) === index;
+    });
+    this.errored = this.errored.filter((element, index) => {
+      return this.errored.indexOf(element) === index;
+    });
+    if (this.errored.length > 0) {
+      // Reflect setup failures in the final report status
+      this.status = "failed";
+    }
+
+    // fs.writeFileSync('./summary.json', JSON.stringify(this, null, '  '));
+    let {
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    (0, _fileUtils.writeFileContents)(_path.default.join(reportPath, './', (0, _configFileNameProvider.getReportFileName)()), JSON.stringify(this, null, '  '));
+  }
+  onExit() {
+    const shouldClearLastLine = this._open !== 'always' || this._open !== 'on-failure';
+    if (shouldClearLastLine) {
+      /**Below code is to replace the playwright default report commond with abstraction tool command */
+      _readline.default.moveCursor(process.stdout, 0, -2); // up two line
+      _readline.default.clearLine(process.stdout, 1); // from cursor to end
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'npx ZDTestingFramework report or npm run uat-report');
+      return;
+    }
+  }
+}
+var _default = exports.default = JSONSummaryReporter;

package/build/core/playwright/setup/qc-custom-reporter.js

@@ -0,0 +1,291 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _codeFrame = require("@babel/code-frame");
+class CustomJsonReporter {
+  constructor({
+    outputFile = 'test-results.json'
+  } = {}) {
+    this.outputFile = _path.default.resolve(process.cwd(), 'uat/test-results/', outputFile);
+    this.rootSuite = null;
+    this.report = {
+      config: {},
+      suites: []
+    };
+    this.testResultsById = new Map();
+  }
+  onBegin = (config, suite) => {
+    this.rootSuite = suite;
+    this.report.config = config;
+  };
+  onTestEnd(test, result) {
+    var _result$errors, _result$steps;
+    const key = `${test.location.file}:${test.location.line}:${test.title}`;
+    const testResult = {
+      status: result.status,
+      attachments: result.attachments,
+      startTime: result.startTime,
+      retry: result.retry,
+      stderr: result.stderr.map(err => stdioEntry(err)),
+      stdout: result.stdout.map(out => stdioEntry(out)),
+      workerIndex: result.workerIndex,
+      duration: result.duration,
+      error: result.error,
+      errors: (_result$errors = result.errors) === null || _result$errors === void 0 ? void 0 : _result$errors.map(processError),
+      steps: ((_result$steps = result.steps) === null || _result$steps === void 0 ? void 0 : _result$steps.map(step => extractMergedSteps(this.report.config.rootDir, step))) ?? []
+    };
+    const existingResults = this.testResultsById.get(key) ?? [];
+    this.testResultsById.set(key, [...existingResults, testResult]);
+  }
+  onEnd() {
+    var _this$rootSuite;
+    (_this$rootSuite = this.rootSuite) === null || _this$rootSuite === void 0 || (_this$rootSuite = _this$rootSuite.suites) === null || _this$rootSuite === void 0 || _this$rootSuite.map(suite => {
+      const extracted = suite.suites.map(suite => extractMergedSuite(this.report.config.rootDir, suite, this.testResultsById));
+      this.report.suites.push(...extracted);
+    });
+    const writableStream = _fs.default.createWriteStream(this.outputFile);
+    writableStream.write('{\n');
+    writableStream.write(`  "config": ${JSON.stringify(this.report.config, null, 2)},\n`);
+    writableStream.write('  "suites": [\n');
+    for (let i = 0; i < this.report.suites.length; i++) {
+      const suite = this.report.suites[i];
+      let suiteStr = JSON.stringify(suite, null, 2).split('\n').map(line => '    ' + line).join('\n');
+      if (i < this.report.suites.length - 1) {
+        suiteStr += ',';
+      }
+      suiteStr += '\n';
+      writableStream.write(suiteStr);
+    }
+    writableStream.write('  ]\n');
+    writableStream.write('}\n');
+    writableStream.end();
+    console.log(`Custom JSON report written to: ${this.outputFile}`);
+  }
+}
+exports.default = CustomJsonReporter;
+const extractMergedSuite = (rootDir, suite, testResultsById) => {
+  var _suite$suites;
+  const specMap = new Map();
+  for (const test of suite.tests ?? []) {
+    const existingSpec = specMap.get(test.title);
+    if (existingSpec) {
+      const newTestInfo = extractTestDetails(test, testResultsById);
+      existingSpec.tests.push(newTestInfo);
+    } else {
+      const newSpec = createSpecEntry(rootDir, test, testResultsById);
+      specMap.set(test.title, newSpec);
+    }
+  }
+  return {
+    title: suite.title,
+    ...parseLocation(rootDir, suite.location),
+    ...(suite.location && {
+      snippet: formSnippet(rootDir, suite.location)
+    }),
+    ...(((_suite$suites = suite.suites) === null || _suite$suites === void 0 ? void 0 : _suite$suites.length) > 0 && {
+      suites: suite.suites.map(child => extractMergedSuite(rootDir, child, testResultsById))
+    }),
+    ...(specMap.size > 0 && {
+      specs: Array.from(specMap.values())
+    })
+  };
+};
+const createSpecEntry = (rootDir, test, testResultsById) => ({
+  title: test.title,
+  ...parseLocation(rootDir, test.location),
+  ...(test.location && {
+    snippet: formSnippet(test.location)
+  }),
+  tags: test.tags,
+  tests: [extractTestDetails(test, testResultsById)]
+});
+const extractTestDetails = (test, testResultsById) => {
+  var _test$location, _test$location2;
+  const key = `${(_test$location = test.location) === null || _test$location === void 0 ? void 0 : _test$location.file}:${(_test$location2 = test.location) === null || _test$location2 === void 0 ? void 0 : _test$location2.line}:${test.title}`;
+  return {
+    annotations: test.annotations,
+    expectedStatus: test.expectedStatus,
+    timeout: test.timeout,
+    retries: test.retries,
+    results: testResultsById.get(key) ?? [],
+    status: test.outcome()
+  };
+};
+const extractMergedSteps = (rootDir, step) => ({
+  title: step.title,
+  duration: step.duration,
+  ...(step.error && {
+    error: {
+      message: step.error.message,
+      stack: step.error.stack,
+      snippet: step.error.snippet
+    }
+  }),
+  ...parseLocation(rootDir, step.location),
+  status: step.status,
+  ...(step.location && {
+    snippet: formSnippet(rootDir, step.location)
+  }),
+  ...(step.steps && step.steps.length > 0 && {
+    steps: step.steps.map(subStep => extractMergedSteps(rootDir, subStep))
+  })
+});
+const formSnippet = (rootDir, location) => {
+  if (location && !(location !== null && location !== void 0 && location.file)) return '';
+  try {
+    const {
+      file,
+      line,
+      column
+    } = parseLocation(rootDir, location, false);
+    const raw = _fs.default.readFileSync(file, 'utf8');
+    return (0, _codeFrame.codeFrameColumns)(raw, {
+      start: {
+        line,
+        column
+      }
+    }, {
+      linesAbove: 2,
+      linesBelow: 2,
+      highlightCode: true
+    });
+  } catch {
+    return '';
+  }
+};
+const parseLocation = (rootDir, {
+  file,
+  line,
+  column
+} = {}, isRelative = true) => file ? {
+  file: isRelative ? _path.default.relative(rootDir, file) : file,
+  line,
+  column
+} : {};
+const stdioEntry = s => typeof s === 'string' ? {
+  text: s
+} : {
+  buffer: s.toString('base64')
+};
+const processError = error => {
+  const message = error.message || error.value || '';
+  const stack = error.stack;
+  if (!stack && !error.location) return {
+    message
+  };
+  const tokens = [];
+  const parsedStack = stack ? constructErrorStack(stack) : undefined;
+  tokens.push((parsedStack === null || parsedStack === void 0 ? void 0 : parsedStack.message) || message);
+  if (error.snippet) {
+    tokens.push('');
+    tokens.push(error.snippet);
+  }
+  if (parsedStack && parsedStack.stackLines.length) {
+    const dimmedStackLines = parsedStack.stackLines.split('\n').map(line => dimify(line));
+    tokens.push(dimmedStackLines.join('\n'));
+  }
+  let location = error.location;
+  if (parsedStack && !location) location = parsedStack.location;
+  if (error.cause) tokens.push(dimify('[cause]: ') + processError(error.cause).message);
+  return {
+    location,
+    message: tokens.join('\n')
+  };
+};
+const constructErrorStack = stack => parseErrorStack(stack, _path.default.sep, false);
+const dimify = text => `\x1b[2m${text}\x1b[22m`;
+const parseErrorStack = (stack, pathSeparator, showInternalStackFrames = false) => {
+  const lines = stack.split("\n");
+  let firstStackLineIndex = lines.findIndex(line => line.startsWith("    at "));
+  if (firstStackLineIndex === -1) firstStackLineIndex = lines.length;
+  const message = lines.slice(0, firstStackLineIndex).join("\n");
+  const stackStartIndex = indexLocator(stack, '\n', firstStackLineIndex) + 1 || 0;
+  const stackLinesString = stackStartIndex ? stack.slice(stackStartIndex) : '';
+  let location;
+  const stackLinesArr = stackLinesString.split('\n');
+  for (const line of stackLinesArr) {
+    const frame = parseStackFrame(line, pathSeparator, showInternalStackFrames);
+    if (!frame || !frame.file) continue;
+    if (isInNodeModules(frame.file, pathSeparator)) continue;
+    location = {
+      file: frame.file,
+      column: frame.column || 0,
+      line: frame.line || 0
+    };
+    break;
+  }
+  return {
+    message,
+    stackLines: stackLinesString,
+    location
+  };
+};
+const indexLocator = (str, pat, n) => {
+  let L = str.length,
+    i = -1;
+  while (n-- && i++ < L) {
+    i = str.indexOf(pat, i);
+    if (i < 0) break;
+  }
+  return i;
+};
+const isInNodeModules = (file, pathSeparator) => file.includes(`${pathSeparator}node_modules${pathSeparator}`);
+const parseStackFrame = (text, pathSeparator, showInternalStackFrames) => {
+  const re = new RegExp("^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$");
+  const methodRe = /^(.*?) \[as (.*?)\]$/;
+  const match = text && text.match(re);
+  if (!match) return null;
+  let fname = match[2];
+  let file = match[7];
+  if (!file) return null;
+  if (!showInternalStackFrames && (file.startsWith("internal") || file.startsWith("node:"))) return null;
+  const line = match[8];
+  const column = match[9];
+  const closeParen = match[11] === ")";
+  const frame = {
+    file: "",
+    line: 0,
+    column: 0
+  };
+  if (line) frame.line = Number(line);
+  if (column) frame.column = Number(column);
+  if (closeParen && file) {
+    let closes = 0;
+    for (let i = file.length - 1; i > 0; i--) {
+      if (file.charAt(i) === ")") {
+        closes++;
+      } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
+        closes--;
+        if (closes === -1 && file.charAt(i - 1) === " ") {
+          const before = file.slice(0, i - 1);
+          const after = file.slice(i + 1);
+          file = after;
+          fname += ` (${before}`;
+          break;
+        }
+      }
+    }
+  }
+  if (fname) {
+    const methodMatch = fname.match(methodRe);
+    if (methodMatch) fname = methodMatch[1];
+  }
+  if (file) {
+    if (file.startsWith("file://")) file = fileURLToPath(file, pathSeparator);
+    frame.file = file;
+  }
+  if (fname) frame.function = fname;
+  return frame;
+};
+const fileURLToPath = (fileUrl, pathSeparator) => {
+  if (!fileUrl.startsWith("file://")) return fileUrl;
+  let path = decodeURIComponent(fileUrl.slice(7));
+  if (path.startsWith("/") && /^[a-zA-Z]:/.test(path.slice(1))) path = path.slice(1);
+  return path.replace(/\//g, pathSeparator);
+};

package/build/core/playwright/tagProcessor.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _logger = require("../../utils/logger");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _TagProcessor_brand = /*#__PURE__*/new WeakSet();
+class TagProcessor {
+  constructor(editionOrder) {
+    _classPrivateMethodInitSpec(this, _TagProcessor_brand);
+    this.editionOrder = editionOrder;
+  }
+  processTags(userArgs) {
+    const tagArgs = userArgs['tags'] || '';
+    const edition = userArgs['edition'] || null;
+    if (!edition) return tagArgs;
+    const editionsArray = edition.split(',');
+    const editionTags = editionsArray.length === 1 ? _assertClassBrand(_TagProcessor_brand, this, _processSingleEdition).call(this, editionsArray[0], tagArgs) : _assertClassBrand(_TagProcessor_brand, this, _processMultipleEditions).call(this, editionsArray, tagArgs);
+    return editionTags;
+  }
+}
+function _buildTagsString(tags, editionTags) {
+  return tags && tags !== '' ? `${tags} and not (${editionTags})` : `not (${editionTags})`;
+}
+function _parseEdition(edition) {
+  if (edition.startsWith('<=')) return ['<=', edition.slice(2)];
+  if (edition.startsWith('>=')) return ['>=', edition.slice(2)];
+  if (edition.startsWith('<')) return ['<', edition.slice(1)];
+  if (edition.startsWith('>')) return ['>', edition.slice(1)];
+  return [null, edition];
+}
+function _processSingleEdition(selectedEdition, tagArgs) {
+  const editionArgs = _assertClassBrand(_TagProcessor_brand, this, _getEditionArgs).call(this, selectedEdition);
+  if (editionArgs && editionArgs.length > 0) {
+    const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, editionArgs, 'or');
+    return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+  }
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
+  return tagArgs;
+}
+function _processMultipleEditions(editionsArray, tagArgs) {
+  const filteredEditions = this.editionOrder.filter(edition => !editionsArray.includes(edition));
+  const editionTags = _assertClassBrand(_TagProcessor_brand, this, _buildEditionTags).call(this, filteredEditions, 'or');
+  return _assertClassBrand(_TagProcessor_brand, this, _buildTagsString).call(this, tagArgs, editionTags);
+}
+function _getEditionArgs(selectedEdition) {
+  const [operator, editionValue] = _assertClassBrand(_TagProcessor_brand, this, _parseEdition).call(this, selectedEdition.toLowerCase());
+  const index = this.editionOrder.findIndex(edition => edition.toLowerCase() === editionValue);
+  if (index === -1) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `No matching editions for ${selectedEdition} found. Running with default edition`);
+    return [];
+  }
+  switch (operator) {
+    case '<=':
+      return this.editionOrder.slice(index + 1);
+    case '>=':
+      return this.editionOrder.slice(0, index);
+    case '<':
+      return this.editionOrder.slice(index);
+    case '>':
+      return this.editionOrder.slice(0, index + 1);
+    default:
+      return this.editionOrder.filter((_, i) => i !== index);
+  }
+}
+function _buildEditionTags(editionArgs, operator = 'or') {
+  return editionArgs.map(edition => `@edition_${edition}`).join(` ${operator} `);
+}
+module.exports = TagProcessor;