decktile 0.2.0__py3-none-any.whl

decktile/parser/markdown.py

@@ -0,0 +1,289 @@
+"""Markdown parser using markdown-it-py with plugin extensions."""
+
+import re
+import frontmatter
+from markdown_it import MarkdownIt
+from markdown_it.token import Token
+
+from decktile.parser.ast import (
+    Document, Meta, Slide,
+    Heading, Paragraph, CodeBlock, Card, Grid, Table, Quote, ListNode, AttrNode,
+    Text, Strong, Emphasis, Strikethrough, CodeSpan, Image, SoftBreak, LucideIcon,
+)
+from decktile.plugins.fenced import extract_fenced, interleave_fences
+from decktile.plugins.directives import preprocess_directives, extract_attrs, parse_attr_token
+from decktile.plugins.lucide import lucide_plugin
+from decktile.plugins.cards import group_cards
+
+# Renders a table cell's inline tokens to HTML (bold, code, links, icons).
+# Concatenating token .content dropped every inline markup.
+_CELL_MD = MarkdownIt("gfm-like", {"html": True}).use(lucide_plugin)
+
+
+def parse(input_text: str) -> Document:
+    post = frontmatter.loads(input_text)
+    raw_meta = dict(post.metadata)
+    style_raw = raw_meta.pop("style", "") or ""
+    logo_raw = raw_meta.pop("logo", "") or ""
+    logo_dark_raw = raw_meta.pop("logo_dark", "") or ""
+    watermark_raw = raw_meta.pop("watermark", "") or ""
+    background_raw = raw_meta.pop("background", "") or ""
+
+    meta = Meta(
+        theme=raw_meta.pop("theme", ""),
+        title=raw_meta.pop("title", ""),
+        footer=raw_meta.pop("footer", ""),
+        paginate=raw_meta.pop("paginate", False),
+        size=raw_meta.pop("size", "16:9"),
+        style=style_raw,
+        logo=logo_raw,
+        logo_dark=logo_dark_raw,
+        watermark=watermark_raw,
+        background=background_raw,
+        pygments_style=raw_meta.pop("pygments_style", "default"),
+        seaborn_theme=raw_meta.pop("seaborn_theme", None) or Meta.seaborn_theme,
+        theme_variant=raw_meta.pop("variant", Meta.theme_variant),
+        transition=raw_meta.pop("transition", Meta.transition),
+        autoplay=raw_meta.pop("autoplay", Meta.autoplay),
+    )
+
+    body = post.content
+    slides = []
+    for part in body.split("\n---\n"):
+        part = part.strip()
+        if not part:
+            continue
+        slide = _parse_slide(part)
+        if slide is not None:
+            slides.append(slide)
+
+    return Document(meta=meta, slides=slides)
+
+
+def _parse_slide(content: str) -> Slide:
+    notes = ""
+    # Collect all HTML comments as speaker notes
+    note_parts = re.findall(r"<!--(?!attr:)(.*?)-->", content, flags=re.DOTALL)
+    if note_parts:
+        blocks = []
+        for p in note_parts:
+            raw_lines = p.splitlines()
+            is_single_line = len(raw_lines) <= 1
+            lines = [line.rstrip() for line in raw_lines]
+            while lines and not lines[0].strip():
+                lines.pop(0)
+            while lines and not lines[-1].strip():
+                lines.pop()
+            if not lines:
+                continue
+            if is_single_line:
+                lines[0] = lines[0].strip()
+            blocks.append("\n".join(lines))
+        notes = "\n\n".join(blocks)
+    # Strip comments from content
+    content = re.sub(r"<!--(?!attr:).*?-->", "", content, flags=re.DOTALL).strip()
+    content = preprocess_directives(content)
+
+    # Extract fenced blocks
+    content, fence_nodes = extract_fenced(content)
+
+    md = MarkdownIt("gfm-like", {"breaks": True, "html": True})
+    md.use(lucide_plugin)
+    tokens = md.parse(content)
+    nodes = _tokens_to_nodes(tokens)
+
+    nodes = interleave_fences(nodes, fence_nodes)
+    nodes = extract_attrs(nodes)
+    nodes = group_cards(nodes)
+
+    layout = _detect_layout(nodes)
+    variant = ""
+    transition = ""
+    hidden = False
+    for n in list(nodes):
+        if isinstance(n, AttrNode) and n.type == "layout":
+            layout = n.value.strip()
+            nodes.remove(n)
+        elif isinstance(n, AttrNode) and n.type == "variant":
+            variant = n.value.strip()
+            nodes.remove(n)
+        elif isinstance(n, AttrNode) and n.type == "transition":
+            transition = n.value.strip()
+            nodes.remove(n)
+        elif isinstance(n, AttrNode) and n.type in ("hidden", "hide"):
+            hidden = True
+            nodes.remove(n)
+
+    if hidden:
+        return None
+
+    return Slide(layout=layout, children=nodes, notes=notes, variant=variant, transition=transition)
+
+
+def _tokens_to_nodes(tokens: list[Token]) -> list:
+    nodes = []
+    i = 0
+    while i < len(tokens):
+        token = tokens[i]
+        if token.type == "heading_open":
+            level = int(token.tag[1])
+            i += 1
+            content = []
+            while i < len(tokens) and tokens[i].type != "heading_close":
+                content.extend(_token_inline(tokens[i]))
+                i += 1
+            nodes.append(Heading(level=level, content=content))
+            i += 1
+        elif token.type == "paragraph_open":
+            i += 1
+            content = []
+            while i < len(tokens) and tokens[i].type != "paragraph_close":
+                content.extend(_token_inline(tokens[i]))
+                i += 1
+            if content:
+                nodes.append(Paragraph(content=content))
+            i += 1
+        elif token.type == "blockquote_open":
+            i += 1
+            content = []
+            while i < len(tokens) and tokens[i].type != "blockquote_close":
+                if tokens[i].type == "inline":
+                    content.extend(_token_inline(tokens[i]))
+                i += 1
+            if content:
+                nodes.append(Quote(content=content))
+            i += 1
+        elif token.type == "table_open":
+            rows = []
+            cur = []
+            i += 1
+            while i < len(tokens) and tokens[i].type != "table_close":
+                t = tokens[i]
+                if t.type in ("th_open", "td_open"):
+                    i += 1
+                    cell = ""
+                    while i < len(tokens) and tokens[i].type not in ("th_close", "td_close"):
+                        if tokens[i].type == "inline":
+                            cell += _CELL_MD.renderer.renderInline(
+                                tokens[i].children or [], _CELL_MD.options, {})
+                        else:
+                            cell += tokens[i].content
+                        i += 1
+                    cur.append(cell.strip())
+                elif t.type == "tr_close":
+                    if cur:
+                        rows.append(cur)
+                        cur = []
+                i += 1
+            if cur:
+                rows.append(cur)
+            if rows:
+                nodes.append(Table(headers=rows[0], rows=rows[1:]))
+            i += 1
+        elif token.type in ("bullet_list_open", "ordered_list_open"):
+            close_type = token.type.replace("_open", "_close")
+            items = []
+            i += 1
+            while i < len(tokens) and tokens[i].type != close_type:
+                if tokens[i].type == "list_item_open":
+                    i += 1
+                    inlines = []
+                    while i < len(tokens) and tokens[i].type != "list_item_close":
+                        if tokens[i].type == "inline":
+                            inlines.extend(_token_inline(tokens[i]))
+                        i += 1
+                    items.append(inlines)
+                    i += 1
+                else:
+                    i += 1
+            if items:
+                nodes.append(ListNode(items=items))
+            i += 1
+        elif token.type == "inline":
+            content = _token_inline(token)
+            if content:
+                nodes.append(Paragraph(content=content))
+            i += 1
+        elif token.type == "html_block":
+            html = token.content.strip()
+            node = parse_attr_token(html)
+            if node:
+                nodes.append(node)
+            i += 1
+        elif token.type in ("fence", "code_block"):
+            lang = token.info.strip() if token.info else ""
+            nodes.append(CodeBlock(content=token.content, language=lang))
+            i += 1
+        else:
+            i += 1
+    return nodes
+
+
+def _token_inline(token: Token) -> list:
+    if token.type == "inline":
+        return _walk_inline_children(token.children or [])
+    elif token.type == "text":
+        return [Text(content=token.content)]
+    elif token.type == "code_inline":
+        return [CodeSpan(content=token.content)]
+    elif token.type == "softbreak":
+        return [SoftBreak()]
+    elif token.type == "hardbreak":
+        return [SoftBreak()]
+    elif token.type == "image":
+        attrs = dict(token.attrs or {})
+        return [Image(src=attrs.get("src", ""), alt=token.content or "", title=attrs.get("title", ""))]
+    elif token.type == "lucide_icon" or token.type == "svg":
+        attrs = dict(token.attrs or {})
+        name = attrs.pop("name", "")
+        return [LucideIcon(name=name, attrs=attrs)]
+    return []
+
+
+def _walk_inline_children(tokens: list) -> list:
+    """Walk inline token children, handling strong/em open/close pairs."""
+    result = []
+    i = 0
+    while i < len(tokens):
+        t = tokens[i]
+        if t.type == "strong_open":
+            i += 1
+            inner = []
+            while i < len(tokens) and tokens[i].type != "strong_close":
+                inner.extend(_token_inline(tokens[i]))
+                i += 1
+            result.append(Strong(children=inner))
+        elif t.type == "em_open":
+            i += 1
+            inner = []
+            while i < len(tokens) and tokens[i].type != "em_close":
+                inner.extend(_token_inline(tokens[i]))
+                i += 1
+            result.append(Emphasis(children=inner))
+        elif t.type == "s_open":
+            i += 1
+            inner = []
+            while i < len(tokens) and tokens[i].type != "s_close":
+                inner.extend(_token_inline(tokens[i]))
+                i += 1
+            result.append(Strikethrough(children=inner))
+        else:
+            result.extend(_token_inline(t))
+        i += 1
+    return result
+
+
+def _detect_layout(nodes: list) -> str:
+    has_h1 = any(isinstance(n, Heading) and n.level == 1 for n in nodes)
+    has_kicker = any(isinstance(n, AttrNode) and n.type == "kicker" for n in nodes)
+    has_speaker = any(isinstance(n, AttrNode) and n.type == "speaker" for n in nodes)
+    if has_h1 or has_kicker or has_speaker:
+        return "title"
+    for n in nodes:
+        if isinstance(n, Grid):
+            if n.children and all(
+                isinstance(c, Card) and "metric" in (c.class_ or "") for c in n.children
+            ):
+                return f"metrics-{n.cols}" if n.cols else "metrics-2"
+            return f"grid-{n.cols}" if n.cols else "grid-2"
+    return "content"

