texlite 0.7.8 → 0.8.1

package/dist/server/texcount.js

@@ -0,0 +1,244 @@
+import { spawn } from "node:child_process";
+import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
+/** TeXcount is an optional host command supplied by TeX Live. */
+export const TEXCOUNT_COMMAND = "texcount";
+const TEXLITE_WORD_REPORT_PREFIX = "__TEXLITE_TEXCOUNT_WORDS__";
+const TEXLITE_CHARACTER_REPORT_PREFIX = "__TEXLITE_TEXCOUNT_CHARS__";
+// TeXcount placeholders {1} through {7} are, respectively: words in text,
+// header words, caption words, header count, float count, inline math, and
+// displayed math.  Do not parse TeXcount's human-facing prose report.
+const TEXLITE_WORD_REPORT_TEMPLATE = `${TEXLITE_WORD_REPORT_PREFIX}|{1}|{2}|{3}|{4}|{5}|{6}|{7}`;
+const TEXLITE_CHARACTER_REPORT_TEMPLATE = `${TEXLITE_CHARACTER_REPORT_PREFIX}|{1}|{2}|{3}|{4}|{5}|{6}|{7}`;
+const PROBE_TIMEOUT_MS = 5_000;
+const COUNT_TIMEOUT_MS = 30_000;
+const UNAVAILABLE_RETRY_MS = 15_000;
+const MAX_OUTPUT_BYTES = 512 * 1024;
+export class TexcountUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TexcountUnavailableError";
+    }
+}
+export class TexcountExecutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TexcountExecutionError";
+    }
+}
+/**
+ * Run the optional host TeXcount binary and normalize its explicit report
+ * template into stable fields for the browser. The command is intentionally
+ * fixed (rather than shell-evaluated) so project sources cannot inject flags.
+ */
+export class TexcountService {
+    command;
+    availability = "unknown";
+    lastUnavailableAt = 0;
+    probePromise = null;
+    activeChildren = new Set();
+    disposed = false;
+    constructor(command = TEXCOUNT_COMMAND) {
+        this.command = command;
+    }
+    async countFile(cwd, filePath) {
+        await this.ensureAvailable();
+        return this.count(cwd, ["-inc", "-total"], filePath);
+    }
+    async countSource(cwd, source) {
+        await this.ensureAvailable();
+        // A dash tells TeXcount to read one virtual TeX document from stdin. No
+        // include traversal is requested for a selection because the selection
+        // is not a complete project tree.
+        return this.count(cwd, ["-total"], "-", source);
+    }
+    async dispose() {
+        this.disposed = true;
+        for (const child of this.activeChildren)
+            killProcessGroup(child, "SIGTERM");
+        this.activeChildren.clear();
+        await this.probePromise?.catch(() => undefined);
+        this.probePromise = null;
+    }
+    async ensureAvailable() {
+        if (this.disposed)
+            throw new TexcountUnavailableError("TeXcount service stopped.");
+        if (this.availability === "available")
+            return;
+        if (this.availability === "unavailable" && Date.now() - this.lastUnavailableAt < UNAVAILABLE_RETRY_MS) {
+            throw new TexcountUnavailableError(`The optional ${this.command} command is not available.`);
+        }
+        if (this.probePromise)
+            return this.probePromise;
+        this.probePromise = this.runCommand(["--version"], undefined, undefined, PROBE_TIMEOUT_MS, 64 * 1024)
+            .then(({ code, stdout, stderr }) => {
+            if (code !== 0)
+                throw new Error((stderr || stdout).trim() || `exited with code ${code}`);
+            this.availability = "available";
+        })
+            .catch((error) => {
+            this.availability = "unavailable";
+            this.lastUnavailableAt = Date.now();
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new TexcountUnavailableError(`The optional ${this.command} command is unavailable: ${detail}`);
+        })
+            .finally(() => { this.probePromise = null; });
+        return this.probePromise;
+    }
+    async count(cwd, options, target, input) {
+        const [wordResult, characterResult] = await Promise.all([
+            this.runCommand([...options, `-template=${TEXLITE_WORD_REPORT_TEMPLATE}`, target], cwd, input),
+            this.runCommand([...options, "-char", `-template=${TEXLITE_CHARACTER_REPORT_TEMPLATE}`, target], cwd, input)
+        ]);
+        const words = this.finishWordCount(wordResult);
+        const characters = this.finishCharacterCount(characterResult);
+        return {
+            ...words,
+            totalCharacters: characters.text + characters.headers + characters.captions,
+            // TeXcount parses the same source twice. Do not show each syntax issue
+            // twice merely because character counting was requested as well.
+            parserErrors: Math.max(words.parserErrors, characters.parserErrors)
+        };
+    }
+    finishWordCount(result) {
+        if (result.code !== 0) {
+            throw new TexcountExecutionError(result.stderr.trim() || `${this.command} exited with code ${result.code}`);
+        }
+        try {
+            return parseTexcountOutput(result.stdout);
+        }
+        catch (error) {
+            throw new TexcountExecutionError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    finishCharacterCount(result) {
+        if (result.code !== 0) {
+            throw new TexcountExecutionError(result.stderr.trim() || `${this.command} exited with code ${result.code}`);
+        }
+        try {
+            return parseTexcountReport(result.stdout, TEXLITE_CHARACTER_REPORT_PREFIX);
+        }
+        catch (error) {
+            throw new TexcountExecutionError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    runCommand(args, cwd, input, timeoutMs = COUNT_TIMEOUT_MS, outputLimit = MAX_OUTPUT_BYTES) {
+        return new Promise((resolve, reject) => {
+            if (this.disposed) {
+                reject(new TexcountUnavailableError("TeXcount service stopped."));
+                return;
+            }
+            let child;
+            try {
+                child = spawn(this.command, args, {
+                    cwd,
+                    env: { ...process.env, LC_ALL: "C" },
+                    shell: false,
+                    detached: detachedProcessGroup(),
+                    stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+                });
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            this.activeChildren.add(child);
+            const stdout = [];
+            const stderr = [];
+            let outputBytes = 0;
+            let settled = false;
+            let timedOut = false;
+            let outputTooLarge = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                killProcessGroup(child);
+            }, timeoutMs);
+            const finish = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.activeChildren.delete(child);
+                callback();
+            };
+            const terminateWithError = (error) => {
+                killProcessGroup(child);
+                finish(() => reject(error));
+            };
+            const collect = (target) => (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > outputLimit) {
+                    outputTooLarge = true;
+                    terminateWithError(new TexcountExecutionError(`${this.command} produced too much output.`));
+                    return;
+                }
+                target.push(chunk);
+            };
+            child.stdout?.on("data", collect(stdout));
+            child.stderr?.on("data", collect(stderr));
+            child.stdin?.on("error", (error) => terminateWithError(error));
+            child.once("error", (error) => finish(() => {
+                if (timedOut) {
+                    reject(new TexcountExecutionError(`${this.command} timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
+                    return;
+                }
+                if (error.code === "ENOENT") {
+                    reject(new TexcountUnavailableError(`The optional ${this.command} command is not available.`));
+                    return;
+                }
+                reject(error);
+            }));
+            child.once("close", (code) => finish(() => {
+                if (timedOut) {
+                    reject(new TexcountExecutionError(`${this.command} timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
+                    return;
+                }
+                if (outputTooLarge) {
+                    reject(new TexcountExecutionError(`${this.command} produced too much output.`));
+                    return;
+                }
+                resolve({
+                    code,
+                    stdout: Buffer.concat(stdout).toString("utf8"),
+                    stderr: Buffer.concat(stderr).toString("utf8")
+                });
+            }));
+            if (input !== undefined)
+                child.stdin?.end(input, "utf8");
+        });
+    }
+}
+/** Parse TexLite's explicit TeXcount template, rather than prose output. */
+export function parseTexcountOutput(output) {
+    const report = parseTexcountReport(output, TEXLITE_WORD_REPORT_PREFIX);
+    const filesMatch = /Files:\s*(\d+)/i.exec(output);
+    return {
+        textWords: report.text,
+        headerWords: report.headers,
+        captionWords: report.captions,
+        totalWords: report.text + report.headers + report.captions,
+        headers: report.headerCount,
+        floats: report.floatCount,
+        inlineMath: report.inlineMathCount,
+        displayMath: report.displayMathCount,
+        files: filesMatch ? Number(filesMatch[1]) : null,
+        parserErrors: report.parserErrors
+    };
+}
+function parseTexcountReport(output, prefix) {
+    const report = new RegExp(`${prefix}\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)`).exec(output);
+    if (!report) {
+        throw new Error("TeXcount did not return TexLite's expected report; a %TC:newtemplate or %TC:template directive may have overridden it.");
+    }
+    const [, text, header, caption, headerCount, floatCount, inlineMathCount, displayMathCount] = report;
+    const errorsMatch = /\(errors:\s*(\d+)\)/i.exec(output);
+    return {
+        text: Number(text),
+        headers: Number(header),
+        captions: Number(caption),
+        headerCount: Number(headerCount),
+        floatCount: Number(floatCount),
+        inlineMathCount: Number(inlineMathCount),
+        displayMathCount: Number(displayMathCount),
+        parserErrors: errorsMatch ? Number(errorsMatch[1]) : 0
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "texlite",
-  "version": "0.7.8",
+  "version": "0.8.1",
   "description": "A lightweight local-first collaborative LaTeX workspace",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -24,8 +24,12 @@
     "dist",
     "README.md",
     "README.zh-CN.md",
+    "OPERATIONS.md",
+    "DESIGN.md",
+    "NPM_TESTING.md",
     "LICENSE",
-    "preview.png",
+    "preview-1.png",
+    "preview-2.png",
     "texlite.config.example.json"
   ],
   "engines": {
@@ -72,7 +76,6 @@
     "bibtex-tidy": "1.14.0",
     "diff-match-patch": "^1.0.5",
     "fastify": "^5.4.0",
-    "harper.js": "^2.7.0",
     "i18next": "^25.3.2",
     "i18next-browser-languagedetector": "^8.2.0",
     "lib0": "^0.2.117",