@tstdl/base 0.93.68 → 0.93.69

package/latex/render.d.ts

@@ -9,11 +9,15 @@ export type LatexRenderOptions = {
 /**
  * Renders LaTeX source code to a PDF file.
  *
+ * ## WARNING
+ * **This function should not be used with untrusted LaTeX source, as it can lead to arbitrary code execution on the system.**
+ *
  * Requires latexmk and LuaTeX to be installed on the system.
  *
  * **Minimal recommendation:**
  * - **Arch Linux:** texlive-binextra texlive-luatex texlive-latexrecommended texlive-fontsrecommended
  * @param source The LaTeX source code to render
+ * @param options Rendering options
  * @returns A TemporaryFile representing the generated PDF
  */
 export declare function renderLatex(source: string, options?: LatexRenderOptions): Promise<TemporaryFile>;

package/latex/render.js

@@ -51,7 +51,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { TemporaryFile } from '../file/server/temporary-file.js';
-import { spawnCommand, spawnWaitCommand } from '../process/spawn.js';
+import { spawnWaitCommand, spawnWaitReadCommand } from '../process/spawn.js';
+import { withTimeout } from '../utils/timing.js';
 import { tryIgnoreAsync } from '../utils/try-ignore.js';
 const engineMapping = {
     pdflatex: '-pdflatex',
@@ -61,11 +62,15 @@ const engineMapping = {
 /**
  * Renders LaTeX source code to a PDF file.
  *
+ * ## WARNING
+ * **This function should not be used with untrusted LaTeX source, as it can lead to arbitrary code execution on the system.**
+ *
  * Requires latexmk and LuaTeX to be installed on the system.
  *
  * **Minimal recommendation:**
  * - **Arch Linux:** texlive-binextra texlive-luatex texlive-latexrecommended texlive-fontsrecommended
  * @param source The LaTeX source code to render
+ * @param options Rendering options
  * @returns A TemporaryFile representing the generated PDF
  */
 export async function renderLatex(source, options) {
@@ -73,14 +78,16 @@ export async function renderLatex(source, options) {
     try {
         const latexFile = __addDisposableResource(env_1, await TemporaryFile.from(source, '.tex'), true);
         const engineFlag = engineMapping[options?.engine ?? 'lualatex'];
-        const process = await spawnCommand('latexmk', ['-interaction=nonstopmode', engineFlag, '-cd', latexFile.path]);
-        console.log(latexFile.path);
-        const { code } = await process.wait();
-        if (code != 0) {
-            const [out, err] = await Promise.all([process.readOutput(), process.readError()]);
-            throw new Error(`LaTeX compilation failed with exit code ${code}. Output:\n${out}\nError Output:\n${err}`);
+        const { code, output, error } = await spawnWaitReadCommand('string', 'latexmk', ['-interaction=nonstopmode', engineFlag, '-cd', latexFile.path], { throwOnNonZeroExitCode: false });
+        await tryIgnoreAsync(async () => await withTimeout(1000, spawnWaitCommand('latexmk', ['-c', '-cd', engineFlag, latexFile.path])));
+        if (code !== 0) {
+            throw new Error(`
+LaTeX compilation failed with exit code ${code}.\n
+File: ${latexFile.path}\n
+Output:\n${output}\n
+Error Output:\n${error}
+`.trim());
         }
-        await tryIgnoreAsync(async () => await spawnWaitCommand('latexmk', ['-interaction=nonstopmode', '-pdflua', '-cd', '-c', latexFile.path]));
         return TemporaryFile.adopt(`${latexFile.path.slice(0, -4)}.pdf`);
     }
     catch (e_1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.68",
+  "version": "0.93.69",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/process/spawn.d.ts

@@ -1,12 +1,18 @@
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
 import type { Record } from '../types/types.js';
+type WaitReadResultFormat = 'string' | 'binary';
+type WaitReadResultFormatType<T extends WaitReadResultFormat> = T extends 'string' ? string : Uint8Array<ArrayBuffer>;
 export type WaitOptions = {
     throwOnNonZeroExitCode?: boolean;
 };
-export type ProcessResult = {
+export type WaitResult = {
     code: number | null;
     signal: string | null;
 };
+export type WaitReadResult<Format extends WaitReadResultFormat> = WaitResult & {
+    output: WaitReadResultFormatType<Format>;
+    error: WaitReadResultFormatType<Format>;
+};
 export type SpawnOptions = {
     arguments?: string[];
     workingDirectory?: string;
@@ -22,11 +28,16 @@ export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
     readErrorBytes(): Promise<Uint8Array>;
     readError(): Promise<string>;
     handleNonZeroExitCode(): void;
-    wait(options?: WaitOptions): Promise<ProcessResult>;
+    wait(options?: WaitOptions): Promise<WaitResult>;
+    waitRead<F extends WaitReadResultFormat>(format: F, options?: WaitOptions): Promise<WaitReadResult<F>>;
 };
 /** spwans a command and waits for it to complete */
-export declare function spawnWaitCommand(command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<ProcessResult>;
-export declare function spawnWaitCommand(command: string, options?: SpawnOptions & WaitOptions): Promise<ProcessResult>;
+export declare function spawnWaitCommand(command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<WaitResult>;
+export declare function spawnWaitCommand(command: string, options?: SpawnOptions & WaitOptions): Promise<WaitResult>;
+/** spwans a command, waits for it to complete and reads its output */
+export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<WaitReadResult<F>>;
+export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, options?: SpawnOptions & WaitOptions): Promise<WaitReadResult<F>>;
 /** Spawns a command as a child process. */
 export declare function spawnCommand(command: string, args?: string[], options?: SpawnOptions): Promise<SpawnCommandResult>;
 export declare function spawnCommand(command: string, options?: SpawnOptions): Promise<SpawnCommandResult>;
+export {};

package/process/spawn.js

@@ -9,6 +9,11 @@ export async function spawnWaitCommand(command, argsOrOptions, optionsOrNothing)
     const process = await spawnCommand(command, args, options);
     return await process.wait({ throwOnNonZeroExitCode: options?.throwOnNonZeroExitCode });
 }
+export async function spawnWaitReadCommand(format, command, argsOrOptions, optionsOrNothing) {
+    const [args, options] = isArray(argsOrOptions) ? [argsOrOptions, optionsOrNothing] : [undefined, argsOrOptions];
+    const process = await spawnCommand(command, args, options);
+    return await process.waitRead(format, { throwOnNonZeroExitCode: options?.throwOnNonZeroExitCode });
+}
 export async function spawnCommand(command, argsOrOptions, optionsOrNothing) {
     const { spawn } = await dynamicImport('node:child_process');
     const { Readable, Writable } = await dynamicImport('node:stream');
@@ -81,6 +86,18 @@ export async function spawnCommand(command, argsOrOptions, optionsOrNothing) {
         }
         return result;
     }
+    async function waitRead(format, { throwOnNonZeroExitCode = true } = {}) {
+        const [result, output, error] = await Promise.all([
+            wait({ throwOnNonZeroExitCode }),
+            (format === 'string') ? readOutput() : readOutputBytes(),
+            (format === 'string') ? readError() : readErrorBytes(),
+        ]);
+        return {
+            ...result,
+            output: output,
+            error: error,
+        };
+    }
     return {
         process,
         readable,
@@ -94,5 +111,6 @@ export async function spawnCommand(command, argsOrOptions, optionsOrNothing) {
         readError,
         handleNonZeroExitCode: () => void handleNonZeroExitCode(),
         wait,
+        waitRead,
     };
 }

package/utils/try-ignore.d.ts

@@ -1,9 +1,9 @@
 import type { Logger } from '../logger/logger.js';
-export declare function tryIgnore<R>(fn: () => R): R;
+export declare function tryIgnore<R>(fn: () => R): R | undefined;
 export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
-export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R | undefined>;
 export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
-export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R;
+export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R | undefined;
 export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
-export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R | undefined>;
 export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;