cli-jaw 2.0.4 → 2.0.5

package/public/manager/src/notes/wiki-link-suggestions.ts

@@ -0,0 +1,153 @@
+import type { NotesNoteMetadata } from './notes-types';
+
+const DEFAULT_SUGGESTION_LIMIT = 20;
+const NOTE_FILE_EXT = '.md';
+
+export type WikiLinkCompletionRange = {
+    from: number;
+    to: number;
+    query: string;
+};
+
+export type WikiLinkCompletionRangeAtCursor = WikiLinkCompletionRange & {
+    hasClosingSuffix: boolean;
+};
+
+export type WikiLinkSuggestion = {
+    path: string;
+    title: string;
+    aliases: readonly string[];
+    tags: readonly string[];
+    insertText: string;
+    matchKind: 'title' | 'alias' | 'path' | 'tag';
+    score: number;
+};
+
+function lower(value: string): string {
+    return value.trim().toLocaleLowerCase();
+}
+
+function pathWithoutExt(path: string): string {
+    return path.endsWith(NOTE_FILE_EXT) ? path.slice(0, -NOTE_FILE_EXT.length) : path;
+}
+
+function noteStem(path: string): string {
+    const filename = path.split('/').at(-1) || path;
+    return pathWithoutExt(filename);
+}
+
+function isEscaped(text: string, index: number): boolean {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && text[cursor] === '\\'; cursor--) {
+        backslashes++;
+    }
+    return backslashes % 2 === 1;
+}
+
+function titleCounts(notes: readonly NotesNoteMetadata[]): Map<string, number> {
+    const counts = new Map<string, number>();
+    for (const note of notes) {
+        const title = note.title.trim();
+        if (!title) continue;
+        const key = lower(title);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+
+function insertionText(note: NotesNoteMetadata, counts: Map<string, number>): string {
+    const title = note.title.trim();
+    if (title && counts.get(lower(title)) === 1) return title;
+    return pathWithoutExt(note.path);
+}
+
+function scoreNote(
+    note: NotesNoteMetadata,
+    query: string,
+): Pick<WikiLinkSuggestion, 'matchKind' | 'score'> | null {
+    if (!query) return { matchKind: 'title', score: 1 };
+
+    const normalizedTitle = lower(note.title);
+    const normalizedPath = lower(note.path);
+    const normalizedStem = lower(noteStem(note.path));
+    if (normalizedTitle === query) return { matchKind: 'title', score: 100 };
+    if (normalizedTitle.startsWith(query)) return { matchKind: 'title', score: 90 };
+
+    for (const alias of note.aliases) {
+        const normalizedAlias = lower(alias);
+        if (normalizedAlias === query) return { matchKind: 'alias', score: 85 };
+        if (normalizedAlias.startsWith(query)) return { matchKind: 'alias', score: 80 };
+    }
+
+    if (normalizedStem === query) return { matchKind: 'path', score: 75 };
+    if (normalizedStem.startsWith(query)) return { matchKind: 'path', score: 70 };
+    if (normalizedPath.includes(query)) return { matchKind: 'path', score: 50 };
+
+    for (const tag of note.tags) {
+        const normalizedTag = lower(tag).replace(/^#/, '');
+        if (normalizedTag === query || normalizedTag.startsWith(query)) return { matchKind: 'tag', score: 40 };
+    }
+
+    return null;
+}
+
+export function getWikiLinkCompletionRange(textBeforeCursor: string): WikiLinkCompletionRange | null {
+    if (!textBeforeCursor) return null;
+    let open = textBeforeCursor.lastIndexOf('[[');
+    while (open !== -1 && isEscaped(textBeforeCursor, open)) {
+        open = textBeforeCursor.lastIndexOf('[[', open - 1);
+    }
+    if (open === -1) return null;
+    const queryStart = open + 2;
+    const query = textBeforeCursor.slice(queryStart);
+    if (query.includes('\n') || query.includes(']') || query.includes('[')) return null;
+    if (textBeforeCursor.slice(queryStart).includes(']]')) return null;
+    return { from: queryStart, to: textBeforeCursor.length, query };
+}
+
+export function getWikiLinkCompletionRangeAtCursor(
+    lineText: string,
+    cursorOffset: number,
+): WikiLinkCompletionRangeAtCursor | null {
+    if (cursorOffset < 0 || cursorOffset > lineText.length) return null;
+    const prefix = getWikiLinkCompletionRange(lineText.slice(0, cursorOffset));
+    if (!prefix) return null;
+    const hasClosingSuffix = lineText.slice(cursorOffset, cursorOffset + 2) === ']]';
+    return {
+        ...prefix,
+        to: prefix.to + (hasClosingSuffix ? 2 : 0),
+        hasClosingSuffix,
+    };
+}
+
+export function getWikiLinkSuggestions(
+    notes: readonly NotesNoteMetadata[],
+    query: string,
+    limit = DEFAULT_SUGGESTION_LIMIT,
+): WikiLinkSuggestion[] {
+    const normalizedQuery = lower(query);
+    const counts = titleCounts(notes);
+    const suggestions: WikiLinkSuggestion[] = [];
+    for (const note of notes) {
+        const scored = scoreNote(note, normalizedQuery);
+        if (!scored) continue;
+        suggestions.push({
+            path: note.path,
+            title: note.title,
+            aliases: note.aliases,
+            tags: note.tags,
+            insertText: insertionText(note, counts),
+            matchKind: scored.matchKind,
+            score: scored.score,
+        });
+    }
+    return suggestions
+        .sort((a, b) => b.score - a.score
+            || a.title.localeCompare(b.title)
+            || a.path.localeCompare(b.path))
+        .slice(0, limit);
+}
+
+export function formatWikiLinkCompletion(suggestion: WikiLinkSuggestion): string {
+    return `${suggestion.insertText}]]`;
+}

package/public/manager/src/notes/wysiwyg/MilkdownWysiwygEditor.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { Editor, defaultValueCtx, editorViewCtx, rootCtx, schemaCtx } from '@milkdown/kit/core';
 import { commonmark } from '@milkdown/kit/preset/commonmark';
 import {
@@ -18,79 +18,101 @@ import { callCommand, getMarkdown, insert, insertPos, replaceAll } from '@milkdo
 import { safeMarkdownUrl } from '../markdown-security';
 import { hasImportableClipboardImage } from '../image-assets/clipboard-images';
 import { uploadClipboardImageMarkdown } from '../image-assets/insert-image-markdown';
-import { notesImageSrc } from '../rendering/markdown-render-security';
+import {
+    focusEditable,
+    htmlToPlainText,
+    isCodeBlockRawPasteTarget,
+    normalizeCodeLanguage,
+    refreshMilkdownAssetImages,
+} from './milkdown-editor-utils';
 import { notesMilkdownBlockKeymap } from './milkdown-block-keymap';
-import { notesMilkdownCodeBlockView } from './milkdown-code-block-view';
+import { CODE_SOURCE_UPDATED_EVENT, notesMilkdownCodeBlockView } from './milkdown-code-block-view';
 import { notesMilkdownGfm } from './milkdown-gfm-safe';
 import { notesMilkdownHeadingSourceView } from './milkdown-heading-source-view';
-import { notesMilkdownKatexOptionsCtx, notesMilkdownMath } from './milkdown-math';
+import { MATH_SOURCE_UPDATED_EVENT, notesMilkdownKatexOptionsCtx, notesMilkdownMath } from './milkdown-math';
 import { normalizeEscapedTaskMarkers, protectUnsupportedGfmForMilkdown } from './milkdown-task-markers';
-
-type MilkdownWysiwygEditorProps = {
-    active: boolean;
-    content: string;
-    notePath: string;
-    onChange: (value: string) => void;
-};
+import { notesMilkdownWikiLinkCompletionPlugin, requestWysiwygWikiLinkCompletionRefresh } from './milkdown-wikilink-completion';
+import { notesMilkdownWikiLinkPlugin, requestWysiwygWikiLinkRefresh } from './milkdown-wikilink-plugin';
+import { WysiwygFrontmatterPanel } from './WysiwygFrontmatterPanel';
+import { composeWysiwygFrontmatter, splitWysiwygFrontmatter, type WysiwygFrontmatterData } from './wysiwyg-frontmatter';
+import type { MilkdownWysiwygEditorProps } from './milkdown-wysiwyg-types';
 
 type MilkdownCommand = (editor: Editor) => void;
 
-function focusEditable(root: HTMLDivElement | null): void {
-    root?.querySelector<HTMLElement>('.ProseMirror')?.focus();
-}
-
-function htmlToPlainText(html: string): string {
-    const element = document.createElement('div');
-    element.innerHTML = html;
-    return element.textContent ?? '';
-}
-
-function isCodeBlockRawPasteTarget(target: EventTarget | null): boolean {
-    return target instanceof HTMLElement
-        && Boolean(target.closest('textarea.notes-code-raw'));
-}
-
-function normalizeCodeLanguage(language: string): string {
-    return language.trim().toLowerCase().replace(/[^a-z0-9_+-]/g, '');
-}
-
-function refreshMilkdownAssetImages(root: HTMLDivElement | null): void {
-    if (!root) return;
-    root.querySelectorAll<HTMLImageElement>('img[src]').forEach(image => {
-        const originalSrc = image.dataset['notesOriginalSrc'] || image.getAttribute('src') || '';
-        if (!originalSrc) return;
-        const resolvedSrc = notesImageSrc(originalSrc);
-        if (!resolvedSrc) return;
-        image.dataset['notesOriginalSrc'] = originalSrc;
-        if (image.getAttribute('src') !== resolvedSrc) image.setAttribute('src', resolvedSrc);
-    });
-}
-
 export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
+    const initialDocument = useMemo(() => splitWysiwygFrontmatter(props.content), []);
     const shellRef = useRef<HTMLDivElement | null>(null);
     const rootRef = useRef<HTMLDivElement | null>(null);
     const editorRef = useRef<Editor | null>(null);
-    const latestMarkdownRef = useRef(props.content);
-    const latestPropContentRef = useRef(props.content);
+    const latestBodyRef = useRef(initialDocument.body);
+    const latestFrontmatterRef = useRef<WysiwygFrontmatterData | null>(initialDocument.frontmatter);
+    const latestComposedRef = useRef(props.content);
     const onChangeRef = useRef(props.onChange);
     const notePathRef = useRef(props.notePath);
+    const wikiRuntimeRef = useRef({
+        outgoing: props.outgoing,
+        notes: props.notes,
+        onNavigate: props.onWikiLinkNavigate,
+    });
+    const wikiCompletionRuntimeRef = useRef({
+        notes: props.notes,
+    });
     const syncingFromPropsRef = useRef(true);
     const [ready, setReady] = useState(false);
     const [error, setError] = useState<string | null>(null);
     const [uploadStatus, setUploadStatus] = useState<'idle' | 'uploading' | 'error'>('idle');
+    const [frontmatterPanel, setFrontmatterPanel] = useState<WysiwygFrontmatterData | null>(initialDocument.frontmatter);
 
     useEffect(() => {
         onChangeRef.current = props.onChange;
     }, [props.onChange]);
 
-    useEffect(() => {
-        latestPropContentRef.current = props.content;
-    }, [props.content]);
-
     useEffect(() => {
         notePathRef.current = props.notePath;
     }, [props.notePath]);
 
+    useEffect(() => {
+        wikiRuntimeRef.current.onNavigate = props.onWikiLinkNavigate;
+    }, [props.onWikiLinkNavigate]);
+
+    useEffect(() => {
+        wikiRuntimeRef.current.outgoing = props.outgoing;
+        wikiRuntimeRef.current.notes = props.notes;
+        wikiCompletionRuntimeRef.current.notes = props.notes;
+        refreshWikiLinkPlugins();
+    }, [props.outgoing, props.notes]);
+
+    function composeBody(body: string): string {
+        return composeWysiwygFrontmatter(latestFrontmatterRef.current, body);
+    }
+
+    function emitBodyChange(body: string): void {
+        latestBodyRef.current = body;
+        const composed = composeBody(body);
+        latestComposedRef.current = composed;
+        onChangeRef.current(composed);
+    }
+
+    function emitFrontmatterChange(next: WysiwygFrontmatterData | null): void {
+        latestFrontmatterRef.current = next;
+        setFrontmatterPanel(next);
+        const composed = composeBody(latestBodyRef.current);
+        latestComposedRef.current = composed;
+        onChangeRef.current(composed);
+    }
+
+    function refreshWikiLinkPlugins(): void {
+        editorRef.current?.action(ctx => {
+            const view = ctx.get(editorViewCtx);
+            requestWysiwygWikiLinkRefresh(view);
+            requestWysiwygWikiLinkCompletionRefresh(view);
+        });
+    }
+
+    function refreshWikiLinkPluginsAfterFrame(): void {
+        requestAnimationFrame(() => refreshWikiLinkPlugins());
+    }
+
     useEffect(() => {
         let disposed = false;
         let editor: Editor | null = null;
@@ -100,17 +122,17 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
         void Editor.make()
             .config(ctx => {
                 ctx.set(rootCtx, root);
-                ctx.set(defaultValueCtx, protectUnsupportedGfmForMilkdown(latestMarkdownRef.current));
+                ctx.set(defaultValueCtx, protectUnsupportedGfmForMilkdown(latestBodyRef.current));
                 ctx.set(notesMilkdownKatexOptionsCtx.key, {
                     throwOnError: false,
                     strict: 'warn',
                 });
                 ctx.get(listenerCtx).markdownUpdated((_, markdown) => {
-                    const normalizedMarkdown = normalizeEscapedTaskMarkers(markdown);
-                    latestMarkdownRef.current = normalizedMarkdown;
+                    const normalizedBody = normalizeEscapedTaskMarkers(markdown);
+                    latestBodyRef.current = normalizedBody;
                     queueMicrotask(() => refreshMilkdownAssetImages(rootRef.current));
                     if (syncingFromPropsRef.current) return;
-                    onChangeRef.current(normalizedMarkdown);
+                    emitBodyChange(normalizedBody);
                 });
             })
             .use(commonmark)
@@ -119,6 +141,8 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
             .use(notesMilkdownMath)
             .use(notesMilkdownCodeBlockView)
             .use(notesMilkdownBlockKeymap)
+            .use(notesMilkdownWikiLinkPlugin(wikiRuntimeRef.current))
+            .use(notesMilkdownWikiLinkCompletionPlugin(wikiCompletionRuntimeRef.current))
             .use(history)
             .use(clipboard)
             .use(listener)
@@ -130,9 +154,13 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
                 }
                 editor = instance;
                 editorRef.current = instance;
-                if (latestPropContentRef.current !== latestMarkdownRef.current) {
-                    latestMarkdownRef.current = latestPropContentRef.current;
-                    instance.action(replaceAll(protectUnsupportedGfmForMilkdown(latestPropContentRef.current), true));
+                const nextDocument = splitWysiwygFrontmatter(latestComposedRef.current);
+                if (nextDocument.body !== latestBodyRef.current) {
+                    latestBodyRef.current = nextDocument.body;
+                    latestFrontmatterRef.current = nextDocument.frontmatter;
+                    setFrontmatterPanel(nextDocument.frontmatter);
+                    instance.action(replaceAll(protectUnsupportedGfmForMilkdown(nextDocument.body), true));
+                    refreshWikiLinkPluginsAfterFrame();
                 }
                 setReady(true);
                 queueMicrotask(() => {
@@ -158,10 +186,15 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
     useEffect(() => {
         const editor = editorRef.current;
         if (!editor) return;
-        if (props.content === latestMarkdownRef.current) return;
+        if (props.content === latestComposedRef.current) return;
+        const nextDocument = splitWysiwygFrontmatter(props.content);
         syncingFromPropsRef.current = true;
-        latestMarkdownRef.current = props.content;
-        editor.action(replaceAll(protectUnsupportedGfmForMilkdown(props.content), true));
+        latestBodyRef.current = nextDocument.body;
+        latestFrontmatterRef.current = nextDocument.frontmatter;
+        latestComposedRef.current = props.content;
+        setFrontmatterPanel(nextDocument.frontmatter);
+        editor.action(replaceAll(protectUnsupportedGfmForMilkdown(nextDocument.body), true));
+        refreshWikiLinkPluginsAfterFrame();
         queueMicrotask(() => {
             syncingFromPropsRef.current = false;
             refreshMilkdownAssetImages(rootRef.current);
@@ -177,17 +210,23 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
         const root = rootRef.current;
         if (!root) return undefined;
 
-        function handleHeadingSourceUpdated(): void {
-            editorRef.current?.action(ctx => {
-                const markdown = normalizeEscapedTaskMarkers(getMarkdown()(ctx));
-                latestMarkdownRef.current = markdown;
-                if (!syncingFromPropsRef.current) onChangeRef.current(markdown);
+        function handleExternalNodeSourceUpdated(): void {
+            queueMicrotask(() => {
+                editorRef.current?.action(ctx => {
+                    const body = normalizeEscapedTaskMarkers(getMarkdown()(ctx));
+                    latestBodyRef.current = body;
+                    if (!syncingFromPropsRef.current) emitBodyChange(body);
+                });
             });
         }
 
-        root.addEventListener('notes-heading-source-updated', handleHeadingSourceUpdated);
+        root.addEventListener('notes-heading-source-updated', handleExternalNodeSourceUpdated);
+        root.addEventListener(MATH_SOURCE_UPDATED_EVENT, handleExternalNodeSourceUpdated);
+        root.addEventListener(CODE_SOURCE_UPDATED_EVENT, handleExternalNodeSourceUpdated);
         return () => {
-            root.removeEventListener('notes-heading-source-updated', handleHeadingSourceUpdated);
+            root.removeEventListener('notes-heading-source-updated', handleExternalNodeSourceUpdated);
+            root.removeEventListener(MATH_SOURCE_UPDATED_EVENT, handleExternalNodeSourceUpdated);
+            root.removeEventListener(CODE_SOURCE_UPDATED_EVENT, handleExternalNodeSourceUpdated);
         };
     }, [ready]);
 
@@ -240,11 +279,11 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
     }
 
     function insertTaskListItem(): void {
-        const currentMarkdown = latestMarkdownRef.current.trimEnd();
+        const currentMarkdown = latestBodyRef.current.trimEnd();
         const nextMarkdown = `${currentMarkdown}${currentMarkdown ? '\n\n' : ''}- [ ] `;
-        latestMarkdownRef.current = nextMarkdown;
-        onChangeRef.current(nextMarkdown);
+        emitBodyChange(nextMarkdown);
         run(editor => editor.action(replaceAll(protectUnsupportedGfmForMilkdown(nextMarkdown), true)));
+        refreshWikiLinkPluginsAfterFrame();
     }
 
     useEffect(() => {
@@ -275,9 +314,9 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
                         ...node.attrs,
                         checked: !node.attrs['checked'],
                     }).scrollIntoView());
-                    const markdown = normalizeEscapedTaskMarkers(getMarkdown()(ctx));
-                    latestMarkdownRef.current = markdown;
-                    if (!syncingFromPropsRef.current) onChangeRef.current(markdown);
+                    const body = normalizeEscapedTaskMarkers(getMarkdown()(ctx));
+                    latestBodyRef.current = body;
+                    if (!syncingFromPropsRef.current) emitBodyChange(body);
                     queueMicrotask(syncTaskListAccessibility);
                     return;
                 }
@@ -465,14 +504,22 @@ export function MilkdownWysiwygEditor(props: MilkdownWysiwygEditorProps) {
                     {uploadStatus === 'uploading' ? 'Uploading image…' : 'Image upload failed'}
                 </div>
             )}
-            <div
-                ref={rootRef}
-                className="notes-milkdown-root"
-                data-ready={ready ? 'true' : 'false'}
-                aria-label="Milkdown WYSIWYG markdown editor"
-                role="textbox"
-                aria-multiline="true"
-            />
+            <div className="notes-milkdown-scroll">
+                <WysiwygFrontmatterPanel
+                    frontmatter={frontmatterPanel}
+                    activeTag={props.activeTag}
+                    onChange={emitFrontmatterChange}
+                    onTagClick={props.onTagSelect}
+                />
+                <div
+                    ref={rootRef}
+                    className="notes-milkdown-root"
+                    data-ready={ready ? 'true' : 'false'}
+                    aria-label="Milkdown WYSIWYG markdown editor"
+                    role="textbox"
+                    aria-multiline="true"
+                />
+            </div>
         </div>
     );
 }

package/public/manager/src/notes/wysiwyg/WysiwygFrontmatterPanel.tsx

@@ -0,0 +1,93 @@
+import {
+    createEmptyWysiwygFrontmatter,
+    updateWysiwygFrontmatter,
+    type WysiwygFrontmatterData,
+} from './wysiwyg-frontmatter';
+
+type WysiwygFrontmatterPanelProps = {
+    frontmatter: WysiwygFrontmatterData | null;
+    activeTag: string | null;
+    onChange: (frontmatter: WysiwygFrontmatterData | null) => void;
+    onTagClick: (tag: string | null) => void;
+};
+
+function parseAliasesInput(value: string): string[] {
+    return value.split(',').map(item => item.trim()).filter(Boolean);
+}
+
+function parseTagsInput(value: string): string[] {
+    return value.split(/[\s,]+/u)
+        .map(item => item.trim().replace(/^#/, '').trim())
+        .filter(Boolean);
+}
+
+export function WysiwygFrontmatterPanel(props: WysiwygFrontmatterPanelProps) {
+    const frontmatter = props.frontmatter;
+    if (!frontmatter) {
+        return (
+            <section className="notes-wysiwyg-frontmatter notes-wysiwyg-frontmatter-empty" aria-label="Frontmatter">
+                <button
+                    type="button"
+                    className="notes-wysiwyg-frontmatter-add"
+                    onClick={() => props.onChange(createEmptyWysiwygFrontmatter())}
+                >
+                    <span>Properties</span>
+                    <strong>Add</strong>
+                </button>
+            </section>
+        );
+    }
+    if (frontmatter.error || !frontmatter.editable) {
+        return (
+            <section className="notes-wysiwyg-frontmatter" aria-label="Frontmatter">
+                <span className="notes-frontmatter-error" role="alert">
+                    {frontmatter.error || 'Frontmatter is preserved as raw YAML'}
+                </span>
+            </section>
+        );
+    }
+
+    return (
+        <section className="notes-wysiwyg-frontmatter" aria-label="Frontmatter">
+            <label className="notes-wysiwyg-frontmatter-field">
+                <span>Aliases</span>
+                <input
+                    value={frontmatter.aliases.join(', ')}
+                    onChange={event => props.onChange(updateWysiwygFrontmatter(frontmatter, {
+                        aliases: parseAliasesInput(event.currentTarget.value),
+                    }))}
+                />
+            </label>
+            <label className="notes-wysiwyg-frontmatter-field">
+                <span>Created</span>
+                <input
+                    value={frontmatter.created ?? ''}
+                    onChange={event => props.onChange(updateWysiwygFrontmatter(frontmatter, {
+                        created: event.currentTarget.value.trim() || null,
+                    }))}
+                />
+            </label>
+            <div className="notes-wysiwyg-frontmatter-tags">
+                {frontmatter.tags.map(tag => (
+                    <button
+                        key={tag}
+                        type="button"
+                        className={`notes-tag-chip${props.activeTag === tag ? ' is-active' : ''}`}
+                        onClick={() => props.onTagClick(props.activeTag === tag ? null : tag)}
+                    >
+                        {tag}
+                    </button>
+                ))}
+            </div>
+            <label className="notes-wysiwyg-frontmatter-field is-wide">
+                <span>Tags</span>
+                <input
+                    value={frontmatter.tags.join(', ')}
+                    onChange={event => props.onChange(updateWysiwygFrontmatter(frontmatter, {
+                        tags: parseTagsInput(event.currentTarget.value),
+                    }))}
+                />
+            </label>
+        </section>
+    );
+}

package/public/manager/src/notes/wysiwyg/milkdown-code-block-view.ts

@@ -6,6 +6,8 @@ import type { EditorView, NodeView, NodeViewConstructor } from '@milkdown/kit/pr
 import { $view } from '@milkdown/kit/utils';
 import { highlightCode } from '../rendering/highlight-languages';
 
+export const CODE_SOURCE_UPDATED_EVENT = 'notes-code-source-updated';
+
 function codeText(node: ProseMirrorNode): string {
     return node.textContent;
 }
@@ -50,6 +52,10 @@ function isCaretAtFenceBoundary(input: HTMLTextAreaElement): boolean {
     return /^```[^\n`]*$/.test(line);
 }
 
+function notifyCodeSourceUpdated(view: EditorView): void {
+    view.dom.dispatchEvent(new CustomEvent(CODE_SOURCE_UPDATED_EVENT, { bubbles: true }));
+}
+
 function updateCodeBlockNode(view: EditorView, getPos: () => number | undefined, source: string): void {
     const pos = getPos();
     if (pos === undefined) return;
@@ -62,6 +68,7 @@ function updateCodeBlockNode(view: EditorView, getPos: () => number | undefined,
         .replaceWith(pos + 1, pos + current.nodeSize - 1, nextText)
         .scrollIntoView();
     view.dispatch(tr);
+    notifyCodeSourceUpdated(view);
 }
 
 function commitAndExitCodeBlock(
@@ -89,6 +96,7 @@ function commitAndExitCodeBlock(
             if (nextNode.isTextblock && nextNode.content.size === 0) {
                 tr.setSelection(TextSelection.create(tr.doc, codeAfter + 1));
                 view.dispatch(tr.scrollIntoView());
+                notifyCodeSourceUpdated(view);
                 return;
             }
         }
@@ -97,6 +105,7 @@ function commitAndExitCodeBlock(
         tr.insert(codeAfter, paragraph);
         tr.setSelection(TextSelection.create(tr.doc, codeAfter + 1));
         view.dispatch(tr.scrollIntoView());
+        notifyCodeSourceUpdated(view);
         return;
     }
 
@@ -108,6 +117,7 @@ function commitAndExitCodeBlock(
             const prevEnd = pos - 1;
             tr.setSelection(TextSelection.create(tr.doc, prevEnd));
             view.dispatch(tr.scrollIntoView());
+            notifyCodeSourceUpdated(view);
             return;
         }
     }
@@ -117,6 +127,7 @@ function commitAndExitCodeBlock(
     tr.insert(pos, paragraph);
     tr.setSelection(TextSelection.create(tr.doc, pos + 1));
     view.dispatch(tr.scrollIntoView());
+    notifyCodeSourceUpdated(view);
 }
 
 function exitDirectionForCaret(raw: HTMLTextAreaElement): 'above' | 'below' {

package/public/manager/src/notes/wysiwyg/milkdown-editor-utils.ts

@@ -0,0 +1,32 @@
+import { notesImageSrc } from '../rendering/markdown-render-security';
+
+export function focusEditable(root: HTMLDivElement | null): void {
+    root?.querySelector<HTMLElement>('.ProseMirror')?.focus();
+}
+
+export function htmlToPlainText(html: string): string {
+    const element = document.createElement('div');
+    element.innerHTML = html;
+    return element.textContent ?? '';
+}
+
+export function isCodeBlockRawPasteTarget(target: EventTarget | null): boolean {
+    return target instanceof HTMLElement
+        && Boolean(target.closest('textarea.notes-code-raw'));
+}
+
+export function normalizeCodeLanguage(language: string): string {
+    return language.trim().toLowerCase().replace(/[^a-z0-9_+-]/g, '');
+}
+
+export function refreshMilkdownAssetImages(root: HTMLDivElement | null): void {
+    if (!root) return;
+    root.querySelectorAll<HTMLImageElement>('img[src]').forEach(image => {
+        const originalSrc = image.dataset['notesOriginalSrc'] || image.getAttribute('src') || '';
+        if (!originalSrc) return;
+        const resolvedSrc = notesImageSrc(originalSrc);
+        if (!resolvedSrc) return;
+        image.dataset['notesOriginalSrc'] = originalSrc;
+        if (image.getAttribute('src') !== resolvedSrc) image.setAttribute('src', resolvedSrc);
+    });
+}