@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

package/dist/ui/file-preview/src/markdown/selection-toolbar.js

@@ -0,0 +1,128 @@
+/**
+ * Floating selection toolbar that appears above non-empty text selections
+ * inside the editor root. Uses `document.execCommand` for formatting so it
+ * works uniformly with ProseMirror (which intercepts beforeinput) and plain
+ * contenteditable.
+ */
+export function attachSelectionToolbar(options) {
+    const toolbar = document.createElement('div');
+    toolbar.className = 'md-selection-toolbar';
+    toolbar.setAttribute('role', 'toolbar');
+    toolbar.hidden = true;
+    toolbar.innerHTML = `
+      <button type="button" class="md-selection-toolbar-btn" data-action="bold" title="Bold"><strong>B</strong></button>
+      <button type="button" class="md-selection-toolbar-btn" data-action="italic" title="Italic"><em>I</em></button>
+      <button type="button" class="md-selection-toolbar-btn" data-action="strike" title="Strikethrough"><span style="text-decoration:line-through">S</span></button>
+      <span class="md-selection-toolbar-sep" aria-hidden="true"></span>
+      <button type="button" class="md-selection-toolbar-btn" data-action="heading-1" title="Heading 1">H1</button>
+      <button type="button" class="md-selection-toolbar-btn" data-action="heading-2" title="Heading 2">H2</button>
+      <button type="button" class="md-selection-toolbar-btn" data-action="heading-3" title="Heading 3">H3</button>
+      <span class="md-selection-toolbar-sep" aria-hidden="true"></span>
+      <button type="button" class="md-selection-toolbar-btn" data-action="code" title="Inline code">&lsaquo;&rsaquo;</button>
+      <button type="button" class="md-selection-toolbar-btn" data-action="link" title="Link">&#128279;</button>
+    `;
+    document.body.appendChild(toolbar);
+    function positionToToolbar(rect) {
+        const toolbarRect = toolbar.getBoundingClientRect();
+        const margin = 8;
+        let top = rect.top - toolbarRect.height - margin;
+        if (top < margin) {
+            top = rect.bottom + margin;
+        }
+        let left = rect.left + rect.width / 2 - toolbarRect.width / 2;
+        const viewportWidth = document.documentElement.clientWidth;
+        left = Math.max(margin, Math.min(left, viewportWidth - toolbarRect.width - margin));
+        toolbar.style.position = 'fixed';
+        toolbar.style.top = `${top}px`;
+        toolbar.style.left = `${left}px`;
+    }
+    function hide() {
+        toolbar.hidden = true;
+    }
+    function selectionIsInsideEditor(selection) {
+        const anchorNode = selection.anchorNode;
+        if (!anchorNode)
+            return false;
+        return options.editorRoot.contains(anchorNode.nodeType === Node.ELEMENT_NODE ? anchorNode : anchorNode.parentElement);
+    }
+    function update() {
+        const selection = window.getSelection();
+        if (!selection || selection.isCollapsed || selection.rangeCount === 0) {
+            hide();
+            return;
+        }
+        if (!selectionIsInsideEditor(selection)) {
+            hide();
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        const rect = range.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) {
+            hide();
+            return;
+        }
+        toolbar.hidden = false;
+        positionToToolbar(rect);
+    }
+    const onSelectionChange = () => {
+        // Debounce to next frame so getBoundingClientRect is stable.
+        requestAnimationFrame(update);
+    };
+    const onScrollOrResize = () => {
+        if (!toolbar.hidden)
+            update();
+    };
+    document.addEventListener('selectionchange', onSelectionChange);
+    window.addEventListener('scroll', onScrollOrResize, true);
+    window.addEventListener('resize', onScrollOrResize);
+    toolbar.addEventListener('mousedown', (event) => {
+        // Keep the editor's selection while interacting with the toolbar.
+        event.preventDefault();
+    });
+    toolbar.addEventListener('click', (event) => {
+        const button = event.target.closest('[data-action]');
+        if (!button)
+            return;
+        const action = button.dataset.action;
+        if (!action)
+            return;
+        const selectedText = window.getSelection()?.toString() ?? '';
+        switch (action) {
+            case 'bold':
+                document.execCommand('bold');
+                break;
+            case 'italic':
+                document.execCommand('italic');
+                break;
+            case 'strike':
+                document.execCommand('strikeThrough');
+                break;
+            case 'code': {
+                const wrapped = `\`${selectedText || 'code'}\``;
+                document.execCommand('insertText', false, wrapped);
+                break;
+            }
+            case 'heading-1':
+                document.execCommand('formatBlock', false, 'h1');
+                break;
+            case 'heading-2':
+                document.execCommand('formatBlock', false, 'h2');
+                break;
+            case 'heading-3':
+                document.execCommand('formatBlock', false, 'h3');
+                break;
+            case 'link':
+                options.onLinkRequest?.(selectedText);
+                break;
+        }
+        hide();
+    });
+    return {
+        destroy: () => {
+            document.removeEventListener('selectionchange', onSelectionChange);
+            window.removeEventListener('scroll', onScrollOrResize, true);
+            window.removeEventListener('resize', onScrollOrResize);
+            toolbar.remove();
+        },
+    };
+}

