pymdownx-mahjong 1.0.0__py3-none-any.whl

pymdownx_mahjong/css/mahjong.css

@@ -0,0 +1,416 @@
+:root {
+    --mahjong-tile-width: 1.8rem;
+    --mahjong-tile-height: 2.4rem;
+    --mahjong-tile-gap: 0.05rem;
+    --mahjong-meld-gap: 1.5rem;
+    --mahjong-bg: transparent;
+    --mahjong-border: transparent;
+    --mahjong-caption-color: #000;
+    --mahjong-error-bg: #fee2e2;
+    --mahjong-error-border: #ef4444;
+    --mahjong-error-color: #991b1b;
+    --mahjong-tile-bg: #f5f0eb;
+    --mahjong-tile-border: #8b8b7a;
+    --mahjong-tile-shadow: rgba(0, 0, 0, 0.15);
+    --mahjong-tile-radius: 4px;
+}
+
+[data-md-color-scheme="slate"],
+[data-theme="dark"],
+.dark {
+    --mahjong-caption-color: #fff;
+    --mahjong-error-bg: #450a0a;
+    --mahjong-error-border: #dc2626;
+    --mahjong-error-color: #fca5a5;
+    --mahjong-tile-bg: #1e1e1e;
+    --mahjong-tile-border: #9a9a8a;
+    --mahjong-tile-shadow: rgba(0, 0, 0, 0.3);
+}
+
+/* Theme-specific tile visibility for auto-switching */
+.mahjong-tile-light {
+    display: contents;
+}
+
+.mahjong-tile-dark {
+    display: none;
+}
+
+[data-md-color-scheme="slate"] .mahjong-tile-light,
+[data-theme="dark"] .mahjong-tile-light,
+.dark .mahjong-tile-light {
+    display: none;
+}
+
+[data-md-color-scheme="slate"] .mahjong-tile-dark,
+[data-theme="dark"] .mahjong-tile-dark,
+.dark .mahjong-tile-dark {
+    display: contents;
+}
+
+/* Main container */
+.mahjong-hand {
+    display: block;
+    margin: 1em 0;
+    padding: 0.5em 0.5em 0.5em 0;
+    background: var(--mahjong-bg);
+    border: 1px solid var(--mahjong-border);
+    border-radius: 4px;
+}
+
+/* Override MkDocs Material theme figure margins */
+.md-typeset .mahjong-hand {
+    margin-left: 1rem;
+}
+
+/* Hand row - contains left (tiles/melds), draw, and right (dora) sections */
+.mahjong-hand-row {
+    display: flex;
+    flex-wrap: nowrap;
+    align-items: flex-end;
+}
+
+/* Left section - closed tiles and melds */
+.mahjong-hand-left {
+    flex: 0 0 auto;
+}
+
+/* Draw tile section - separated from main hand */
+.mahjong-hand-draw {
+    flex: 0 0 auto;
+    margin-left: calc(var(--mahjong-meld-gap) * 0.75);
+    position: relative;
+}
+
+/* Draw label floats above the drawn tile */
+.mahjong-hand-draw::before {
+    content: "Draw";
+    position: absolute;
+    bottom: calc(90% + 0.25em);
+    left: 50%;
+    transform: translateX(-50%);
+    font-size: 0.75em;
+    font-weight: 600;
+    color: var(--mahjong-caption-color);
+    white-space: nowrap;
+    pointer-events: none;
+}
+
+/* Melds section - after draw tile */
+.mahjong-hand-melds {
+    flex: 0 0 auto;
+    margin-left: calc(var(--mahjong-meld-gap) * 0.75);
+}
+
+/* Tiles container - flexbox layout */
+.mahjong-tiles {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-end;
+    gap: var(--mahjong-tile-gap);
+}
+
+/* Individual tile - styled like physical riichi tiles */
+.mahjong-tile {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: var(--mahjong-tile-width);
+    height: var(--mahjong-tile-height);
+    vertical-align: bottom;
+    flex-shrink: 0;
+    background: var(--mahjong-tile-bg);
+    border: 2px solid var(--mahjong-tile-border);
+    border-radius: 6px;
+    box-shadow:
+        1px 2px 3px var(--mahjong-tile-shadow),
+        inset 0 1px 0 rgba(255, 255, 255, 0.3);
+    padding: 2px;
+    box-sizing: border-box;
+    position: relative;
+}
+
+.mahjong-tile svg,
+.mahjong-tile img {
+    width: 100%;
+    height: 100%;
+    display: block;
+}
+
+.mahjong-tile img {
+    object-fit: contain;
+}
+
+/* Rotated tile (called from another player) */
+.mahjong-tile-rotated {
+    transform: rotate(90deg);
+    margin-left: calc(var(--mahjong-tile-gap) * 6);
+    margin-right: calc(var(--mahjong-tile-gap) * 6);
+    position: relative;
+    top: calc((var(--mahjong-tile-height) - var(--mahjong-tile-width)) / 2);
+}
+
+/* Stacked tiles container for added kan (shouminkan) */
+.mahjong-tile-stack {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: flex-end;
+    width: var(--mahjong-tile-height);
+    vertical-align: bottom;
+    margin-left: calc(var(--mahjong-tile-gap) * 1.5);
+    margin-right: calc(var(--mahjong-tile-gap) * 1.5);
+}
+
+/* Rotated tiles inside the stack */
+.mahjong-tile-stack .mahjong-tile-rotated {
+    margin: 0;
+    margin-top: calc(
+        -1 * (var(--mahjong-tile-height) - var(--mahjong-tile-width)) / 2
+    );
+    margin-bottom: calc(
+        -1 * (var(--mahjong-tile-height) - var(--mahjong-tile-width)) / 2
+    );
+    top: 0;
+}
+
+/* Gap between the two stacked tiles */
+.mahjong-tile-stack .mahjong-tile-rotated:first-child {
+    margin-bottom: calc(
+        var(--mahjong-tile-gap) -
+            (var(--mahjong-tile-height) - var(--mahjong-tile-width)) / 2
+    );
+}
+
+/* Unknown/placeholder tile */
+.mahjong-tile-unknown {
+    font-size: 1.5em;
+    color: #999;
+}
+
+/* Meld container */
+.mahjong-meld {
+    display: inline-flex;
+    align-items: flex-end;
+    gap: var(--mahjong-tile-gap);
+}
+
+/* Back tile - SVG contains full tile design */
+.mahjong-tile-back {
+    background: none;
+    border: 0.5px solid transparent;
+    box-shadow: none;
+    padding: 0;
+    margin: 0 0.05rem;
+}
+
+/* Remove left margin when back tiles are adjacent */
+.mahjong-tile-back + .mahjong-tile-back {
+    margin-left: 0;
+}
+
+/* Dora row - contains dora and uradora on same line, above hand */
+.mahjong-dora-row {
+    display: flex;
+    align-items: center;
+    gap: 1.5em;
+    margin-bottom: 0.5em;
+}
+
+/* Dora tiles at 80% size */
+.mahjong-dora-row .mahjong-tile {
+    width: calc(var(--mahjong-tile-width) * 0.8);
+    height: calc(var(--mahjong-tile-height) * 0.8);
+}
+
+/* Dora indicators */
+.mahjong-dora {
+    display: flex;
+    align-items: center;
+}
+
+.mahjong-dora-label {
+    font-size: 0.9em;
+    font-weight: 600;
+    margin-right: 0.5em;
+    color: var(--mahjong-caption-color);
+    white-space: nowrap;
+}
+
+.mahjong-dora-tiles {
+    display: inline-flex;
+    align-items: flex-end;
+    gap: var(--mahjong-tile-gap);
+}
+
+/* Caption/title below the hand */
+.mahjong-caption {
+    display: block;
+    margin-top: 0.75em;
+    font-size: 0.9em;
+    color: var(--mahjong-caption-color);
+    text-align: center;
+}
+
+/* Higher specificity override for MkDocs */
+.md-typeset .mahjong-hand .mahjong-dora-label,
+.md-typeset .mahjong-hand .mahjong-caption,
+.md-typeset figure.mahjong-hand figcaption {
+    color: var(--mahjong-caption-color);
+}
+
+/* Error display */
+.mahjong-error {
+    display: inline-block;
+    padding: 0.75em 1em;
+    background: var(--mahjong-error-bg);
+    border: 1px solid var(--mahjong-error-border);
+    border-radius: 4px;
+    color: var(--mahjong-error-color);
+    font-family: monospace;
+    font-size: 0.9em;
+}
+
+.mahjong-error strong {
+    color: var(--mahjong-error-border);
+}
+
+/* Size variants */
+.mahjong-hand-small {
+    --mahjong-tile-width: 30px;
+    --mahjong-tile-height: 40px;
+    --mahjong-tile-gap: 1px;
+    --mahjong-meld-gap: 8px;
+}
+
+.mahjong-hand-large {
+    --mahjong-tile-width: 60px;
+    --mahjong-tile-height: 80px;
+    --mahjong-tile-gap: 3px;
+    --mahjong-meld-gap: 16px;
+}
+
+.mahjong-hand-xlarge {
+    --mahjong-tile-width: 75px;
+    --mahjong-tile-height: 100px;
+    --mahjong-tile-gap: 4px;
+    --mahjong-meld-gap: 20px;
+}
+
+/* Responsive adjustments for mobile devices */
+@media (max-width: 768px) {
+    .mahjong-hand {
+        --mahjong-tile-width: 1.4rem;
+        --mahjong-tile-height: 1.87rem;
+        --mahjong-tile-gap: 1px;
+        --mahjong-meld-gap: 0.5rem;
+    }
+
+    .mahjong-tile {
+        border-width: 1px;
+        border-radius: 3px;
+        padding: 1px;
+    }
+
+    .mahjong-dora-label {
+        font-size: 0.75em;
+    }
+
+    .mahjong-hand-draw::before {
+        font-size: 0.65em;
+    }
+}
+
+@media (max-width: 480px) {
+    .mahjong-hand {
+        --mahjong-tile-width: 1.1rem;
+        --mahjong-tile-height: 1.47rem;
+        --mahjong-tile-gap: 0.5px;
+        --mahjong-meld-gap: 0.35rem;
+    }
+
+    .mahjong-tile {
+        border-width: 1px;
+        border-radius: 2px;
+        padding: 0.5px;
+    }
+
+    .mahjong-dora-row {
+        gap: 0.75em;
+    }
+
+    .mahjong-dora-label {
+        font-size: 0.65em;
+        margin-right: 0.25em;
+    }
+
+    .mahjong-hand-draw::before {
+        font-size: 0.6em;
+    }
+
+    .mahjong-caption {
+        font-size: 0.8em;
+    }
+}
+
+@media (max-width: 360px) {
+    .mahjong-hand {
+        --mahjong-tile-width: 0.9rem;
+        --mahjong-tile-height: 1.2rem;
+        --mahjong-tile-gap: 0.25px;
+        --mahjong-meld-gap: 0.25rem;
+        padding: 0.25em 0.25em 0.25em 0;
+    }
+
+    .mahjong-tile {
+        border-width: 1px;
+        border-radius: 2px;
+        padding: 0;
+    }
+
+    .mahjong-dora-row {
+        gap: 0.5em;
+        margin-bottom: 0.35em;
+    }
+
+    .mahjong-dora-label {
+        font-size: 0.6em;
+    }
+
+    .mahjong-hand-draw::before {
+        font-size: 0.55em;
+    }
+
+    .mahjong-caption {
+        font-size: 0.75em;
+        margin-top: 0.5em;
+    }
+}
+
+/* Print styles */
+@media print {
+    .mahjong-hand {
+        break-inside: avoid;
+    }
+}
+
+/* Inline tile styles (emoji-sized) */
+.mahjong-inline {
+    display: inline;
+}
+
+.mahjong-inline .mahjong-tile {
+    --mahjong-tile-width: 1.8em;
+    --mahjong-tile-height: 2.4em;
+    display: inline-flex;
+    vertical-align: text-bottom;
+    margin: 0 0.05em;
+    border-width: 1px;
+    border-radius: 3px;
+    padding: 1px;
+    box-shadow: 0 1px 2px var(--mahjong-tile-shadow);
+}
+
+.mahjong-inline .mahjong-tile + .mahjong-tile {
+    margin-left: 0;
+}

