leepi 0.0.2 → 0.0.3

package/dist/core/plugins/inline.js

@@ -0,0 +1,103 @@
+import { markRegistry, shortcutRegistry } from "../registry.js";
+import { toggleMarker } from "../commands.js";
+import { keymap } from "@codemirror/view";
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { tags } from "@lezer/highlight";
+//#region src/core/plugins/inline.ts
+const defaultShortcuts = {
+	bold: "Mod-b",
+	italic: "Mod-i",
+	strikethrough: "Mod-Shift-x",
+	code: "Mod-e"
+};
+const inlineHighlight = HighlightStyle.define([
+	{
+		tag: tags.strong,
+		fontWeight: "var(--lp-font-weight-bold, 700)"
+	},
+	{
+		tag: tags.emphasis,
+		fontStyle: "italic"
+	},
+	{
+		tag: tags.strikethrough,
+		textDecoration: "line-through"
+	},
+	{
+		tag: tags.monospace,
+		fontFamily: "var(--lp-font-mono)",
+		fontSize: "0.875em",
+		backgroundColor: "var(--lp-color-surface)",
+		borderRadius: "var(--lp-radius, 6px)",
+		padding: "0.1em 0.3em"
+	}
+]);
+function inlinePlugin(options) {
+	const keys = {
+		...defaultShortcuts,
+		...options?.shortcuts
+	};
+	return [
+		syntaxHighlighting(inlineHighlight),
+		shortcutRegistry.of([
+			{
+				key: keys.bold,
+				action: "bold",
+				plugin: "inline"
+			},
+			{
+				key: keys.italic,
+				action: "italic",
+				plugin: "inline"
+			},
+			{
+				key: keys.strikethrough,
+				action: "strikethrough",
+				plugin: "inline"
+			},
+			{
+				key: keys.code,
+				action: "code",
+				plugin: "inline"
+			}
+		]),
+		markRegistry.of([
+			{
+				mark: "bold",
+				detect: (nodeName) => nodeName === "StrongEmphasis"
+			},
+			{
+				mark: "italic",
+				detect: (nodeName) => nodeName === "Emphasis"
+			},
+			{
+				mark: "strikethrough",
+				detect: (nodeName) => nodeName === "Strikethrough"
+			},
+			{
+				mark: "code",
+				detect: (nodeName) => nodeName === "InlineCode"
+			}
+		]),
+		keymap.of([
+			{
+				key: keys.bold,
+				run: toggleMarker("**")
+			},
+			{
+				key: keys.italic,
+				run: toggleMarker("_")
+			},
+			{
+				key: keys.strikethrough,
+				run: toggleMarker("~~")
+			},
+			{
+				key: keys.code,
+				run: toggleMarker("`")
+			}
+		])
+	];
+}
+//#endregion
+export { inlinePlugin };

package/dist/core/plugins/link.d.ts

@@ -0,0 +1,25 @@
+import { PopoverRequest } from "../types.js";
+import { findLinkAtCursor, insertLink } from "../commands.js";
+import { Extension } from "@codemirror/state";
+
+//#region src/core/plugins/link.d.ts
+interface LinkData {
+  /** Selected text or existing link label */
+  text: string;
+  /** Pre-filled URL when editing an existing link */
+  url: string;
+  /** Document range to replace when the link is inserted/removed */
+  from: number;
+  to: number;
+}
+type LinkRequest = PopoverRequest<"link", LinkData>;
+interface LinkPluginOptions {
+  shortcuts?: {
+    insertLink?: string;
+    removeLink?: string;
+  };
+  urlRegex?: RegExp;
+}
+declare function linkPlugin(options?: LinkPluginOptions): Extension;
+//#endregion
+export { LinkData, LinkPluginOptions, LinkRequest, linkPlugin };

package/dist/core/plugins/link.js