package/dist/ui/file-preview/src/markdown/slugify.d.ts

@@ -0,0 +1,3 @@
+export type MarkdownSlugTracker = (text: string) => string;
+export declare function slugifyMarkdownHeading(text: string): string;
+export declare function createSlugTracker(): MarkdownSlugTracker;

package/dist/ui/file-preview/src/markdown/slugify.js

@@ -0,0 +1,31 @@
+function sanitizeSlugPart(text) {
+    const normalized = text
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized.length > 0 ? normalized : 'section';
+}
+export function slugifyMarkdownHeading(text) {
+    return sanitizeSlugPart(text);
+}
+export function createSlugTracker() {
+    const counts = new Map();
+    const usedSlugs = new Set();
+    return (text) => {
+        const baseSlug = slugifyMarkdownHeading(text);
+        let nextCount = counts.get(baseSlug) ?? 1;
+        let nextSlug = nextCount === 1 ? baseSlug : `${baseSlug}-${nextCount}`;
+        while (usedSlugs.has(nextSlug)) {
+            nextCount += 1;
+            nextSlug = `${baseSlug}-${nextCount}`;
+        }
+        counts.set(baseSlug, nextCount + 1);
+        usedSlugs.add(nextSlug);
+        return nextSlug;
+    };
+}

package/dist/ui/file-preview/src/markdown/toc.d.ts

@@ -0,0 +1,11 @@
+import type { MarkdownOutlineItem } from './outline.js';
+export interface MarkdownTocHandle {
+    dispose: () => void;
+}
+export declare function renderMarkdownToc(outline: MarkdownOutlineItem[], activeHeadingId?: string | null): string;
+export declare function attachMarkdownToc(options: {
+    shell: HTMLElement;
+    outline: MarkdownOutlineItem[];
+    scrollContainer: HTMLElement;
+    onSelect: (headingId: string) => void;
+}): MarkdownTocHandle | null;

package/dist/ui/file-preview/src/markdown/toc.js

