texlite 0.2.0

package/dist/server/compileArtifacts.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+import { publishedCompileArtifacts } from "./compiler.js";
+import { outputRoot, resolveSourcePath, safeRelativePath, sourceRoot } from "./files.js";
+import { hasDocumentClass } from "./zip.js";
+export function availablePdf(config, projectId, mainFile, defaultMainFile) {
+    const isDefault = mainFile === defaultMainFile;
+    const published = publishedCompileArtifacts(config, projectId, mainFile, isDefault);
+    if (published)
+        return { path: published.pdf, version: published.runId };
+    if (!isDefault)
+        return null;
+    const retained = retainedPdfPath(config, projectId);
+    if (fs.existsSync(retained))
+        return { path: retained, version: String(fs.statSync(retained).mtimeMs) };
+    const legacy = path.join(outputRoot(config, projectId), `${path.basename(mainFile, ".tex")}.pdf`);
+    return fs.existsSync(legacy) ? { path: legacy, version: String(fs.statSync(legacy).mtimeMs) } : null;
+}
+export function syncArtifacts(config, projectId, mainFile, defaultMainFile) {
+    const isDefault = mainFile === defaultMainFile;
+    const published = publishedCompileArtifacts(config, projectId, mainFile, isDefault);
+    if (published?.synctex)
+        return { source: published.source, pdf: published.pdf, synctex: published.synctex };
+    if (!isDefault)
+        return null;
+    const retained = {
+        source: sourceRoot(config, projectId),
+        pdf: retainedPdfPath(config, projectId),
+        synctex: retainedSynctexPath(config, projectId)
+    };
+    if (fs.existsSync(retained.pdf) && fs.existsSync(retained.synctex))
+        return retained;
+    const basename = path.basename(mainFile, ".tex");
+    const legacy = {
+        source: sourceRoot(config, projectId),
+        pdf: path.join(outputRoot(config, projectId), `${basename}.pdf`),
+        synctex: path.join(outputRoot(config, projectId), `${basename}.synctex.gz`)
+    };
+    return fs.existsSync(legacy.pdf) && fs.existsSync(legacy.synctex) ? legacy : null;
+}
+export function compileMainFile(config, projectId, defaultMainFile, value) {
+    let mainFile;
+    try {
+        mainFile = typeof value === "string" && value ? safeRelativePath(value) : defaultMainFile;
+    }
+    catch {
+        return null;
+    }
+    if (!mainFile.toLocaleLowerCase().endsWith(".tex"))
+        return null;
+    const absolute = resolveSourcePath(config, projectId, mainFile);
+    if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile())
+        return null;
+    if (mainFile !== defaultMainFile && !hasDocumentClass(fs.readFileSync(absolute, "utf8")))
+        return null;
+    return mainFile;
+}
+export function compilePdfUrl(projectId, mainFile, version) {
+    return `/api/projects/${projectId}/pdf?mainFile=${encodeURIComponent(mainFile)}&run=${encodeURIComponent(version)}`;
+}
+export function listCompileArtifacts(directory) {
+    const artifacts = [];
+    const visit = (current, prefix) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory())
+                visit(absolute, relative);
+            else if (entry.isFile()) {
+                const size = fs.statSync(absolute).size;
+                artifacts.push({ path: relative, size, viewable: size <= 2 * 1024 * 1024 && isTextCompileArtifact(relative) });
+            }
+        }
+    };
+    visit(directory, "");
+    return artifacts.sort((left, right) => left.path.localeCompare(right.path));
+}
+export function isTextCompileArtifact(filePath) {
+    return /(?:\.aux|\.bbl|\.bcf|\.blg|\.fls|\.log|\.lof|\.lot|\.nav|\.out|\.run\.xml|\.snm|\.toc|\.vrb|\.fdb_latexmk)$/i.test(filePath);
+}
+function retainedPdfPath(config, projectId) {
+    return path.join(outputRoot(config, projectId), ".texlite", "latest.pdf");
+}
+function retainedSynctexPath(config, projectId) {
+    return path.join(outputRoot(config, projectId), ".texlite", "latest.synctex.gz");
+}

package/dist/server/compileDiagnostics.js

