quasar-ui-danx 0.4.99 → 0.5.1

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

@@ -0,0 +1,85 @@
+/**
+ * Code block parser
+ * Handles both fenced (```) and indented (4 spaces) code blocks
+ */
+
+import type { ParseResult } from "../types";
+
+/**
+ * Parse a fenced code block (``` ... ```)
+ */
+export function parseFencedCodeBlock(lines: string[], index: number): ParseResult | null {
+	const trimmedLine = lines[index].trim();
+
+	if (!trimmedLine.startsWith("```")) {
+		return null;
+	}
+
+	const language = trimmedLine.slice(3).trim();
+	const contentLines: string[] = [];
+	let i = index + 1;
+
+	while (i < lines.length && !lines[i].trim().startsWith("```")) {
+		contentLines.push(lines[i]);
+		i++;
+	}
+
+	// Skip closing ```
+	if (i < lines.length) i++;
+
+	return {
+		token: {
+			type: "code_block",
+			language,
+			content: contentLines.join("\n")
+		},
+		endIndex: i
+	};
+}
+
+/**
+ * Parse an indented code block (4+ spaces or tab at start)
+ */
+export function parseIndentedCodeBlock(lines: string[], index: number): ParseResult | null {
+	const line = lines[index];
+
+	if (!/^( {4}|\t)/.test(line)) {
+		return null;
+	}
+
+	const contentLines: string[] = [];
+	let i = index;
+
+	while (i < lines.length) {
+		const codeLine = lines[i];
+		if (/^( {4}|\t)/.test(codeLine)) {
+			// Remove the 4 spaces or tab prefix
+			contentLines.push(codeLine.replace(/^( {4}|\t)/, ""));
+			i++;
+		} else if (codeLine.trim() === "") {
+			// Empty lines within indented block are kept
+			contentLines.push("");
+			i++;
+		} else {
+			break;
+		}
+	}
+
+	// Remove trailing empty lines
+	while (contentLines.length > 0 && contentLines[contentLines.length - 1] === "") {
+		contentLines.pop();
+	}
+
+	if (contentLines.length === 0) {
+		return null;
+	}
+
+	return {
+		token: {
+			type: "code_block",
+			language: "",
+			content: contentLines.join("\n")
+		},
+		endIndex: i
+	};
+}

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

@@ -0,0 +1,88 @@
+/**
+ * Definition list parser
+ * Handles term/definition pairs with : prefix
+ */
+
+import type { ParseResult } from "../types";
+
+/**
+ * Parse a definition list section
+ * Format: Term\n: Definition
+ */
+export function parseDefinitionList(lines: string[], index: number): ParseResult | null {
+	const trimmedLine = lines[index].trim();
+
+	// Check if current line could be a term (non-empty, doesn't start with special chars)
+	// and next line starts with `: `
+	if (
+		!trimmedLine ||
+		trimmedLine.startsWith(":") ||
+		/^[-*+#>\d]/.test(trimmedLine) ||
+		index + 1 >= lines.length
+	) {
+		return null;
+	}
+
+	const nextLine = lines[index + 1].trim();
+	if (!nextLine.startsWith(": ")) {
+		return null;
+	}
+
+	// This is a definition list
+	const items: Array<{ term: string; definitions: string[] }> = [];
+	let i = index;
+
+	while (i < lines.length) {
+		const termLine = lines[i].trim();
+
+		// Empty line ends the definition list
+		if (!termLine) {
+			i++;
+			// Check if there's another term after empty line
+			if (i < lines.length && lines[i].trim() && !lines[i].trim().startsWith(":")) {
+				const afterEmpty = lines[i + 1]?.trim();
+				if (afterEmpty?.startsWith(": ")) {
+					continue; // Another term-definition pair follows
+				}
+			}
+			break;
+		}
+
+		// If line starts with :, it's a definition for previous term
+		if (termLine.startsWith(": ")) {
+			// Add to last item's definitions if exists
+			if (items.length > 0) {
+				items[items.length - 1].definitions.push(termLine.slice(2));
+			}
+			i++;
+			continue;
+		}
+
+		// Check if this could be a new term
+		if (!termLine.startsWith(":") && i + 1 < lines.length) {
+			const nextDef = lines[i + 1].trim();
+			if (nextDef.startsWith(": ")) {
+				// New term
+				items.push({
+					term: termLine,
+					definitions: []
+				});
+				i++;
+				continue;
+			}
+		}
+
+		// Not part of definition list anymore
+		break;
+	}
+
+	// Must have items with at least one definition
+	if (items.length === 0 || !items.some(item => item.definitions.length > 0)) {
+		return null;
+	}
+
+	return {
+		token: { type: "dl", items },
+		endIndex: i
+	};
+}

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 {