jekyll-dice-tray 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3d407c51d39049511c08f665a5b70a71d0eff1a0ec1522472948ce6350fd670
-  data.tar.gz: d2ae3f53ca8018c55bfff796cba3781684076bdeb8ba5bfdc9307c5f3e30c127
+  metadata.gz: 8ee11a49a55ee16f40ee46a91b01a40d3074da6b6bc1cdde28b7bbe36b41386d
+  data.tar.gz: a35ce460b6c0181c03acc99d38916407eac12d1c6d89feae6412335302cedd64
 SHA512:
-  metadata.gz: e30263b41fc804cb82a2f6ba76a0697bd31e0e6d5ace3550a94fb6d41d20a25eec1c2db6e65048ea94b549b3137de4a079dc57c7c9f6209b6b841d5b20723ac4
-  data.tar.gz: 843991fe95b1a12b60550fc6bc462ea547b46e23b740eda47fe3a454dda4d0e34c4757d7ba8f2f3ae68989814c551b3011fbb571b7f022ab1dd404a4f28942fe
+  metadata.gz: c754090c423cbd76a96b532e0bccc16d2cd2e76db5006fae17ed1766b5c8e19305a8838346640117de26bc6793e7c41021dbcf05ce61541095b97bd1dfde5edd
+  data.tar.gz: 03d2e7cdfaa42614d46fba9fac3eebf0722b6ba324def7a5c40d6f53576aadc0b4f73a17354218aa7ad508b002818c93e49db65f9b1170a37ce389ddbc26e3ea

data/README.md

@@ -4,7 +4,7 @@ A Jekyll plugin gem that:
 
 - Adds an overlay dice tray that accepts dice rolling input
 - Recognizes dice expressions in rendered pages like `d4`, `1d6`, `1d20+1` and turns them into clickable links that roll in the tray
-- Clicking a lookup-table die in the header row (e.g. `1d12`) rolls and shows the matching row
+- Clicking a lookup-table die (any `dN`) rolls and shows the matching entry — supports any number of side-by-side key/value column groups, ranges like `3–12`, and tables with or without headers. One die in the header searches the whole table; multiple dice each search their own column group
 - Persists input history, result history, minimize status
 
 https://github.com/user-attachments/assets/6ef8d788-a1ee-49d4-ab26-f63899bb4a10
@@ -31,7 +31,7 @@ Optional `_config.yml` settings:
 ```yml
 dice_tray:
   enabled: true
-  assets_path: /assets/jekyll-dice-tray
+  assets_path: /assets/jekyll-dice-tray  # prefixed with site baseurl automatically
   inject_tray: true
   link_dice_in_markdown: true
 ```

data/assets/jekyll-dice-tray/dice_tray.css

@@ -163,7 +163,8 @@
   text-underline-offset: 2px;
 }
 
-#jekyll-dice-tray .jdt-table-value a.dice-tray-roll {
+#jekyll-dice-tray .jdt-table-value a.dice-tray-roll,
+#jekyll-dice-tray .jdt-table-header a.dice-tray-roll {
   color: #ff0000;
 }
 
@@ -171,7 +172,8 @@
   color: inherit;
 }
 
-#jekyll-dice-tray .jdt-table-value a.dice-tray-roll:visited {
+#jekyll-dice-tray .jdt-table-value a.dice-tray-roll:visited,
+#jekyll-dice-tray .jdt-table-header a.dice-tray-roll:visited {
   color: #ff0000;
 }
 

data/assets/jekyll-dice-tray/dice_tray.js

@@ -158,21 +158,7 @@
       return node && node.innerHTML ? node.innerHTML.trim() : "";
     }
 