@@ -0,0 +1,104 @@
+import { markRegistry, shortcutRegistry } from "../registry.js";
+import { isInsideCodeBlock } from "../utils.js";
+import { findLinkAtCursor, insertLink } from "../commands.js";
+import { openPopover } from "../popover.js";
+import { EditorView, keymap } from "@codemirror/view";
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { EditorSelection } from "@codemirror/state";
+import { tags } from "@lezer/highlight";
+//#region src/core/plugins/link.ts
+const defaultShortcuts = {
+	insertLink: "Mod-k",
+	removeLink: "Mod-Shift-k"
+};
+const URL_RE = /^(?:https?:\/\/|mailto:|tel:)\S+$/;
+const linkHighlight = HighlightStyle.define([{
+	tag: tags.link,
+	color: "var(--lp-color-accent)"
+}, {
+	tag: tags.url,
+	color: "var(--lp-color-accent)"
+}]);
+function linkPlugin(options) {
+	const keys = {
+		...defaultShortcuts,
+		...options?.shortcuts
+	};
+	const urlRegex = options?.urlRegex ?? URL_RE;
+	return [
+		syntaxHighlighting(linkHighlight),
+		EditorView.domEventHandlers({ paste(event, view) {
+			const range = view.state.selection.main;
+			if (range.empty) return false;
+			if (isInsideCodeBlock(view)) return false;
+			const text = event.clipboardData?.getData("text/plain")?.trim();
+			if (!text || !urlRegex.test(text)) return false;
+			event.preventDefault();
+			const label = view.state.sliceDoc(range.from, range.to);
+			insertLink(view, range.from, range.to, label, text);
+			return true;
+		} }),
+		shortcutRegistry.of([{
+			key: keys.insertLink,
+			action: "insertLink",
+			plugin: "link"
+		}, {
+			key: keys.removeLink,
+			action: "removeLink",
+			plugin: "link"
+		}]),
+		markRegistry.of([{
+			mark: "link",
+			detect: (nodeName) => nodeName === "Link"
+		}]),
+		keymap.of([{
+			key: keys.removeLink,
+			run(view) {
+				if (isInsideCodeBlock(view)) return false;
+				const { state } = view;
+				const range = state.selection.main;
+				const existing = findLinkAtCursor(state, range.from);
+				if (!existing) return false;
+				view.dispatch({
+					changes: {
+						from: existing.from,
+						to: existing.to,
+						insert: existing.label
+					},
+					selection: EditorSelection.cursor(existing.from + existing.label.length)
+				});
+				return true;
+			}
+		}, {
+			key: keys.insertLink,
+			run(view) {
+				if (isInsideCodeBlock(view)) return false;
+				const { state } = view;
+				const range = state.selection.main;
+				const existing = findLinkAtCursor(state, range.from);
+				const coords = view.coordsAtPos(range.from);
+				if (!coords) return false;
+				const req = {
+					type: "link",
+					x: coords.left,
+					y: coords.bottom,
+					data: existing ? {
+						text: existing.label,
+						url: existing.url,
+						from: existing.from,
+						to: existing.to
+					} : {
+						text: state.sliceDoc(range.from, range.to),
+						url: "",
+						from: range.from,
+						to: range.to
+					}
+				};
+				view.dispatch({ effects: openPopover.of(req) });
+				return true;
+			}
+		}])
+	];
+}
+//#endregion
+export { linkPlugin };

package/dist/core/plugins/list.d.ts

@@ -0,0 +1,14 @@
+import { Extension } from "@codemirror/state";
+
+//#region src/core/plugins/list.d.ts
+interface ListPluginOptions {
+  shortcuts?: {
+    unorderedList?: string;
+    orderedList?: string;
+    taskList?: string;
+    toggleTask?: string;
+  };
+}
+declare function listPlugin(options?: ListPluginOptions): Extension;
+//#endregion
+export { ListPluginOptions, listPlugin };

package/dist/core/plugins/list.js

