@plebeiantech/lat.md 0.12.3-fork.13 → 0.12.3-fork.14

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

@@ -168,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;
@@ -200,6 +384,9 @@ 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)) {

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 '../path.js';
 const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 const MAX_GIT_OUTPUT = 50 * 1024 * 1024;
 function runGit(cwd, args) {

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

@@ -1,6 +1,7 @@
-import { type Section } from '../lattice.js';
+import { type Section } from '../lattice-model.js';
 import type { ViewDocumentError, ViewGraph } from './protocol.js';
 import type { ViewCodeReferenceFile, ViewParsedMarkdownFile } from './references.js';
 import type { ViewGitSnapshot } from './git.js';
+import type { ExternalResolver } from '../external-sources.js';
 /** 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): ViewGraph;
+export declare function buildViewGraph(markdownFiles: Iterable<ViewParsedMarkdownFile>, codeFiles: Iterable<ViewCodeReferenceFile>, allSections: Section[], diagnostics: ReadonlyMap<string, readonly ViewDocumentError[]>, git: ViewGitSnapshot, generation: number, external?: ExternalResolver): ViewGraph;

package/dist/src/view/graph.js

@@ -1,26 +1,39 @@
 import { posix } from 'node:path';
-import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '../lattice.js';
+import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '../lattice-model.js';
 import { linkedSection } from './references.js';
 import { viewSourceTarget } from './source-target.js';
+import { isDocumentPath, stripDocumentExtension } from '../document-formats.js';
+import { documentUrl } from './document-route.js';
 function encodedPath(path) {
     return path.split('/').map(encodeURIComponent).join('/');
 }
-function documentUrl(path, fragment = '') {
-    return `/docs/${encodedPath(path)}${fragment ? `#${encodeURIComponent(fragment)}` : ''}`;
-}
 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 path.replace(/\.md$/i, '').split('/');
+    return stripDocumentExtension(path).split('/');
 }
 function nodeLabelFromPath(path) {
-    return posix.basename(path).replace(/\.md$/i, '');
+    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) {
+export function buildViewGraph(markdownFiles, codeFiles, allSections, diagnostics, git, generation, 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()));
@@ -94,6 +107,38 @@ export function buildViewGraph(markdownFiles, codeFiles, allSections, diagnostic
             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}`)) {
@@ -137,6 +182,48 @@ export function buildViewGraph(markdownFiles, codeFiles, allSections, diagnostic
     }
     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;

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[];