unaltraweb 0.3.0

data/assets/js/callouts.js

@@ -0,0 +1,115 @@
+(() => {
+  const TYPES = ["info", "example", "warning", "objectives", "danger"];
+  const DEFAULT_LABELS = {
+    ca: {
+      info: "NOTA",
+      example: "EXEMPLE",
+      warning: "ADVERTENCIA",
+      objectives: "OBJECTIUS D'APRENENTATGE",
+      danger: "ATENCIO",
+    },
+    es: {
+      info: "NOTA",
+      example: "EJEMPLO",
+      warning: "ADVERTENCIA",
+      objectives: "OBJETIVOS DE APRENDIZAJE",
+      danger: "ATENCION",
+    },
+    en: {
+      info: "NOTE",
+      example: "EXAMPLE",
+      warning: "WARNING",
+      objectives: "LEARNING OBJECTIVES",
+      danger: "CAUTION",
+    },
+  };
+
+  function currentLang() {
+    return (document.documentElement.getAttribute("lang") || "en").toLowerCase().split("-")[0];
+  }
+
+  function labelsFor(lang) {
+    const siteLabels = window.unaltrawebCalloutLabels || {};
+    return siteLabels[lang] || siteLabels.en || DEFAULT_LABELS[lang] || DEFAULT_LABELS.en;
+  }
+
+  function blockquoteDepth(blockquote) {
+    let depth = 0;
+    let parent = blockquote.parentElement;
+
+    while (parent) {
+      if (parent.tagName === "BLOCKQUOTE") depth += 1;
+      parent = parent.parentElement;
+    }
+
+    return depth;
+  }
+
+  function removeGeneratedCallouts(scope) {
+    scope.querySelectorAll("[data-unaltraweb-callout-title='true']").forEach((title) => title.remove());
+    scope.querySelectorAll("blockquote").forEach((blockquote) => {
+      blockquote.classList.remove(
+        "uw-callout",
+        "uw-callout-wrapper",
+        "uw-callout-info",
+        "uw-callout-example",
+        "uw-callout-warning",
+        "uw-callout-objectives",
+        "uw-callout-danger",
+      );
+      blockquote.removeAttribute("data-callout");
+    });
+  }
+
+  function directChildBlockquote(blockquote) {
+    return Array.from(blockquote.children).some((child) => child.tagName === "BLOCKQUOTE");
+  }
+
+  function firstMeaningfulChild(blockquote) {
+    return Array.from(blockquote.children).find((child) => child.nodeType === Node.ELEMENT_NODE);
+  }
+
+  function injectTitle(blockquote, label) {
+    const firstChild = firstMeaningfulChild(blockquote);
+    if (firstChild && firstChild.classList.contains("uw-callout-title")) return;
+
+    const title = document.createElement("p");
+    title.className = "uw-callout-title";
+    title.dataset.unaltrawebCalloutTitle = "true";
+    title.textContent = label;
+    blockquote.insertBefore(title, blockquote.firstChild);
+  }
+
+  function processCallouts(scope = document) {
+    const lang = currentLang();
+    const labels = labelsFor(lang);
+    const roots = scope.querySelectorAll(".post article, .markdown-section, main, [role='main']");
+
+    roots.forEach((root) => {
+      removeGeneratedCallouts(root);
+
+      root.querySelectorAll("blockquote").forEach((blockquote) => {
+        if (directChildBlockquote(blockquote)) {
+          blockquote.classList.add("uw-callout-wrapper");
+          return;
+        }
+
+        const depth = blockquoteDepth(blockquote);
+        if (depth === 0) return;
+
+        const type = TYPES[Math.min(depth, TYPES.length) - 1] || TYPES[0];
+        blockquote.classList.add("uw-callout", `uw-callout-${type}`);
+        blockquote.dataset.callout = type;
+        injectTitle(blockquote, labels[type] || DEFAULT_LABELS.en[type]);
+      });
+    });
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", () => processCallouts());
+  } else {
+    processCallouts();
+  }
+
+  document.addEventListener("unaltraweb:contentchange", (event) => processCallouts(event.target || document));
+})();

data/assets/js/chartjs-setup.js

@@ -0,0 +1,14 @@
+$(document).ready(function () {
+  var $canvas = null,
+    $this = null,
+    _ctx = null,
+    _text = "";
+  $(".language-chartjs").each(function () {
+    $this = $(this);
+    $canvas = $("<canvas></canvas>");
+    _text = $this.text();
+    $this.text("").append($canvas);
+    _ctx = $canvas.get(0).getContext("2d");
+    _ctx && _text && new Chart(_ctx, JSON.parse(_text)) && $this.attr("data-processed", true);
+  });
+});