@@ -0,0 +1,91 @@
+import { markRegistry, shortcutRegistry } from "../registry.js";
+import { toggleListKind, toggleTaskCheck } from "../commands.js";
+import { keymap } from "@codemirror/view";
+import { syntaxTree } from "@codemirror/language";
+//#region src/core/plugins/list.ts
+const defaultShortcuts = {
+	orderedList: "Mod-Shift-7",
+	unorderedList: "Mod-Shift-8",
+	taskList: "Mod-Shift-9",
+	toggleTask: "Mod-Enter"
+};
+/** Walk up from pos to find a ListItem node containing a Task child */
+function hasTaskAtLine(state, pos) {
+	let node = syntaxTree(state).resolveInner(pos, 1);
+	while (node) {
+		if (node.name === "ListItem") return !!node.getChild("Task");
+		if (!node.parent) break;
+		node = node.parent;
+	}
+	return false;
+}
+function listPlugin(options) {
+	const keys = {
+		...defaultShortcuts,
+		...options?.shortcuts
+	};
+	return [
+		shortcutRegistry.of([
+			{
+				key: keys.unorderedList,
+				action: "unorderedList",
+				plugin: "list"
+			},
+			{
+				key: keys.orderedList,
+				action: "orderedList",
+				plugin: "list"
+			},
+			{
+				key: keys.taskList,
+				action: "taskList",
+				plugin: "list"
+			},
+			{
+				key: keys.toggleTask,
+				action: "toggleTask",
+				plugin: "list"
+			}
+		]),
+		markRegistry.of([
+			{
+				mark: "ul",
+				detect: (nodeName, state, pos) => {
+					if (nodeName !== "BulletList") return false;
+					return !hasTaskAtLine(state, pos);
+				}
+			},
+			{
+				mark: "ol",
+				detect: (nodeName) => nodeName === "OrderedList"
+			},
+			{
+				mark: "task",
+				detect: (nodeName, state, pos) => {
+					if (nodeName !== "__line__") return false;
+					return hasTaskAtLine(state, pos);
+				}
+			}
+		]),
+		keymap.of([
+			{
+				key: keys.unorderedList,
+				run: toggleListKind("ul")
+			},
+			{
+				key: keys.orderedList,
+				run: toggleListKind("ol")
+			},
+			{
+				key: keys.taskList,
+				run: toggleListKind("task")
+			},
+			{
+				key: keys.toggleTask,
+				run: toggleTaskCheck
+			}
+		])
+	];
+}
+//#endregion
+export { listPlugin };

package/dist/core/plugins/table.d.ts

@@ -0,0 +1,12 @@
+import { EditorView } from "@codemirror/view";
+import { Extension } from "@codemirror/state";
+
+//#region src/core/plugins/table.d.ts
+interface TablePluginOptions {
+  shortcuts?: {
+    formatTable?: string;
+  };
+}
+declare function tablePlugin(options?: TablePluginOptions): Extension;
+//#endregion
+export { TablePluginOptions, tablePlugin };

package/dist/core/plugins/table.js