decktile/plugins/cards.py

@@ -0,0 +1,25 @@
+"""Card auto-grouping: consecutive Card nodes → Grid."""
+
+from decktile.parser.ast import Card, Grid, Node
+
+
+def group_cards(nodes: list[Node]) -> list[Node]:
+    """Auto-group consecutive Card nodes into a Grid."""
+    result = []
+    i = 0
+    while i < len(nodes):
+        if isinstance(nodes[i], Card):
+            cards = [nodes[i]]
+            j = i + 1
+            while j < len(nodes) and isinstance(nodes[j], Card):
+                cards.append(nodes[j])
+                j += 1
+            if len(cards) >= 2:
+                result.append(Grid(cols=len(cards), children=list(cards)))
+            else:
+                result.append(cards[0])
+            i = j
+        else:
+            result.append(nodes[i])
+            i += 1
+    return result

decktile/plugins/directives.py

@@ -0,0 +1,56 @@
+"""Directive parsing: @kicker, @speaker, @subtitle, etc. → AttrNode."""
+
+import re
+from decktile.parser.ast import AttrNode, Paragraph, Text, Node
+
+
+def preprocess_directives(content: str) -> str:
+    """Convert @directive lines to HTML comment markers."""
+    lines = content.split("\n")
+    result = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("@") and not stripped.startswith("@@"):
+            parts = stripped[1:].split(" ", 1)
+            typ = parts[0]
+            value = parts[1] if len(parts) > 1 else ""
+            result.append(f"<!--attr:{typ}:{value}-->")
+        else:
+            result.append(line)
+    return "\n".join(result)
+
+
+def extract_attrs(nodes: list[Node]) -> list[Node]:
+    """Post-process: convert attr comment markers to AttrNodes."""
+    result = []
+    for node in nodes:
+        if isinstance(node, Paragraph) and len(node.content) == 1:
+            text = node.content[0].content if isinstance(node.content[0], Text) else ""
+            m = re.match(r"<!--attr:([\w-]+):(.*)-->", text)
+            if m:
+                typ, value = m.group(1), m.group(2)
+                attrs = _parse_attrs(value)
+                result.append(AttrNode(type=typ, value=value, attrs=attrs))
+                continue
+        result.append(node)
+    return result
+
+
+def parse_attr_token(html: str) -> AttrNode | None:
+    """Parse a single <!--attr:...--> comment into an AttrNode."""
+    m = re.match(r"<!--attr:([\w-]+):(.*)-->", html)
+    if m:
+        typ, value = m.group(1), m.group(2)
+        return AttrNode(type=typ, value=value, attrs=_parse_attrs(value))
+    return None
+
+
+def _parse_attrs(value: str) -> dict[str, str]:
+    """Parse key="val" and key=val patterns from a value string."""
+    attrs = {}
+    for ma in re.finditer(r'(\w+)="([^"]*)"', value):
+        attrs[ma.group(1)] = ma.group(2)
+    for ma in re.finditer(r'(\w+)=(\S+)', value):
+        if ma.group(1) not in attrs:
+            attrs[ma.group(1)] = ma.group(2)
+    return attrs

