@fabasoad/sarif-to-slack 0.2.5 → 1.1.0

package/dist/index.cjs

@@ -30,20 +30,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CalculateResultsBy: () => CalculateResultsBy,
+  Color: () => Color,
   FooterType: () => FooterType,
-  GroupResultsBy: () => GroupResultsBy,
   LogLevel: () => LogLevel,
-  SarifToSlackService: () => SarifToSlackService
+  RepresentationType: () => RepresentationType,
+  SarifToSlackClient: () => SarifToSlackClient,
+  SendIf: () => SendIf
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/SarifToSlackService.ts
-var import_fs = require("fs");
-
-// src/Logger.ts
-var import_tslog = require("tslog");
-
 // src/types.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["Silly"] = 0] = "Silly";
@@ -60,19 +55,161 @@ var FooterType = /* @__PURE__ */ ((FooterType2) => {
   FooterType2["Markdown"] = "mrkdwn";
   return FooterType2;
 })(FooterType || {});
-var GroupResultsBy = /* @__PURE__ */ ((GroupResultsBy2) => {
-  GroupResultsBy2[GroupResultsBy2["ToolName"] = 0] = "ToolName";
-  GroupResultsBy2[GroupResultsBy2["Run"] = 1] = "Run";
-  GroupResultsBy2[GroupResultsBy2["Total"] = 2] = "Total";
-  return GroupResultsBy2;
-})(GroupResultsBy || {});
-var CalculateResultsBy = /* @__PURE__ */ ((CalculateResultsBy2) => {
-  CalculateResultsBy2[CalculateResultsBy2["Level"] = 0] = "Level";
-  CalculateResultsBy2[CalculateResultsBy2["Severity"] = 1] = "Severity";
-  return CalculateResultsBy2;
-})(CalculateResultsBy || {});
+var RepresentationType = /* @__PURE__ */ ((RepresentationType2) => {
+  RepresentationType2[RepresentationType2["CompactGroupByRunPerLevel"] = 0] = "CompactGroupByRunPerLevel";
+  RepresentationType2[RepresentationType2["CompactGroupByRunPerSeverity"] = 1] = "CompactGroupByRunPerSeverity";
+  RepresentationType2[RepresentationType2["CompactGroupByToolNamePerLevel"] = 2] = "CompactGroupByToolNamePerLevel";
+  RepresentationType2[RepresentationType2["CompactGroupByToolNamePerSeverity"] = 3] = "CompactGroupByToolNamePerSeverity";
+  RepresentationType2[RepresentationType2["CompactGroupBySarifPerLevel"] = 4] = "CompactGroupBySarifPerLevel";
+  RepresentationType2[RepresentationType2["CompactGroupBySarifPerSeverity"] = 5] = "CompactGroupBySarifPerSeverity";
+  RepresentationType2[RepresentationType2["CompactTotalPerLevel"] = 6] = "CompactTotalPerLevel";
+  RepresentationType2[RepresentationType2["CompactTotalPerSeverity"] = 7] = "CompactTotalPerSeverity";
+  return RepresentationType2;
+})(RepresentationType || {});
+var SendIf = /* @__PURE__ */ ((SendIf2) => {
+  SendIf2[SendIf2["SeverityCritical"] = 0] = "SeverityCritical";
+  SendIf2[SendIf2["SeverityHigh"] = 1] = "SeverityHigh";
+  SendIf2[SendIf2["SeverityHighOrHigher"] = 2] = "SeverityHighOrHigher";
+  SendIf2[SendIf2["SeverityMedium"] = 3] = "SeverityMedium";
+  SendIf2[SendIf2["SeverityMediumOrHigher"] = 4] = "SeverityMediumOrHigher";
+  SendIf2[SendIf2["SeverityLow"] = 5] = "SeverityLow";
+  SendIf2[SendIf2["SeverityLowOrHigher"] = 6] = "SeverityLowOrHigher";
+  SendIf2[SendIf2["SeverityNone"] = 7] = "SeverityNone";
+  SendIf2[SendIf2["SeverityNoneOrHigher"] = 8] = "SeverityNoneOrHigher";
+  SendIf2[SendIf2["SeverityUnknown"] = 9] = "SeverityUnknown";
+  SendIf2[SendIf2["SeverityUnknownOrHigher"] = 10] = "SeverityUnknownOrHigher";
+  SendIf2[SendIf2["LevelError"] = 11] = "LevelError";
+  SendIf2[SendIf2["LevelWarning"] = 12] = "LevelWarning";
+  SendIf2[SendIf2["LevelWarningOrHigher"] = 13] = "LevelWarningOrHigher";
+  SendIf2[SendIf2["LevelNote"] = 14] = "LevelNote";
+  SendIf2[SendIf2["LevelNoteOrHigher"] = 15] = "LevelNoteOrHigher";
+  SendIf2[SendIf2["LevelNone"] = 16] = "LevelNone";
+  SendIf2[SendIf2["LevelNoneOrHigher"] = 17] = "LevelNoneOrHigher";
+  SendIf2[SendIf2["LevelUnknown"] = 18] = "LevelUnknown";
+  SendIf2[SendIf2["LevelUnknownOrHigher"] = 19] = "LevelUnknownOrHigher";
+  SendIf2[SendIf2["Always"] = 20] = "Always";
+  SendIf2[SendIf2["Some"] = 21] = "Some";
+  SendIf2[SendIf2["Empty"] = 22] = "Empty";
+  SendIf2[SendIf2["Never"] = 23] = "Never";
+  return SendIf2;
+})(SendIf || {});
+var SecuritySeverity = /* @__PURE__ */ ((SecuritySeverity2) => {
+  SecuritySeverity2[SecuritySeverity2["Unknown"] = 0] = "Unknown";
+  SecuritySeverity2[SecuritySeverity2["None"] = 1] = "None";
+  SecuritySeverity2[SecuritySeverity2["Low"] = 2] = "Low";
+  SecuritySeverity2[SecuritySeverity2["Medium"] = 3] = "Medium";
+  SecuritySeverity2[SecuritySeverity2["High"] = 4] = "High";
+  SecuritySeverity2[SecuritySeverity2["Critical"] = 5] = "Critical";
+  return SecuritySeverity2;
+})(SecuritySeverity || {});
+var SecurityLevel = /* @__PURE__ */ ((SecurityLevel2) => {
+  SecurityLevel2[SecurityLevel2["Unknown"] = 0] = "Unknown";
+  SecurityLevel2[SecurityLevel2["None"] = 1] = "None";
+  SecurityLevel2[SecurityLevel2["Note"] = 2] = "Note";
+  SecurityLevel2[SecurityLevel2["Warning"] = 3] = "Warning";
+  SecurityLevel2[SecurityLevel2["Error"] = 4] = "Error";
+  return SecurityLevel2;
+})(SecurityLevel || {});
+
+// src/model/Color.ts
+var Color = class {
+  _color;
+  /**
+   * Creates an instance of {@link Color} class. Before creating an instance of
+   * {@link Color} class, it (if applicable) maps CI status into the hex color,
+   * and also validates {@param color} to be a valid string that represents a
+   * color in hex format.
+   * @param color Can be either undefined, valid color in hex format or GitHub
+   * CI status (one of: success, failure, cancelled, skipped)
+   * @public
+   */
+  constructor(color) {
+    this._color = this.mapColor(color);
+    this.validateHexColor();
+  }
+  /**
+   * Returns a valid string that represents a color in hex format, or undefined.
+   */
+  get value() {
+    return this._color;
+  }
+  validateHexColor() {
+    if (this._color != null) {
+      const hexColorRegex = /^#(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/;
+      if (!hexColorRegex.test(this._color)) {
+        throw new Error(`Invalid hex color: "${this._color}"`);
+      }
+    }
+  }
+  mapColor(from) {
+    switch (from) {
+      case "success":
+        return "#008000";
+      case "failure":
+        return "#ff0000";
+      case "cancelled":
+        return "#0047ab";
+      case "skipped":
+        return "#808080";
+      default:
+        return from;
+    }
+  }
+};
+function identifyColorCommon(findings, prop, none, unknown, color, defaultColor) {
+  if (color.none != null && findings.findByProperty(prop, none) != null) {
+    return color.none.value;
+  }
+  if (color.unknown != null && findings.findByProperty(prop, unknown) != null) {
+    return color.unknown.value;
+  }
+  if (color.empty != null && findings.length === 0) {
+    return color.empty.value;
+  }
+  return defaultColor?.value;
+}
+function identifyColorBySeverity(findings, color, defaultColor) {
+  if (color.critical != null && findings.findByProperty("severity", 5 /* Critical */) != null) {
+    return color.critical.value;
+  }
+  if (color.high != null && findings.findByProperty("severity", 4 /* High */) != null) {
+    return color.high.value;
+  }
+  if (color.medium != null && findings.findByProperty("severity", 3 /* Medium */) != null) {
+    return color.medium.value;
+  }
+  if (color.low != null && findings.findByProperty("severity", 2 /* Low */) != null) {
+    return color.low.value;
+  }
+  return identifyColorCommon(findings, "severity", 1 /* None */, 0 /* Unknown */, color, defaultColor);
+}
+function identifyColorByLevel(findings, color, defaultColor) {
+  if (color.error != null && findings.findByProperty("level", 4 /* Error */) != null) {
+    return color.error.value;
+  }
+  if (color.warning != null && findings.findByProperty("level", 3 /* Warning */) != null) {
+    return color.warning.value;
+  }
+  if (color.note != null && findings.findByProperty("level", 2 /* Note */) != null) {
+    return color.note.value;
+  }
+  return identifyColorCommon(findings, "level", 1 /* None */, 0 /* Unknown */, color, defaultColor);
+}
+function identifyColor(findings, colorOpts) {
+  if (colorOpts?.bySeverity != null) {
+    return identifyColorBySeverity(findings, colorOpts.bySeverity, colorOpts.default);
+  }
+  if (colorOpts?.byLevel != null) {
+    return identifyColorByLevel(findings, colorOpts.byLevel, colorOpts.default);
+  }
+  return colorOpts?.default?.value;
+}
+
+// src/SarifToSlackClient.ts
+var import_fs2 = require("fs");
 
 // src/Logger.ts
