@json-to-office/jto 0.28.1 → 0.29.0

package/dist/render-server.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { PptxRasterizer } from '@json-to-office/shared';
+import { PptxRasterizer, PptxBatchRasterizer } from '@json-to-office/shared';
 
 type ApiAuthMode = 'auto' | 'required' | 'disabled';
 type OutboundSourceMode = 'development' | 'safe';
@@ -34,6 +34,7 @@ interface RenderServerOptions {
     sourcePolicy?: OutboundSourcePolicy;
     fetch?: FetchImplementation;
     getRasterizer?: () => PptxRasterizer;
+    getBatchRasterizer?: () => PptxBatchRasterizer;
 }
 declare function createRenderServerApp(options?: RenderServerOptions): Hono;
 

package/dist/render-server.js

@@ -15,9 +15,13 @@ import {
   clampVisualDpi,
   DEFAULT_VISUAL_DPI,
   MIN_VISUAL_DPI,
-  MAX_VISUAL_DPI
+  MAX_VISUAL_DPI,
+  MAX_RASTERIZE_BATCH_SLIDES
 } from "@json-to-office/shared";
-import { createLibreOfficePptxRasterizer } from "@json-to-office/jto-cli";
+import {
+  createLibreOfficePptxRasterizer,
+  createLibreOfficePptxBatchRasterizer
+} from "@json-to-office/jto-cli";
 
 // src/server/lib/typebox-validator.ts
 import { Value } from "@sinclair/typebox/value";
@@ -392,6 +396,24 @@ var RasterizeRequestSchema = Type.Object(
   },
   { additionalProperties: false }
 );