decktile/plugins/fenced.py

@@ -0,0 +1,228 @@
+"""Fenced block extraction: ::: card, ::: grid → AST nodes.
+
+Card/grid ``{...}`` attributes: bare words → CSS classes, ``k=v`` → ``k-v`` classes.
+Grid: ``cols=N`` and ``class=name`` used literally.
+"""
+
+import re
+from markdown_it import MarkdownIt
+from decktile.parser.ast import Arrow, Card, CodeBlock, Grid, Node, Notes
+from decktile.plugins.lucide import lucide_plugin
+
+_CARD_MD = MarkdownIt("gfm-like", {"breaks": False, "html": True})
+_CARD_MD.use(lucide_plugin)
+
+_ICON_RE = re.compile(r'\{icon:(\S+)\s*([^}]*)\}')
+
+
+def _expand_icons(text: str) -> str:
+    """Expand {icon:...} markers using the shared lucide plugin renderer."""
+    if not text or "{" not in text:
+        return text
+    from decktile.plugins.lucide import render_icon, _parse_opts
+    def _render(m):
+        return render_icon(m.group(1), _parse_opts(m.group(2)))
+    return _ICON_RE.sub(_render, text)
+
+
+def extract_fenced(content: str) -> tuple[str, list[Node]]:
+    """Extract ::: fence blocks from content, returning cleaned text and nodes."""
+    lines = content.split("\n")
+    result = []
+    nodes = []
+    count = 0
+    i = 0
+    while i < len(lines):
+        t = lines[i].strip()
+        if t == ":::":
+            i += 1
+            continue
+        if t.startswith(":::") and not t.startswith("::::"):
+            rest = t[3:].strip()
+            typ = rest.split()[0].split("{")[0]
+            depth = 1
+            inner = []
+            j = i + 1
+            while j < len(lines) and depth > 0:
+                lt = lines[j].strip()
+                if lt.startswith(":::") and not lt.startswith("::::") and lt != ":::":
+                    depth += 1
+                elif lt == ":::":
+                    depth -= 1
+                if depth > 0:
+                    inner.append(lines[j])
+                j += 1
+            inner_text = "\n".join(inner)
+
+            if typ == "card":
+                nodes.append(_parse_card(inner_text, rest))
+            elif typ == "grid":
+                nodes.append(_parse_grid(inner_text, rest))
+            elif typ == "arrow":
+                nodes.append(_parse_arrow(inner_text))
+            elif typ == "notes":
+                nodes.append(_parse_notes(inner_text, rest))
+
+            # blank lines around the marker: adjacent fences (cards with no
+            # blank line between them) would otherwise merge into one
+            # markdown paragraph, and interleave_fences restores one fence
+            # per marker paragraph -- the rest got appended after every
+            # other block, splitting a card group
+            result.extend(["", f"\u25caFENCE_{count}", ""])
+            count += 1
+            i = j
+            continue
+        result.append(lines[i])
+        i += 1
+
+    return "\n".join(result), nodes
+
+
+def _parse_card(text: str, rest: str = "") -> Card:
+    header = ""
+    body = []
+    children = []
+
+    lines = text.strip().split("\n")
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
+
+        if line.startswith("```"):
+            lang = line[3:].strip()
+            inner = []
+            i += 1
+            while i < len(lines) and not lines[i].strip().startswith("```"):
+                inner.append(lines[i])
+                i += 1
+            children.append(CodeBlock(content="\n".join(inner), language=lang))
+            i += 1  # skip closing ```
+            continue
+        elif line.startswith(":::") and not line.startswith("::::"):
+            depth = 1
+            inner = []
+            j = i + 1
+            while j < len(lines) and depth > 0:
+                lt = lines[j].strip()
+                if lt.startswith(":::") and not lt.startswith("::::") and lt != ":::":
+                    depth += 1
+                elif lt == ":::":
+                    depth -= 1
+                if depth > 0:
+                    inner.append(lines[j])
+                j += 1
+            _, nested = extract_fenced("\n".join(inner))
+            children.extend(nested)
+            i = j
+            continue
+        elif line.startswith("### "):
+            header = _expand_markdown(line[4:])
+        elif line.startswith("- "):
+            items = []
+            while i < len(lines) and lines[i].strip().startswith("- "):
+                li = lines[i].strip()[2:]
+                items.append(f"<li>{_expand_markdown(li)}</li>")
+                i += 1
+            body.append(f"<ul>{''.join(items)}</ul>")
+            continue
+        elif line:
+            rendered = _expand_markdown(line)
+            if rendered.strip():
+                body.append(rendered)
+        i += 1
+
+    class_ = ""
+    tag = None
+    label = ""
+    raw = rest.split("{", 1)[1].rstrip("}") if "{" in rest else ""
+    for attr in raw.split(","):
+        attr = attr.strip()
+        if not attr:
+            continue
+        if "=" in attr:
+            k, v = attr.split("=", 1)
+            k, v = k.strip(), v.strip().strip('"')
+            if k == "tag":
+                tag = v
+            elif k == "label":
+                label = v
+            else:
+                class_ = (class_ + f" {k}-{v}").strip()
+        else:
+            class_ = (class_ + " " + attr).strip() if class_ else attr
+
+    # ponytail: metric cards: first non-empty line is the value, rest is the label
+    if "metric" in class_ and not header and body:
+        header = body.pop(0)
+
+    return Card(header=header, body=body, children=children, tag=tag, class_=class_, label=label)
+
+
+def _expand_markdown(text: str) -> str:
+    """Render inline markdown (bold, italic, code, images, lucide icons, links)."""
+    if not text:
+        return text
+    text = _expand_icons(text)
+    return _CARD_MD.renderInline(text)
+
+
+def _parse_grid(inner_text: str, rest: str) -> Grid:
+    _, children = extract_fenced(inner_text)
+    raw = " ".join(rest.split()[1:]).strip("{}")
+    cols = 0
+    class_ = ""
+    for attr in raw.split(","):
+        attr = attr.strip()
+        if not attr:
+            continue
+        if "=" in attr:
+            k, v = attr.split("=", 1)
+            k, v = k.strip(), v.strip().strip('"')
+            if k == "cols":
+                cols = int(v)
+            elif k == "class":
+                class_ = v
+        else:
+            class_ = (class_ + " " + attr).strip() if class_ else attr
+    if cols == 0:
+        cols = len(children) or 2
+    return Grid(cols=cols, class_=class_, children=children)
+
+
+def _parse_arrow(text: str) -> Arrow:
+    return Arrow(content=_expand_icons(text.strip()) or "\u2192")
+
+
+def _parse_notes(text: str, rest: str) -> Notes:
+    tag = ""
+    raw = rest.split("{", 1)[1].rstrip("}") if "{" in rest else ""
+    for attr in raw.split(","):
+        attr = attr.strip()
+        if "=" in attr:
+            k, v = attr.split("=", 1)
+            if k.strip() == "tag":
+                tag = v.strip().strip('"')
+    # README documents `> quote` lines inside notes; the callout is rendered
+    # inline, so the blockquote marker otherwise showed as a literal '>'
+    text = "\n".join(re.sub(r"^\s*>\s?", "", line) for line in text.strip().splitlines())
+    return Notes(content=_expand_markdown(text), tag=tag or None)
+
+
+def interleave_fences(nodes: list[Node], fence_nodes: list[Node]) -> list[Node]:
+    """Replace FENCE marker paragraphs with actual fence nodes."""
+    from decktile.parser.ast import Paragraph, Text
+    result = []
+    fi = 0
+    for node in nodes:
+        if isinstance(node, Paragraph) and node.content:
+            text = node.content[0].content if isinstance(node.content[0], Text) else ""
+            if text.startswith("\u25caFENCE_"):
+                if fi < len(fence_nodes):
+                    result.append(fence_nodes[fi])
+                    fi += 1
+                continue
+        result.append(node)
+    while fi < len(fence_nodes):
+        result.append(fence_nodes[fi])
+        fi += 1
+    return result