+var import_tslog = require("tslog");
 var Logger = class _Logger {
   static DEFAULT_LOG_LEVEL = 3 /* Info */;
   static DEFAULT_LOG_TEMPLATE = "[{{logLevelName}}] [{{name}}] {{dateIsoStr}} ";
@@ -99,345 +236,40 @@ var Logger = class _Logger {
   static debug(...args) {
     _Logger.instance.debug(...args);
   }
-};
-
-// src/Processors.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-function processColor(color) {
-  switch (color) {
-    case "success":
-      Logger.info(`Converting "${color}" to #008000`);
-      return "#008000";
-    case "failure":
-      Logger.info(`Converting "${color}" to #ff0000`);
-      return "#ff0000";
-    case "cancelled":
-      Logger.info(`Converting "${color}" to #0047ab`);
-      return "#0047ab";
-    case "skipped":
-      Logger.info(`Converting "${color}" to #808080`);
-      return "#808080";
-    default:
-      Logger.debug(`"${color}" color is not a CI status identifier. Returning as is.`);
-      return color;
+  static trace(...args) {
+    _Logger.instance.trace(...args);
   }
-}
-function processSarifPath(sarifPath) {
-  if (!fs.existsSync(sarifPath)) {
-    throw new Error(`"sarif-path" does not exist: ${sarifPath}`);
-  }
-  const sarifStats = fs.statSync(sarifPath);
-  if (sarifStats.isDirectory()) {
-    Logger.info(`"sarif-path" is a directory: ${sarifPath}`);
-    const files = fs.readdirSync(sarifPath);
-    const filteredFiles = files.filter(
-      (file) => path.extname(file).toLowerCase() === ".sarif"
-    );
-    Logger.info(`Found ${filteredFiles.length} SARIF files in ${sarifPath} directory`);
-    Logger.debug(`Filtered SARIF files: ${filteredFiles.join(", ")}`);
-    return filteredFiles.map((file) => path.join(sarifPath, file));
-  }
-  if (sarifStats.isFile()) {
-    Logger.info(`"sarif-path" is a file: ${sarifPath}`);
-    return [sarifPath];
-  }
-  throw new Error(`"sarif-path" is neither a file nor a directory: ${sarifPath}`);
-}
+};
 
 // src/SlackMessageBuilder.ts
 var import_webhook = require("@slack/webhook");
 