pymdownx_mahjong/extension.py

@@ -0,0 +1,206 @@
+"""Python Markdown extension to render and stylize Mahjong tiles."""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as etree
+from typing import TYPE_CHECKING, Any
+
+import markdown
+from markdown.blockprocessors import BlockProcessor
+
+from .inline import INLINE_TILE_PATTERN, MahjongInlineProcessor
+from .parser import MahjongParser, ParseError
+from .renderer import MahjongRenderer
+from .utils import apply_hand_options, parse_block_content
+
+if TYPE_CHECKING:
+    from markdown import Markdown
+    from markdown.blockparser import BlockParser
+
+
+class MahjongBlockProcessor(BlockProcessor):
+    """Block processor that handles ```mahjong fenced code blocks.
+
+    Converts mahjong notation blocks into HTML.
+    """
+
+    # Pattern to match the start of a mahjong block
+    START_PATTERN = re.compile(r"^`{3,}mahjong\s*$")
+    END_PATTERN = re.compile(r"^`{3,}\s*$")
+
+    md: Markdown
+
+    def __init__(self, parser: BlockParser, config: dict[str, Any]) -> None:
+        """Initialize the block processor.
+
+        Args:
+            parser: Block parser instance
+            config: Extension configuration
+        """
+        super().__init__(parser)
+        self.config = config
+        self.mj_parser = MahjongParser()
+        self.renderer = MahjongRenderer(
+            theme=config.get("theme", "light"),
+            css_class=config.get("css_class", "mahjong-hand"),
+            show_labels=config.get("show_labels", True),
+            inline_svg=config.get("inline_svg", True),
+            assets_path=config.get("assets_path"),
+        )
+
+    def test(self, parent: etree.Element, block: str) -> bool:
+        """Test if this block should be processed.
+
+        Args:
+            parent: Parent element
+            block: Block text
+
+        Returns:
+            True if block starts with ```mahjong
+        """
+        return bool(self.START_PATTERN.match(block.split("\n")[0]))
+
+    def run(self, parent: etree.Element, blocks: list[str]) -> bool:
+        """Process the mahjong block.
+
+        Args:
+            parent: Parent element
+            blocks: List of blocks
+
+        Returns:
+            True if block was processed
+        """
+        block = blocks.pop(0)
+        lines = block.split("\n")
+
+        # Find the end of the fenced block
+        content_lines: list[str] = []
+        fence_closed = False
+
+        # Skip the opening fence
+        for i, line in enumerate(lines[1:], 1):
+            if self.END_PATTERN.match(line):
+                fence_closed = True
+                # Put remaining lines back
+                remaining = "\n".join(lines[i + 1 :])
+                if remaining.strip():
+                    blocks.insert(0, remaining)
+                break
+            content_lines.append(line)
+
+        # If fence wasn't closed in this block, check subsequent blocks
+        if not fence_closed:
+            while blocks:
+                next_block = blocks.pop(0)
+                next_lines = next_block.split("\n")
+                for i, line in enumerate(next_lines):
+                    if self.END_PATTERN.match(line):
+                        fence_closed = True
+                        remaining = "\n".join(next_lines[i + 1 :])
+                        if remaining.strip():
+                            blocks.insert(0, remaining)
+                        break
+                    content_lines.append(line)
+                if fence_closed:
+                    break
+
+        content = "\n".join(content_lines).strip()
+
+        # Parse block content
+        notation, options = parse_block_content(content)
+
+        if not notation:
+            self._render_error(parent, "No hand notation provided")
+            return True
+
+        try:
+            hand = self.mj_parser.parse(notation)
+        except ParseError as e:
+            self._render_error(parent, str(e))
+            return True
+
+        apply_hand_options(hand, self.mj_parser, options)
+
+        # Render the hand
+        html = self.renderer.render(
+            hand,
+            title=options.get("title"),
+            notation=notation,
+        )
+
+        # Store the raw HTML and use a placeholder that survives processing
+        placeholder = self.md.htmlStash.store(html)
+        p = etree.SubElement(parent, "div")
+        p.text = placeholder
+
+        return True
+
+    def _render_error(self, parent: etree.Element, message: str) -> None:
+        """Render an error message.
+
+        Args:
+            parent: Parent element
+            message: Error message
+        """
+        div = etree.SubElement(parent, "div")
+        div.set("class", "mahjong-error")
+        strong = etree.SubElement(div, "strong")
+        strong.text = "Mahjong Error: "
+        strong.tail = message
+
+
+class MahjongExtension(markdown.Extension):
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the extension with configuration.
+
+        Args:
+            **kwargs: Configuration options
+        """
+        # Define configuration options with defaults
+        self.config = {
+            "theme": ["auto", "Color theme: 'light', 'dark', or 'auto'"],
+            "css_class": ["mahjong-hand", "CSS class for container"],
+            "show_labels": [True, "Show tile names as title attributes"],
+            "inline_svg": [True, "Inline SVG content vs img tags"],
+            "assets_path": ["", "Custom path to SVG assets"],
+            "enable_inline": [True, "Enable inline tile syntax (:1m:)"],
+        }
+        super().__init__(**kwargs)
+
+    def extendMarkdown(self, md: Markdown) -> None:
+        """Register the extension with the Markdown instance.
+
+        Args:
+            md: Markdown instance
+        """
+        # Get configuration values
+        config = {key: self.getConfig(key) for key in self.config}
+
+        # Register block processor at high priority (before fenced_code)
+        processor = MahjongBlockProcessor(md.parser, config)
+        processor.md = md
+        md.parser.blockprocessors.register(processor, "mahjong", 110)
+
+        # Register inline processor if enabled
+        # Priority 76 to run before pymdownx.emoji (which uses 75)
+        if config.get("enable_inline", True):
+            inline_processor = MahjongInlineProcessor(INLINE_TILE_PATTERN, md, config)
+            md.inlinePatterns.register(inline_processor, "mahjong_inline", 76)
+
+        # Reset on each conversion
+        md.registerExtension(self)
+
+
+def makeExtension(**kwargs: Any) -> MahjongExtension:
+    """Create the extension instance.
+
+    This is the entry point called by Python Markdown.
+
+    Args:
+        **kwargs: Configuration options
+
+    Returns:
+        MahjongExtension instance
+    """
+    return MahjongExtension(**kwargs)

pymdownx_mahjong/inline.py

@@ -0,0 +1,78 @@
+"""Inline processor for Mahjong tile notation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from markdown.inlinepatterns import InlineProcessor
+
+from .parser import MahjongParser, ParseError
+from .renderer import MahjongRenderer
+
+if TYPE_CHECKING:
+    import re
+
+    from markdown import Markdown
+
+# Pattern matches :123m:, :1z:, :0m: (red dora), etc.
+# Must be valid MPSZ: one or more groups of digits followed by m/p/s/z
+# Examples: :1m:, :123p:, :5z:, :0s:, :123m456p:
+INLINE_TILE_PATTERN = r":([0-9]+[mpsz])+:"
+
+
+class MahjongInlineProcessor(InlineProcessor):
+    """Inline processor for mahjong tile notation.
+
+    Matches patterns like :1m:, :123m:, :123m456p:
+    Renders emoji-sized tiles inline with text.
+    """
+
+    def __init__(self, pattern: str, md: Markdown, config: dict[str, Any]) -> None:
+        """Initialize the inline processor.
+
+        Args:
+            pattern: Regex pattern to match
+            md: Markdown instance
+            config: Extension configuration
+        """
+        super().__init__(pattern, md)
+        self.config = config
+        self.parser = MahjongParser()
+        self.renderer = MahjongRenderer(
+            theme=config.get("theme", "auto"),
+            css_class="mahjong-inline",
+            show_labels=config.get("show_labels", True),
+            inline_svg=config.get("inline_svg", True),
+            assets_path=config.get("assets_path"),
+        )
+
+    def handleMatch(self, m: re.Match, data: str) -> tuple[str | None, int | None, int | None]:
+        """Handle matched inline tile notation.
+
+        Args:
+            m: Match object
+            data: Full text being processed
+
+        Returns:
+            Tuple of (placeholder, start_index, end_index) or (None, None, None) if invalid
+        """
+        # Extract notation without colons
+        full_match = m.group(0)
+        notation = full_match[1:-1]  # Strip leading/trailing colons
+
+        try:
+            tiles = self.parser.parse_tiles(notation)
+        except ParseError:
+            # Invalid notation - return None to leave text unchanged
+            return None, None, None
+
+        if not tiles:
+            return None, None, None
+
+        # Render tiles as HTML
+        html = self.renderer.render_tiles(tiles)
+
+        # Store raw HTML and return placeholder
+        placeholder = self.md.htmlStash.store(html)
+
+        return placeholder, m.start(0), m.end(0)