@lexmata/micropdf 0.4.0

package/native/page.cc

@@ -0,0 +1,572 @@
+/**
+ * Page FFI Bindings
+ *
+ * Implements N-API bindings for PDF page functions including rendering and text extraction.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+#include <vector>
+
+/**
+ * Helper: Extract context from object
+ */
+static fz_context GetContext(const Napi::Object& obj) {
+    return obj.Get("_handle").As<Napi::Number>().Int32Value();
+}
+
+/**
+ * Helper: Extract document handle from object
+ */
+static fz_document GetDocument(const Napi::Object& obj) {
+    return obj.Get("_handle").As<Napi::Number>().Int32Value();
+}
+
+/**
+ * Helper: Extract page handle from object
+ */
+static fz_page GetPage(const Napi::Object& obj) {
+    return obj.Get("_handle").As<Napi::Number>().Int32Value();
+}
+
+/**
+ * Helper: Extract matrix from object
+ */
+static fz_matrix GetMatrix(const Napi::Object& obj) {
+    fz_matrix m;
+    m.a = obj.Get("a").As<Napi::Number>().FloatValue();
+    m.b = obj.Get("b").As<Napi::Number>().FloatValue();
+    m.c = obj.Get("c").As<Napi::Number>().FloatValue();
+    m.d = obj.Get("d").As<Napi::Number>().FloatValue();
+    m.e = obj.Get("e").As<Napi::Number>().FloatValue();
+    m.f = obj.Get("f").As<Napi::Number>().FloatValue();
+    return m;
+}
+
+/**
+ * Helper: Create rect object
+ */
+static Napi::Object CreateRect(Napi::Env env, const fz_rect& r) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("x0", Napi::Number::New(env, r.x0));
+    obj.Set("y0", Napi::Number::New(env, r.y0));
+    obj.Set("x1", Napi::Number::New(env, r.x1));
+    obj.Set("y1", Napi::Number::New(env, r.y1));
+    return obj;
+}
+
+/**
+ * Load page from document
+ * JavaScript: loadPage(ctx: NativeContext, doc: NativeDocument, pageNum: number): NativePage
+ */
+Napi::Value LoadPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsNumber()) {
+        Napi::TypeError::New(env, "Expected (context, document, pageNum)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+    int pageNum = info[2].As<Napi::Number>().Int32Value();
+
+    fz_page page = fz_load_page(ctx, doc, pageNum);
+    if (page == 0) {
+        Napi::Error::New(env, "Failed to load page").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("_handle", Napi::Number::New(env, page));
+    return obj;
+}
+
+/**
+ * Drop/free a page
+ * JavaScript: dropPage(ctx: NativeContext, page: NativePage): void
+ */
+Napi::Value DropPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+
+    fz_drop_page(ctx, page);
+
+    return env.Undefined();
+}
+
+/**
+ * Get page bounds
+ * JavaScript: boundPage(ctx: NativeContext, page: NativePage): NativeRect
+ */
+Napi::Value BoundPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+
+    fz_rect bounds = fz_bound_page(ctx, page);
+
+    return CreateRect(env, bounds);
+}
+
+/**
+ * Render page to pixmap
+ * JavaScript: renderPage(ctx: NativeContext, page: NativePage, matrix: NativeMatrix, colorspace: NativeColorspace, alpha: boolean): NativePixmap
+ */
+Napi::Value RenderPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 5) {
+        Napi::TypeError::New(env, "Expected (context, page, matrix, colorspace, alpha)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+    fz_matrix matrix = GetMatrix(info[2].As<Napi::Object>());
+    bool alpha = info[4].As<Napi::Boolean>().Value();
+
+    // Get colorspace (simplified - assume RGB for now)
+    fz_colorspace cs = fz_device_rgb(ctx);
+
+    fz_pixmap pix = fz_new_pixmap_from_page(ctx, page, matrix, cs, alpha ? 1 : 0);
+    if (pix == 0) {
+        Napi::Error::New(env, "Failed to render page").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("_handle", Napi::Number::New(env, pix));
+    obj.Set("width", Napi::Number::New(env, fz_pixmap_width(ctx, pix)));
+    obj.Set("height", Napi::Number::New(env, fz_pixmap_height(ctx, pix)));
+    return obj;
+}
+
+/**
+ * Render page to PNG buffer
+ * JavaScript: renderPageToPNG(ctx: NativeContext, page: NativePage, dpi: number, colorspace: NativeColorspace): Buffer
+ */
+Napi::Value RenderPageToPNG(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4) {
+        Napi::TypeError::New(env, "Expected (context, page, dpi, colorspace)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+    float dpi = info[2].As<Napi::Number>().FloatValue();
+
+    // Create transform matrix for DPI
+    fz_matrix matrix = fz_scale(dpi / 72.0f, dpi / 72.0f);
+    fz_colorspace cs = fz_device_rgb(ctx);
+
+    // Render to pixmap
+    fz_pixmap pix = fz_new_pixmap_from_page(ctx, page, matrix, cs, 0);
+    if (pix == 0) {
+        Napi::Error::New(env, "Failed to render page").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Encode to PNG
+    fz_buffer buf = fz_new_buffer_from_pixmap_as_png(ctx, pix, 0);
+    fz_drop_pixmap(ctx, pix);
+
+    if (buf == 0) {
+        Napi::Error::New(env, "Failed to encode PNG").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Get buffer data
+    size_t len;
+    const unsigned char* data = fz_buffer_data(ctx, buf, &len);
+
+    // Create Node.js buffer
+    Napi::Buffer<uint8_t> result = Napi::Buffer<uint8_t>::Copy(env, data, len);
+
+    fz_drop_buffer(ctx, buf);
+
+    return result;
+}
+
+/**
+ * Extract text from page
+ * JavaScript: extractText(ctx: NativeContext, page: NativePage): string
+ */
+Napi::Value ExtractText(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+
+    // Create text page
+    fz_stext_page stext = fz_new_stext_page_from_page(ctx, page, nullptr);
+    if (stext == 0) {
+        Napi::Error::New(env, "Failed to extract text").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Extract text to buffer
+    fz_buffer buf = fz_new_buffer_from_stext_page(ctx, stext);
+    fz_drop_stext_page(ctx, stext);
+
+    if (buf == 0) {
+        Napi::Error::New(env, "Failed to create text buffer").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    size_t len;
+    const char* data = (const char*)fz_buffer_data(ctx, buf, &len);
+    std::string text(data, len);
+
+    fz_drop_buffer(ctx, buf);
+
+    return Napi::String::New(env, text);
+}
+
+/**
+ * Extract text blocks from page
+ * JavaScript: extractTextBlocks(ctx: NativeContext, page: NativePage): Array<{text: string, bbox: NativeRect}>
+ */
+Napi::Value ExtractTextBlocks(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+
+    // Create text page
+    fz_stext_page stext = fz_new_stext_page_from_page(ctx, page, nullptr);
+    if (stext == 0) {
+        Napi::Error::New(env, "Failed to extract text").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Array blocks = Napi::Array::New(env);
+    uint32_t blockIndex = 0;
+
+    // Iterate through blocks (simplified - would need to access stext_page internals)
+    // For now, return a single block with all text
+    fz_buffer buf = fz_new_buffer_from_stext_page(ctx, stext);
+    size_t len;
+    const char* data = (const char*)fz_buffer_data(ctx, buf, &len);
+
+    Napi::Object block = Napi::Object::New(env);
+    block.Set("text", Napi::String::New(env, data, len));
+    block.Set("bbox", CreateRect(env, fz_bound_page(ctx, page)));
+
+    blocks[blockIndex++] = block;
+
+    fz_drop_buffer(ctx, buf);
+    fz_drop_stext_page(ctx, stext);
+
+    return blocks;
+}
+
+/**
+ * Get page links
+ * JavaScript: getPageLinks(ctx: NativeContext, page: NativePage): Array<{rect: NativeRect, uri?: string, page?: number}>
+ */
+Napi::Value GetPageLinks(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+
+    Napi::Array links = Napi::Array::New(env);
+
+    // Get links from page
+    fz_link link = fz_load_links(ctx, page);
+    uint32_t linkIndex = 0;
+
+    while (link != 0) {
+        Napi::Object linkObj = Napi::Object::New(env);
+
+        fz_rect rect = fz_link_rect(ctx, link);
+        linkObj.Set("rect", CreateRect(env, rect));
+
+        char uri_buffer[2048];
+        fz_link_uri(ctx, link, uri_buffer, sizeof(uri_buffer));
+        if (uri_buffer[0] != '\0') {
+            linkObj.Set("uri", Napi::String::New(env, uri_buffer));
+        }
+
+        links[linkIndex++] = linkObj;
+        link = fz_next_link(ctx, link);
+    }
+
+    return links;
+}
+
+/**
+ * Search text on page
+ * JavaScript: searchText(ctx: NativeContext, page: NativePage, needle: string, hitMax: boolean): Array<NativeRect>
+ */
+Napi::Value SearchText(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4) {
+        Napi::TypeError::New(env, "Expected (context, page, needle, hitMax)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+    std::string needle = info[2].As<Napi::String>().Utf8Value();
+
+    // Create text page for searching
+    fz_stext_page stext = fz_new_stext_page_from_page(ctx, page, nullptr);
+    if (stext == 0) {
+        Napi::Error::New(env, "Failed to create text page").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Array results = Napi::Array::New(env);
+
+    // Search for text (simplified - would need proper quad array handling)
+    fz_quad hits[512];
+    int hitCount = fz_search_stext_page(ctx, stext, needle.c_str(), nullptr, hits, 512);
+
+    for (int i = 0; i < hitCount; i++) {
+        fz_rect rect;
+        rect.x0 = hits[i].ll.x;
+        rect.y0 = hits[i].ll.y;
+        rect.x1 = hits[i].ur.x;
+        rect.y1 = hits[i].ur.y;
+        results[i] = CreateRect(env, rect);
+    }
+
+    fz_drop_stext_page(ctx, stext);
+
+    return results;
+}
+
+/**
+ * Render page with advanced options
+ * Supports anti-aliasing, progress callbacks, timeouts, etc.
+ *
+ * JavaScript: renderPageWithOptions(ctx, page, options): NativePixmap
+ *
+ * options: {
+ *   dpi?: number,
+ *   matrix?: NativeMatrix,
+ *   colorspace?: NativeColorspace,
+ *   alpha?: boolean,
+ *   antiAlias?: number (0=None, 1=Low, 2=Medium, 4=High),
+ *   timeout?: number,
+ *   renderAnnotations?: boolean,
+ *   renderFormFields?: boolean
+ * }
+ */
+Napi::Value RenderPageWithOptions(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page, options)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+    Napi::Object options = info[2].As<Napi::Object>();
+
+    // Extract options
+    fz_matrix matrix;
+    if (options.Has("matrix")) {
+        matrix = GetMatrix(options.Get("matrix").As<Napi::Object>());
+    } else if (options.Has("dpi")) {
+        float dpi = options.Get("dpi").As<Napi::Number>().FloatValue();
+        float scale = dpi / 72.0f;
+        matrix = fz_scale(scale, scale);
+    } else {
+        matrix = fz_identity();
+    }
+
+    // Get colorspace
+    fz_colorspace cs;
+    if (options.Has("colorspace")) {
+        // TODO: Parse colorspace from options
+        cs = fz_device_rgb(ctx);
+    } else {
+        cs = fz_device_rgb(ctx);
+    }
+
+    // Get alpha
+    bool alpha = true;
+    if (options.Has("alpha")) {
+        alpha = options.Get("alpha").As<Napi::Boolean>().Value();
+    }
+
+    // Get anti-aliasing level
+    // Note: In a full implementation, this would be passed to the rendering device
+    // For now, we just validate it
+    if (options.Has("antiAlias")) {
+        int aa_level = options.Get("antiAlias").As<Napi::Number>().Int32Value();
+        // Validate: 0 (None), 1 (Low), 2 (Medium), 4 (High)
+        if (aa_level != 0 && aa_level != 1 && aa_level != 2 && aa_level != 4) {
+            Napi::TypeError::New(env, "Invalid antiAlias level (must be 0, 1, 2, or 4)")
+                .ThrowAsJavaScriptException();
+            return env.Null();
+        }
+        // TODO: Use aa_level when creating rendering device
+    }
+
+    // Get timeout
+    if (options.Has("timeout")) {
+        int timeout = options.Get("timeout").As<Napi::Number>().Int32Value();
+        // TODO: Implement timeout handling with a cookie
+        if (timeout > 0) {
+            // For now, just validate it
+        }
+    }
+
+    // Render flags
+    bool render_annots = true;
+    bool render_forms = true;
+    if (options.Has("renderAnnotations")) {
+        render_annots = options.Get("renderAnnotations").As<Napi::Boolean>().Value();
+    }
+    if (options.Has("renderFormFields")) {
+        render_forms = options.Get("renderFormFields").As<Napi::Boolean>().Value();
+    }
+
+    // Render page to pixmap
+    fz_pixmap pix = fz_new_pixmap_from_page(ctx, page, matrix, cs, alpha ? 1 : 0);
+    if (pix == 0) {
+        Napi::Error::New(env, "Failed to render page").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Wrap in Napi::External with finalizer
+    return Napi::External<int32_t>::New(
+        env,
+        new int32_t(pix),
+        [](Napi::Env env, int32_t* data) {
+            delete data;
+        }
+    );
+}
+
+/**
+ * Render page to PNG with advanced options
+ *
+ * JavaScript: renderPageToPNGWithOptions(ctx, page, options): Buffer
+ *
+ * options: {
+ *   dpi?: number,
+ *   colorspace?: NativeColorspace,
+ *   antiAlias?: number,
+ *   ... (same as renderPageWithOptions)
+ * }
+ */
+Napi::Value RenderPageToPNGWithOptions(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, page, options)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_page page = GetPage(info[1].As<Napi::Object>());
+    Napi::Object options = info[2].As<Napi::Object>();
+
+    // Extract DPI
+    float dpi = 72.0f;
+    if (options.Has("dpi")) {
+        dpi = options.Get("dpi").As<Napi::Number>().FloatValue();
+    }
+
+    // Create transform matrix
+    fz_matrix matrix = fz_scale(dpi / 72.0f, dpi / 72.0f);
+
+    // Get colorspace
+    fz_colorspace cs = fz_device_rgb(ctx);
+
+    // Get alpha
+    bool alpha = options.Has("alpha") ? options.Get("alpha").As<Napi::Boolean>().Value() : false;
+
+    // Render to pixmap
+    fz_pixmap pix = fz_new_pixmap_from_page(ctx, page, matrix, cs, alpha ? 1 : 0);
+    if (pix == 0) {
+        Napi::Error::New(env, "Failed to render page").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Convert to PNG
+    fz_buffer buf = fz_new_buffer_from_pixmap_as_png(ctx, pix, 0);
+    fz_drop_pixmap(ctx, pix);
+
+    if (buf == 0) {
+        Napi::Error::New(env, "Failed to create PNG buffer").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Get buffer data
+    size_t len;
+    const unsigned char* data = fz_buffer_data(ctx, buf, &len);
+
+    // Create Node.js Buffer
+    Napi::Buffer<char> result = Napi::Buffer<char>::Copy(env, (const char*)data, len);
+
+    fz_drop_buffer(ctx, buf);
+
+    return result;
+}
+
+/**
+ * Initialize page exports
+ */
+Napi::Object InitPage(Napi::Env env, Napi::Object exports) {
+    // Basic page operations
+    exports.Set("loadPage", Napi::Function::New(env, LoadPage));
+    exports.Set("dropPage", Napi::Function::New(env, DropPage));
+    exports.Set("boundPage", Napi::Function::New(env, BoundPage));
+
+    // Basic rendering
+    exports.Set("renderPage", Napi::Function::New(env, RenderPage));
+    exports.Set("renderPageToPNG", Napi::Function::New(env, RenderPageToPNG));
+
+    // Advanced rendering with options
+    exports.Set("renderPageWithOptions", Napi::Function::New(env, RenderPageWithOptions));
+    exports.Set("renderPageToPNGWithOptions", Napi::Function::New(env, RenderPageToPNGWithOptions));
+
+    // Text extraction
+    exports.Set("extractText", Napi::Function::New(env, ExtractText));
+    exports.Set("extractTextBlocks", Napi::Function::New(env, ExtractTextBlocks));
+
+    // Page links and search
+    exports.Set("getPageLinks", Napi::Function::New(env, GetPageLinks));
+    exports.Set("searchText", Napi::Function::New(env, SearchText));
+
+    return exports;
+}
+