@@ -0,0 +1,161 @@
+import { shortcutRegistry } from "../registry.js";
+import { Decoration, EditorView, ViewPlugin, keymap } from "@codemirror/view";
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+import { EditorSelection, RangeSetBuilder } from "@codemirror/state";
+//#region src/core/plugins/table.ts
+const defaultShortcuts = { formatTable: "Mod-Alt-f" };
+/**
+* Find the Table node containing the cursor position.
+* Returns the node's from/to range or null if not in a table.
+*/
+function findTableAtCursor(view) {
+	const { state } = view;
+	const pos = state.selection.main.from;
+	const tree = ensureSyntaxTree(state, pos) ?? syntaxTree(state);
+	for (const bias of [-1, 1]) {
+		let node = tree.resolveInner(pos, bias);
+		while (node) {
+			if (node.name === "Table") return {
+				from: node.from,
+				to: node.to
+			};
+			if (!node.parent) break;
+			node = node.parent;
+		}
+	}
+	return null;
+}
+/**
+* Parse a markdown table string into a 2D array of cell strings.
+* Returns { rows, delimiterIndex } where delimiterIndex is the index
+* of the separator row (e.g. |---|---|).
+*/
+function parseTable(text) {
+	const lines = text.split("\n").filter((l) => l.trim().length > 0);
+	if (lines.length < 2) return null;
+	const rows = [];
+	let delimiterIndex = -1;
+	for (let i = 0; i < lines.length; i++) {
+		const cells = lines[i].trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+		if (delimiterIndex === -1 && cells.every((c) => /^:?-{1,}:?$/.test(c))) delimiterIndex = i;
+		rows.push(cells);
+	}
+	if (delimiterIndex === -1) return null;
+	return {
+		rows,
+		delimiterIndex
+	};
+}
+/**
+* Format a parsed table into an aligned markdown string.
+*/
+function formatTable(rows, delimiterIndex) {
+	const colCount = rows[0].length;
+	const alignments = [];
+	const delimRow = rows[delimiterIndex];
+	for (let col = 0; col < colCount; col++) {
+		const cell = col < delimRow.length ? delimRow[col] : "---";
+		const left = cell.startsWith(":");
+		const right = cell.endsWith(":");
+		if (left && right) alignments.push("center");
+		else if (right) alignments.push("right");
+		else if (left) alignments.push("left");
+		else alignments.push("none");
+	}
+	const colWidths = Array.from({ length: colCount }, () => 3);
+	for (let i = 0; i < rows.length; i++) {
+		if (i === delimiterIndex) continue;
+		for (let col = 0; col < colCount; col++) {
+			const cell = col < rows[i].length ? rows[i][col] : "";
+			colWidths[col] = Math.max(colWidths[col], cell.length);
+		}
+	}
+	const lines = [];
+	for (let i = 0; i < rows.length; i++) if (i === delimiterIndex) {
+		const cells = colWidths.map((w, col) => {
+			const align = alignments[col];
+			const dashes = "-".repeat(w);
+			if (align === "center") return `:${dashes}:`;
+			if (align === "right") return `${dashes}:`;
+			if (align === "left") return `:${dashes}`;
+			return dashes;
+		});
+		lines.push(`| ${cells.join(" | ")} |`);
+	} else {
+		const cells = colWidths.map((w, col) => {
+			return (col < rows[i].length ? rows[i][col] : "").padEnd(w);
+		});
+		lines.push(`| ${cells.join(" | ")} |`);
+	}
+	return lines.join("\n");
+}
+function formatTableCommand(view) {
+	const tableRange = findTableAtCursor(view);
+	if (!tableRange) return false;
+	const tableText = view.state.sliceDoc(tableRange.from, tableRange.to);
+	const parsed = parseTable(tableText);
+	if (!parsed) return false;
+	const formatted = formatTable(parsed.rows, parsed.delimiterIndex);
+	if (formatted === tableText) return true;
+	const cursorOffset = view.state.selection.main.from - tableRange.from;
+	const newCursorPos = Math.min(tableRange.from + cursorOffset, tableRange.from + formatted.length);
+	view.dispatch({
+		changes: {
+			from: tableRange.from,
+			to: tableRange.to,
+			insert: formatted
+		},
+		selection: EditorSelection.cursor(newCursorPos)
+	});
+	return true;
+}
+const tableLineDecoration = Decoration.line({ class: "cm-table-line" });
+function buildTableDecorations(state) {
+	const builder = new RangeSetBuilder();
+	syntaxTree(state).iterate({ enter(node) {
+		if (node.name === "Table") {
+			const from = state.doc.lineAt(node.from).number;
+			const to = state.doc.lineAt(node.to).number;
+			for (let i = from; i <= to; i++) {
+				const line = state.doc.line(i);
+				builder.add(line.from, line.from, tableLineDecoration);
+			}
+		}
+	} });
+	return builder.finish();
+}
+const tableLineDecorations = ViewPlugin.fromClass(class {
+	decorations;
+	constructor(view) {
+		this.decorations = buildTableDecorations(view.state);
+	}
+	update(update) {
+		if (update.docChanged || update.viewportChanged || syntaxTree(update.state) !== syntaxTree(update.startState)) this.decorations = buildTableDecorations(update.state);
+	}
+}, { decorations: (v) => v.decorations });
+const tableTheme = EditorView.theme({ ".cm-table-line": {
+	fontFamily: "var(--lp-font-mono, ui-monospace, monospace)",
+	fontSize: "0.875em"
+} });
+function tablePlugin(options) {
+	const keys = {
+		...defaultShortcuts,
+		...options?.shortcuts
+	};
+	return [
+		shortcutRegistry.of([{
+			key: keys.formatTable,
+			action: "formatTable",
+			plugin: "table"
+		}]),
+		keymap.of([{
+			key: keys.formatTable,
+			run: formatTableCommand,
+			preventDefault: true
+		}]),
+		tableLineDecorations,
+		tableTheme
+	];
+}
+//#endregion
+export { tablePlugin };

