@plebeiantech/lat.md 0.12.3-fork.4 → 0.12.3-fork.6

package/dist/src/view/markdown.js

@@ -10,6 +10,7 @@ const CODE_LINK_CLASSES = [
     'wiki-link-code',
     'wiki-link-active',
     'code-link-language',
+    'code-link-leading',
     'code-language-ts',
     'code-language-js',
     'code-language-py',
@@ -18,11 +19,17 @@ const CODE_LINK_CLASSES = [
     'code-language-c',
 ];
 const ERROR_CLASS = 'markdown-error';
+const EXTERNAL_LINK_CLASS = 'external-link';
+const EXTERNAL_LINK_ICON_CLASS = 'external-link-icon';
 const GIT_CLASSES = ['git-added', 'git-removed'];
 function classAttributes(tag) {
+    const attributes = defaultSchema.attributes?.[tag] ?? [];
+    const allowedClasses = attributes.flatMap((attribute) => Array.isArray(attribute) && attribute[0] === 'className'
+        ? attribute.slice(1)
+        : []);
     return [
-        ...(defaultSchema.attributes?.[tag] ?? []),
-        ['className', ERROR_CLASS, ...GIT_CLASSES],
+        ...attributes.filter((attribute) => !(Array.isArray(attribute) && attribute[0] === 'className')),
+        ['className', ...allowedClasses, ERROR_CLASS, ...GIT_CLASSES],
     ];
 }
 const sanitizeSchema = {
@@ -38,6 +45,7 @@ const sanitizeSchema = {
                 'wiki-link-segmented',
                 'wiki-link-code',
                 'wiki-link-active',
+                EXTERNAL_LINK_CLASS,
                 ERROR_CLASS,
                 ...GIT_CLASSES,
             ],
@@ -55,20 +63,25 @@ const sanitizeSchema = {
         img: classAttributes('img'),
         ins: classAttributes('ins'),
         li: classAttributes('li'),
+        ol: classAttributes('ol'),
         p: classAttributes('p'),
         pre: classAttributes('pre'),
         span: [
             ...(defaultSchema.attributes?.span ?? []),
             'ariaHidden',
+            'ariaLabel',
             [
                 'className',
                 'wiki-link-context',
                 'wiki-link-leaf',
+                'wiki-link-ref-count',
+                EXTERNAL_LINK_ICON_CLASS,
                 ...CODE_LINK_CLASSES.slice(2),
                 ERROR_CLASS,
                 ...GIT_CLASSES,
             ],
         ],
+        ul: classAttributes('ul'),
     },
 };
 const htmlProcessor = unified()
@@ -155,6 +168,61 @@ function languageIcon(language) {
         children: [{ type: 'text', value: language.label }],
     };
 }