@@ -0,0 +1,75 @@
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function setActiveItem(nav, activeId) {
+    const buttons = Array.from(nav.querySelectorAll('[data-toc-id]'));
+    buttons.forEach((button) => {
+        const isActive = button.dataset.tocId === activeId;
+        button.classList.toggle('is-active', isActive);
+        button.setAttribute('aria-current', isActive ? 'location' : 'false');
+    });
+}
+export function renderMarkdownToc(outline, activeHeadingId) {
+    if (outline.length === 0) {
+        return '';
+    }
+    const items = outline.map((item) => {
+        const activeClass = item.id === activeHeadingId ? ' is-active' : '';
+        return `<button class="markdown-toc-link${activeClass}" type="button" data-toc-id="${escapeHtml(item.id)}" data-level="${item.level}" aria-current="${item.id === activeHeadingId ? 'location' : 'false'}">${escapeHtml(item.text)}</button>`;
+    }).join('');
+    return `
+      <aside class="markdown-toc-shell" aria-label="Table of contents">
+        <div class="markdown-toc-title">Contents</div>
+        <nav class="markdown-toc-nav">${items}</nav>
+      </aside>
+    `;
+}
+export function attachMarkdownToc(options) {
+    const nav = options.shell.querySelector('.markdown-toc-nav');
+    if (!nav) {
+        return null;
+    }
+    const handleClick = (event) => {
+        const target = event.target;
+        const button = target?.closest('[data-toc-id]');
+        const headingId = button?.dataset.tocId;
+        if (!headingId) {
+            return;
+        }
+        options.onSelect(headingId);
+        setActiveItem(nav, headingId);
+    };
+    const updateActiveHeading = () => {
+        const headings = options.outline
+            .map((item) => {
+            const element = document.getElementById(item.id);
+            return element ? { item, element } : null;
+        })
+            .filter((entry) => entry !== null);
+        if (headings.length === 0) {
+            return;
+        }
+        const scrollTop = options.scrollContainer.scrollTop;
+        const nextActive = headings.reduce((activeId, current) => {
+            if (current.element.offsetTop - scrollTop <= 96) {
+                return current.item.id;
+            }
+            return activeId;
+        }, headings[0].item.id);
+        setActiveItem(nav, nextActive);
+    };
+    nav.addEventListener('click', handleClick);
+    options.scrollContainer.addEventListener('scroll', updateActiveHeading, { passive: true });
+    updateActiveHeading();
+    return {
+        dispose: () => {
+            nav.removeEventListener('click', handleClick);
+            options.scrollContainer.removeEventListener('scroll', updateActiveHeading);
+        },
+    };
+}

package/dist/ui/file-preview/src/markdown/utils.d.ts

@@ -0,0 +1 @@
+export declare function extractInlineText(token: Record<string, unknown> | undefined): string;

package/dist/ui/file-preview/src/markdown/utils.js

@@ -0,0 +1,15 @@
+export function extractInlineText(token) {
+    if (!token) {
+        return '';
+    }
+    const children = Array.isArray(token.children) ? token.children : [];
+    if (children.length === 0) {
+        return typeof token.content === 'string' ? token.content : '';
+    }
+    return children.map((child) => {
+        if (typeof child.content === 'string') {
+            return child.content;
+        }
+        return '';
+    }).join('');
+}

package/dist/ui/file-preview/src/markdown-workspace/editor.d.ts

@@ -0,0 +1,36 @@
+export type MarkdownEditorView = 'raw' | 'markdown';
+export interface MarkdownLinkSearchItem {
+    path: string;
+    title: string;
+    wikiPath: string;
+    relativePath: string;
+}
+export interface MarkdownLinkHeading {
+    id: string;
+    text: string;
+}
+export interface MarkdownEditorHandle {
+    destroy: () => void;
+    focus: () => void;
+    getValue: () => string;
+    setValue: (value: string) => void;
+    revealLine: (lineNumber: number, headingId?: string) => void;
+    setScrollTop: (scrollTop: number) => void;
+}
+export declare function renderMarkdownCopyButton(): string;
+export declare function renderMarkdownModeToggle(view: MarkdownEditorView): string;
+export declare function renderMarkdownEditorShell(options: {
+    content: string;
+    view: MarkdownEditorView;
+}): string;
+export declare function mountMarkdownEditor(options: {
+    target: HTMLElement;
+    value: string;
+    view: MarkdownEditorView;
+    initialScrollTop?: number;
+    currentFilePath: string;
+    searchLinks?: (query: string) => Promise<MarkdownLinkSearchItem[]>;
+    loadHeadings?: (filePath: string) => Promise<MarkdownLinkHeading[]>;
+    onChange: (value: string) => void;
+    onBlur?: () => void;
+}): MarkdownEditorHandle;