latex-renderer-sdk 1.0.0

package/README.md

@@ -0,0 +1,84 @@
+# latex-renderer-sdk
+
+TypeScript SDK for the LaTeX Renderer API.
+
+## Installation
+
+```bash
+npm install latex-renderer-sdk
+```
+
+## Usage
+
+```typescript
+import { LatexRenderer } from "latex-renderer-sdk";
+
+const client = new LatexRenderer({
+  apiKey: "your-api-key",
+  baseUrl: "https://your-api-url.com", // optional, defaults to http://localhost:8080
+});
+```
+
+### Render LaTeX to HTML
+
+```typescript
+const html = await client.renderHTML(
+  "\\documentclass{article}\\begin{document}Hello $E=mc^2$\\end{document}",
+);
+```
+
+### Render LaTeX to PDF
+
+```typescript
+import { writeFile } from "fs/promises";
+
+const pdf = await client.renderPDF(
+  "\\documentclass{article}\\begin{document}Hello World\\end{document}",
+);
+
+await writeFile("output.pdf", pdf);
+```
+
+### Error handling
+
+```typescript
+import {
+  LatexRenderer,
+  RenderError,
+  AuthenticationError,
+  ConnectionError,
+} from "latex-renderer-sdk";
+
+try {
+  const html = await client.renderHTML(latex);
+} catch (error) {
+  if (error instanceof RenderError) {
+    console.error("LaTeX compilation failed:", error.detail);
+  } else if (error instanceof AuthenticationError) {
+    console.error("Invalid API key:", error.message);
+  } else if (error instanceof ConnectionError) {
+    console.error("Network error:", error.message);
+  }
+}
+```
+
+### Request cancellation
+
+```typescript
+const controller = new AbortController();
+setTimeout(() => controller.abort(), 5000);
+
+const html = await client.renderHTML(latex, { signal: controller.signal });
+```
+
+## Configuration
+
+| Option    | Type     | Default                  | Description             |
+| --------- | -------- | ------------------------ | ----------------------- |
+| `apiKey`  | `string` | _(required)_             | API authentication key  |
+| `baseUrl` | `string` | `http://localhost:8080`  | API base URL            |
+| `timeout` | `number` | `30000`                  | Request timeout (ms)    |
+
+## Requirements
+
+Node.js >= 18.0.0

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class LatexRendererError extends Error {
+    readonly statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}
+export declare class AuthenticationError extends LatexRendererError {
+    constructor(message: string);
+}
+export declare class RenderError extends LatexRendererError {
+    readonly detail?: string;
+    constructor(message: string, detail?: string);
+}
+export declare class APIError extends LatexRendererError {
+    constructor(message: string, statusCode: number);
+}
+export declare class ConnectionError extends LatexRendererError {
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}

package/dist/errors.js

@@ -0,0 +1,36 @@
+export class LatexRendererError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.name = "LatexRendererError";
+        this.statusCode = statusCode;
+    }
+}
+export class AuthenticationError extends LatexRendererError {
+    constructor(message) {
+        super(message, 401);
+        this.name = "AuthenticationError";
+    }
+}
+export class RenderError extends LatexRendererError {
+    detail;
+    constructor(message, detail) {
+        super(message, 400);
+        this.name = "RenderError";
+        this.detail = detail;
+    }
+}
+export class APIError extends LatexRendererError {
+    constructor(message, statusCode) {
+        super(message, statusCode);
+        this.name = "APIError";
+    }
+}
+export class ConnectionError extends LatexRendererError {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "ConnectionError";
+        this.cause = cause;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { LatexRendererConfig, RenderOptions } from "./types.js";
+export { LatexRendererError, AuthenticationError, RenderError, APIError, ConnectionError, } from "./errors.js";
+export type { LatexRendererConfig, RenderOptions } from "./types.js";
+export declare class LatexRenderer {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(config: LatexRendererConfig);
+    renderHTML(latex: string, options?: RenderOptions): Promise<string>;
+    renderPDF(latex: string, options?: RenderOptions): Promise<Uint8Array>;
+    private request;
+    private handleError;
+}

package/dist/index.js

@@ -0,0 +1,72 @@
+import { LatexRendererError, AuthenticationError, RenderError, APIError, ConnectionError, } from "./errors.js";
+export { LatexRendererError, AuthenticationError, RenderError, APIError, ConnectionError, } from "./errors.js";
+export class LatexRenderer {
+    apiKey;
+    baseUrl;
+    timeout;
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new LatexRendererError("apiKey is required");
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl ?? "http://localhost:8080").replace(/\/$/, "");
+        this.timeout = config.timeout ?? 30_000;
+    }
+    async renderHTML(latex, options) {
+        const response = await this.request("/render", latex, options);
+        return response.text();
+    }
+    async renderPDF(latex, options) {
+        const response = await this.request("/render/pdf", latex, options);
+        const buffer = await response.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    async request(endpoint, body, options) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}${endpoint}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "text/plain",
+                },
+                body,
+                signal: options?.signal ?? controller.signal,
+            });
+            if (!response.ok) {
+                await this.handleError(response);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof LatexRendererError)
+                throw error;
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new ConnectionError("Request timed out or was cancelled", error);
+            }
+            throw new ConnectionError(error instanceof Error ? error.message : "Unknown network error", error instanceof Error ? error : undefined);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async handleError(response) {
+        let json;
+        try {
+            json = await response.json();
+        }
+        catch {
+            throw new APIError(`HTTP ${response.status}: ${response.statusText}`, response.status);
+        }
+        const message = json?.error ?? "Unknown error";
+        if (response.status === 401) {
+            throw new AuthenticationError(message);
+        }
+        if (response.status === 400 &&
+            (message === "latex render failed" || message === "pdf render failed")) {
+            throw new RenderError(message, json?.detail);
+        }
+        throw new APIError(message, response.status);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+export interface LatexRendererConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export interface RenderOptions {
+    signal?: AbortSignal;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "latex-renderer-sdk",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for LaTeX Renderer API",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "publish:first": "npm publish --access public",
+    "publish:patch": "npm version patch && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
+    "publish:major": "npm version major && npm publish --access public"
+  },
+  "keywords": [
+    "latex",
+    "renderer",
+    "pdf",
+    "html",
+    "mathml",
+    "sdk"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}