+function codeLinkContent(language, children) {
+    const [first, ...rest] = children;
+    if (!first)
+        return [languageIcon(language)];
+    let leading = first;
+    let remainder = null;
+    if (first.type === 'text') {
+        const breakAt = first.value.search(/\s/);
+        if (breakAt > 0) {
+            leading = { ...first, value: first.value.slice(0, breakAt) };
+            remainder = { ...first, value: first.value.slice(breakAt) };
+        }
+    }
+    return [
+        {
+            type: 'emphasis',
+            data: {
+                hName: 'span',
+                hProperties: { className: ['code-link-leading'] },
+            },
+            children: [languageIcon(language), leading],
+        },
+        ...(remainder ? [remainder] : []),
+        ...rest,
+    ];
+}
+function externalLinkIcon() {
+    return {
+        type: 'emphasis',
+        data: {
+            hName: 'span',
+            hProperties: {
+                ariaHidden: 'true',
+                className: [EXTERNAL_LINK_ICON_CLASS],
+            },
+        },
+        children: [],
+    };
+}
+function isExternalSiteUrl(url) {
+    return /^(?:https?:)?\/\//i.test(url);
+}
+function referenceCountBadge(count) {
+    return {
+        type: 'emphasis',
+        data: {
+            hName: 'span',
+            hProperties: {
+                className: ['wiki-link-ref-count'],
+                ariaLabel: `${count} ${count === 1 ? 'reference' : 'references'}`,
+            },
+        },
+        children: [{ type: 'text', value: String(count) }],
+    };
+}
 function targetMatches(node, target) {
     if (node.type === 'wikiLink') {
         return node.value.toLowerCase() === target.toLowerCase();
@@ -229,24 +297,39 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
     tree.children = tree.children.filter((node) => node.type !== 'yaml');
     if (options.errors)
         markMarkdownErrors(tree, options.errors);
-    if (options.rewriteMarkdownLink || options.activeMarkdownLink) {
-        visit(tree, 'link', (node) => {
-            const authoredUrl = node.url;
-            if (options.activeMarkdownLink &&
-                authoredUrl === options.activeMarkdownLink) {
-                node.data = {
-                    ...node.data,
-                    hProperties: {
-                        ...(node.data?.hProperties ?? {}),
-                        className: ['wiki-link-active'],
-                    },
-                };
-            }
-            if (options.rewriteMarkdownLink) {
-                node.url = options.rewriteMarkdownLink(authoredUrl);
-            }
-        });
-    }
+    visit(tree, 'link', (node) => {
+        const authoredUrl = node.url;
+        if (options.activeMarkdownLink &&
+            authoredUrl === options.activeMarkdownLink) {
+            node.data = {
+                ...node.data,
+                hProperties: {
+                    ...(node.data?.hProperties ?? {}),
+                    className: ['wiki-link-active'],
+                },
+            };
+        }
+        if (options.rewriteMarkdownLink) {
+            node.url = options.rewriteMarkdownLink(authoredUrl);
+        }
+        if (!isExternalSiteUrl(node.url))
+            return;
+        const properties = node.data?.hProperties ?? {};
+        const currentClasses = properties.className;
+        const classes = Array.isArray(currentClasses)
+            ? currentClasses.map(String)
+            : currentClasses
+                ? [String(currentClasses)]
+                : [];
+        node.data = {
+            ...node.data,
+            hProperties: {
+                ...properties,
+                className: [...classes, EXTERNAL_LINK_CLASS],
+            },
+        };
+        node.children.push(externalLinkIcon());
+    });
     const firstHeading = tree.children.find((node) => node.type === 'heading');
     const title = firstHeading
         ? nodeText(firstHeading)
@@ -266,9 +349,10 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
     visit(tree, 'wikiLink', (node, index, parent) => {
         if (index === undefined || !parent || !('children' in parent))
             return;
-        const href = resolvedLinks.get(node);
+        const resolution = resolvedLinks.get(node);
         const markedProperties = node.data?.hProperties;
-        if (href) {
+        if (resolution) {
+            const { href, referenceCount } = resolution;
             const content = wikiLinkContent(node);
             const language = href.startsWith('/code/')
                 ? codeLanguage(node.value)
@@ -296,9 +380,12 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
                         },
                     }
                     : undefined,
-                children: language
-                    ? [languageIcon(language), ...content.children]
-                    : content.children,
+                children: [
+                    ...(language
+                        ? codeLinkContent(language, content.children)
+                        : content.children),
+                    ...(referenceCount > 1 ? [referenceCountBadge(referenceCount)] : []),
+                ],
             };
             return;
         }

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

@@ -7,7 +7,9 @@ export type ViewIndex = {
     entry: string;
     errorCounts: Record<string, number>;
     git: ViewGitState | null;
+    logoText: string;
 };
+export declare const DEFAULT_VIEW_LOGO_TEXT = "lat.md";
 export type ViewDocumentError = {
     anchor: string;
     line: number;
@@ -22,6 +24,7 @@ export type ViewSearchResult = {
     breadcrumbs: string[];
     description: string;
     url: string;
+    score: number;
 };
 export type ViewSearchResponse = {
     query: string;
@@ -31,11 +34,51 @@ export type ViewProjectChange = {
     generation: number;
     markdownGeneration: number;
 };
+export type ViewGraphNodeKind = 'document' | 'source' | 'code-reference';
+export type ViewGraphNode = {
+    id: string;
+    kind: ViewGraphNodeKind;
+    label: string;
+    url: string;
+    breadcrumbs: string[];
+    inDegree: number;
+    outDegree: number;
+    documentPath?: string;
+    sectionId?: string;
+    sourcePath?: string;
+    symbol?: string;
+    line?: number;
+    snippet?: string;
+    gitStatus?: ViewGitFileStatus;
+    errorCount?: number;
+};
+export type ViewGraphEdgeKind = 'wiki' | 'markdown' | 'source' | 'code-mention';
+export type ViewGraphEdge = {
+    id: string;
+    from: string;
+    to: string;
+    kind: ViewGraphEdgeKind;
+    weight: number;
+};
+export type ViewGraph = {
+    generation: number;
+    nodes: ViewGraphNode[];
+    edges: ViewGraphEdge[];
+};
+export type ViewDocumentTocItem = {
+    id: string;
+    title: string;
+    depth: number;
+    errorCount: number;
+    hasGitChanges: boolean;
+};
 export type ViewDocument = {
     path: string;
     title: string;
     html: string;
     gitHtml: string | null;
+    graphNodeIds: Record<string, string>;
+    tableOfContents: ViewDocumentTocItem[];
     errors: ViewDocumentError[];
     backReferences: ViewSectionBackReferences[];
     frontmatter: {

package/dist/src/view/protocol.js

@@ -1 +1 @@
-export {};
+export const DEFAULT_VIEW_LOGO_TEXT = 'lat.md';

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

@@ -47,9 +47,11 @@ type IndexedBackReference = IndexedMarkdownReference | ViewCodeBackReference;
 export type ViewReferenceIndex = {
     incomingBySection: ReadonlyMap<string, readonly IndexedBackReference[]>;
     sourceByTarget: ReadonlyMap<string, readonly IndexedMarkdownReference[]>;
+    sourceReferenceCounts: ReadonlyMap<string, number>;
 };
 /** Parse one Markdown file once into every structure needed by the view store. */
 export declare function parseViewMarkdownFile(absolutePath: string, content: string, latDir: string, projectRoot: string): ViewParsedMarkdownFile;
+export declare function linkedSection(url: string, sourcePath: string, sectionsByPath: ReadonlyMap<string, Section[]>): Section | null;
 /** Resolve cached outgoing occurrences into direct section and source indexes. */
 export declare function buildViewReferenceIndex(markdownFiles: Iterable<ViewParsedMarkdownFile>, codeFiles: Iterable<ViewCodeReferenceFile>, allSections: Section[]): ViewReferenceIndex;
 /** Render direct reverse-index entries for the sections visible in one file. */

package/dist/src/view/references.js

@@ -4,6 +4,7 @@ import { buildFileIndex, buildSectionSlugIndex, extractRefs, extractLinks, flatt
 import { parse } from '../parser.js';
 import { toPosix } from '../walk.js';
 import { renderMarkdown } from './markdown.js';
+import { viewSourceTarget } from './source-target.js';
 function inlineText(node) {
     if (node.type === 'wikiLink')
         return node.data.alias ?? node.value;
@@ -115,7 +116,7 @@ function sourceLineUrl(path, line) {
     const encoded = path.split('/').map(encodeURIComponent).join('/');
     return `/code/${encoded}?at=${line}`;
 }
-function linkedSection(url, sourcePath, sectionsByPath) {
+export function linkedSection(url, sourcePath, sectionsByPath) {
     if (url.startsWith('//') || /^[a-z][a-z\d+.-]*:/i.test(url))
         return null;
     const encodedSourcePath = sourcePath
@@ -184,6 +185,15 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
         if (!references.has(key))
             references.set(key, reference);
     };
+    const addSourceReference = (target, key, reference) => {
+        let references = sourceByTarget.get(target);
+        if (!references) {
+            references = new Map();
+            sourceByTarget.set(target, references);
+        }
+        if (!references.has(key))
+            references.set(key, reference);
+    };
     for (const file of files) {
         const fileSections = flattenSections(file.sections).sort((a, b) => a.startLine - b.startLine);
         for (const ref of file.wikiRefs) {
@@ -198,16 +208,20 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
                 paragraph: paragraphFor(file, section, ref.line),
                 activeWikiLink: ref.target,
             };
-            const sourceKey = ref.target.toLowerCase();
-            const sourceReferences = sourceByTarget.get(sourceKey) ?? [];
-            sourceReferences.push(reference);
-            sourceByTarget.set(sourceKey, sourceReferences);
+            const locationKey = `markdown:${section.filePath}:${reference.paragraph.startLine}`;
+            const source = viewSourceTarget(ref.target);
+            if (source) {
+                addSourceReference(source.key, locationKey, reference);
+                if (source.symbol) {
+                    addSourceReference(source.fileKey, locationKey, reference);
+                }
+            }
             const resolved = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
             if (resolved.ambiguous ||
                 !sectionById.has(resolved.resolved.toLowerCase())) {
                 continue;
             }
-            addIncoming(resolved.resolved, `markdown:${section.filePath}:${reference.paragraph.startLine}`, reference);
+            addIncoming(resolved.resolved, locationKey, reference);
         }
         for (const link of file.markdownLinks) {
             if (link.kind !== 'link')
@@ -252,7 +266,14 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
             target,
             [...references.values()],
         ])),
-        sourceByTarget,
+        sourceByTarget: new Map([...sourceByTarget].map(([target, references]) => [
+            target,
+            [...references.values()],
+        ])),
+        sourceReferenceCounts: new Map([...sourceByTarget].map(([target, references]) => [
+            target,
+            references.size,
+        ])),
     };
 }
 async function renderIndexedMarkdownReference(reference, latDir, projectRoot, resolveWikiLink) {
@@ -305,7 +326,8 @@ export async function renderSectionBackReferences(index, visibleSections, latDir
 }
 /** Render cached Markdown occurrences that point to one source target. */
 export async function renderSourceReferenceContext(index, target, origin, latDir, projectRoot, createWikiLinkResolver) {
-    const indexed = index.sourceByTarget.get(target.toLowerCase()) ?? [];
+    const source = viewSourceTarget(target);
+    const indexed = source ? (index.sourceByTarget.get(source.key) ?? []) : [];
     const resolverByPath = new Map();
     const located = [];
     for (const reference of indexed) {

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

@@ -5,8 +5,11 @@ export declare class ViewDocumentNotFoundError extends Error {
 }
 export declare class ViewSourceNotFoundError extends Error {
 }
-export declare function createMarkdownWikiLinkResolver(latDir: string, requestedPath: string, loadedSections: Section[]): Promise<(target: string, context: {
+export declare function createMarkdownWikiLinkResolver(latDir: string, requestedPath: string, loadedSections: Section[], referenceIndex?: ViewReferenceIndex): Promise<(target: string, context: {
     line: number;
-}) => Promise<string | null>>;
+}) => Promise<{
+    href: string;
+    referenceCount: number;
+} | null>>;
 /** Read and highlight a source file after constraining it to the project root. */
 export declare function getViewSource(latDir: string, projectRoot: string, requestedPath: string, requestedSymbol?: string, origin?: SourceReferenceOrigin, requestedLine?: number, allSections?: Section[], referenceIndex?: ViewReferenceIndex): Promise<ViewSourceDocument>;

package/dist/src/view/repository.js

@@ -5,6 +5,7 @@ import { resolveSourceSymbol, SOURCE_EXTENSIONS, } from '../source-parser.js';
 import { toPosix } from '../walk.js';
 import { highlightSource } from './highlight.js';
 import { renderSourceReferenceContext, } from './references.js';
+import { viewSourceTarget } from './source-target.js';
 export class ViewDocumentNotFoundError extends Error {
 }
 export class ViewSourceNotFoundError extends Error {
@@ -28,13 +29,6 @@ function sourceUrl(path, symbol, origin) {
     const fragment = symbol ? `#${encodeURIComponent(symbol)}` : '';
     return `/code/${encodedPath}${search}${fragment}`;
 }
-function sourceTarget(target) {
-    const hash = target.indexOf('#');
-    const path = hash === -1 ? target : target.slice(0, hash);
-    if (!SOURCE_EXTENSIONS.has(extname(path)))
-        return null;
-    return { path, symbol: hash === -1 ? '' : target.slice(hash + 1) };
-}
 function matchingSymbol(symbols, symbolPath) {
     const parts = symbolPath.split('#');
     if (parts.length === 1) {
@@ -45,7 +39,7 @@ function matchingSymbol(symbols, symbolPath) {
     }
     return undefined;
 }
-export async function createMarkdownWikiLinkResolver(latDir, requestedPath, loadedSections) {
+export async function createMarkdownWikiLinkResolver(latDir, requestedPath, loadedSections, referenceIndex) {
     const projectRoot = dirname(latDir);
     const flat = flattenSections(loadedSections);
     const sectionIds = new Set(flat.map((section) => section.id.toLowerCase()));
@@ -67,9 +61,13 @@ export async function createMarkdownWikiLinkResolver(latDir, requestedPath, load
             const fragment = target.includes('#') && section.githubSlug
                 ? `#${encodeURIComponent(section.githubSlug)}`
                 : '';
-            return `${documentUrl(file)}${fragment}`;
+            return {
+                href: `${documentUrl(file)}${fragment}`,
+                referenceCount: referenceIndex?.incomingBySection.get(section.id.toLowerCase())
+                    ?.length ?? 0,
+            };
         }
-        const source = sourceTarget(target);
+        const source = viewSourceTarget(target);
         if (!source)
             return null;
         try {
@@ -83,7 +81,10 @@ export async function createMarkdownWikiLinkResolver(latDir, requestedPath, load
             const origin = section
                 ? { sectionId: section.id, line: context.line }
                 : undefined;
-            return sourceUrl(source.path, source.symbol, origin);
+            return {
+                href: sourceUrl(source.path, source.symbol, origin),
+                referenceCount: referenceIndex?.sourceReferenceCounts.get(source.key) ?? 0,
+            };
         }
         catch (error) {
             if (error instanceof ViewSourceNotFoundError)
@@ -157,7 +158,7 @@ async function readViewSource(projectRoot, requestedPath, requestedSymbol = '',
 export async function getViewSource(latDir, projectRoot, requestedPath, requestedSymbol = '', origin, requestedLine = 0, allSections = [], referenceIndex) {
     const source = await readViewSource(projectRoot, requestedPath, requestedSymbol, requestedLine);
     const references = referenceIndex
-        ? await renderSourceReferenceContext(referenceIndex, `${source.path}${requestedSymbol ? `#${requestedSymbol}` : ''}`, origin, latDir, projectRoot, (path) => createMarkdownWikiLinkResolver(latDir, path, allSections))
+        ? await renderSourceReferenceContext(referenceIndex, `${source.path}${requestedSymbol ? `#${requestedSymbol}` : ''}`, origin, latDir, projectRoot, (path) => createMarkdownWikiLinkResolver(latDir, path, allSections, referenceIndex))
         : { context: null, otherReferences: [] };
     return {
         ...source,

package/dist/src/view/search.js

@@ -28,6 +28,7 @@ function viewSearchResult(latDir, match) {
         breadcrumbs: [...fileBreadcrumbs, ...section.id.split('#').slice(1)],
         description: section.firstParagraph,
         url: documentUrl(path, section.githubSlug),
+        score: match.score ?? 0,
     };
 }
 /** Create the lazily indexed semantic search service used by `lat ui`. */

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

@@ -2,6 +2,7 @@ import { type Server } from 'node:http';
 import type { CmdContext } from '../context.js';
 import { type ViewSearch } from './search.js';
 import { type ViewStore } from './store.js';
+export declare const DEFAULT_VIEW_PORT = 4242;
 export type ViewServer = {
     server: Server;
     store: ViewStore;
@@ -11,7 +12,9 @@ export type ViewServer = {
 export type ViewServerOptions = {
     clientDir?: string;
     git?: boolean;
+    gitPollMs?: number;
     host?: string;
+    logoText?: string;
     port?: number;
     search?: ViewSearch;
     watch?: boolean;

package/dist/src/view/server.js

@@ -2,16 +2,18 @@ import { readFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { extname, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { DEFAULT_VIEW_LOGO_TEXT, } from './protocol.js';
 import { ViewDocumentNotFoundError, ViewSourceNotFoundError, } from './repository.js';
 import { createViewSearch } from './search.js';
 import { createViewStore } from './store.js';
 const DEFAULT_HOST = '127.0.0.1';
+export const DEFAULT_VIEW_PORT = 4242;
 const defaultClientDir = fileURLToPath(new URL('./client/', import.meta.url));
 function documentUrl(path) {
     return `/docs/${path.split('/').map(encodeURIComponent).join('/')}`;
 }
 function setSecurityHeaders(res) {
-    res.setHeader('Content-Security-Policy', "default-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'");
+    res.setHeader('Content-Security-Policy', "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; worker-src 'self' blob:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'");
     res.setHeader('Referrer-Policy', 'no-referrer');
     res.setHeader('X-Content-Type-Options', 'nosniff');
 }
@@ -69,12 +71,29 @@ async function sendClientFile(res, path, headOnly, immutable = false) {
         send(res, 404, 'text/plain; charset=utf-8', 'Not found', headOnly);
     }
 }
+function listen(server, host, port) {
+    return new Promise((resolveListen, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolveListen();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, host);
+    });
+}
 /** Start the read-only loopback server used by `lat ui`. */
 export async function startViewServer(ctx, options = {}) {
     const host = options.host ?? DEFAULT_HOST;
     const clientDir = options.clientDir ?? defaultClientDir;
+    const logoText = options.logoText ?? DEFAULT_VIEW_LOGO_TEXT;
     const store = await createViewStore(ctx.latDir, ctx.projectRoot, {
         git: options.git,
+        gitPollMs: options.gitPollMs,
         watch: options.watch,
     });
     const search = options.search ??
@@ -109,7 +128,11 @@ export async function startViewServer(ctx, options = {}) {
                 return;
             }
             if (url.pathname === '/api/index') {
-                sendJson(res, 200, store.getIndex(), headOnly);
+                sendJson(res, 200, { ...store.getIndex(), logoText }, headOnly);
+                return;
+            }
+            if (url.pathname === '/api/graph') {
+                sendJson(res, 200, store.getGraph(), headOnly);
                 return;
             }
             if (url.pathname === '/api/events') {
@@ -180,6 +203,7 @@ export async function startViewServer(ctx, options = {}) {
                 return;
             }
             if (url.pathname === '/search' ||
+                url.pathname === '/graph' ||
                 url.pathname.startsWith('/docs/') ||
                 url.pathname.startsWith('/code/')) {
                 await sendClientFile(res, join(clientDir, 'index.html'), headOnly);
@@ -195,13 +219,22 @@ export async function startViewServer(ctx, options = {}) {
         });
     });
     try {
-        await new Promise((resolveListen, reject) => {
-            server.once('error', reject);
-            server.listen(options.port ?? 0, host, () => {
-                server.off('error', reject);
-                resolveListen();
-            });
-        });
+        const requestedPort = options.port;
+        let port = requestedPort ?? DEFAULT_VIEW_PORT;
+        while (true) {
+            try {
+                await listen(server, host, port);
+                break;
+            }
+            catch (error) {
+                if (requestedPort !== undefined ||
+                    error.code !== 'EADDRINUSE' ||
+                    port === 65_535) {
+                    throw error;
+                }
+                port++;
+            }
+        }
     }
     catch (error) {
         unsubscribeStore();

package/dist/src/view/source-target.d.ts

@@ -0,0 +1,8 @@
+export type ViewSourceTarget = {
+    path: string;
+    symbol: string;
+    key: string;
+    fileKey: string;
+};
+/** Normalize a supported source wiki-link target for view indexes and routes. */
+export declare function viewSourceTarget(target: string): ViewSourceTarget | null;

package/dist/src/view/source-target.js

@@ -0,0 +1,22 @@
+import { extname, posix } from 'node:path';
+import { SOURCE_EXTENSIONS } from '../source-parser.js';
+/** Normalize a supported source wiki-link target for view indexes and routes. */
+export function viewSourceTarget(target) {
+    const hash = target.indexOf('#');
+    const authoredPath = hash === -1 ? target : target.slice(0, hash);
+    if (!authoredPath ||
+        authoredPath.includes('\\') ||
+        posix.isAbsolute(authoredPath) ||
+        !SOURCE_EXTENSIONS.has(extname(authoredPath))) {
+        return null;
+    }
+    const path = posix.normalize(authoredPath).replace(/^\.\//, '');
+    const symbol = hash === -1 ? '' : target.slice(hash + 1);
+    const fileKey = path.toLowerCase();
+    return {
+        path,
+        symbol,
+        key: `${fileKey}${symbol ? `#${symbol.toLowerCase()}` : ''}`,
+        fileKey,
+    };
+}

package/dist/src/view/static-build.d.ts

@@ -0,0 +1,16 @@
+import type { CmdContext } from '../context.js';
+export type StaticViewBuildOptions = {
+    basePath?: string;
+    clientDir?: string;
+    logoText?: string;
+};
+export type StaticViewBuildResult = {
+    documents: number;
+    outputDir: string;
+    sources: number;
+};
+export declare function normalizeStaticViewBasePath(value: string): string;
+/** Convert a live view route to its physical static-directory URL. */
+export declare function staticViewUrl(value: string, basePath: string): string;
+/** Build a serverless snapshot of the current read-only Lat UI. */
+export declare function buildStaticView(ctx: CmdContext, requestedOutput: string, options?: StaticViewBuildOptions): Promise<StaticViewBuildResult>;