package/dist/core/plugins.d.ts

@@ -0,0 +1,9 @@
+import { CodeBlockData, CodeBlockPluginOptions, CodeBlockRequest, codeBlockPlugin } from "./plugins/code-block.js";
+import { InlinePluginOptions, inlinePlugin } from "./plugins/inline.js";
+import { HeadingPluginOptions, headingPlugin } from "./plugins/heading.js";
+import { ListPluginOptions, listPlugin } from "./plugins/list.js";
+import { BlockquotePluginOptions, blockquotePlugin } from "./plugins/blockquote.js";
+import { LinkData, LinkPluginOptions, LinkRequest, linkPlugin } from "./plugins/link.js";
+import { TablePluginOptions, tablePlugin } from "./plugins/table.js";
+import { bracketPlugin } from "./plugins/bracket.js";
+export { type BlockquotePluginOptions, type CodeBlockData, type CodeBlockPluginOptions, type CodeBlockRequest, type HeadingPluginOptions, type InlinePluginOptions, type LinkData, type LinkPluginOptions, type LinkRequest, type ListPluginOptions, type TablePluginOptions, blockquotePlugin, bracketPlugin, codeBlockPlugin, headingPlugin, inlinePlugin, linkPlugin, listPlugin, tablePlugin };

package/dist/core/plugins.js

@@ -0,0 +1,9 @@
+import { inlinePlugin } from "./plugins/inline.js";
+import { headingPlugin } from "./plugins/heading.js";
+import { listPlugin } from "./plugins/list.js";
+import { blockquotePlugin } from "./plugins/blockquote.js";
+import { linkPlugin } from "./plugins/link.js";
+import { codeBlockPlugin } from "./plugins/code-block.js";
+import { tablePlugin } from "./plugins/table.js";
+import { bracketPlugin } from "./plugins/bracket.js";
+export { blockquotePlugin, bracketPlugin, codeBlockPlugin, headingPlugin, inlinePlugin, linkPlugin, listPlugin, tablePlugin };

package/dist/core/popover.d.ts

@@ -0,0 +1,9 @@
+import { PopoverRequest } from "./types.js";
+import { StateEffectType, StateField } from "@codemirror/state";
+
+//#region src/core/popover.d.ts
+declare const openPopover: StateEffectType<PopoverRequest>;
+declare const closePopover: StateEffectType<void>;
+declare const popoverField: StateField<PopoverRequest | null>;
+//#endregion
+export { closePopover, openPopover, popoverField };

package/dist/core/popover.js

@@ -0,0 +1,16 @@
+import { StateEffect, StateField } from "@codemirror/state";
+//#region src/core/popover.ts
+const openPopover = StateEffect.define();
+const closePopover = StateEffect.define();
+const popoverField = StateField.define({
+	create: () => null,
+	update(value, tr) {
+		for (const e of tr.effects) {
+			if (e.is(openPopover)) return e.value;
+			if (e.is(closePopover)) return null;
+		}
+		return value;
+	}
+});
+//#endregion
+export { closePopover, openPopover, popoverField };