+var RasterizeBatchRequestSchema = Type.Object(
+  {
+    slides: Type.Array(
+      Type.Object(
+        {
+          presentation: Type.Object({}, { additionalProperties: true }),
+          dpi: Type.Optional(
+            Type.Number({ minimum: MIN_VISUAL_DPI, maximum: MAX_VISUAL_DPI })
+          )
+        },
+        { additionalProperties: false }
+      ),
+      { minItems: 1, maxItems: MAX_RASTERIZE_BATCH_SLIDES }
+    ),
+    baseDir: Type.Optional(Type.String())
+  },
+  { additionalProperties: false }
+);
 var sharedRasterizer;
 function getSharedRasterizer() {
   if (!sharedRasterizer) {
@@ -399,6 +421,13 @@ function getSharedRasterizer() {
   }
   return sharedRasterizer;
 }
+var sharedBatchRasterizer;
+function getSharedBatchRasterizer() {
+  if (!sharedBatchRasterizer) {
+    sharedBatchRasterizer = createLibreOfficePptxBatchRasterizer();
+  }
+  return sharedBatchRasterizer;
+}
 var jsonOnly = async (c, next) => {
   const contentType = c.req.header("content-type");
   if (!contentType || !contentType.includes("application/json")) {
@@ -408,10 +437,65 @@ var jsonOnly = async (c, next) => {
   }
   await next();
 };
+var DEFAULT_SLIDE_WIDTH_IN = 13.34;
+var DEFAULT_SLIDE_HEIGHT_IN = 7.5;
+var MAX_SLIDE_PIXELS = 64e6;
+var MAX_BATCH_PIXELS = 256e6;
+function estimateSlidePixels(presentation, dpi) {
+  const props = presentation?.props;
+  const dim = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+  const widthIn = dim(props?.slideWidth, DEFAULT_SLIDE_WIDTH_IN);
+  const heightIn = dim(props?.slideHeight, DEFAULT_SLIDE_HEIGHT_IN);
+  return widthIn * dpi * (heightIn * dpi);
+}
+function assertPixelBudget(slides) {
+  let total = 0;
+  for (const slide of slides) {
+    const pixels = estimateSlidePixels(slide.presentation, slide.dpi);
+    if (pixels > MAX_SLIDE_PIXELS) {
+      throw new HTTPException2(400, {
+        message: "Requested slide dimensions are too large"
+      });
+    }
+    total += pixels;
+  }
+  if (total > MAX_BATCH_PIXELS) {
+    throw new HTTPException2(400, {
+      message: "Requested batch raster size is too large"
+    });
+  }
+}
+function resolveSafeBaseDir(baseDir) {
+  if (baseDir === void 0) return void 0;
+  const resolved = path.resolve(baseDir);
+  const cwd = process.cwd();
+  if (resolved !== cwd && !resolved.startsWith(cwd + path.sep)) {
+    throw new HTTPException2(400, {
+      message: "baseDir must be inside the server working directory"
+    });
+  }
+  return resolved;
+}
+function toHttpException(error) {
+  if (error instanceof HTTPException2) return error;
+  if (error instanceof UnsafeOutboundSourceError) {
+    return new HTTPException2(400, { message: error.message });
+  }
+  const msg = error instanceof Error ? error.message.toLowerCase() : String(error);
+  if (msg.includes("not found") || msg.includes("rasterization needs")) {
+    return new HTTPException2(503, { message: error.message });
+  }
+  if (msg.includes("invalid") || msg.includes("validation")) {
+    return new HTTPException2(400, { message: error.message });
+  }
+  return new HTTPException2(500, {
+    message: "Internal server error during rasterization"
+  });
+}
 function registerRasterizeRoute(router, options = {}) {
   const getRasterizer = options.getRasterizer ?? getSharedRasterizer;
-  router.post(
-    "/rasterize",
+  const getBatchRasterizer = options.getBatchRasterizer ?? getSharedBatchRasterizer;
+  const shared = [
     ...options.preMiddleware ?? [],
     bodyLimit({
       maxSize: 32 * 1024 * 1024,
@@ -419,22 +503,26 @@ function registerRasterizeRoute(router, options = {}) {
         throw new HTTPException2(413, { message: "Request body too large" });
       }
     }),
-    jsonOnly,
+    jsonOnly
+  ];
+  const guard = async (run) => {
+    try {
+      return await run();
+    } catch (error) {
+      options.onError?.(error);
+      throw toHttpException(error);
+    }
+  };
+  router.post(
+    "/rasterize",
+    ...shared,
     tbValidator(RasterizeRequestSchema),
     async (c) => {
       const { presentation, dpi, baseDir } = getValidated(c, "json");
-      let safeBaseDir;
-      if (baseDir !== void 0) {
-        const resolved = path.resolve(baseDir);
-        const cwd = process.cwd();
-        if (resolved !== cwd && !resolved.startsWith(cwd + path.sep)) {
-          throw new HTTPException2(400, {
-            message: "baseDir must be inside the server working directory"
-          });
-        }
-        safeBaseDir = resolved;
-      }
-      try {
+      const safeBaseDir = resolveSafeBaseDir(baseDir);
+      const effectiveDpi = clampVisualDpi(dpi ?? DEFAULT_VISUAL_DPI);
+      assertPixelBudget([{ presentation, dpi: effectiveDpi }]);
+      const result = await guard(async () => {
         if (options.sourcePolicy) {
           assertSafeOutboundSources(
             presentation,
@@ -442,29 +530,53 @@ function registerRasterizeRoute(router, options = {}) {
             "presentation"
           );
         }
-        const result = await getRasterizer()({
+        return getRasterizer()({
           presentation,
-          dpi: clampVisualDpi(dpi ?? DEFAULT_VISUAL_DPI),
+          dpi: effectiveDpi,
           baseDir: safeBaseDir
         });
-        return c.json(result);
-      } catch (error) {
-        options.onError?.(error);
-        if (error instanceof HTTPException2) throw error;
-        if (error instanceof UnsafeOutboundSourceError) {
-          throw new HTTPException2(400, { message: error.message });
-        }
-        const msg = error instanceof Error ? error.message.toLowerCase() : String(error);
-        if (msg.includes("not found") || msg.includes("rasterization needs")) {
-          throw new HTTPException2(503, { message: error.message });
-        }
-        if (msg.includes("invalid") || msg.includes("validation")) {
-          throw new HTTPException2(400, { message: error.message });
+      });
+      return c.json(result);
+    }
+  );
+  router.post(
+    "/rasterize/batch",
+    ...shared,
+    tbValidator(RasterizeBatchRequestSchema),
+    async (c) => {
+      const { slides, baseDir } = getValidated(c, "json");
+      const safeBaseDir = resolveSafeBaseDir(baseDir);
+      const effectiveSlides = slides.map((slide) => ({
+        presentation: slide.presentation,
+        dpi: clampVisualDpi(slide.dpi ?? DEFAULT_VISUAL_DPI)
+      }));
+      assertPixelBudget(effectiveSlides);
+      const result = await guard(async () => {
+        if (options.sourcePolicy) {
+          slides.forEach(
+            (slide, index) => assertSafeOutboundSources(
+              slide.presentation,
+              options.sourcePolicy,
+              `slides[${index}].presentation`
+            )
+          );
         }
-        throw new HTTPException2(500, {
-          message: "Internal server error during rasterization"
+        return getBatchRasterizer()({
+          slides: effectiveSlides,
+          baseDir: safeBaseDir
         });
-      }
+      });
+      return c.json({
+        results: result.results.map((slide) => {
+          if (slide.ok) return slide;
+          options.onError?.(new Error(slide.error));
+          return slide.stage === "build" ? { ok: false, error: slide.error, stage: slide.stage } : {
+            ok: false,
+            error: "Slide rasterization failed",
+            stage: slide.stage
+          };
+        })
+      });
     }
   );
 }
@@ -903,6 +1015,7 @@ function createRenderServerApp(options = {}) {
   });
   registerRasterizeRoute(app, {
     getRasterizer: options.getRasterizer,
+    getBatchRasterizer: options.getBatchRasterizer,
     preMiddleware: [
       rateLimiter({
         limit: options.rasterizeRateLimit ?? positiveInteger2(
@@ -1010,7 +1123,7 @@ function createRenderServerApp(options = {}) {
       return c.body(payload, response.status, headers);
     }
   );
-  for (const route of ["/export", "/rasterize"]) {
+  for (const route of ["/export", "/rasterize", "/rasterize/batch"]) {
     app.all(route, (c) => {
       c.header("Allow", "POST");
       return c.json({ success: false, error: "Method not allowed" }, 405);