decktile/plugins/layouts.py

@@ -0,0 +1,69 @@
+"""Layout processing: applies predefined layouts to slide content."""
+
+from decktile.parser.ast import Paragraph, AttrNode, Image
+
+KNOWN_LAYOUTS = {"image-right", "image-left", "two-col", "compare", "ecosystem"}
+
+
+def apply_layout(nodes: list, layout: str, render_fn) -> str:
+    """Wrap body nodes into columns per the layout definition."""
+    if layout not in KNOWN_LAYOUTS:
+        return "\n".join(filter(None, (render_fn(n) for n in nodes)))
+
+    if layout == "image-right":
+        left, right = _split_col_or_image(nodes, flip=False)
+    elif layout == "image-left":
+        left, right = _split_col_or_image(nodes, flip=True)
+    elif layout == "two-col":
+        left, right = _split_two_col_nodes(nodes)
+    elif layout == "compare":
+        left, right = _split_two_col_nodes(nodes)
+    else:
+        return "\n".join(filter(None, (render_fn(n) for n in nodes)))
+
+    left_html = "\n".join(filter(None, (render_fn(n) for n in left)))
+    right_html = "\n".join(filter(None, (render_fn(n) for n in right)))
+    parts = []
+    if left_html or right_html:
+        if layout == "compare":
+            parts.append('<div class="layout-cols compare">')
+            parts.append('<div class="col-left">\n' + left_html + '\n</div>')
+            parts.append('<div class="card-arrow">\u2192</div>')
+            parts.append('<div class="col-right">\n' + right_html + '\n</div>')
+        else:
+            parts.append('<div class="layout-cols">')
+            parts.append('<div class="col-left">\n' + left_html + '\n</div>')
+            if right_html:
+                parts.append('<div class="col-right">\n' + right_html + '\n</div>')
+        parts.append('</div>')
+    return "\n".join(parts)
+
+
+def _split_col_or_image(nodes: list, flip: bool = False) -> tuple[list, list]:
+    col_idx = _find_col(nodes)
+    if col_idx >= 0:
+        left, right = nodes[:col_idx], nodes[col_idx + 1:]
+        return (right, left) if flip else (left, right)
+    return _split_image_nodes(nodes, flip)
+
+
+def _split_image_nodes(nodes: list, flip: bool = False) -> tuple[list, list]:
+    for i, n in enumerate(nodes):
+        if isinstance(n, Paragraph) and any(isinstance(t, Image) for t in n.content):
+            left, right = nodes[:i] + nodes[i + 1:], [n]
+            return (right, left) if flip else (left, right)
+    return (nodes, []) if not flip else ([], nodes)
+
+
+def _split_two_col_nodes(nodes: list) -> tuple[list, list]:
+    col_idx = _find_col(nodes)
+    if col_idx >= 0:
+        return nodes[:col_idx], nodes[col_idx + 1:]
+    return nodes, []
+
+
+def _find_col(nodes: list) -> int:
+    for i, n in enumerate(nodes):
+        if isinstance(n, AttrNode) and n.type == "col":
+            return i
+    return -1