package/dist/core/registry.d.ts

@@ -0,0 +1,10 @@
+import { MarkDetector, ShortcutEntry } from "./types.js";
+import { Facet } from "@codemirror/state";
+
+//#region src/core/registry.d.ts
+/** Plugins register their keybindings here so the React layer can display them. */
+declare const shortcutRegistry: Facet<ShortcutEntry[], ShortcutEntry[]>;
+/** Plugins register node-to-mark detectors here for active mark detection. */
+declare const markRegistry: Facet<MarkDetector[], MarkDetector[]>;
+//#endregion
+export { markRegistry, shortcutRegistry };

package/dist/core/registry.js

@@ -0,0 +1,8 @@
+import { Facet } from "@codemirror/state";
+//#region src/core/registry.ts
+/** Plugins register their keybindings here so the React layer can display them. */
+const shortcutRegistry = Facet.define({ combine: (values) => values.flat() });
+/** Plugins register node-to-mark detectors here for active mark detection. */
+const markRegistry = Facet.define({ combine: (values) => values.flat() });
+//#endregion
+export { markRegistry, shortcutRegistry };

package/dist/core/types.d.ts

@@ -0,0 +1,25 @@
+import { EditorState } from "@codemirror/state";
+
+//#region src/core/types.d.ts
+interface ShortcutDef {
+  key: string;
+  action: string;
+}
+interface PopoverRequest<Type extends string = string, Data = unknown> {
+  type: Type;
+  /** Screen coordinates for anchoring the popover */
+  x: number;
+  y: number;
+  data: Data;
+}
+interface ShortcutEntry {
+  key: string;
+  action: string;
+  plugin: string;
+}
+interface MarkDetector {
+  mark: string;
+  detect: (nodeName: string, state: EditorState, pos: number) => boolean;
+}
+//#endregion
+export { MarkDetector, PopoverRequest, ShortcutDef, ShortcutEntry };

package/dist/core/utils.d.ts

@@ -0,0 +1,13 @@
+import { EditorView } from "@codemirror/view";
+
+//#region src/core/utils.d.ts
+/**
+* Returns true when the primary cursor sits inside a fenced code block.
+* Used to disable inline/block formatting commands that would produce
+* broken markdown if applied inside code.
+*/
+declare function isInsideCodeBlock(view: EditorView): boolean;
+/** Parse a CodeMirror key string into individual key tokens for display */
+declare function formatShortcutKeys(key: string): string[];
+//#endregion
+export { formatShortcutKeys, isInsideCodeBlock };

package/dist/core/utils.js

@@ -0,0 +1,32 @@
+import { syntaxTree } from "@codemirror/language";
+//#region src/core/utils.ts
+/**
+* Returns true when the primary cursor sits inside a fenced code block.
+* Used to disable inline/block formatting commands that would produce
+* broken markdown if applied inside code.
+*/
+function isInsideCodeBlock(view) {
+	const pos = view.state.selection.main.from;
+	let node = syntaxTree(view.state).resolveInner(pos, -1);
+	while (node) {
+		if (node.name === "FencedCode") return true;
+		if (!node.parent) break;
+		node = node.parent;
+	}
+	return false;
+}
+const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/.test(navigator.platform);
+/** Parse a CodeMirror key string into individual key tokens for display */
+function formatShortcutKeys(key) {
+	return key.split("-").map((part) => {
+		switch (part) {
+			case "Mod": return isMac ? "⌘" : "Ctrl";
+			case "Shift": return isMac ? "⇧" : "Shift";
+			case "Alt": return isMac ? "⌥" : "Alt";
+			case "Enter": return "⏎";
+			default: return part;
+		}
+	});
+}
+//#endregion
+export { formatShortcutKeys, isInsideCodeBlock };