data/assets/js/common.js

@@ -0,0 +1,117 @@
+$(document).ready(function () {
+  // add toggle functionality to publication detail buttons
+  const biblioPanelClasses = ["cite", "abstract", "award", "bibtex", "openalex", "scimago"];
+
+  function updateBiblioButtonState($entry) {
+    biblioPanelClasses.forEach(function (panelClass) {
+      const isOpen = $entry.find(`.${panelClass}.hidden.open`).length > 0;
+      $entry.find(`.links a.${panelClass}.btn`).toggleClass("biblio-active", isOpen).attr("aria-expanded", isOpen ? "true" : "false");
+    });
+  }
+
+  function toggleBiblioPanel(link, panelClass) {
+    const $entry = $(link).parent().parent();
+    const panelSelector = `.${panelClass}.hidden`;
+
+    biblioPanelClasses.forEach(function (otherPanelClass) {
+      if (otherPanelClass !== panelClass) $entry.find(`.${otherPanelClass}.hidden.open`).removeClass("open");
+    });
+
+    $entry.find(panelSelector).toggleClass("open");
+    updateBiblioButtonState($entry);
+  }
+
+  $("a.abstract").click(function () {
+    toggleBiblioPanel(this, "abstract");
+  });
+  $("a.cite").click(function () {
+    toggleBiblioPanel(this, "cite");
+  });
+  $("a.award").click(function () {
+    toggleBiblioPanel(this, "award");
+  });
+  $("a.bibtex").click(function () {
+    toggleBiblioPanel(this, "bibtex");
+  });
+  $("a.openalex").click(function () {
+    toggleBiblioPanel(this, "openalex");
+  });
+  $("a.scimago").click(function () {
+    toggleBiblioPanel(this, "scimago");
+  });
+
+  $(document).on("click", "[data-copy-target]", function () {
+    const button = this;
+    const target = document.querySelector(button.getAttribute("data-copy-target"));
+    if (!target) return;
+    const text = target.innerText.trim();
+    const doneLabel = button.getAttribute("data-copy-done") || "Copied";
+    const copyLabel = button.getAttribute("data-copy-label") || button.innerText;
+    const markCopied = function () {
+      button.innerText = doneLabel;
+      window.setTimeout(function () {
+        button.innerText = copyLabel;
+      }, 1600);
+    };
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard.writeText(text).then(markCopied).catch(function () {});
+      return;
+    }
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.setAttribute("readonly", "");
+    textarea.style.position = "fixed";
+    textarea.style.left = "-9999px";
+    document.body.appendChild(textarea);
+    textarea.select();
+    try {
+      document.execCommand("copy");
+      markCopied();
+    } finally {
+      document.body.removeChild(textarea);
+    }
+  });
+
+  $("a").removeClass("waves-effect waves-light");
+
+  // bootstrap-toc
+  if ($("#toc-sidebar").length) {
+    // remove related publications years from the TOC
+    $(".publications h2").each(function () {
+      $(this).attr("data-toc-skip", "");
+    });
+    var navSelector = "#toc-sidebar";
+    var $myNav = $(navSelector);
+    Toc.init($myNav);
+    $("body").scrollspy({
+      target: navSelector,
+      offset: 100,
+    });
+  }
+
+  // add css to jupyter notebooks
+  const cssLink = document.createElement("link");
+  cssLink.href = "../css/jupyter.css";
+  cssLink.rel = "stylesheet";
+  cssLink.type = "text/css";
+
+  let jupyterTheme = determineComputedTheme();
+
+  $(".jupyter-notebook-iframe-container iframe").each(function () {
+    $(this).contents().find("head").append(cssLink);
+
+    if (jupyterTheme == "dark") {
+      $(this).bind("load", function () {
+        $(this).contents().find("body").attr({
+          "data-jp-theme-light": "false",
+          "data-jp-theme-name": "JupyterLab Dark",
+        });
+      });
+    }
+  });
+
+  // trigger popovers
+  $('[data-toggle="popover"]').popover({
+    trigger: "hover",
+  });
+});

data/assets/js/content-search-match.js

