com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/site/javascripts/csharp-highlight.js

@@ -0,0 +1,246 @@
+/**
+ * C# Semantic Syntax Highlighting Enhancement
+ *
+ * Pygments' C# lexer classifies many tokens as generic "Name" (.n) tokens,
+ * making it impossible to differentiate types from methods from variables
+ * with CSS alone. This script post-processes code blocks to add semantic
+ * classes based on contextual patterns:
+ *
+ * - .n-type: Type names (PascalCase identifiers, often followed by < or at line start)
+ * - .n-method: Method names (identifiers followed by < and ( or just ()
+ * - .n-param: Parameter names (after type in parameter list, before = or , or ))
+ * - .n-var: Variable names (other identifiers)
+ */
+(function () {
+  "use strict";
+
+  /** Maximum iterations for look-ahead loops to prevent hangs */
+  var MAX_LOOKAHEAD = 50;
+
+  /**
+   * Check if a string is PascalCase (starts with uppercase)
+   */
+  function isPascalCase(text) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(text);
+  }
+
+  /**
+   * Check if a string is camelCase (starts with lowercase)
+   */
+  function isCamelCase(text) {
+    return /^[a-z][a-zA-Z0-9]*$/.test(text);
+  }
+
+  /**
+   * Safely get classList as array, handling elements without classList
+   */
+  function getClassList(element) {
+    if (element && element.classList) {
+      return Array.from(element.classList);
+    }
+    return [];
+  }
+
+  /**
+   * Get the next sibling element (skipping whitespace spans)
+   */
+  function getNextNonWhitespace(element) {
+    var next = element.nextElementSibling;
+    while (next && next.classList && next.classList.contains("w")) {
+      next = next.nextElementSibling;
+    }
+    return next;
+  }
+
+  /**
+   * Get the previous sibling element (skipping whitespace spans)
+   */
+  function getPrevNonWhitespace(element) {
+    var prev = element.previousElementSibling;
+    while (prev && prev.classList && prev.classList.contains("w")) {
+      prev = prev.previousElementSibling;
+    }
+    return prev;
+  }
+
+  /**
+   * Process a single .n token and determine its semantic type
+   */
+  function classifyNameToken(span) {
+    var text = span.textContent.trim();
+    if (!text) return null;
+
+    var next = getNextNonWhitespace(span);
+    var prev = getPrevNonWhitespace(span);
+    var nextText = next ? next.textContent.trim() : "";
+    var prevText = prev ? prev.textContent.trim() : "";
+    var nextClass = getClassList(next);
+    var prevClass = getClassList(prev);
+
+    // Method call: followed by (
+    // Pattern: name(
+    if (nextClass.includes("p") && nextText === "(") {
+      return "n-method";
+    }
+
+    // Generic method or type: followed by < (operator)
+    // Need to check if it's eventually followed by ( for method
+    if (nextClass.includes("o") && nextText.startsWith("<")) {
+      // Look ahead to see if there's a ( after the generic parameters
+      var lookahead = next;
+      var depth = 0;
+      var iterations = 0;
+
+      while (lookahead && iterations < MAX_LOOKAHEAD) {
+        iterations++;
+        var t = lookahead.textContent.trim();
+
+        // Count generic bracket depth
+        if (t === "<") depth++;
+        if (t === ">") depth--;
+
+        // Found ( after closing all generics - it's a method
+        if (depth === 0 && t === "(") {
+          return "n-method";
+        }
+
+        // Went negative or found definitive end
+        if (depth < 0) break;
+
+        lookahead = lookahead.nextElementSibling;
+
+        // Stop at comments or end of line
+        var lookaheadClass = getClassList(lookahead);
+        if (lookaheadClass.includes("c1") || lookaheadClass.includes("cm")) {
+          break;
+        }
+      }
+      // If no ( found, it's likely a type
+      return "n-type";
+    }
+
+    // Parameter: after another .n token (the type) and followed by , or ) or =
+    if (
+      (nextText === "," || nextText === ")" || nextText === "=") &&
+      prevClass.includes("n") &&
+      isCamelCase(text)
+    ) {
+      return "n-param";
+    }
+
+    // Parameter: after > (closing generic) and followed by , or ) or =
+    if (
+      (nextText === "," || nextText === ")" || nextText === "=") &&
+      prevText === ">" &&
+      isCamelCase(text)
+    ) {
+      return "n-param";
+    }
+
+    // Parameter: after ] (array type like int[]) and followed by , or ) or =
+    if (
+      (nextText === "," || nextText === ")" || nextText === "=") &&
+      prevText === "]" &&
+      isCamelCase(text)
+    ) {
+      return "n-param";
+    }
+
+    // Parameter: after ? (nullable type like int?) and followed by , or ) or =
+    if (
+      (nextText === "," || nextText === ")" || nextText === "=") &&
+      prevText === "?" &&
+      isCamelCase(text)
+    ) {
+      return "n-param";
+    }
+
+    // Parameter: after out/ref/in keywords
+    if (
+      prevClass.includes("k") &&
+      (prevText === "out" || prevText === "ref" || prevText === "in") &&
+      isCamelCase(text)
+    ) {
+      return "n-param";
+    }
+
+    // Type: PascalCase identifiers in various contexts
+    if (isPascalCase(text)) {
+      // After a keyword, it's likely a type (e.g., "class Foo", "new Bar")
+      if (prevClass.includes("k") || prevClass.includes("kt")) {
+        return "n-type";
+      }
+
+      // At the start of a code line (no previous sibling)
+      if (!prev) {
+        return "n-type";
+      }
+
+      // After punctuation like ( or < or , - likely a type in parameter list
+      if (prevText === "(" || prevText === "<" || prevText === ",") {
+        return "n-type";
+      }
+
+      // After . (dot) - member access, could be nested type or static member
+      if (prevText === ".") {
+        // If followed by < or ( it would have been caught above
+        // Otherwise assume it's a type or type-like member
+        return "n-type";
+      }
+
+      // Default: PascalCase is likely a type
+      return "n-type";
+    }
+
+    // Variable/field: camelCase identifiers not caught above
+    if (isCamelCase(text)) {
+      return "n-var";
+    }
+
+    // Default: leave as-is (don't add any class)
+    return null;
+  }
+
+  /**
+   * Process all C# code blocks on the page
+   */
+  function enhanceCSharpHighlighting() {
+    // Find all C# code blocks - handle both class orderings
+    // .language-csharp.highlight is the actual structure from Pygments
+    var codeBlocks = document.querySelectorAll(
+      ".language-csharp.highlight code, .highlight.language-csharp code"
+    );
+
+    codeBlocks.forEach(function (codeBlock) {
+      // Skip if already processed (idempotency)
+      if (codeBlock.hasAttribute("data-semantic-enhanced")) {
+        return;
+      }
+      codeBlock.setAttribute("data-semantic-enhanced", "true");
+
+      // Find all .n spans (generic Name tokens)
+      var nameSpans = codeBlock.querySelectorAll("span.n");
+
+      nameSpans.forEach(function (span) {
+        var semanticClass = classifyNameToken(span);
+        if (semanticClass) {
+          span.classList.add(semanticClass);
+        }
+      });
+    });
+  }
+
+  // Run when DOM is ready
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", enhanceCSharpHighlighting);
+  } else {
+    enhanceCSharpHighlighting();
+  }
+
+  // Also run on navigation (for single-page app behavior in Material)
+  if (typeof document$ !== "undefined") {
+    document$.subscribe(function () {
+      enhanceCSharpHighlighting();
+    });
+  }
+})();

