@plebeiantech/lat.md 0.12.3-fork.2 → 0.12.3-fork.20

package/dist/src/view/git-diff.js

@@ -1,6 +1,8 @@
-import { parse } from '../parser.js';
+import { parse } from '@plebeiantech/lat.md-core/parser';
 const MAX_DIFF_CELLS = 1_000_000;
+const MIN_INLINE_WORD_OVERLAP = 0.6;
 const WORDS = /\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]+/gu;
+const WORD_TOKENS = /[\p{L}\p{N}_]+/gu;
 function sequenceDiff(oldValues, newValues, key) {
     const oldKeys = oldValues.map(key);
     const newKeys = newValues.map(key);
@@ -83,6 +85,15 @@ function nodeText(node) {
         return node.value;
     return withChildren(node) ? node.children.map(nodeText).join('') : '';
 }
+function inlineWordOverlap(oldNode, newNode) {
+    const oldWords = nodeText(oldNode).toLowerCase().match(WORD_TOKENS) ?? [];
+    const newWords = nodeText(newNode).toLowerCase().match(WORD_TOKENS) ?? [];
+    if (oldWords.length === 0 || newWords.length === 0) {
+        return oldWords.length === newWords.length ? 1 : 0;
+    }
+    const shared = sequenceDiff(oldWords, newWords, (word) => word).filter((change) => change.kind === 'same').length;
+    return shared / (oldWords.length + newWords.length - shared);
+}
 function wrapperSignature(node) {
     switch (node.type) {
         case 'link':
@@ -157,7 +168,191 @@ function sourceForNode(markdown, node) {
         ? `${node.type}:${nodeText(node)}`
         : `${node.type}:${markdown.slice(start, end)}`;
 }
+function tableShape(table) {
+    const columns = table.children[0]?.children.length ?? 0;
+    if (columns === 0 ||
+        table.children.some((row) => row.children.length !== columns)) {
+        return null;
+    }
+    return {
+        columns,
+        align: Array.from({ length: columns }, (_, index) => table.align?.[index] ?? ''),
+    };
+}
+function tablesAreCompatible(oldTable, newTable) {
+    const oldShape = tableShape(oldTable);
+    const newShape = tableShape(newTable);
+    return (oldShape !== null &&
+        newShape !== null &&
+        oldShape.columns === newShape.columns &&
+        oldShape.align.every((align, index) => align === newShape.align[index]));
+}
+function tableRowSimilarity(oldRow, newRow) {
+    if (oldRow.children.length !== newRow.children.length)
+        return 0;
+    const matchingCells = oldRow.children.filter((cell, index) => nodeText(cell) === nodeText(newRow.children[index])).length;
+    return Math.max(matchingCells / oldRow.children.length, inlineWordOverlap(oldRow, newRow));
+}
+function alignChangedTableRows(oldRows, newRows) {
+    if (oldRows.length * newRows.length > MAX_DIFF_CELLS) {
+        const paired = Math.min(oldRows.length, newRows.length);
+        return [
+            ...oldRows.slice(0, paired).map((oldValue, index) => ({
+                kind: 'same',
+                oldValue,
+                newValue: newRows[index],
+            })),
+            ...oldRows
+                .slice(paired)
+                .map((value) => ({ kind: 'removed', value })),
+            ...newRows
+                .slice(paired)
+                .map((value) => ({ kind: 'added', value })),
+        ];
+    }
+    const costs = Array.from({ length: oldRows.length + 1 }, () => new Float64Array(newRows.length + 1));
+    for (let oldIndex = oldRows.length; oldIndex >= 0; oldIndex--) {
+        for (let newIndex = newRows.length; newIndex >= 0; newIndex--) {
+            if (oldIndex === oldRows.length) {
+                costs[oldIndex][newIndex] = newRows.length - newIndex;
+            }
+            else if (newIndex === newRows.length) {
+                costs[oldIndex][newIndex] = oldRows.length - oldIndex;
+            }
+            else {
+                const pairCost = costs[oldIndex + 1][newIndex + 1] +
+                    1.5 -
+                    tableRowSimilarity(oldRows[oldIndex], newRows[newIndex]);
+                costs[oldIndex][newIndex] = Math.min(pairCost, costs[oldIndex + 1][newIndex] + 1, costs[oldIndex][newIndex + 1] + 1);
+            }
+        }
+    }
+    const changes = [];
+    let oldIndex = 0;
+    let newIndex = 0;
+    const epsilon = 1e-9;
+    while (oldIndex < oldRows.length || newIndex < newRows.length) {
+        if (oldIndex === oldRows.length) {
+            changes.push({ kind: 'added', value: newRows[newIndex++] });
+            continue;
+        }
+        if (newIndex === newRows.length) {
+            changes.push({ kind: 'removed', value: oldRows[oldIndex++] });
+            continue;
+        }
+        const currentCost = costs[oldIndex][newIndex];
+        const pairCost = costs[oldIndex + 1][newIndex + 1] +
+            1.5 -
+            tableRowSimilarity(oldRows[oldIndex], newRows[newIndex]);
+        const removeCost = costs[oldIndex + 1][newIndex] + 1;
+        const addCost = costs[oldIndex][newIndex + 1] + 1;
+        const oldRemaining = oldRows.length - oldIndex;
+        const newRemaining = newRows.length - newIndex;
+        const pairIsBest = Math.abs(pairCost - currentCost) < epsilon;
+        const pairIsStrictlyBest = pairCost < removeCost - epsilon && pairCost < addCost - epsilon;
+        if (pairIsBest && (pairIsStrictlyBest || oldRemaining === newRemaining)) {
+            changes.push({
+                kind: 'same',
+                oldValue: oldRows[oldIndex++],
+                newValue: newRows[newIndex++],
+            });
+        }
+        else if (oldRemaining > newRemaining &&
+            Math.abs(removeCost - currentCost) < epsilon) {
+            changes.push({ kind: 'removed', value: oldRows[oldIndex++] });
+        }
+        else if (Math.abs(addCost - currentCost) < epsilon) {
+            changes.push({ kind: 'added', value: newRows[newIndex++] });
+        }
+        else if (Math.abs(removeCost - currentCost) < epsilon) {
+            changes.push({ kind: 'removed', value: oldRows[oldIndex++] });
+        }
+        else {
+            changes.push({
+                kind: 'same',
+                oldValue: oldRows[oldIndex++],
+                newValue: newRows[newIndex++],
+            });
+        }
+    }
+    return changes;
+}
+function diffTableRow(oldRow, newRow) {
+    return {
+        ...structuredClone(newRow),
+        children: newRow.children.map((newCell, index) => ({
+            ...structuredClone(newCell),
+            children: diffInline(oldRow.children[index].children, newCell.children),
+        })),
+    };
+}
+function diffTableRows(oldRows, newRows, oldMarkdown, newMarkdown) {
+    const output = [diffTableRow(oldRows[0], newRows[0])];
+    const oldBody = oldRows.slice(1);
+    const newBody = newRows.slice(1);
+    const changes = sequenceDiff(oldBody, newBody, (row) => oldBody.includes(row)
+        ? sourceForNode(oldMarkdown, row)
+        : sourceForNode(newMarkdown, row));
+    for (let index = 0; index < changes.length;) {
+        const change = changes[index];
+        if (change.kind === 'same') {
+            output.push(structuredClone(change.newValue));
+            index++;
+            continue;
+        }
+        const removed = [];
+        const added = [];
+        while (index < changes.length && changes[index].kind !== 'same') {
+            const pending = changes[index++];
+            if (pending.kind === 'removed')
+                removed.push(pending.value);
+            if (pending.kind === 'added')
+                added.push(pending.value);
+        }
+        output.push(...alignChangedTableRows(removed, added).map((rowChange) => {
+            switch (rowChange.kind) {
+                case 'same':
+                    return diffTableRow(rowChange.oldValue, rowChange.newValue);
+                case 'added':
+                    return addClass(rowChange.value, 'added');
+                case 'removed':
+                    return addClass(rowChange.value, 'removed');
+            }
+        }));
+    }
+    return output;
+}
+function diffTable(oldTable, newTable, oldMarkdown, newMarkdown) {
+    if (!tablesAreCompatible(oldTable, newTable))
+        return null;
+    return {
+        ...structuredClone(newTable),
+        children: diffTableRows(oldTable.children, newTable.children, oldMarkdown, newMarkdown),
+    };
+}
+function isDisplayMath(node) {
+    return (node.type === 'math' ||
+        (node.type === 'code' &&
+            node.lang?.split(/\s+/, 1)[0].toLowerCase() === 'math'));
+}
+function wrapDisplayMath(node, kind) {
+    const child = structuredClone(node);
+    if (kind === 'removed')
+        stripPositions(child);
+    return {
+        type: 'blockquote',
+        data: {
+            hName: 'div',
+            hProperties: {
+                className: ['git-math-block', `git-${kind}`],
+            },
+        },
+        children: [child],
+    };
+}
 function addClass(node, kind) {
+    if (isDisplayMath(node))
+        return wrapDisplayMath(node, kind);
     const result = structuredClone(node);
     const properties = result.data?.hProperties ?? {};
     const current = properties.className;
@@ -166,6 +361,9 @@ function addClass(node, kind) {
         : current
             ? [String(current)]
             : [];
+    if (result.type === 'code' && result.lang) {
+        classes.push(`language-${result.lang}`);
+    }
     classes.push(`git-${kind}`);
     result.data = {
         ...result.data,
@@ -186,9 +384,15 @@ function stripPositions(node) {
 function pairedNode(oldNode, newNode, oldMarkdown, newMarkdown) {
     if (oldNode.type !== newNode.type)
         return null;
+    if (oldNode.type === 'table' && newNode.type === 'table') {
+        return diffTable(oldNode, newNode, oldMarkdown, newMarkdown);
+    }
     if ((newNode.type === 'heading' || newNode.type === 'paragraph') &&
         withChildren(oldNode) &&
         withChildren(newNode)) {
+        if (inlineWordOverlap(oldNode, newNode) < MIN_INLINE_WORD_OVERLAP) {
+            return null;
+        }
         return {
             ...structuredClone(newNode),
             children: diffInline(oldNode.children, newNode.children),

package/dist/src/view/git.js

@@ -1,7 +1,7 @@
 import { execFile } from 'node:child_process';
 import { realpath } from 'node:fs/promises';
 import { isAbsolute, relative, sep } from 'node:path';
-import { toPosix } from '../walk.js';
+import { toPosix } from '@plebeiantech/lat.md-core/path';
 const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 const MAX_GIT_OUTPUT = 50 * 1024 * 1024;
 function runGit(cwd, args) {

package/dist/src/view/graph.d.ts

@@ -0,0 +1,7 @@
+import { type Section } from '@plebeiantech/lat.md-core/lattice-model';
+import type { ViewDocumentError, ViewGraph } from './protocol.js';
+import type { ViewCodeReferenceFile, ViewParsedMarkdownFile, ViewReferenceIndex } from './references.js';
+import type { ViewGitSnapshot } from './git.js';
+import type { ExternalResolver } from '@plebeiantech/lat.md-core/external-sources';
+/** Project the cached view state into stable nodes and weighted relationships. */
+export declare function buildViewGraph(markdownFiles: Iterable<ViewParsedMarkdownFile>, codeFiles: Iterable<ViewCodeReferenceFile>, allSections: Section[], diagnostics: ReadonlyMap<string, readonly ViewDocumentError[]>, git: ViewGitSnapshot, generation: number, references: ViewReferenceIndex, external?: ExternalResolver): ViewGraph;

package/dist/src/view/graph.js

@@ -0,0 +1,267 @@
+import { posix } from 'node:path';
+import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '@plebeiantech/lat.md-core/lattice-model';
+import { linkedSection } from './references.js';
+import { viewSourceTarget } from './source-target.js';
+import { isDocumentPath, stripDocumentExtension, } from '@plebeiantech/lat.md-core/document-formats';
+import { documentUrl } from './document-route.js';
+function encodedPath(path) {
+    return path.split('/').map(encodeURIComponent).join('/');
+}
+function sourceUrl(path, symbol = '', line = 0) {
+    const search = line > 0 ? `?at=${line}` : '';
+    const fragment = symbol ? `#${encodeURIComponent(symbol)}` : '';
+    return `/code/${encodedPath(path)}${search}${fragment}`;
+}
+function externalUrl(target) {
+    const colon = target.indexOf(':');
+    const hash = target.indexOf('#', colon + 1);
+    const handle = target.slice(0, colon);
+    const path = hash === -1 ? target.slice(colon + 1) : target.slice(colon + 1, hash);
+    const fragment = hash === -1 ? '' : target.slice(hash + 1);
+    return `/external/${encodeURIComponent(handle)}/${encodedPath(path)}${fragment ? `#${encodeURIComponent(fragment)}` : ''}`;
+}
+function externalNodeTarget(target) {
+    if (!isDocumentPath(target.resolvedPath))
+        return target.identity;
+    const hash = target.identity.indexOf('#');
+    return hash === -1 ? target.identity : target.identity.slice(0, hash);
+}
+function pathBreadcrumbs(path) {
+    return stripDocumentExtension(path).split('/');
+}
+function nodeLabelFromPath(path) {
+    return posix.basename(stripDocumentExtension(path));
+}
+/** Project the cached view state into stable nodes and weighted relationships. */
+export function buildViewGraph(markdownFiles, codeFiles, allSections, diagnostics, git, generation, references, external) {
+    const files = [...markdownFiles].sort((left, right) => left.path.localeCompare(right.path));
+    const sections = flattenSections(allSections);
+    const sectionIds = new Set(sections.map((section) => section.id.toLowerCase()));
+    const fileIndex = buildFileIndex(allSections);
+    const slugIndex = buildSectionSlugIndex(allSections);
+    const sectionById = new Map(sections.map((section) => [section.id.toLowerCase(), section]));
+    const sectionsByPath = new Map();
+    const documentNodeBySection = new Map();
+    const nodes = new Map();
+    const edges = new Map();
+    const invalidWikiTargets = new Set();
+    for (const [path, errors] of diagnostics) {
+        for (const error of errors) {
+            invalidWikiTargets.add(`${path}\0${error.line}\0${error.target}`);
+        }
+    }
+    const addNode = (node) => {
+        if (!nodes.has(node.id))
+            nodes.set(node.id, node);
+        return node.id;
+    };
+    const addEdge = (from, to, kind) => {
+        if (from === to)
+            return;
+        const key = `${kind}\0${from}\0${to}`;
+        const existing = edges.get(key);
+        if (existing) {
+            existing.weight++;
+            return;
+        }
+        edges.set(key, {
+            id: `edge:${kind}:${from}->${to}`,
+            from,
+            to,
+            kind,
+            weight: 1,
+        });
+    };
+    for (const file of files) {
+        const flat = flattenSections(file.sections);
+        sectionsByPath.set(file.path.toLowerCase(), flat);
+        const root = file.sections[0];
+        const id = `document:${file.path}`;
+        for (const section of flat) {
+            documentNodeBySection.set(section.id.toLowerCase(), id);
+        }
+        const errorCount = diagnostics.get(file.path)?.length ?? 0;
+        addNode({
+            id,
+            kind: 'document',
+            label: root?.heading ?? nodeLabelFromPath(file.path),
+            url: documentUrl(file.path),
+            breadcrumbs: pathBreadcrumbs(file.path),
+            documentPath: file.path,
+            sectionId: root?.id,
+            inDegree: flat.reduce((count, section) => count +
+                (references.incomingBySection.get(section.id.toLowerCase())?.length ??
+                    0), 0),
+            outDegree: 0,
+            ...(git.files.get(file.path)?.status
+                ? { gitStatus: git.files.get(file.path)?.status }
+                : {}),
+            ...(errorCount > 0 ? { errorCount } : {}),
+        });
+    }
+    const documentNodeForSection = (section) => documentNodeBySection.get(section.id.toLowerCase()) ?? null;
+    for (const file of files) {
+        const fileSections = flattenSections(file.sections).sort((left, right) => left.startLine - right.startLine);
+        const containingSection = (line) => fileSections.filter((section) => section.startLine <= line).at(-1) ??
+            file.sections[0];
+        for (const ref of file.wikiRefs) {
+            const sourceSection = sectionById.get(ref.fromSection.toLowerCase());
+            const from = sourceSection ? documentNodeForSection(sourceSection) : null;
+            if (!from)
+                continue;
+            let externalTarget = null;
+            try {
+                externalTarget = external?.parse(ref.target) ?? null;
+            }
+            catch {
+                continue;
+            }
+            if (externalTarget) {
+                const target = externalNodeTarget(externalTarget);
+                const document = isDocumentPath(externalTarget.resolvedPath);
+                const to = addNode({
+                    id: `${document ? 'external-document' : 'external-source'}:${target}`,
+                    kind: document ? 'document' : 'source',
+                    label: document
+                        ? nodeLabelFromPath(externalTarget.resolvedPath)
+                        : externalTarget.fragment ||
+                            posix.basename(externalTarget.authoredPath),
+                    url: externalUrl(target),
+                    breadcrumbs: [
+                        externalTarget.handle,
+                        ...externalTarget.authoredPath.split('/'),
+                        ...(!document && externalTarget.fragment
+                            ? [externalTarget.fragment]
+                            : []),
+                    ],
+                    externalTarget: target,
+                    inDegree: 0,
+                    outDegree: 0,
+                });
+                addEdge(from, to, document ? 'wiki' : 'source');
+                continue;
+            }
+            const source = viewSourceTarget(ref.target);
+            if (source) {
+                if (invalidWikiTargets.has(`${file.path}\0${ref.line}\0${ref.target}`)) {
+                    continue;
+                }
+                const sourceId = addNode({
+                    id: `source:${source.path}${source.symbol ? `#${source.symbol}` : ''}`,
+                    kind: 'source',
+                    label: source.symbol || posix.basename(source.path),
+                    url: sourceUrl(source.path, source.symbol),
+                    breadcrumbs: [
+                        ...source.path.split('/'),
+                        ...(source.symbol ? [source.symbol] : []),
+                    ],
+                    sourcePath: source.path,
+                    symbol: source.symbol || undefined,
+                    inDegree: 0,
+                    outDegree: 0,
+                });
+                addEdge(from, sourceId, 'source');
+                continue;
+            }
+            const resolved = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+            if (resolved.ambiguous)
+                continue;
+            const target = sectionById.get(resolved.resolved.toLowerCase());
+            const to = target ? documentNodeForSection(target) : null;
+            if (to)
+                addEdge(from, to, 'wiki');
+        }
+        for (const link of file.markdownLinks) {
+            if (link.kind !== 'link')
+                continue;
+            const target = linkedSection(link.url, file.path, sectionsByPath);
+            const source = containingSection(link.line);
+            const from = source ? documentNodeForSection(source) : null;
+            const to = target ? documentNodeForSection(target) : null;
+            if (from && to)
+                addEdge(from, to, 'markdown');
+        }
+    }
+    for (const file of [...codeFiles].sort((left, right) => left.path.localeCompare(right.path))) {
+        for (const ref of [...file.refs].sort((left, right) => left.line - right.line)) {
+            let externalTarget = null;
+            try {
+                externalTarget = external?.parse(ref.target) ?? null;
+            }
+            catch {
+                continue;
+            }
+            if (externalTarget) {
+                const target = externalNodeTarget(externalTarget);
+                const document = isDocumentPath(externalTarget.resolvedPath);
+                const to = addNode({
+                    id: `${document ? 'external-document' : 'external-source'}:${target}`,
+                    kind: document ? 'document' : 'source',
+                    label: document
+                        ? nodeLabelFromPath(externalTarget.resolvedPath)
+                        : externalTarget.fragment ||
+                            posix.basename(externalTarget.authoredPath),
+                    url: externalUrl(target),
+                    breadcrumbs: [
+                        externalTarget.handle,
+                        ...externalTarget.authoredPath.split('/'),
+                    ],
+                    externalTarget: target,
+                    inDegree: 0,
+                    outDegree: 0,
+                });
+                const snippet = file.lines[ref.line - 1]?.trim() ?? '';
+                const from = addNode({
+                    id: `code-ref:${file.path}:${ref.line}`,
+                    kind: 'code-reference',
+                    label: `${posix.basename(file.path)}:${ref.line}`,
+                    url: sourceUrl(file.path, '', ref.line),
+                    breadcrumbs: [...file.path.split('/'), `line ${ref.line}`],
+                    sourcePath: file.path,
+                    line: ref.line,
+                    snippet,
+                    inDegree: 0,
+                    outDegree: 0,
+                });
+                addEdge(from, to, 'code-mention');
+                continue;
+            }
+            const resolved = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+            if (resolved.ambiguous)
+                continue;
+            const target = sectionById.get(resolved.resolved.toLowerCase());
+            const to = target ? documentNodeForSection(target) : null;
+            if (!to)
+                continue;
+            const snippet = file.lines[ref.line - 1]?.trim() ?? '';
+            const from = addNode({
+                id: `code-ref:${file.path}:${ref.line}`,
+                kind: 'code-reference',
+                label: `${posix.basename(file.path)}:${ref.line}`,
+                url: sourceUrl(file.path, '', ref.line),
+                breadcrumbs: [...file.path.split('/'), `line ${ref.line}`],
+                sourcePath: file.path,
+                line: ref.line,
+                snippet,
+                inDegree: 0,
+                outDegree: 0,
+            });
+            addEdge(from, to, 'code-mention');
+        }
+    }
+    for (const edge of edges.values()) {
+        const source = nodes.get(edge.from);
+        const target = nodes.get(edge.to);
+        if (source)
+            source.outDegree += edge.weight;
+        // Local documents use the sum of their headings' displayed backlink counts,
+        // not visual edge weights (which omit self-links and count repeat links).
+        if (target && !target.documentPath)
+            target.inDegree += edge.weight;
+    }
+    return {
+        generation,
+        nodes: [...nodes.values()].sort((left, right) => left.id.localeCompare(right.id)),
+        edges: [...edges.values()].sort((left, right) => left.id.localeCompare(right.id)),
+    };
+}

package/dist/src/view/highlight.d.ts

@@ -1,2 +1,10 @@
-/** Highlight source into independently valid, escaped HTML lines. */
-export declare function highlightSource(path: string, content: string): string[];
+import type { ElementContent } from 'hast';
+import type { ViewDocumentTree } from './protocol.js';
+export type HighlightedCodeTree = {
+    type: 'root';
+    children: ElementContent[];
+};
+/** Highlight a supported fenced-code language into a safe HAST fragment. */
+export declare function highlightCode(language: string, content: string): HighlightedCodeTree | null;
+/** Highlight source directly into independently renderable document trees. */
+export declare function highlightSource(path: string, content: string): ViewDocumentTree[];