@@ -0,0 +1,159 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.UnaltrawebContentSearchMatch = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  var MARK_RE = /\p{M}/gu;
+  var WORD_RE = /[\p{L}\p{N}]/u;
+
+  function foldWithMap(value) {
+    var source = (value || "").toString();
+    var folded = "";
+    var starts = [];
+    var ends = [];
+
+    for (var index = 0; index < source.length;) {
+      var codePoint = source.codePointAt(index);
+      var character = String.fromCodePoint(codePoint);
+      var end = index + character.length;
+      var normalized = character.toLowerCase().normalize("NFD").replace(MARK_RE, "");
+
+      if (!normalized) {
+        if (ends.length) ends[ends.length - 1] = end;
+        index = end;
+        continue;
+      }
+
+      for (var offset = 0; offset < normalized.length; offset += 1) {
+        var unit = normalized[offset];
+        if (/\s/u.test(unit)) {
+          if (folded.endsWith(" ")) {
+            ends[ends.length - 1] = end;
+            continue;
+          }
+          unit = " ";
+        }
+        folded += unit;
+        starts.push(index);
+        ends.push(end);
+      }
+      index = end;
+    }
+
+    return { text: folded, starts: starts, ends: ends };
+  }
+
+  function normalize(value) {
+    return foldWithMap(value).text.trim();
+  }
+
+  function collapseWhitespaceWithMap(value) {
+    var source = (value || "").toString();
+    var text = "";
+    var starts = [];
+    var ends = [];
+
+    for (var index = 0; index < source.length;) {
+      var codePoint = source.codePointAt(index);
+      var character = String.fromCodePoint(codePoint);
+      var end = index + character.length;
+      if (/\s/u.test(character)) {
+        if (text && !text.endsWith(" ")) {
+          text += " ";
+          starts.push(index);
+          ends.push(end);
+        } else if (text.endsWith(" ")) {
+          ends[ends.length - 1] = end;
+        }
+      } else {
+        text += character;
+        for (var offset = 0; offset < character.length; offset += 1) {
+          starts.push(index);
+          ends.push(end);
+        }
+      }
+      index = end;
+    }
+
+    if (text.endsWith(" ")) {
+      text = text.slice(0, -1);
+      starts.pop();
+      ends.pop();
+    }
+    return { text: text, starts: starts, ends: ends };
+  }
+
+  function codePointBefore(value, index) {
+    if (index <= 0) return "";
+    var points = Array.from(value.slice(0, index));
+    return points[points.length - 1] || "";
+  }
+
+  function codePointAt(value, index) {
+    return Array.from(value.slice(index))[0] || "";
+  }
+
+  function isWordCharacter(value) {
+    return Boolean(value && WORD_RE.test(value));
+  }
+
+  function hasWordBoundaries(source, start, end, needle) {
+    var needlePoints = Array.from(needle);
+    if (isWordCharacter(needlePoints[0]) && isWordCharacter(codePointBefore(source, start))) return false;
+    if (isWordCharacter(needlePoints[needlePoints.length - 1]) && isWordCharacter(codePointAt(source, end))) return false;
+    return true;
+  }
+
+  function findOccurrences(value, query) {
+    var source = (value || "").toString();
+    var folded = foldWithMap(source);
+    var needle = normalize(query);
+    var matches = [];
+    if (!needle) return matches;
+
+    var cursor = 0;
+    while (cursor <= folded.text.length - needle.length) {
+      var found = folded.text.indexOf(needle, cursor);
+      if (found < 0) break;
+      var foldedEnd = found + needle.length;
+      if (hasWordBoundaries(folded.text, found, foldedEnd, needle)) {
+        matches.push({
+          start: folded.starts[found],
+          end: folded.ends[foldedEnd - 1]
+        });
+        cursor = foldedEnd;
+      } else {
+        cursor = found + 1;
+      }
+    }
+    return matches;
+  }
+
+  function excerptParts(value, occurrence, before, after) {
+    var source = (value || "").toString();
+    var start = Math.max(0, occurrence.start - (before || 72));
+    var end = Math.min(source.length, occurrence.end + (after || 112));
+    if (start > 0) {
+      var nextSpace = source.indexOf(" ", start);
+      if (nextSpace >= 0 && nextSpace < occurrence.start) start = nextSpace + 1;
+    }
+    if (end < source.length) {
+      var previousSpace = source.lastIndexOf(" ", end);
+      if (previousSpace > occurrence.end) end = previousSpace;
+    }
+    return {
+      before: (start > 0 ? "..." : "") + source.slice(start, occurrence.start),
+      match: source.slice(occurrence.start, occurrence.end),
+      after: source.slice(occurrence.end, end) + (end < source.length ? "..." : "")
+    };
+  }
+
+  return {
+    normalize: normalize,
+    collapseWhitespaceWithMap: collapseWhitespaceWithMap,
+    findOccurrences: findOccurrences,
+    excerptParts: excerptParts
+  };
+});