@@ -0,0 +1,227 @@
+/**
+ * A bounded, machine-readable view of a latexmk transcript.
+ *
+ * The process result is deliberately passed to the parser.  latexmk runs
+ * several tools and may print an error-looking message from an intermediate
+ * pass even when the final PDF was produced successfully.  The exit/result
+ * status is therefore authoritative for the error list; the transcript is
+ * still retained separately for users who need all details.
+ */
+const commandPattern = /\b(pdflatex|xelatex|lualatex|bibtex|biber)\b/i;
+const locationPattern = /^(?<file>[^:\n]+):(?<line>\d+)(?::(?<column>\d+))?:\s*(?<rest>.*)$/;
+const inputLinePattern = /\bon input line (?<line>\d+)\b/i;
+const latexLinePattern = /^l\.(?<line>\d+)\b/;
+export function parseCompileDiagnostics(log, outcome = null) {
+    const lines = log.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const resolvedOutcome = outcome ?? (hasSuccessfulLatexmkResult(log) ? "succeeded" : null);
+    const diagnostics = [];
+    let phase = "unknown";
+    let currentFile;
+    let pendingBang;
+    let latexPass = 0;
+    let lastLatexPass = 0;
+    for (const line of lines) {
+        const command = line.match(commandPattern);
+        if (/^Running\s+['"]?/i.test(line) && command) {
+            phase = command[1].toLowerCase();
+            if (phase === "pdflatex" || phase === "xelatex" || phase === "lualatex") {
+                latexPass += 1;
+                lastLatexPass = latexPass;
+            }
+            const texArgument = [...line.matchAll(/(?:['"]|\s)([^\s'"]+\.tex)(?:['"]|\s|$)/gi)].at(-1)?.[1];
+            if (texArgument)
+                currentFile = texArgument.replaceAll("\\", "/");
+            pendingBang = undefined;
+            continue;
+        }
+        if (/^Latexmk:/i.test(line))
+            phase = "latexmk";
+        const located = parseLocatedLine(line);
+        if (located) {
+            currentFile = located.file ?? currentFile;
+            const severity = located.severity;
+            if (severity) {
+                addDiagnostic(diagnostics, {
+                    severity,
+                    phase,
+                    message: located.message,
+                    raw: line,
+                    file: located.file ?? currentFile,
+                    line: located.line,
+                    column: located.column,
+                    latexPass: isLatexPhase(phase) ? latexPass : undefined
+                });
+                pendingBang = undefined;
+                continue;
+            }
+        }
+        const packageDiagnostic = parsePackageLine(line);
+        if (packageDiagnostic) {
+            addDiagnostic(diagnostics, {
+                ...packageDiagnostic,
+                phase,
+                raw: line,
+                file: currentFile,
+                line: lineFromMessage(packageDiagnostic.message),
+                latexPass: isLatexPhase(phase) ? latexPass : undefined
+            });
+            pendingBang = undefined;
+            continue;
+        }
+        const latexDiagnostic = parseLatexLine(line);
+        if (latexDiagnostic) {
+            addDiagnostic(diagnostics, {
+                ...latexDiagnostic,
+                phase: phase === "unknown" ? "pdflatex" : phase,
+                raw: line,
+                file: currentFile,
+                line: lineFromMessage(latexDiagnostic.message),
+                latexPass: isLatexPhase(phase) ? latexPass : undefined
+            });
+            pendingBang = undefined;
+            continue;
+        }
+        if (/^!\s+/.test(line)) {
+            pendingBang = addDiagnostic(diagnostics, {
+                severity: "error",
+                phase: phase === "unknown" ? "pdflatex" : phase,
+                message: line.slice(2).trim(),
+                raw: line,
+                file: currentFile,
+                latexPass: isLatexPhase(phase) ? latexPass : undefined
+            });
+            continue;
+        }
+        const texLocation = line.match(latexLinePattern);
+        if (texLocation && pendingBang) {
+            pendingBang.line = Number(texLocation.groups?.line);
+            pendingBang.key = diagnosticKey(pendingBang);
+            continue;
+        }
+        const warning = parseGenericWarning(line);
+        if (warning) {
+            addDiagnostic(diagnostics, {
+                ...warning,
+                phase,
+                raw: line,
+                file: currentFile,
+                line: lineFromMessage(warning.message),
+                latexPass: isLatexPhase(phase) ? latexPass : undefined
+            });
+            pendingBang = undefined;
+            continue;
+        }
+        if (isLatexmkFailure(line)) {
+            addDiagnostic(diagnostics, {
+                severity: "error",
+                phase: "latexmk",
+                message: line.replace(/^Latexmk:\s*/i, "").trim(),
+                raw: line
+            });
+            pendingBang = undefined;
+        }
+    }
+    const unique = dedupeDiagnostics(diagnostics);
+    // A successful process/PDF is the source of truth.  Do not report a stale
+    // BibTeX error from an earlier pass as a compile error after latexmk has
+    // completed successfully.
+    const errors = resolvedOutcome === "succeeded" ? [] : unique.filter((item) => item.severity === "error");
+    const warnings = unique.filter((item) => item.severity === "warning")
+        .filter((item) => lastLatexPass < 2 || !isLatexPhase(item.phase) || item.latexPass === lastLatexPass);
+    if (resolvedOutcome === "failed" && errors.length === 0) {
+        const fallback = {
+            severity: "error",
+            phase: "system",
+            message: "Compilation failed without a parsed diagnostic; inspect the raw log.",
+            raw: "",
+            key: "system-failure"
+        };
+        errors.push(fallback);
+    }
+    return { warnings: publicDiagnostics(warnings), errors: publicDiagnostics(errors) };
+}
+function hasSuccessfulLatexmkResult(log) {
+    return /Latexmk: All targets .* are up-to-date/i.test(log)
+        && /Output written on .*\.pdf/i.test(log);
+}
+function parseLocatedLine(line) {
+    const match = line.match(locationPattern);
+    if (!match?.groups)
+        return null;
+    const rest = match.groups.rest;
+    const marker = rest.match(/\b(?:LaTeX(?:\s+[^:]+)?|Package|Class|pdfTeX|XeTeX|LuaTeX)\s+(?<severity>Error|Warning):\s*(?<message>.*)$/i);
+    if (!marker?.groups)
+        return { file: match.groups.file, line: Number(match.groups.line), column: match.groups.column ? Number(match.groups.column) : undefined, message: rest };
+    return {
+        file: match.groups.file.replaceAll("\\", "/"),
+        line: Number(match.groups.line),
+        column: match.groups.column ? Number(match.groups.column) : undefined,
+        severity: marker.groups.severity.toLowerCase(),
+        message: marker.groups.message.trim()
+    };
+}
+function parsePackageLine(line) {
+    const match = line.match(/^(?:Package|Class)\s+[^:]+\s+(?<severity>Error|Warning):\s*(?<message>.*)$/i);
+    if (!match?.groups)
+        return null;
+    return { severity: match.groups.severity.toLowerCase(), message: match.groups.message.trim() };
+}
+function parseLatexLine(line) {
+    const match = line.match(/^(?:LaTeX(?:\s+[^:]+)?|pdfTeX|XeTeX|LuaTeX)\s+(?<severity>Error|Warning):\s*(?<message>.*)$/i);
+    if (!match?.groups)
+        return null;
+    return { severity: match.groups.severity.toLowerCase(), message: match.groups.message.trim() };
+}
+function parseGenericWarning(line) {
+    if (/^(?:Overfull|Underfull)\b/i.test(line) || /^(?:pdfTeX|XeTeX|LuaTeX)\s+warning\b/i.test(line)) {
+        return { severity: "warning", message: line };
+    }
+    return null;
+}
+function lineFromMessage(message) {
+    const match = message.match(inputLinePattern);
+    return match?.groups?.line ? Number(match.groups.line) : undefined;
+}
+function isLatexmkFailure(line) {
+    return /^Latexmk:.*(?:\bErrors?,|did not complete making targets|failure)/i.test(line)
+        || /^Collected error summary/i.test(line)
+        || /^error, and then rerun latexmk/i.test(line)
+        || /\b(?:fatal error|emergency stop|no output pdf|no pages of output)\b/i.test(line)
+        || /\b(?:bibtex|biber) errors?:/i.test(line);
+}
+function addDiagnostic(target, input) {
+    const diagnostic = { ...input, key: diagnosticKey(input) };
+    const existing = target.find((item) => item.key === diagnostic.key
+        || (item.severity === diagnostic.severity && item.phase === diagnostic.phase
+            && item.message === diagnostic.message && item.file === diagnostic.file
+            && (item.line === undefined || diagnostic.line === undefined)));
+    if (existing) {
+        if (existing.line === undefined && diagnostic.line !== undefined)
+            existing.line = diagnostic.line;
+        if (!existing.file && diagnostic.file)
+            existing.file = diagnostic.file;
+        existing.key = diagnosticKey(existing);
+        return existing;
+    }
+    target.push(diagnostic);
+    return diagnostic;
+}
+function diagnosticKey(item) {
+    return [item.severity, item.phase, item.file ?? "", item.line ?? "", item.column ?? "", item.message].join("\u0000");
+}
+function dedupeDiagnostics(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        const key = diagnosticKey(item);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function publicDiagnostics(items) {
+    return items.map(({ key: _key, latexPass: _latexPass, ...item }) => item);
+}
+function isLatexPhase(phase) {
+    return phase === "pdflatex" || phase === "xelatex" || phase === "lualatex";
+}