package/site/javascripts/csharp-highlight.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ac7e2bdb826842b49909c33ad5e03a52
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/site/javascripts/mermaid-config.js

@@ -0,0 +1,350 @@
+/**
+ * Mermaid theme-aware configuration for MkDocs Material
+ *
+ * This script:
+ * 1. Detects the current MkDocs Material theme (light vs slate/dark)
+ * 2. Initializes Mermaid with appropriate theme variables
+ * 3. Listens for theme changes and re-renders diagrams
+ * 4. Uses semantic class-based styling that works with both themes
+ *
+ * For GitHub/VSCode markdown preview fallback, diagrams include:
+ * %%{init: {'theme': 'dark'}}%%
+ *
+ * This provides consistent dark-themed diagrams in GitHub markdown preview
+ * while MkDocs Material dynamically adjusts themes based on user preference.
+ */
+
+(function () {
+  "use strict";
+
+  // Color palettes for light and dark themes
+  // These provide semantic colors for diagram elements
+  const lightTheme = {
+    // Base colors
+    primaryColor: "#e3f2fd", // Light blue background
+    primaryTextColor: "#1565c0", // Dark blue text
+    primaryBorderColor: "#1976d2", // Blue border
+    // Secondary (success)
+    secondaryColor: "#e8f5e9", // Light green background
+    secondaryTextColor: "#2e7d32", // Dark green text
+    secondaryBorderColor: "#388e3c", // Green border
+    // Tertiary (warning/accent)
+    tertiaryColor: "#fff3e0", // Light orange background
+    tertiaryTextColor: "#c43e00", // Dark orange text (contrast ratio ~5.5:1)
+    tertiaryBorderColor: "#f57c00", // Orange border
+    // Quaternary (danger/red)
+    quaternaryColor: "#ffebee", // Light red background
+    quaternaryTextColor: "#b71c1c", // Dark red text
+    quaternaryBorderColor: "#d32f2f", // Red border
+    // Quinary (accent/purple) - fifth semantic color
+    quinaryColor: "#f3e5f5", // Light purple background
+    quinaryTextColor: "#4a148c", // Dark purple text
+    quinaryBorderColor: "#8e24aa", // Purple border
+    // Neutral colors
+    background: "#ffffff",
+    mainBkg: "#f5f5f5",
+    lineColor: "#37474f",
+    textColor: "#263238",
+    // Flowchart specific
+    nodeBorder: "#1976d2",
+    clusterBkg: "#eceff1",
+    clusterBorder: "#90a4ae",
+    defaultLinkColor: "#37474f",
+    // Sequence diagram specific
+    actorBkg: "#e3f2fd",
+    actorBorder: "#1976d2",
+    actorTextColor: "#1565c0",
+    actorLineColor: "#37474f",
+    signalColor: "#37474f",
+    signalTextColor: "#263238",
+    labelBoxBkgColor: "#eceff1",
+    labelBoxBorderColor: "#90a4ae",
+    labelTextColor: "#263238",
+    loopTextColor: "#263238",
+    noteBorderColor: "#f57c00",
+    noteBkgColor: "#fff3e0",
+    noteTextColor: "#c43e00",
+    activationBorderColor: "#1976d2",
+    activationBkgColor: "#e3f2fd",
+    sequenceNumberColor: "#ffffff",
+  };
+
+  const darkTheme = {
+    // Base colors
+    primaryColor: "#1e3a5f", // Dark blue background
+    primaryTextColor: "#90caf9", // Light blue text
+    primaryBorderColor: "#42a5f5", // Blue border
+    // Secondary (success)
+    secondaryColor: "#1b3d2e", // Dark green background
+    secondaryTextColor: "#81c784", // Light green text
+    secondaryBorderColor: "#66bb6a", // Green border
+    // Tertiary (warning/accent)
+    tertiaryColor: "#3d2e1a", // Dark orange background
+    tertiaryTextColor: "#ffb74d", // Light orange text
+    tertiaryBorderColor: "#ffa726", // Orange border
+    // Quaternary (danger/red)
+    quaternaryColor: "#3d1a1a", // Dark red background
+    quaternaryTextColor: "#ef9a9a", // Light red text
+    quaternaryBorderColor: "#ef5350", // Red border
+    // Quinary (accent/purple) - fifth semantic color
+    quinaryColor: "#2d1f3d", // Dark purple background
+    quinaryTextColor: "#ce93d8", // Light purple text
+    quinaryBorderColor: "#ab47bc", // Purple border
+    // Neutral colors
+    background: "#1e1e1e",
+    mainBkg: "#2d2d2d",
+    lineColor: "#90a4ae",
+    textColor: "#e0e0e0",
+    // Flowchart specific
+    nodeBorder: "#42a5f5",
+    clusterBkg: "#2d2d2d",
+    clusterBorder: "#546e7a",
+    defaultLinkColor: "#90a4ae",
+    // Sequence diagram specific
+    actorBkg: "#1e3a5f",
+    actorBorder: "#42a5f5",
+    actorTextColor: "#90caf9",
+    actorLineColor: "#90a4ae",
+    signalColor: "#90a4ae",
+    signalTextColor: "#e0e0e0",
+    labelBoxBkgColor: "#2d2d2d",
+    labelBoxBorderColor: "#546e7a",
+    labelTextColor: "#e0e0e0",
+    loopTextColor: "#e0e0e0",
+    noteBorderColor: "#ffa726",
+    noteBkgColor: "#3d2e1a",
+    noteTextColor: "#ffb74d",
+    activationBorderColor: "#42a5f5",
+    activationBkgColor: "#1e3a5f",
+    sequenceNumberColor: "#1e1e1e",
+  };
+
+  /**
+   * Detect if dark theme is currently active
+   * MkDocs Material uses data-md-color-scheme attribute on body
+   */
+  function isDarkTheme() {
+    const scheme = document.body.getAttribute("data-md-color-scheme");
+    return scheme === "slate";
+  }
+
+  /**
+   * Get the current theme configuration
+   */
+  function getThemeConfig() {
+    return isDarkTheme() ? darkTheme : lightTheme;
+  }
+
+  /**
+   * Build Mermaid configuration object with current theme
+   * @param {Object} options - Optional overrides for sequence diagram settings
+   * @returns {Object} Mermaid configuration object
+   */
+  function buildMermaidConfig(options = {}) {
+    const themeVars = getThemeConfig();
+    const sequenceDefaults = {
+      useMaxWidth: true,
+      wrap: true,
+    };
+
+    return {
+      startOnLoad: false,
+      theme: "base",
+      themeVariables: themeVars,
+      flowchart: {
+        htmlLabels: true,
+        curve: "basis",
+        useMaxWidth: true,
+      },
+      sequence: {
+        ...sequenceDefaults,
+        diagramMarginX: 50,
+        diagramMarginY: 10,
+        actorMargin: 50,
+        boxMargin: 10,
+        boxTextMargin: 5,
+        noteMargin: 10,
+        messageMargin: 35,
+        ...options.sequence,
+      },
+      securityLevel: "loose",
+    };
+  }
+
+  /**
+   * Initialize or reinitialize Mermaid with the current theme
+   */
+  function initMermaid() {
+    if (typeof mermaid === "undefined") {
+      // Mermaid not loaded yet, wait and retry
+      setTimeout(initMermaid, 100);
+      return;
+    }
+
+    mermaid.initialize(buildMermaidConfig());
+    renderDiagrams();
+  }
+
+  /**
+   * Render all Mermaid diagrams on the page
+   */
+  async function renderDiagrams() {
+    if (typeof mermaid === "undefined") {
+      return;
+    }
+
+    const diagrams = document.querySelectorAll(".mermaid:not([data-processed])");
+
+    for (let i = 0; i < diagrams.length; i++) {
+      const element = diagrams[i];
+      const graphDefinition = element.textContent || element.innerText;
+
+      // Skip if already processed or empty
+      if (!graphDefinition.trim()) {
+        continue;
+      }
+
+      try {
+        // Generate unique ID for this diagram
+        const id = `mermaid-diagram-${Date.now()}-${i}`;
+
+        // Render the diagram
+        const { svg } = await mermaid.render(id, graphDefinition);
+        element.innerHTML = svg;
+        element.setAttribute("data-processed", "true");
+      } catch (error) {
+        console.error("Mermaid rendering error:", error);
+        // Show user-friendly error message styled for current theme
+        const errorColor = isDarkTheme() ? "#ff6b6b" : "#c62828";
+        const bgColor = isDarkTheme() ? "#3d1a1a" : "#ffebee";
+        const borderColor = isDarkTheme() ? "#ef5350" : "#d32f2f";
+        element.innerHTML = `<div style="padding: 1rem; border: 1px solid ${borderColor}; border-radius: 4px; background: ${bgColor}; color: ${errorColor}; font-family: system-ui, sans-serif;">⚠️ Diagram failed to render. Check console for details.</div>`;
+      }
+    }
+  }
+
+  /**
+   * Re-render all diagrams (used after theme change)
+   */
+  async function reRenderDiagrams() {
+    if (typeof mermaid === "undefined") {
+      return;
+    }
+
+    // Reinitialize mermaid with new theme using shared config
+    mermaid.initialize(buildMermaidConfig());
+
+    // Find all processed diagrams and re-render them
+    const diagrams = document.querySelectorAll(".mermaid[data-processed]");
+
+    for (let i = 0; i < diagrams.length; i++) {
+      const element = diagrams[i];
+
+      // Get original source from data attribute or SVG title
+      const originalSource = element.getAttribute("data-original-source");
+      if (!originalSource) {
+        continue;
+      }
+
+      try {
+        const id = `mermaid-rerender-${Date.now()}-${i}`;
+        const { svg } = await mermaid.render(id, originalSource);
+        element.innerHTML = svg;
+      } catch (error) {
+        console.error("Mermaid re-rendering error:", error);
+      }
+    }
+  }
+
+  /**
+   * Store original diagram sources before first render
+   */
+  function storeOriginalSources() {
+    const diagrams = document.querySelectorAll(".mermaid:not([data-original-source])");
+    diagrams.forEach((element) => {
+      const source = element.textContent || element.innerText;
+      if (source.trim()) {
+        element.setAttribute("data-original-source", source.trim());
+      }
+    });
+  }
+
+  /**
+   * Create a debounced version of a function
+   * @param {Function} func - Function to debounce
+   * @param {number} wait - Milliseconds to wait before invoking
+   * @returns {Function} Debounced function
+   */
+  function debounce(func, wait) {
+    let timeoutId = null;
+    return function (...args) {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        func.apply(this, args);
+        timeoutId = null;
+      }, wait);
+    };
+  }
+
+  /**
+   * Set up theme change observer with debouncing
+   */
+  function observeThemeChanges() {
+    // Debounce re-renders to prevent rapid theme toggle issues.
+    // 150ms chosen as a balance: fast enough to feel responsive to users,
+    // but slow enough to coalesce rapid theme toggles and avoid redundant renders.
+    // Lower values (50-100ms) may cause double-renders; higher values (200ms+) feel sluggish.
+    const debouncedReRender = debounce(reRenderDiagrams, 150);
+
+    // MkDocs Material changes the data-md-color-scheme attribute on the body
+    const observer = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (
+          mutation.type === "attributes" &&
+          mutation.attributeName === "data-md-color-scheme"
+        ) {
+          // Theme changed, re-render diagrams (debounced)
+          debouncedReRender();
+          break;
+        }
+      }
+    });
+
+    observer.observe(document.body, {
+      attributes: true,
+      attributeFilter: ["data-md-color-scheme"],
+    });
+  }
+
+  /**
+   * Initialize everything when DOM is ready
+   */
+  function init() {
+    // Store original sources before any rendering
+    storeOriginalSources();
+
+    // Initialize Mermaid
+    initMermaid();
+
+    // Set up theme change observer
+    observeThemeChanges();
+
+    // Also handle MkDocs instant navigation (if enabled)
+    // MkDocs fires a 'DOMContentLoaded'-like event when new content loads
+    if (typeof document$ !== "undefined") {
+      document$.subscribe(function () {
+        storeOriginalSources();
+        initMermaid();
+      });
+    }
+  }
+
+  // Wait for DOM to be ready
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();

package/site/javascripts/mermaid-config.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b7eec37fc321d0a458665ab3ac3b7e01
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/site/javascripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d6e05423e497da8419f957db98cba2e6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: