quasar-ui-danx 0.4.99 → 0.5.0

package/src/helpers/formats/markdown/tokenize/parseHeading.ts

@@ -0,0 +1,65 @@
+/**
+ * Heading parser
+ * Handles both ATX-style (#) and setext-style (=== or ---) headings
+ */
+
+import type { ParseResult } from "../types";
+
+/**
+ * Parse an ATX-style heading (# through ######)
+ */
+export function parseAtxHeading(line: string, index: number): ParseResult | null {
+	const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+
+	if (!headingMatch) {
+		return null;
+	}
+
+	return {
+		token: {
+			type: "heading",
+			level: headingMatch[1].length,
+			content: headingMatch[2]
+		},
+		endIndex: index + 1
+	};
+}
+
+/**
+ * Parse a setext-style heading (text followed by === or ---)
+ */
+export function parseSetextHeading(lines: string[], index: number): ParseResult | null {
+	if (index + 1 >= lines.length) {
+		return null;
+	}
+
+	const trimmedLine = lines[index].trim();
+	const nextLine = lines[index + 1].trim();
+
+	// Level 1: ===
+	if (/^=+$/.test(nextLine) && trimmedLine.length > 0) {
+		return {
+			token: {
+				type: "heading",
+				level: 1,
+				content: trimmedLine
+			},
+			endIndex: index + 2
+		};
+	}
+
+	// Level 2: ---
+	// Must not be a list item (starts with - followed by space)
+	if (/^-+$/.test(nextLine) && trimmedLine.length > 0 && !/^[-*+]\s+/.test(trimmedLine)) {
+		return {
+			token: {
+				type: "heading",
+				level: 2,
+				content: trimmedLine
+			},
+			endIndex: index + 2
+		};
+	}
+
+	return null;
+}

package/src/helpers/formats/markdown/tokenize/parseHorizontalRule.ts

@@ -0,0 +1,22 @@
+/**
+ * Horizontal rule parser
+ * Handles ---, ***, ___ patterns
+ */
+
+import type { ParseResult } from "../types";
+
+/**
+ * Parse a horizontal rule
+ */
+export function parseHorizontalRule(line: string, index: number): ParseResult | null {
+	const trimmedLine = line.trim();
+
+	if (!/^(-{3,}|\*{3,}|_{3,})$/.test(trimmedLine)) {
+		return null;
+	}
+
+	return {
+		token: { type: "hr" },
+		endIndex: index + 1
+	};
+}

package/src/helpers/formats/markdown/tokenize/parseList.ts

@@ -0,0 +1,119 @@
+/**
+ * Unified list parser for ordered and unordered lists
+ * DRY implementation handling both list types with nested content support
+ */
+
+import type { BlockToken, ListItem } from "../types";
+import { getIndent } from "./utils";
+
+type ListType = "ul" | "ol";
+
+interface ListParseResult {
+	tokens: BlockToken[];
+	endIndex: number;
+}
+
+/**
+ * Detect if a line is a list item and return its type and content
+ */
+function detectListItem(trimmed: string): { type: ListType; content: string; start?: number } | null {
+	// Unordered: -, *, +
+	const ulMatch = trimmed.match(/^[-*+]\s+(.*)$/);
+	if (ulMatch) {
+		return { type: "ul", content: ulMatch[1] };
+	}
+
+	// Ordered: 1., 2., etc.
+	const olMatch = trimmed.match(/^(\d+)\.\s+(.*)$/);
+	if (olMatch) {
+		return { type: "ol", content: olMatch[2], start: parseInt(olMatch[1], 10) };
+	}
+
+	return null;
+}
+
+/**
+ * Parse a list starting at current position, supporting nested lists
+ * Unified implementation for both ul and ol
+ */
+export function parseList(lines: string[], startIndex: number, baseIndent: number): ListParseResult {
+	const tokens: BlockToken[] = [];
+	let i = startIndex;
+
+	while (i < lines.length) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		const indent = getIndent(line);
+
+		// Empty line - could be end of list or spacing within
+		if (!trimmed) {
+			i++;
+			continue;
+		}
+
+		// If indent is less than base, we've exited this list level
+		if (indent < baseIndent && trimmed) {
+			break;
+		}
+
+		const itemInfo = detectListItem(trimmed);
+
+		// Check if this is a list item at our indent level
+		if (itemInfo && indent === baseIndent) {
+			// Collect all items of the same type
+			const items: ListItem[] = [];
+			const listType = itemInfo.type;
+			const startNum = itemInfo.start || 1;
+
+			while (i < lines.length) {
+				const itemLine = lines[i];
+				const itemTrimmed = itemLine.trim();
+				const itemIndent = getIndent(itemLine);
+
+				if (!itemTrimmed) {
+					i++;
+					continue;
+				}
+
+				if (itemIndent < baseIndent) break;
+
+				const currentItem = detectListItem(itemTrimmed);
+
+				// Must be same list type and at base indent
+				if (currentItem && currentItem.type === listType && itemIndent === baseIndent) {
+					const content = currentItem.content;
+					i++;
+
+					// Check for nested content (items indented more than base)
+					const nestedIndent = baseIndent + 2;
+					const nested = parseList(lines, i, nestedIndent);
+
+					items.push({
+						content,
+						children: nested.tokens.length > 0 ? nested.tokens : undefined
+					});
+					i = nested.endIndex;
+				} else if (itemIndent > baseIndent) {
+					// This is nested content, let recursion handle it
+					break;
+				} else {
+					break;
+				}
+			}
+
+			if (items.length > 0) {
+				if (listType === "ul") {
+					tokens.push({ type: "ul", items });
+				} else {
+					tokens.push({ type: "ol", items, start: startNum });
+				}
+			}
+			continue;
+		}
+
+		// Not a list item at this level
+		break;
+	}
+
+	return { tokens, endIndex: i };
+}

package/src/helpers/formats/markdown/tokenize/parseParagraph.ts

@@ -0,0 +1,59 @@
+/**
+ * Paragraph parser
+ * Collects consecutive non-block lines into paragraphs
+ */
+
+import type { ParseResult } from "../types";
+
+/**
+ * Check if a line starts a block-level element
+ */
+function isBlockStarter(trimmed: string): boolean {
+	return (
+		trimmed.startsWith("#") ||
+		trimmed.startsWith("```") ||
+		trimmed.startsWith(">") ||
+		/^[-*+]\s+/.test(trimmed) ||
+		/^\d+\.\s+/.test(trimmed) ||
+		/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)
+	);
+}
+
+/**
+ * Parse a paragraph (consecutive non-empty, non-block lines)
+ */
+export function parseParagraph(lines: string[], index: number): ParseResult | null {
+	const paragraphLines: string[] = [];
+	let i = index;
+
+	while (i < lines.length) {
+		const pLine = lines[i];
+		const pTrimmed = pLine.trim();
+
+		// Stop on empty line or block-level element
+		if (!pTrimmed) {
+			i++;
+			break;
+		}
+
+		// Check for block-level starters
+		if (isBlockStarter(pTrimmed)) {
+			break;
+		}
+
+		paragraphLines.push(pLine);
+		i++;
+	}
+
+	if (paragraphLines.length === 0) {
+		return null;
+	}
+
+	return {
+		token: {
+			type: "paragraph",
+			content: paragraphLines.join("\n")
+		},
+		endIndex: i
+	};
+}

package/src/helpers/formats/markdown/tokenize/parseTable.ts

@@ -0,0 +1,70 @@
+/**
+ * Table parser
+ * Handles markdown tables with alignment support
+ */
+
+import type { TableAlignment, ParseResult } from "../types";
+import { parsePipeRow } from "./utils";
+
+/**
+ * Parse a markdown table
+ * Format: | col | col | followed by |---|---| separator
+ */
+export function parseTable(lines: string[], index: number): ParseResult | null {
+	const trimmedLine = lines[index].trim();
+
+	// Must start with | or contain |
+	if (!trimmedLine.startsWith("|") && !trimmedLine.includes(" | ")) {
+		return null;
+	}
+
+	// Check if next line is a separator
+	if (index + 1 >= lines.length) {
+		return null;
+	}
+
+	const nextLine = lines[index + 1].trim();
+
+	// Separator pattern: |---|---| or |:---|---:| etc
+	if (!/^\|?[\s:]*-+[\s:]*(\|[\s:]*-+[\s:]*)+\|?$/.test(nextLine)) {
+		return null;
+	}
+
+	// Parse header row
+	const headers = parsePipeRow(trimmedLine);
+
+	// Parse separator to get alignments
+	const separatorCells = parsePipeRow(nextLine);
+	const alignments: TableAlignment[] = separatorCells.map(cell => {
+		const trimmed = cell.trim();
+		const leftColon = trimmed.startsWith(":");
+		const rightColon = trimmed.endsWith(":");
+		if (leftColon && rightColon) return "center";
+		if (rightColon) return "right";
+		if (leftColon) return "left";
+		return null;
+	});
+
+	// Collect body rows
+	const rows: string[][] = [];
+	let i = index + 2; // Skip header and separator
+
+	while (i < lines.length) {
+		const rowLine = lines[i].trim();
+		if (!rowLine || (!rowLine.startsWith("|") && !rowLine.includes(" | "))) {
+			break;
+		}
+		rows.push(parsePipeRow(rowLine));
+		i++;
+	}
+
+	return {
+		token: {
+			type: "table",
+			headers,
+			alignments,
+			rows
+		},
+		endIndex: i
+	};
+}

package/src/helpers/formats/markdown/tokenize/parseTaskList.ts

@@ -0,0 +1,47 @@
+/**
+ * Task list parser
+ * Handles - [ ] and - [x] style task items
+ */
+
+import type { ParseResult } from "../types";
+
+/**
+ * Parse a task list section
+ */
+export function parseTaskList(lines: string[], index: number): ParseResult | null {
+	const trimmedLine = lines[index].trim();
+	const taskListMatch = trimmedLine.match(/^[-*+]\s+\[([ xX])\]\s+(.*)$/);
+
+	if (!taskListMatch) {
+		return null;
+	}
+
+	const items: Array<{ checked: boolean; content: string }> = [];
+	let i = index;
+
+	while (i < lines.length) {
+		const taskLine = lines[i].trim();
+		const itemMatch = taskLine.match(/^[-*+]\s+\[([ xX])\]\s+(.*)$/);
+
+		if (itemMatch) {
+			items.push({
+				checked: itemMatch[1].toLowerCase() === "x",
+				content: itemMatch[2]
+			});
+			i++;
+		} else if (taskLine === "") {
+			i++;
+			const nextNonEmpty = lines.slice(i).find((l) => l.trim() !== "");
+			if (!nextNonEmpty || !/^[-*+]\s+\[([ xX])\]/.test(nextNonEmpty.trim())) {
+				break;
+			}
+		} else {
+			break;
+		}
+	}
+
+	return {
+		token: { type: "task_list", items },
+		endIndex: i
+	};
+}

package/src/helpers/formats/markdown/tokenize/utils.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared utilities for block tokenizers
+ */
+
+/**
+ * Get indentation level of a line (count leading spaces/tabs)
+ * Tabs are counted as 2 spaces for indentation purposes
+ */
+export function getIndent(line: string): number {
+	const match = line.match(/^(\s*)/);
+	if (!match) return 0;
+	// Count tabs as 2 spaces for indentation purposes
+	return match[1].replace(/\t/g, "  ").length;
+}
+
+/**
+ * Parse a pipe-delimited table row into cells
+ */
+export function parsePipeRow(line: string): string[] {
+	// Remove leading/trailing pipes and split
+	let trimmed = line.trim();
+	if (trimmed.startsWith("|")) trimmed = trimmed.slice(1);
+	if (trimmed.endsWith("|")) trimmed = trimmed.slice(0, -1);
+	return trimmed.split("|").map(cell => cell.trim());
+}

package/src/helpers/formats/markdown/types.ts

@@ -0,0 +1,63 @@
+/**
+ * Markdown parser and renderer type definitions
+ */
+
+/**
+ * Options for markdown rendering
+ */
+export interface MarkdownRenderOptions {
+	sanitize?: boolean; // XSS protection (default: true)
+	preserveState?: boolean; // Don't reset link refs and footnotes (for nested rendering)
+}
+
+/**
+ * Link reference for reference-style links
+ */
+export interface LinkReference {
+	url: string;
+	title?: string;
+}
+
+/**
+ * Footnote definition for footnote references
+ */
+export interface FootnoteDefinition {
+	content: string;
+	index: number; // For numbered display
+}
+
+/**
+ * List item type supporting nested content
+ */
+export interface ListItem {
+	content: string;
+	children?: BlockToken[]; // Nested lists or other block content
+}
+
+/**
+ * Token types for block-level parsing
+ */
+export type BlockToken =
+	| { type: "heading"; level: number; content: string }
+	| { type: "code_block"; language: string; content: string }
+	| { type: "blockquote"; content: string }
+	| { type: "ul"; items: ListItem[] }
+	| { type: "ol"; items: ListItem[]; start: number }
+	| { type: "task_list"; items: Array<{ checked: boolean; content: string }> }
+	| { type: "table"; headers: string[]; alignments: TableAlignment[]; rows: string[][] }
+	| { type: "dl"; items: Array<{ term: string; definitions: string[] }> }
+	| { type: "hr" }
+	| { type: "paragraph"; content: string };
+
+/**
+ * Table column alignment
+ */
+export type TableAlignment = "left" | "center" | "right" | null;
+
+/**
+ * Result from a block parser function
+ */
+export interface ParseResult {
+	token: BlockToken;
+	endIndex: number;
+}

package/src/styles/danx.scss

@@ -1,5 +1,6 @@
 @import "themes/danx/scrollbar";
 @import "themes/danx/code";
+@import "themes/danx/markdown";
 
 .dx-action-table {
 	.dx-column-shrink {

package/src/styles/themes/danx/markdown.scss

@@ -94,6 +94,24 @@
     list-style-type: decimal;
   }
 
+  // Task lists
+  .task-list {
+    list-style: none;
+    padding-left: 0;
+
+    .task-list-item {
+      display: flex;
+      align-items: flex-start;
+      gap: 0.5em;
+      margin: 0.25em 0;
+
+      input[type="checkbox"] {
+        margin-top: 0.3em;
+        cursor: default;
+      }
+    }
+  }
+
   // Links
   a {
     color: #60a5fa; // blue-400
@@ -121,6 +139,32 @@
   strong { font-weight: 600; }
   em { font-style: italic; }
 
+  // Strikethrough
+  del {
+    text-decoration: line-through;
+    opacity: 0.7;
+  }
+
+  // Highlight
+  mark {
+    background: rgba(250, 204, 21, 0.4); // yellow-400 with opacity
+    padding: 0.1em 0.2em;
+    border-radius: 2px;
+  }
+
+  // Subscript/Superscript
+  sub, sup {
+    font-size: 0.75em;
+  }
+
+  sub {
+    vertical-align: sub;
+  }
+
+  sup {
+    vertical-align: super;
+  }
+
   // Tables
   table {
     border-collapse: collapse;
@@ -142,4 +186,56 @@
       background: rgba(255, 255, 255, 0.05);
     }
   }
+
+  // Definition lists
+  dl {
+    margin: 1em 0;
+  }
+
+  dt {
+    font-weight: 600;
+    margin-top: 1em;
+
+    &:first-child {
+      margin-top: 0;
+    }
+  }
+
+  dd {
+    margin-left: 2em;
+    margin-top: 0.25em;
+  }
+
+  // Footnotes
+  .footnote-ref {
+    font-size: 0.75em;
+    vertical-align: super;
+    line-height: 0;
+
+    a {
+      text-decoration: none;
+    }
+  }
+
+  .footnotes {
+    margin-top: 2em;
+    font-size: 0.875em;
+
+    hr {
+      margin-bottom: 1em;
+    }
+
+    .footnote-list {
+      padding-left: 1.5em;
+    }
+
+    .footnote-item {
+      margin: 0.5em 0;
+    }
+
+    .footnote-backref {
+      margin-left: 0.5em;
+      text-decoration: none;
+    }
+  }
 }