-// src/metadata.ts
-var LIB_VERSION = "0.2.5";
-
-// src/model/SarifModelPerSarif.ts
-var import_immutable2 = require("immutable");
-
-// src/utils/SarifUtils.ts
-function findToolComponentByResult(run, result) {
-  let tool;
-  if (result.rule?.toolComponent?.index != null) {
-    tool = run.tool.extensions?.[result.rule.toolComponent.index];
-  }
-  if (!tool) {
-    tool = run.tool.driver;
-  }
-  return tool;
-}
-function findRuleByResult(run, result) {
-  const ruleData = {};
-  if (result.rule) {
-    if (result.rule?.index != null) {
-      ruleData.index = result.rule.index;
-    }
-    if (result.rule?.id) {
-      ruleData.id = result.rule.id;
-    }
-  }
-  if (ruleData.index == null && result.ruleIndex != null) {
-    ruleData.index = result.ruleIndex;
-  }
-  if (!ruleData.id && result.ruleId) {
-    ruleData.id = result.ruleId;
-  }
-  const tool = findToolComponentByResult(run, result);
-  if (ruleData.index != null && tool?.rules && ruleData.index < tool.rules.length) {
-    return tool.rules[ruleData.index];
-  }
-  if (ruleData.id && tool?.rules) {
-    return tool.rules.find(
-      (r) => r.id === ruleData.id
-    );
-  }
-  return void 0;
-}
-function tryGetRulePropertyByResult(run, result, propertyName) {
-  const rule = findRuleByResult(run, result);
-  if (rule && rule.properties && propertyName in rule.properties) {
-    return rule.properties[propertyName];
-  }
-  return void 0;
-}
-
-// src/model/types.ts
-var SecuritySeverityOrder = [
-  "Critical" /* Critical */,
-  "High" /* High */,
-  "Medium" /* Medium */,
-  "Low" /* Low */,
-  "None" /* None */,
-  "Unknown" /* Unknown */
-];
-var SecurityLevelOrder = [
-  "Error" /* Error */,
-  "Warning" /* Warning */,
-  "Note" /* Note */,
-  "Unknown" /* Unknown */
-];
-
-// src/model/SarifModelPerRun.ts
-var import_immutable = require("immutable");
-
-// src/utils/SortUtils.ts
-function sortSecurityLevelMap(map) {
-  return map.sortBy(
-    (_, level) => level,
-    (a, b) => SecurityLevelOrder.indexOf(a) - SecurityLevelOrder.indexOf(b)
-  ).asImmutable();
-}
-function sortSecuritySeverityMap(map) {
-  return map.sortBy(
-    (_, severity) => severity,
-    (a, b) => SecuritySeverityOrder.indexOf(a) - SecuritySeverityOrder.indexOf(b)
-  ).asImmutable();
-}
-
-// src/model/SarifModelPerRun.ts
-var SarifModelPerRun = class {
-  toolName;
-  _securitySeverityMap;
-  _securityLevelMap;
-  constructor(run) {
-    this.toolName = run.tool.driver.name;
-    this._securitySeverityMap = (0, import_immutable.Map)().asMutable();
-    this._securityLevelMap = (0, import_immutable.Map)().asMutable();
-    this.buildSecuritySeverityMap(run);
-    this.buildSecurityLevelMap(run);
-  }
-  identifySecuritySeverity(score) {
-    if (score === void 0) {
-      return "Unknown" /* Unknown */;
-    }
-    if (score >= 9 && score <= 10) {
-      return "Critical" /* Critical */;
-    }
-    if (score >= 7) {
-      return "High" /* High */;
-    }
-    if (score >= 4) {
-      return "Medium" /* Medium */;
-    }
-    if (score >= 0.1) {
-      return "Low" /* Low */;
-    }
-    if (score == 0) {
-      return "None" /* None */;
-    }
-    Logger.warn(`Unsupported "${score}" security severity. Saving as "Unknown".`);
-    return "Unknown" /* Unknown */;
-  }
-  identifySecurityLevel(level) {
-    if (level === void 0) {
-      return "Unknown" /* Unknown */;
-    }
-    if (level.toLowerCase() === "error") {
-      return "Error" /* Error */;
-    }
-    if (level.toLowerCase() === "warning") {
-      return "Warning" /* Warning */;
-    }
-    if (level.toLowerCase() === "note") {
-      return "Note" /* Note */;
-    }
-    Logger.warn(`Unsupported ${level} security level. Saving as "Unknown".`);
-    return "Unknown" /* Unknown */;
-  }
-  buildSecuritySeverityMap(run) {
-    const results = run.results ?? [];
-    for (const result of results) {
-      const severity = this.identifySecuritySeverity(
-        tryGetRulePropertyByResult(run, result, "security-severity")
-      );
-      const count = this._securitySeverityMap.get(severity) || 0;
-      this._securitySeverityMap.set(severity, count + 1);
-    }
-  }
-  tryGetSecurityLevel(run, result) {
-    if (result.level) {
-      return result.level;
-    }
-    return tryGetRulePropertyByResult(run, result, "problem.severity");
-  }
-  buildSecurityLevelMap(run) {
-    const results = run.results ?? [];
-    for (const result of results) {
-      const level = this.identifySecurityLevel(
-        this.tryGetSecurityLevel(run, result)
-      );
-      const count = this._securityLevelMap.get(level) || 0;
-      this._securityLevelMap.set(level, count + 1);
-    }
-  }
-  get securitySeverityMap() {
-    return sortSecuritySeverityMap(this._securitySeverityMap);
-  }
-  get securityLevelMap() {
-    return sortSecurityLevelMap(this._securityLevelMap);
-  }
-};
-
-// src/model/SarifModelPerSarif.ts
-var SarifModelPerSarif = class {
-  sarifModelPerRunList;
-  constructor(sarif) {
-    this.sarifModelPerRunList = new Array();
-    this.buildRunsList(sarif);
-  }
-  buildRunsList(sarif) {
-    for (const run of sarif.runs) {
-      this.sarifModelPerRunList.push(new SarifModelPerRun(run));
-    }
-  }
-  groupByToolNameWithSecurityLevel() {
-    const result = /* @__PURE__ */ new Map();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      if (!result.has(sarifModelPerRun.toolName)) {
-        result.set(sarifModelPerRun.toolName, (0, import_immutable2.Map)().asMutable());
-      }
-      for (const [k, v] of sarifModelPerRun.securityLevelMap.entries()) {
-        const count = result.get(sarifModelPerRun.toolName)?.get(k) || 0;
-        result.get(sarifModelPerRun.toolName)?.set(k, count + v);
-      }
-    }
-    for (const [k, v] of result) {
-      result.set(k, sortSecurityLevelMap(v));
-    }
-    return result;
-  }
-  groupByRunWithSecurityLevel() {
-    const result = new Array();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      result.push({
-        toolName: sarifModelPerRun.toolName,
-        data: sarifModelPerRun.securityLevelMap
-      });
-    }
-    return result;
-  }
-  groupByTotalWithSecurityLevel() {
-    const result = (0, import_immutable2.Map)().asMutable();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      for (const [k, v] of sarifModelPerRun.securityLevelMap.entries()) {
-        const count = result.get(k) || 0;
-        result.set(k, count + v);
-      }
-    }
-    return sortSecurityLevelMap(result);
-  }
-  groupByToolNameWithSecuritySeverity() {
-    const result = /* @__PURE__ */ new Map();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      if (!result.has(sarifModelPerRun.toolName)) {
-        result.set(sarifModelPerRun.toolName, (0, import_immutable2.Map)().asMutable());
-      }
-      for (const [k, v] of sarifModelPerRun.securitySeverityMap.entries()) {
-        const count = result.get(sarifModelPerRun.toolName)?.get(k) || 0;
-        result.get(sarifModelPerRun.toolName)?.set(k, count + v);
-      }
-    }
-    for (const [k, v] of result.entries()) {
-      result.set(k, sortSecuritySeverityMap(v));
-    }
-    return result;
-  }
-  groupByRunWithSecuritySeverity() {
-    const result = new Array();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      result.push({
-        toolName: sarifModelPerRun.toolName,
-        data: sarifModelPerRun.securitySeverityMap
-      });
-    }
-    return result;
-  }
-  groupByTotalWithSecuritySeverity() {
-    const result = (0, import_immutable2.Map)().asMutable();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      for (const [k, v] of sarifModelPerRun.securitySeverityMap.entries()) {
-        const count = result.get(k) || 0;
-        result.set(k, count + v);
-      }
-    }
-    return sortSecuritySeverityMap(result);
-  }
-  listToolNames() {
-    const toolNames = /* @__PURE__ */ new Set();
-    for (const sarifModelPerRun of this.sarifModelPerRunList) {
-      toolNames.add(sarifModelPerRun.toolName);
-    }
-    return toolNames;
-  }
-};
+// src/metadata.json
+var version = "1.1.0";
+var sha = "cf8ff099965ca704d7e58bd11f6d4481f69e3125";
+var buildAt = "2025-08-15T05:22:37Z";
 
 // src/SlackMessageBuilder.ts
 var SlackMessageBuilder = class {
-  webhook;
-  gitHubServerUrl;
-  color;
-  sarifModelPerSarif;
-  output;
-  header;
-  footer;
-  actor;
-  runId;
-  sarif;
+  _webhook;
+  _gitHubServerUrl;
+  _color;
+  _representation;
+  _header;
+  _footer;
+  _actor;
+  _runId;
   constructor(url, opts) {
-    this.webhook = new import_webhook.IncomingWebhook(url, {
+    this._webhook = new import_webhook.IncomingWebhook(url, {
       username: opts.username || "SARIF results",
       icon_url: opts.iconUrl
     });
-    this.gitHubServerUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
-    this.color = opts.color;
-    this.sarif = opts.sarif;
-    this.sarifModelPerSarif = new SarifModelPerSarif(opts.sarif);
-    this.output = opts.output || {
-      groupBy: 0 /* ToolName */,
-      calculateBy: 0 /* Level */
-    };
+    this._gitHubServerUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
+    this._color = opts.color;
+    this._representation = opts.representation;
   }
   withHeader(header) {
-    this.header = {
+    this._header = {
       type: "header",
       text: {
         type: "plain_text",
@@ -446,23 +278,23 @@ var SlackMessageBuilder = class {
     };
   }
   withActor(actor) {
-    this.actor = actor || process.env.GITHUB_ACTOR;
+    this._actor = actor || process.env.GITHUB_ACTOR;
   }
   withRun() {
-    this.runId = process.env.GITHUB_RUN_ID;
+    this._runId = process.env.GITHUB_RUN_ID;
   }
   withFooter(text, type) {
     const repoName = "fabasoad/sarif-to-slack";
-    const element = text ? { type: type || "plain_text" /* PlainText */, text } : { type: "mrkdwn" /* Markdown */, text: `Generated by <${this.gitHubServerUrl}/${repoName}|@${repoName}@${LIB_VERSION}>` };
-    this.footer = {
+    const element = text ? { type: type || "plain_text" /* PlainText */, text } : { type: "mrkdwn" /* Markdown */, text: `Generated by <${this._gitHubServerUrl}/${repoName}|@${repoName}@${version}>` };
+    this._footer = {
       type: "context",
       elements: [element]
     };
   }
   async send() {
     const blocks = [];
-    if (this.header) {
-      blocks.push(this.header);
+    if (this._header) {
+      blocks.push(this._header);
     }
     blocks.push({
       type: "section",
@@ -471,181 +303,703 @@ var SlackMessageBuilder = class {
         text: this.buildText()
       }
     });
-    if (this.footer) {
-      blocks.push(this.footer);
+    if (this._footer) {
+      blocks.push(this._footer);
     }
-    const { text } = await this.webhook.send({
-      attachments: [{ color: this.color, blocks }]
+    const { text } = await this._webhook.send({
+      attachments: [{ color: this._color, blocks }]
     });
     return text;
   }
   buildText() {
     const text = [];
-    if (this.actor) {
-      const actorUrl = `${this.gitHubServerUrl}/${this.actor}`;
-      text.push(`_Triggered by <${actorUrl}|${this.actor}>_`);
+    if (this._actor) {
+      const actorUrl = `${this._gitHubServerUrl}/${this._actor}`;
+      text.push(`_Triggered by <${actorUrl}|${this._actor}>_`);
     }
-    text.push(this.composeSummary());
-    if (this.runId) {
+    text.push(this._representation.compose());
+    if (this._runId) {
       let runText = "Job ";
       if (process.env.GITHUB_REPOSITORY) {
-        runText += `<${this.gitHubServerUrl}/${process.env.GITHUB_REPOSITORY}/actions/runs/${this.runId}|#${this.runId}>`;
+        runText += `<${this._gitHubServerUrl}/${process.env.GITHUB_REPOSITORY}/actions/runs/${this._runId}|#${this._runId}>`;
       } else {
-        runText += `#${this.runId}`;
+        runText += `#${this._runId}`;
       }
       text.push(runText);
     }
     return text.join("\n\n");
   }
-  composeSummaryWith(map, resultProcessor = (result) => result) {
-    const stats = new Array();
-    for (const [key, count] of map.entries()) {
-      stats.push(`*${key}*: ${count}`);
-    }
-    return resultProcessor(
-      stats.length == 0 ? "No issues found" : stats.join(", ")
-    );
-  }
-  composeSummary() {
-    const summaries = new Array();
-    switch (this.output.groupBy) {
-      case 0 /* ToolName */: {
-        const dataGroupedByToolName = this.output.calculateBy === 0 /* Level */ ? this.sarifModelPerSarif.groupByToolNameWithSecurityLevel() : this.sarifModelPerSarif.groupByToolNameWithSecuritySeverity();
-        for (const [toolName, map] of dataGroupedByToolName.entries()) {
-          summaries.push(this.composeSummaryWith(
-            map,
-            (result) => `*${toolName}*
-${result}`
-          ));
-        }
-        break;
+};
+
+// src/System.ts
+var System = class {
+  static initialize() {
+    Logger.info(`@fabasoad/sarif-to-slack version: ${version}`);
+    Logger.info(`@fabasoad/sarif-to-slack sha: ${sha}`);
+    Logger.info(`@fabasoad/sarif-to-slack built at: ${buildAt}`);
+  }
+};
+
+// src/utils/FileUtils.ts
+var import_fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function listFilesRecursively(dir, extension, fileList = []) {
+  const entries = import_fs.default.readdirSync(dir);
+  entries.forEach((entry) => {
+    const fullPath = path.join(dir, entry);
+    if (import_fs.default.statSync(fullPath).isDirectory()) {
+      listFilesRecursively(fullPath, extension, fileList);
+    } else if (path.extname(fullPath).toLowerCase() === `.${extension}`) {
+      fileList.push(fullPath);
+    }
+  });
+  return fileList;
+}
+function extractListOfFiles(opts) {
+  if (!import_fs.default.existsSync(opts.path)) {
+    throw new Error(`Provided path does not exist: ${opts.path}`);
+  }
+  const stats = import_fs.default.statSync(opts.path);
+  if (stats.isDirectory()) {
+    Logger.info(`Provided path is a directory: ${opts.path}`);
+    const files = opts.recursive && listFilesRecursively(opts.path, opts.extension ?? "sarif") || import_fs.default.readdirSync(opts.path);
+    Logger.info(`Found ${files.length} files in ${opts.path} directory with ${opts.extension} extension`);
+    Logger.debug(`Found files: ${files.join(", ")}`);
+    return files;
+  }
+  if (stats.isFile()) {
+    Logger.info(`Provided path is a file: ${opts.path}`);
+    return [opts.path];
+  }
+  throw new Error(`Provided path is neither a file nor a directory: ${opts.path}`);
+}
+
+// src/utils/Comparators.ts
+function findingsComparatorByKey(key) {
+  return (a, b) => {
+    switch (key) {
+      case "severity":
+        return b.severity - a.severity;
+      case "level":
+        return b.level - a.level;
+      case "runId":
+        return a.runId - b.runId;
+      case "toolName":
+        return a.toolName.toLowerCase().localeCompare(b.toolName.toLowerCase());
+      default:
+        return 1;
+    }
+  };
+}
+
+// src/utils/ExtendedArray.ts
+var ExtendedArray = class extends Array {
+  findByProperty(prop, value) {
+    return this.find((v) => v[prop] === value);
+  }
+};
+
+// src/model/FindingsArray.ts
+var FindingsArray = class extends ExtendedArray {
+  hasSeverityOrHigher(severity) {
+    return Object.values(SecuritySeverity).filter((v) => typeof v === "number").filter((v) => v >= severity).some((v) => this.findByProperty("severity", v) != null);
+  }
+  hasLevelOrHigher(level) {
+    return Object.values(SecurityLevel).filter((v) => typeof v === "number").filter((v) => v >= level).some((v) => this.findByProperty("level", v) != null);
+  }
+};
+
+// src/representations/Representation.ts
+var Representation = class {
+  _model;
+  constructor(model, findingSortKey = "level") {
+    this._model = model;
+    this._model.findings = model.findings.map((f) => f.clone()).sort(findingsComparatorByKey(findingSortKey)).reduce((arr, f) => {
+      arr.push(f);
+      return arr;
+    }, new FindingsArray());
+  }
+  bold(text) {
+    return `*${text}*`;
+  }
+  italic(text) {
+    return `_${text}_`;
+  }
+};
+
+// src/representations/CompactGroupByRepresentation.ts
+var NO_VULNS_FOUND_TEXT = "No vulnerabilities found";
+var CompactGroupByRepresentation = class extends Representation {
+  composeByProperty(key) {
+    const grouped = this.groupFindings();
+    if (grouped.size === 0) {
+      return NO_VULNS_FOUND_TEXT;
+    }
+    return Array.from(grouped).map(([title, findings]) => {
+      findings.sort(findingsComparatorByKey(key));
+      const summary = findings.length === 0 ? NO_VULNS_FOUND_TEXT : this.composeCompactReport(findings, key);
+      return `${title}
+${summary}`;
+    }).join("\n\n");
+  }
+  composeCompactReport(findings, key) {
+    return Object.entries(Object.groupBy(findings, (f) => f[key])).map(([prop, findings2]) => {
+      if (findings2 == null) {
+        return void 0;
       }
-      case 1 /* Run */: {
-        const dataGroupedByRun = this.output.calculateBy === 0 /* Level */ ? this.sarifModelPerSarif.groupByRunWithSecurityLevel() : this.sarifModelPerSarif.groupByRunWithSecuritySeverity();
-        for (let i = 0; i < dataGroupedByRun.length; i++) {
-          const { data, toolName } = dataGroupedByRun[i];
-          summaries.push(this.composeSummaryWith(
-            data,
-            (result) => `_[Run ${i + 1}]_: *${toolName}*
-${result}`
-          ));
-        }
-        break;
+      return `${this.bold(this.extractEnumValue(key, prop))}: ${findings2.length}`;
+    }).filter((v) => v != null).join(", ");
+  }
+  extractEnumValue(key, prop) {
+    switch (key) {
+      case "level":
+        return SecurityLevel[Number(prop)];
+      case "severity":
+        return SecuritySeverity[Number(prop)];
+      default:
+        throw new Error("Unknown property:", key);
+    }
+  }
+};
+
+// src/representations/CompactGroupByRunRepresentation.ts
+var CompactGroupByRunRepresentation = class extends CompactGroupByRepresentation {
+  constructor(model) {
+    super(model, "runId");
+  }
+  groupFindings() {
+    const result = /* @__PURE__ */ new Map();
+    for (const run of this._model.runs) {
+      const key = this.composeGroupTitle(run.id, run.toolName);
+      if (result.get(key) == null) {
+        result.set(key, []);
       }
-      default: {
-        const dataTotal = this.output.calculateBy === 0 /* Level */ ? this.sarifModelPerSarif.groupByTotalWithSecurityLevel() : this.sarifModelPerSarif.groupByTotalWithSecuritySeverity();
-        const toolNames = this.sarifModelPerSarif.listToolNames();
-        summaries.push(this.composeSummaryWith(
-          dataTotal,
-          (result) => `*${Array.from(toolNames).join("*, *")}*
-${result}`
-        ));
-        break;
+      this._model.findings.filter((f) => f.runId === run.id).forEach((f) => result.get(key)?.push(f));
+    }
+    return result;
+  }
+  composeGroupTitle(runId, toolName) {
+    return `${this.italic(`[Run ${runId}]`)} ${this.bold(toolName)}`;
+  }
+};
+
+// src/representations/CompactGroupByRunPerLevelRepresentation.ts
+var CompactGroupByRunPerLevelRepresentation = class extends CompactGroupByRunRepresentation {
+  compose() {
+    return this.composeByProperty("level");
+  }
+};
+
+// src/representations/CompactGroupByRunPerSeverityRepresentation.ts
+var CompactGroupByRunPerSeverityRepresentation = class extends CompactGroupByRunRepresentation {
+  compose() {
+    return this.composeByProperty("severity");
+  }
+};
+
+// src/representations/CompactGroupByToolNameRepresentation.ts
+var CompactGroupByToolNameRepresentation = class extends CompactGroupByRepresentation {
+  constructor(model) {
+    super(model, "toolName");
+  }
+  groupFindings() {
+    const result = /* @__PURE__ */ new Map();
+    for (const run of this._model.runs) {
+      const key = this.composeGroupTitle(run.toolName);
+      if (result.get(key) == null) {
+        result.set(key, []);
       }
+      this._model.findings.filter((f) => f.runId === run.id).forEach((f) => result.get(key)?.push(f));
     }
-    return summaries.join("\n\n");
+    return result;
+  }
+  composeGroupTitle(toolName) {
+    return this.bold(toolName);
   }
 };
 
-// src/System.ts
-var System = class {
-  static initialize() {
-    Logger.info(`Version: ${LIB_VERSION}`);
+// src/representations/CompactGroupByToolNamePerLevelRepresentation.ts
+var CompactGroupByToolNamePerLevelRepresentation = class extends CompactGroupByToolNameRepresentation {
+  compose() {
+    return this.composeByProperty("level");
   }
 };
 
-// src/SarifToSlackService.ts
-async function initialize(opts) {
-  const slackMessages = /* @__PURE__ */ new Map();
-  const sarifFiles = processSarifPath(opts.sarifPath);
-  if (sarifFiles.length === 0) {
-    throw new Error(`No SARIF files found at the provided path: ${opts.sarifPath}`);
+// src/representations/CompactGroupByToolNamePerSeverityRepresentation.ts
+var CompactGroupByToolNamePerSeverityRepresentation = class extends CompactGroupByToolNameRepresentation {
+  compose() {
+    return this.composeByProperty("severity");
   }
-  for (const sarifFile of sarifFiles) {
-    const jsonString = await import_fs.promises.readFile(sarifFile, "utf8");
-    const messageBuilder = new SlackMessageBuilder(opts.webhookUrl, {
-      username: opts.username,
-      iconUrl: opts.iconUrl,
-      color: processColor(opts.color),
-      sarif: JSON.parse(jsonString),
-      output: opts.output
-    });
-    if (opts.header?.include) {
-      messageBuilder.withHeader(opts.header?.value);
+};
+
+// src/representations/CompactGroupBySarifRepresentation.ts
+var import_node_path = __toESM(require("path"));
+var CompactGroupBySarifRepresentation = class extends CompactGroupByRepresentation {
+  constructor(model) {
+    super(model, "sarifPath");
+  }
+  groupFindings() {
+    const result = /* @__PURE__ */ new Map();
+    for (let index = 0; index < this._model.sarifFiles.length; index++) {
+      const key = this.composeGroupTitle(this._model.sarifFiles[index], index);
+      if (result.get(key) == null) {
+        result.set(key, []);
+      }
+      this._model.findings.filter((f) => f.sarifPath === this._model.sarifFiles[index]).forEach((f) => result.get(key)?.push(f));
     }
-    if (opts.footer?.include) {
-      messageBuilder.withFooter(opts.footer?.value, opts.footer?.type);
+    return result;
+  }
+  composeGroupTitle(sarifPath, index) {
+    return `${this.italic(`[File ${index + 1}]`)} ${this.bold(import_node_path.default.basename(sarifPath))}`;
+  }
+};
+
+// src/representations/CompactGroupBySarifPerLevelRepresentation.ts
+var CompactGroupBySarifPerLevelRepresentation = class extends CompactGroupBySarifRepresentation {
+  compose() {
+    return this.composeByProperty("level");
+  }
+};
+
+// src/representations/CompactGroupBySarifPerSeverityRepresentation.ts
+var CompactGroupBySarifPerSeverityRepresentation = class extends CompactGroupBySarifRepresentation {
+  compose() {
+    return this.composeByProperty("severity");
+  }
+};
+
+// src/representations/CompactTotalRepresentation.ts
+var CompactTotalRepresentation = class extends CompactGroupByRepresentation {
+  groupFindings() {
+    const result = /* @__PURE__ */ new Map();
+    if (this._model.findings.length > 0) {
+      result.set("Total", this._model.findings);
     }
-    if (opts.actor?.include) {
-      messageBuilder.withActor(opts.actor?.value);
+    return result;
+  }
+};
+
+// src/representations/CompactTotalPerSeverityRepresentation.ts
+var CompactTotalPerSeverityRepresentation = class extends CompactTotalRepresentation {
+  compose() {
+    return this.composeByProperty("severity");
+  }
+};
+
+// src/representations/CompactTotalPerLevelRepresentation.ts
+var CompactTotalPerLevelRepresentation = class extends CompactTotalRepresentation {
+  compose() {
+    return this.composeByProperty("level");
+  }
+};
+
+// src/representations/RepresentationFactory.ts
+function createRepresentation(model, type = 3 /* CompactGroupByToolNamePerSeverity */) {
+  switch (type) {
+    case 0 /* CompactGroupByRunPerLevel */:
+      return new CompactGroupByRunPerLevelRepresentation(model);
+    case 1 /* CompactGroupByRunPerSeverity */:
+      return new CompactGroupByRunPerSeverityRepresentation(model);
+    case 2 /* CompactGroupByToolNamePerLevel */:
+      return new CompactGroupByToolNamePerLevelRepresentation(model);
+    case 3 /* CompactGroupByToolNamePerSeverity */:
+      return new CompactGroupByToolNamePerSeverityRepresentation(model);
+    case 4 /* CompactGroupBySarifPerLevel */:
+      return new CompactGroupBySarifPerLevelRepresentation(model);
+    case 5 /* CompactGroupBySarifPerSeverity */:
+      return new CompactGroupBySarifPerSeverityRepresentation(model);
+    case 6 /* CompactTotalPerLevel */:
+      return new CompactTotalPerLevelRepresentation(model);
+    case 7 /* CompactTotalPerSeverity */:
+      return new CompactTotalPerSeverityRepresentation(model);
+    default:
+      throw new Error(`Unknown representation type: ${type}`);
+  }
+}
+
+// src/utils/SarifUtils.ts
+function findToolComponentDriver(run) {
+  return run.tool.driver;
+}
+function tryFindToolComponentExtension(run, result) {
+  let tool;
+  if (result.rule?.toolComponent?.index != null) {
+    tool = run.tool.extensions?.[result.rule.toolComponent.index];
+  }
+  return tool;
+}
+function findToolComponent(run, result) {
+  return tryFindToolComponentExtension(run, result) ?? findToolComponentDriver(run);
+}
+
+// src/processors/CommonProcessor.ts
+var CommonProcessor = class {
+  _run;
+  _result;
+  /**
+   * Creates an instance of {@link CommonProcessor} class.
+   * @param run An instance of {@link Run} object.
+   * @param result An instance of {@link Result} object.
+   */
+  constructor(run, result) {
+    this._run = run;
+    this._result = result;
+  }
+  tryFindCvssScore() {
+    return this.tryFindRuleProperty("security-severity");
+  }
+  tryFindLevel() {
+    return this._result.level ?? this.tryFindRule()?.defaultConfiguration?.level;
+  }
+  findToolComponentDriver() {
+    return findToolComponentDriver(this._run);
+  }
+  tryFindToolComponentExtension() {
+    return tryFindToolComponentExtension(this._run, this._result);
+  }
+  findToolComponent() {
+    return findToolComponent(this._run, this._result);
+  }
+  /**
+   * This function tries to find the respective rule for the given result.
+   * @internal
+   */
+  tryFindRule() {
+    const ruleData = {};
+    if (this._result.rule) {
+      if (this._result.rule?.index != null) {
+        ruleData.index = this._result.rule.index;
+      }
+      if (this._result.rule?.id) {
+        ruleData.id = this._result.rule.id;
+      }
     }
-    if (opts.run?.include) {
-      messageBuilder.withRun();
+    if (ruleData.index == null && this._result.ruleIndex != null) {
+      ruleData.index = this._result.ruleIndex;
+    }
+    if (!ruleData.id && this._result.ruleId) {
+      ruleData.id = this._result.ruleId;
+    }
+    const tool = this.findToolComponent();
+    if (ruleData.index != null && tool?.rules && ruleData.index < tool.rules.length) {
+      return tool.rules[ruleData.index];
+    }
+    if (ruleData.id && tool?.rules) {
+      return tool.rules.find(
+        (r) => r.id === ruleData.id
+      );
     }
-    slackMessages.set(sarifFile, messageBuilder);
+    return void 0;
   }
-  return slackMessages;
-}
-var SarifToSlackService = class _SarifToSlackService {
-  _slackMessages;
-  constructor() {
-    this._slackMessages = /* @__PURE__ */ new Map();
+  /**
+   * This function searches respective rule for the given result, and then gets
+   * the property of interest from it.
+   * @param propertyName The property name that you want to get the value from.
+   * @protected
+   */
+  tryFindRuleProperty(propertyName) {
+    const rule = this.tryFindRule();
+    if (rule?.properties && propertyName in rule.properties) {
+      return rule.properties[propertyName];
+    }
+    return void 0;
   }
+};
+
+// src/processors/SnykProcessor.ts
+var SnykProcessor = class extends CommonProcessor {
   /**
-   * Gets the Slack messages prepared for each SARIF file.
-   * @returns A read-only map where keys are SARIF file paths and values are SlackMessage instances.
-   * @public
+   * Rules in SARIF files produced by Snyk Open Source has additional "cvssv3_baseScore"
+   * property where CVSS score is also defined. This method tries to get level
+   * from this "cvssv3_baseScore" property and if it fails to do so, then it tries
+   * to get CVSS score in a common way.
    */
-  get slackMessages() {
-    return this._slackMessages;
+  tryFindCvssScore() {
+    return this.tryFindRuleProperty("cvssv3_baseScore") ?? super.tryFindCvssScore();
   }
+};
+
+// src/processors/CodeQLProcessor.ts
+var CodeQLProcessor = class extends CommonProcessor {
   /**
-   * Creates an instance of SarifToSlackService.
-   * @param opts - Options for the service, including webhook URL, SARIF path, and other configurations.
-   * @returns A promise that resolves to an instance of SarifToSlackService.
-   * @throws Error if no SARIF files are found at the provided path.
-   * @public
+   * Rules in SARIF files produced by CodeQL has additional "problem.severity"
+   * property where level is also defined. This method tries to get level in a
+   * common way but if it fails to do so, then it tries to get level from
+   * "problem.severity" property.
    */
-  static async create(opts) {
-    Logger.initialize(opts.log);
+  tryFindLevel() {
+    return super.tryFindLevel() ?? this.tryFindRuleProperty("problem.severity");
+  }
+};
+
+// src/processors/ProcessorFactory.ts
+function createProcessor(run, result) {
+  const toolComponent = findToolComponent(run, result);
+  switch (toolComponent.name) {
+    case "CodeQL":
+      return new CodeQLProcessor(run, result);
+    case "Snyk Open Source":
+      return new SnykProcessor(run, result);
+    default:
+      return new CommonProcessor(run, result);
+  }
+}
+
+// src/model/Finding.ts
+function createFinding(opts) {
+  return new SarifFinding(opts);
+}
+var SarifFinding = class {
+  _runMetadata;
+  _result;
+  _sarifPath;
+  _rule;
+  _processor;
+  _cvssScoreCacheProcessed = false;
+  _cvssScoreCache = void 0;
+  _levelCacheProcessed = false;
+  _levelCache = void 0;
+  constructor(opts) {
+    this._processor = createProcessor(opts.runMetadata.run, opts.result);
+    this._sarifPath = opts.sarifPath;
+    this._runMetadata = opts.runMetadata;
+    this._result = opts.result;
+    this._rule = this._processor.tryFindRule();
+  }
+  clone() {
+    return createFinding({
+      sarifPath: this._sarifPath,
+      runMetadata: this._runMetadata,
+      result: this._result
+    });
+  }
+  get sarifPath() {
+    return this._sarifPath;
+  }
+  get runId() {
+    return this._runMetadata.id;
+  }
+  get toolName() {
+    return this._processor.findToolComponent().name;
+  }
+  get cvssScore() {
+    if (!this._cvssScoreCacheProcessed) {
+      this._cvssScoreCacheProcessed = true;
+      this._cvssScoreCache = this._processor.tryFindCvssScore();
+    }
+    return this._cvssScoreCache;
+  }
+  get level() {
+    if (!this._levelCacheProcessed) {
+      this._levelCacheProcessed = true;
+      this._levelCache = this._processor.tryFindLevel();
+    }
+    if (this._levelCache === void 0) {
+      Logger.debug(`Unknown level of ${this._rule?.id} rule`);
+      return 0 /* Unknown */;
+    }
+    switch (this._levelCache) {
+      case "error":
+        return 4 /* Error */;
+      case "warning":
+        return 3 /* Warning */;
+      case "note":
+        return 2 /* Note */;
+      default:
+        return 1 /* None */;
+    }
+  }
+  get severity() {
+    if (this.cvssScore == null || this.cvssScore < 0 || this.cvssScore > 10) {
+      Logger.debug(`Unsupported CVSS score ${this.cvssScore} in ${this._rule?.id} rule`);
+      return 0 /* Unknown */;
+    }
+    if (this.cvssScore >= 9) {
+      return 5 /* Critical */;
+    }
+    if (this.cvssScore >= 7) {
+      return 4 /* High */;
+    }
+    if (this.cvssScore >= 4) {
+      return 3 /* Medium */;
+    }
+    if (this.cvssScore >= 0.1) {
+      return 2 /* Low */;
+    }
+    return 1 /* None */;
+  }
+};
+
+// src/SarifToSlackClient.ts
+var SarifToSlackClient = class _SarifToSlackClient {
+  _message;
+  _sarifModel;
+  _sendIf = 20 /* Always */;
+  constructor(log) {
+    Logger.initialize(log);
     System.initialize();
-    const instance = new _SarifToSlackService();
-    const map = await initialize(opts);
-    map.forEach((val, key) => instance._slackMessages.set(key, val));
+  }
+  static *createRunIdGenerator() {
+    let runId = 1;
+    while (true) {
+      yield runId++;
+    }
+  }
+  static async create(opts) {
+    const instance = new _SarifToSlackClient(opts.log);
+    Logger.trace("opts", opts);
+    instance._sendIf = opts.sendIf ?? instance._sendIf;
+    instance._sarifModel = await _SarifToSlackClient.buildModel(opts.sarif);
+    Logger.trace("instance._sarifModel", instance._sarifModel);
+    instance._message = await _SarifToSlackClient.initialize(instance._sarifModel, opts);
+    Logger.trace("instance._message", instance._message);
     return instance;
   }
+  static async buildModel(sarifOpts) {
+    const sarifFiles = extractListOfFiles(sarifOpts);
+    if (sarifFiles.length === 0) {
+      throw new Error(`No SARIF files found at the provided path: ${sarifOpts.path}`);
+    }
+    const model = { sarifFiles, runs: [], findings: new FindingsArray() };
+    const runIdGenerator = _SarifToSlackClient.createRunIdGenerator();
+    for (const sarifPath of sarifFiles) {
+      const sarifJson = await import_fs2.promises.readFile(sarifPath, "utf8");
+      const sarifLog = JSON.parse(sarifJson);
+      for (const run of sarifLog.runs) {
+        const runId = runIdGenerator.next();
+        let runMetadata = void 0;
+        for (const result of run.results ?? []) {
+          runMetadata = {
+            id: runId.value,
+            run,
+            toolName: findToolComponent(run, result).name
+          };
+          model.findings.push(createFinding({ sarifPath, result, runMetadata }));
+        }
+        runMetadata ??= {
+          id: runId.value,
+          run,
+          toolName: findToolComponentDriver(run).name
+        };
+        model.runs.push(runMetadata);
+      }
+    }
+    return model;
+  }
   /**
-   * Sends all prepared Slack messages.
-   * @returns A promise that resolves when all messages have been sent.
-   * @throws Error if a Slack message was not prepared for a SARIF path.
-   * @public
+   * The main function to initialize a list of {@link SlackMessage} objects based
+   * on the given SARIF file(s).
+   * @param sarifModel An instance of {@link SarifModel} object.
+   * @param opts An instance of {@link SarifToSlackClientOptions} object.
+   * @returns A map where key is the SARIF file and value is an instance of
+   * {@link SlackMessage} object
+   * @private
    */
-  async sendAll() {
-    for (const sarifPath of this._slackMessages.keys()) {
-      await this.send(sarifPath);
+  static async initialize(sarifModel, opts) {
+    const message = new SlackMessageBuilder(opts.webhookUrl, {
+      username: opts.username,
+      iconUrl: opts.iconUrl,
+      color: identifyColor(sarifModel.findings, opts.color),
+      representation: createRepresentation(sarifModel, opts.representation)
+    });
+    if (opts.header?.include) {
+      message.withHeader(opts.header?.value);
     }
+    if (opts.footer?.include) {
+      message.withFooter(opts.footer?.value, opts.footer?.type);
+    }
+    if (opts.actor?.include) {
+      message.withActor(opts.actor?.value);
+    }
+    if (opts.run?.include) {
+      message.withRun();
+    }
+    return message;
   }
   /**
-   * Sends a Slack message for a specific SARIF path.
-   * @param sarifPath - The path of the SARIF file for which the message should be sent.
+   * Sends a Slack message.
    * @returns A promise that resolves when the message has been sent.
    * @throws Error if a Slack message was not prepared for the given SARIF path.
    * @public
    */
-  async send(sarifPath) {
-    const message = this._slackMessages.get(sarifPath);
-    if (!message) {
-      throw new Error(`Slack message was not prepared for SARIF path: ${sarifPath}.`);
+  async send() {
+    if (this._sarifModel == null) {
+      throw new Error("Could not parse SARIF file(s).");
+    }
+    if (this.shouldSendMessage) {
+      if (this._message == null) {
+        throw new Error("Slack message was not prepared.");
+      }
+      const text = await this._message.send();
+      Logger.info("Message sent. Status:", text);
+    } else {
+      Logger.info("Message was not sent based on the sendIf parameter:", SendIf[this._sendIf]);
+    }
+  }
+  get shouldSendMessage() {
+    if (this._sendIf == null) {
+      return true;
+    }
+    switch (this._sendIf) {
+      case 0 /* SeverityCritical */:
+        return this._sarifModel?.findings.findByProperty("severity", 5 /* Critical */) != null;
+      case 1 /* SeverityHigh */:
+        return this._sarifModel?.findings.findByProperty("severity", 4 /* High */) != null;
+      case 2 /* SeverityHighOrHigher */:
+        return !!this._sarifModel?.findings.hasSeverityOrHigher(4 /* High */);
+      case 3 /* SeverityMedium */:
+        return this._sarifModel?.findings.findByProperty("severity", 3 /* Medium */) != null;
+      case 4 /* SeverityMediumOrHigher */:
+        return !!this._sarifModel?.findings.hasSeverityOrHigher(3 /* Medium */);
+      case 5 /* SeverityLow */:
+        return this._sarifModel?.findings.findByProperty("severity", 2 /* Low */) != null;
+      case 6 /* SeverityLowOrHigher */:
+        return !!this._sarifModel?.findings.hasSeverityOrHigher(2 /* Low */);
+      case 7 /* SeverityNone */:
+        return this._sarifModel?.findings.findByProperty("severity", 1 /* None */) != null;
+      case 8 /* SeverityNoneOrHigher */:
+        return !!this._sarifModel?.findings.hasSeverityOrHigher(1 /* None */);
+      case 9 /* SeverityUnknown */:
+        return this._sarifModel?.findings.findByProperty("severity", 0 /* Unknown */) != null;
+      case 10 /* SeverityUnknownOrHigher */:
+        return !!this._sarifModel?.findings.hasSeverityOrHigher(0 /* Unknown */);
+      case 11 /* LevelError */:
+        return this._sarifModel?.findings.findByProperty("level", 4 /* Error */) != null;
+      case 12 /* LevelWarning */:
+        return this._sarifModel?.findings.findByProperty("level", 3 /* Warning */) != null;
+      case 13 /* LevelWarningOrHigher */:
+        return !!this._sarifModel?.findings.hasLevelOrHigher(3 /* Warning */);
+      case 14 /* LevelNote */:
+        return this._sarifModel?.findings.findByProperty("level", 2 /* Note */) != null;
+      case 15 /* LevelNoteOrHigher */:
+        return !!this._sarifModel?.findings.hasLevelOrHigher(2 /* Note */);
+      case 16 /* LevelNone */:
+        return this._sarifModel?.findings.findByProperty("level", 1 /* None */) != null;
+      case 17 /* LevelNoneOrHigher */:
+        return !!this._sarifModel?.findings.hasLevelOrHigher(1 /* None */);
+      case 18 /* LevelUnknown */:
+        return this._sarifModel?.findings.findByProperty("level", 0 /* Unknown */) != null;
+      case 19 /* LevelUnknownOrHigher */:
+        return !!this._sarifModel?.findings.hasLevelOrHigher(0 /* Unknown */);
+      case 20 /* Always */:
+        return true;
+      case 21 /* Some */:
+        return (this._sarifModel?.findings.length ?? 0) > 0;
+      case 22 /* Empty */:
+        return (this._sarifModel?.findings.length ?? 0) === 0;
+      case 23 /* Never */:
+        return false;
+      default:
+        throw new Error(`Unknown sendIf parameter: ${this._sendIf}`);
     }
-    const text = await message.send();
-    Logger.info(`Message sent for ${sarifPath} file. Status:`, text);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CalculateResultsBy,
+  Color,
   FooterType,
-  GroupResultsBy,
   LogLevel,
-  SarifToSlackService
+  RepresentationType,
+  SarifToSlackClient,
+  SendIf
 });