-    function findTableHeaderRow(table) {
-      if (!table) return null;
-      var thead = table.querySelector("thead");
-      if (thead) {
-        var theadRows = thead.querySelectorAll("tr");
-        if (theadRows.length) return theadRows[theadRows.length - 1];
-      }
-      var rows = table.querySelectorAll("tr");
-      for (var i = 0; i < rows.length; i++) {
-        if (rows[i].querySelector("th")) return rows[i];
-      }
-      return table.querySelector("tr");
-    }
-
-    function parseFirstColumnEntry(text) {
+    function parseKeyEntry(text) {
       if (!text) return null;
       var normalized = text.replace(/[\u2013\u2014]/g, "-");
       if (/^\d+$/.test(normalized)) {
@@ -187,72 +173,290 @@
       return null;
     }
 
-    function firstColumnEntry(row) {
-      if (!row) return null;
-      var cell = row.querySelector("td, th");
-      if (!cell) return null;
-      return parseFirstColumnEntry(normalizeCellText(cell));
+    function rowCells(row) {
+      if (!row) return [];
+      return Array.prototype.slice.call(row.querySelectorAll("td, th"));
     }
 
-    function isLookupTable(table, headerRow) {
-      if (!table || !headerRow) return false;
+    function cellColumnIndex(row, cell) {
+      var cells = rowCells(row);
+      for (var i = 0; i < cells.length; i++) {
+        if (cells[i] === cell) return i;
+      }
+      return -1;
+    }
+
+    function rowLooksLikeHeader(row) {
+      if (!row) return false;
+      if (row.querySelector("th")) return true;
+      var cells = rowCells(row);
+      if (!cells.length) return false;
+      var keyCount = 0;
+      for (var i = 0; i < cells.length; i++) {
+        if (parseKeyEntry(normalizeCellText(cells[i]))) keyCount++;
+      }
+      // Data rows start with roll keys; header rows are labels / dice expr.
+      return keyCount === 0;
+    }
+
+    function findTableHeaderRow(table) {
+      if (!table) return null;
+      var thead = table.querySelector("thead");
+      if (thead) {
+        var theadRows = thead.querySelectorAll("tr");
+        if (theadRows.length) {
+          var head = theadRows[theadRows.length - 1];
+          // Markdown always wraps the first row in <thead>; skip if it's really data.
+          if (!parseKeyEntry(normalizeCellText(rowCells(head)[0] || null))) return head;
+        }
+      }
       var rows = table.querySelectorAll("tr");
-      var matches = 0;
       for (var i = 0; i < rows.length; i++) {
-        if (rows[i] === headerRow) continue;
-        if (firstColumnEntry(rows[i]) !== null) matches++;
+        if (rows[i].querySelector("th") && rowLooksLikeHeader(rows[i])) return rows[i];
       }
-      return matches >= 2;
+      if (rows.length && rowLooksLikeHeader(rows[0])) return rows[0];
+      return null;
     }
 
-    function findLookupRow(table, headerRow, rollTotal) {
+    function eachDataRow(table, headerRow, fn) {
       var rows = table.querySelectorAll("tr");
-      var rangeRow = null;
       for (var i = 0; i < rows.length; i++) {
-        var row = rows[i];
-        if (row === headerRow) continue;
-        var entry = firstColumnEntry(row);
-        if (!entry) continue;
-        if (entry.kind === "exact" && entry.value === rollTotal) return row;
-        if (entry.kind === "range" && !rangeRow && rollTotal >= entry.min && rollTotal <= entry.max) {
-          rangeRow = row;
+        if (rows[i] === headerRow) continue;
+        fn(rows[i]);
+      }
+    }
+
+    // Infer key columns from data: any column that holds a roll number/range in enough rows.
+    // Supports 1..N side-by-side (key, value...) groups for any die size.
+    function inferKeyColumns(table, headerRow) {
+      var counts = [];
+      var rowCount = 0;
+      eachDataRow(table, headerRow, function (row) {
+        var cells = rowCells(row);
+        rowCount++;
+        for (var i = 0; i < cells.length; i++) {
+          if (!counts[i]) counts[i] = 0;
+          if (parseKeyEntry(normalizeCellText(cells[i]))) counts[i]++;
+        }
+      });
+      if (rowCount < 1) return [];
+      var minHits = Math.min(2, rowCount);
+      var keys = [];
+      for (var c = 0; c < counts.length; c++) {
+        if ((counts[c] || 0) >= minHits) keys.push(c);
+      }
+      return keys;
+    }
+
+    function buildColumnGroups(keyColumns, columnCount) {
+      var groups = [];
+      for (var k = 0; k < keyColumns.length; k++) {
+        var keyIndex = keyColumns[k];
+        var nextKey = k + 1 < keyColumns.length ? keyColumns[k + 1] : columnCount;
+        var valueIndices = [];
+        for (var v = keyIndex + 1; v < nextKey; v++) valueIndices.push(v);
+        groups.push({ keyIndex: keyIndex, valueIndices: valueIndices });
+      }
+      return groups;
+    }
+
+    function tableColumnCount(table, headerRow) {
+      var max = headerRow ? rowCells(headerRow).length : 0;
+      eachDataRow(table, headerRow, function (row) {
+        max = Math.max(max, rowCells(row).length);
+      });
+      return max;
+    }
+
+    function collectRowEntriesForGroups(row, groups, allowedKeyIndices) {
+      var cells = rowCells(row);
+      var entries = [];
+      var allowAll = !allowedKeyIndices || !allowedKeyIndices.length;
+      for (var g = 0; g < groups.length; g++) {
+        var group = groups[g];
+        if (!allowAll && allowedKeyIndices.indexOf(group.keyIndex) === -1) continue;
+        var keyCell = cells[group.keyIndex];
+        if (!keyCell) continue;
+        var key = parseKeyEntry(normalizeCellText(keyCell));
+        if (!key) continue;
+        var valueCells = [];
+        var valueIndices = [];
+        for (var vi = 0; vi < group.valueIndices.length; vi++) {
+          var idx = group.valueIndices[vi];
+          if (!cells[idx]) continue;
+          valueCells.push(cells[idx]);
+          valueIndices.push(idx);
         }
+        entries.push({
+          key: key,
+          keyIndex: group.keyIndex,
+          valueCells: valueCells,
+          valueIndices: valueIndices,
+        });
       }
-      return rangeRow;
+      return entries;
+    }
+
+    function isLookupTable(table, headerRow, groups) {
+      if (!table || !groups || !groups.length) return false;
+      var matches = 0;
+      eachDataRow(table, headerRow, function (row) {
+        matches += collectRowEntriesForGroups(row, groups, null).length;
+      });
+      return matches >= 2;
+    }
+
+    function findLookupMatch(table, headerRow, groups, rollTotal, allowedKeyIndices) {
+      var exact = null;
+      var range = null;
+      eachDataRow(table, headerRow, function (row) {
+        var entries = collectRowEntriesForGroups(row, groups, allowedKeyIndices);
+        for (var e = 0; e < entries.length; e++) {
+          var entry = entries[e];
+          if (entry.key.kind === "exact" && entry.key.value === rollTotal) {
+            if (!exact) exact = { row: row, entry: entry };
+          } else if (
+            entry.key.kind === "range" &&
+            !range &&
+            rollTotal >= entry.key.min &&
+            rollTotal <= entry.key.max
+          ) {
+            range = { row: row, entry: entry };
+          }
+        }
+      });
+      return exact || range;
+    }
+
+    function headerDiceCount(headerRow) {
+      if (!headerRow) return 0;
+      return headerRow.querySelectorAll('a[data-dice]').length;
+    }
+
+    function groupForColumn(groups, columnIndex) {
+      for (var g = 0; g < groups.length; g++) {
+        var group = groups[g];
+        if (columnIndex === group.keyIndex) return group;
+        if (group.valueIndices.indexOf(columnIndex) !== -1) return group;
+      }
+      return null;
+    }
+
+    // One die in the header (e.g. d100 over many pairs) => search every group.
+    // Several dice (e.g. d10 | Weather | d10 | Terrain | d6 | Mood) => only the clicked group.
+    function allowedKeyIndicesForClick(headerRow, clickCell, groups) {
+      if (!headerRow || !clickCell || !groups.length) return null;
+      if (headerDiceCount(headerRow) <= 1) return null;
+      var col = cellColumnIndex(headerRow, clickCell);
+      if (col < 0) return null;
+      var group = groupForColumn(groups, col);
+      return group ? [group.keyIndex] : null;
+    }
+
+    function findFollowingTable(node) {
+      var elNode = node;
+      while (elNode && elNode !== document.body) {
+        var sib = elNode.nextElementSibling;
+        while (sib) {
+          if (sib.tagName === "TABLE") return sib;
+          var nested = sib.querySelector && sib.querySelector("table");
+          if (nested) return nested;
+          sib = sib.nextElementSibling;
+        }
+        elNode = elNode.parentElement;
+      }
+      return null;
     }
 
     function getLookupTableContext(anchor, rollTotal) {
       if (!anchor || !anchor.closest || rollTotal == null) return null;
-      var cell = anchor.closest("td, th");
-      if (!cell) return null;
-      var clickRow = cell.closest("tr");
-      if (!clickRow) return null;
-      var table = clickRow.closest("table");
-      if (!table) return null;
 
-      var headerRow = findTableHeaderRow(table);
-      if (!headerRow || !headerRow.contains(cell)) return null;
-      if (!isLookupTable(table, headerRow)) return null;
+      var cell = null;
+      var table = null;
+      var headerRow = null;
+      var allowedKeys = null;
+      var sourceTable = anchor._jdtSourceTable;
+
+      if (sourceTable && sourceTable.querySelector) {
+        // Re-roll from a previous table result in the tray.
+        table = sourceTable;
+        headerRow = findTableHeaderRow(table);
+        allowedKeys = anchor._jdtAllowedKeyIndices || null;
+      } else {
+        cell = anchor.closest("td, th");
+        if (cell) {
+          table = cell.closest("table");
+          if (!table) return null;
+          headerRow = findTableHeaderRow(table);
+          // With a header, only header-cell dice trigger lookup (data cells may contain other dice).
+          // Without a header, any in-table die can trigger lookup.
+          if (headerRow && !headerRow.contains(cell)) return null;
+        } else {
+          table = findFollowingTable(anchor);
+          if (!table) return null;
+          headerRow = findTableHeaderRow(table);
+        }
+      }
+
+      var keyColumns = inferKeyColumns(table, headerRow);
+      if (!keyColumns.length) return null;
+      var groups = buildColumnGroups(keyColumns, tableColumnCount(table, headerRow));
+      if (!isLookupTable(table, headerRow, groups)) return null;
 
-      var matchedRow = findLookupRow(table, headerRow, rollTotal);
-      if (!matchedRow) return null;
+      if (allowedKeys == null && cell && headerRow) {
+        allowedKeys = allowedKeyIndicesForClick(headerRow, cell, groups);
+      }
+      var matched = findLookupMatch(table, headerRow, groups, rollTotal, allowedKeys);
+      if (!matched) return null;
 
-      var headerCells = Array.prototype.slice.call(headerRow.querySelectorAll("td, th"));
-      var valueCells = Array.prototype.slice.call(matchedRow.querySelectorAll("td, th"));
+      var headerCells = headerRow ? rowCells(headerRow) : [];
+      var entry = matched.entry;
       var columns = [];
-
-      for (var c = 0; c < valueCells.length; c++) {
-        var headerCell = headerCells[c];
-        var valueCell = valueCells[c];
+      var indices = [entry.keyIndex].concat(entry.valueIndices);
+      var cells = [rowCells(matched.row)[entry.keyIndex]].concat(entry.valueCells);
+      var diceLabel = String(anchor.getAttribute("data-dice") || normalizeCellText(anchor) || "").trim();
+
+      for (var c = 0; c < cells.length; c++) {
+        var valueCell = cells[c];
+        if (!valueCell) continue;
+        var headerCell = headerCells[indices[c]];
+        var headerText = headerCell ? normalizeCellText(headerCell) : "";
+        var headerHtml = headerCell ? cellInnerHtml(headerCell) : "";
+        // Blank/whitespace key-column headers (common in side-by-side tables) inherit the die notation.
+        if (!headerText && c === 0 && diceLabel) {
+          headerText = diceLabel;
+          headerHtml = "";
+        } else if (!headerText) {
+          headerHtml = "";
+        }
         columns.push({
-          header: headerCell ? normalizeCellText(headerCell) : "",
-          header_html: headerCell ? cellInnerHtml(headerCell) : "",
+          header: headerText,
+          header_html: headerHtml,
           value: normalizeCellText(valueCell),
           value_html: cellInnerHtml(valueCell),
+          // Key-column die prefix is clickable for a table re-roll.
+          reroll_expr: c === 0 && diceLabel ? diceLabel : "",
         });
       }
 
-      return columns.length ? { columns: columns } : null;
+      return columns.length
+        ? { columns: columns, _sourceTable: table, _allowedKeyIndices: allowedKeys }
+        : null;
+    }
+
+    function serializableTableContext(tableContext) {
+      if (!tableContext || !tableContext.columns || !tableContext.columns.length) return null;
+      return {
+        columns: tableContext.columns.map(function (col) {
+          return {
+            header: col.header || "",
+            header_html: col.header_html || "",
+            value: col.value || "",
+            value_html: col.value_html || "",
+            reroll_expr: col.reroll_expr || "",
+          };
+        }),
+      };
     }
 
     function appendTableContext(entry, tableContext) {
@@ -262,10 +466,27 @@
       tableContext.columns.forEach(function (col) {
         if (!col || (!col.value && !col.value_html)) return;
         var line = el("div", { class: "jdt-table-row" });
-        if (col.header || col.header_html) {
+        var headerText = col.header ? String(col.header).trim() : "";
+        if (headerText) {
           var headerSpan = el("span", { class: "jdt-table-header" });
-          if (col.header_html) headerSpan.innerHTML = col.header_html;
-          else headerSpan.textContent = col.header;
+          if (col.reroll_expr) {
+            var reroll = el(
+              "a",
+              { class: "dice-tray-roll", href: "#", "data-dice": col.reroll_expr },
+              headerText
+            );
+            if (tableContext._sourceTable && tableContext._sourceTable.querySelector) {
+              reroll._jdtSourceTable = tableContext._sourceTable;
+            }
+            if (tableContext._allowedKeyIndices) {
+              reroll._jdtAllowedKeyIndices = tableContext._allowedKeyIndices;
+            }
+            headerSpan.appendChild(reroll);
+          } else if (col.header_html) {
+            headerSpan.innerHTML = col.header_html;
+          } else {
+            headerSpan.textContent = headerText;
+          }
           line.appendChild(headerSpan);
           line.appendChild(el("span", { class: "jdt-table-sep" }, ": "));
         }
@@ -466,7 +687,7 @@
         success: success,
         time: timeStr,
       };
-      if (tableContext) item.table_context = tableContext;
+      if (tableContext) item.table_context = serializableTableContext(tableContext);
       pushHistory(item);
     }
 
@@ -490,7 +711,7 @@
       if (skipHistory) return;
 
       var item = { kind: "roll", expr: expr, total: total, rolls: rolls, mod: mod, time: timeStr };
-      if (tableContext) item.table_context = tableContext;
+      if (tableContext) item.table_context = serializableTableContext(tableContext);
       pushHistory(item);
     }
 
@@ -545,14 +766,14 @@
         mod: mod,
         time: timeStr,
       };
-      if (tableContext) item.table_context = tableContext;
+      if (tableContext) item.table_context = serializableTableContext(tableContext);
       pushHistory(item);
     }
 
     function showHelp() {
       addSystemEntry(
         "Usage: 1d6, d4, 2d8+1, 2-in-6",
-        "Click linked dice like 1d20+5, chance like 2-in-6 (roll d6, 1-2 succeed), or bracket modifiers like [+1] (rolls d20+1). Clicking a table die (e.g. 1d12) shows the matching row (first column: single number or range like 3-12). Commands: /help, /clear",
+        "Click linked dice like 1d20+5, chance like 2-in-6 (roll d6, 1-2 succeed), or bracket modifiers like [+1] (rolls d20+1). Clicking a table die (any dN) shows the matching entry (number or range; any number of side-by-side key/value column groups; headers optional). Commands: /help, /clear",
         nowTime()
       );
     }

data/lib/jekyll/dice_tray/config.rb

@@ -0,0 +1,26 @@
+module Jekyll
+  module DiceTray
+    module Config
+      DEFAULT_ASSETS_PATH = "/assets/jekyll-dice-tray"
+
+      # Site-relative directory for writing static assets (no baseurl).
+      def self.assets_dir(site)
+        path = configured_path(site)
+        path.sub(%r{\A/}, "")
+      end
+
+      # URL path for linking assets in HTML (includes baseurl).
+      def self.assets_url(site)
+        baseurl = site.config["baseurl"].to_s.chomp("/")
+        "#{baseurl}#{configured_path(site)}"
+      end
+
+      def self.configured_path(site)
+        cfg = site.config["dice_tray"] || {}
+        path = (cfg["assets_path"] || DEFAULT_ASSETS_PATH).to_s
+        path.start_with?("/") ? path : "/#{path}"
+      end
+      private_class_method :configured_path
+    end
+  end
+end

data/lib/jekyll/dice_tray/generator.rb

@@ -8,10 +8,8 @@ module Jekyll
         cfg = (site.config["dice_tray"] || {})
         return if cfg["enabled"] == false
 
-        assets_path = cfg["assets_path"] || "/assets/jekyll-dice-tray"
-        assets_path = "/#{assets_path}" unless assets_path.start_with?("/")
-
         asset_dir = File.expand_path("../../../assets/jekyll-dice-tray", __dir__)
+        dest_dir = Config.assets_dir(site)
 
         files = {
           "dice_tray.js" => File.join(asset_dir, "dice_tray.js"),
@@ -23,7 +21,7 @@ module Jekyll
           site.static_files << AssetFile.new(
             site,
             site.source,
-            assets_path.sub(%r{\A/}, ""),
+            dest_dir,
             name,
             source_path: source_path
           )

data/lib/jekyll/dice_tray/hooks.rb

@@ -8,13 +8,10 @@ module Jekyll
           next if cfg["enabled"] == false
           next unless doc.respond_to?(:output_ext) && doc.output_ext == ".html"
 
-          assets_path = cfg["assets_path"] || "/assets/jekyll-dice-tray"
-          assets_path = "/#{assets_path}" unless assets_path.start_with?("/")
-
           begin
             out = doc.output.to_s
             out = HtmlRewriter.rewrite(out) if cfg.fetch("link_dice_in_markdown", true)
-            out = HtmlRewriter.inject_tray(out, assets_path: assets_path) if cfg.fetch("inject_tray", true)
+            out = HtmlRewriter.inject_tray(out, assets_path: Config.assets_url(site)) if cfg.fetch("inject_tray", true)
             doc.output = out
           rescue StandardError => e
             Jekyll.logger.warn("jekyll-dice-tray:", "Failed to process #{doc.relative_path}: #{e.class}: #{e.message}")

data/lib/jekyll/dice_tray/version.rb

@@ -1,6 +1,6 @@
 module Jekyll
   module DiceTray
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end
 

data/lib/jekyll-dice-tray.rb

@@ -2,6 +2,7 @@ require "jekyll"
 require "nokogiri"
 
 require_relative "jekyll/dice_tray/version"
+require_relative "jekyll/dice_tray/config"
 require_relative "jekyll/dice_tray/asset_file"
 require_relative "jekyll/dice_tray/generator"
 require_relative "jekyll/dice_tray/html_rewriter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-dice-tray
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - directsun
@@ -54,6 +54,7 @@ files:
 - assets/jekyll-dice-tray/dice_tray.js
 - lib/jekyll-dice-tray.rb
 - lib/jekyll/dice_tray/asset_file.rb
+- lib/jekyll/dice_tray/config.rb
 - lib/jekyll/dice_tray/generator.rb
 - lib/jekyll/dice_tray/hooks.rb
 - lib/jekyll/dice_tray/html_rewriter.rb