@lexmata/micropdf 0.4.0

package/native/path.cc

@@ -0,0 +1,259 @@
+/**
+ * MicroPDF Path Bindings
+ *
+ * N-API bindings for path operations.
+ * Paths represent vector graphics for stroking and filling.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Create a new empty path
+ *
+ * @param ctx - Context handle
+ * @returns Path handle
+ */
+Napi::BigInt NewPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Expected 1 argument: ctx")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint64_t path_handle = fz_new_path(ctx_handle);
+
+    return Napi::BigInt::New(env, path_handle);
+}
+
+/**
+ * Drop path handle
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ */
+Napi::Value DropPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, path")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_path(ctx_handle, path_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Move to a point (start new subpath)
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ */
+Napi::Value PathMoveTo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4) {
+        Napi::TypeError::New(env, "Expected 4 arguments: ctx, path, x, y")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    float x = info[2].As<Napi::Number>().FloatValue();
+    float y = info[3].As<Napi::Number>().FloatValue();
+
+    fz_moveto(ctx_handle, path_handle, x, y);
+
+    return env.Undefined();
+}
+
+/**
+ * Line to a point
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ */
+Napi::Value PathLineTo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4) {
+        Napi::TypeError::New(env, "Expected 4 arguments: ctx, path, x, y")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    float x = info[2].As<Napi::Number>().FloatValue();
+    float y = info[3].As<Napi::Number>().FloatValue();
+
+    fz_lineto(ctx_handle, path_handle, x, y);
+
+    return env.Undefined();
+}
+
+/**
+ * Cubic Bezier curve to a point
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ * @param x1 - Control point 1 X
+ * @param y1 - Control point 1 Y
+ * @param x2 - Control point 2 X
+ * @param y2 - Control point 2 Y
+ * @param x3 - End point X
+ * @param y3 - End point Y
+ */
+Napi::Value PathCurveTo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 8) {
+        Napi::TypeError::New(env, "Expected 8 arguments: ctx, path, x1, y1, x2, y2, x3, y3")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    float x1 = info[2].As<Napi::Number>().FloatValue();
+    float y1 = info[3].As<Napi::Number>().FloatValue();
+    float x2 = info[4].As<Napi::Number>().FloatValue();
+    float y2 = info[5].As<Napi::Number>().FloatValue();
+    float x3 = info[6].As<Napi::Number>().FloatValue();
+    float y3 = info[7].As<Napi::Number>().FloatValue();
+
+    fz_curveto(ctx_handle, path_handle, x1, y1, x2, y2, x3, y3);
+
+    return env.Undefined();
+}
+
+/**
+ * Close the current subpath
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ */
+Napi::Value PathClosePath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, path")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_closepath(ctx_handle, path_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Add rectangle to path
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param w - Width
+ * @param h - Height
+ */
+Napi::Value PathRect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 6) {
+        Napi::TypeError::New(env, "Expected 6 arguments: ctx, path, x, y, w, h")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    float x = info[2].As<Napi::Number>().FloatValue();
+    float y = info[3].As<Napi::Number>().FloatValue();
+    float w = info[4].As<Napi::Number>().FloatValue();
+    float h = info[5].As<Napi::Number>().FloatValue();
+
+    fz_rectto(ctx_handle, path_handle, x, y, w, h);
+
+    return env.Undefined();
+}
+
+/**
+ * Get path bounding box
+ *
+ * @param ctx - Context handle
+ * @param path - Path handle
+ * @param stroke - Optional stroke state handle
+ * @param ctm - Optional transform matrix
+ * @returns Rectangle {x0, y0, x1, y1}
+ */
+Napi::Object PathBoundPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Object result = Napi::Object::New(env);
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected at least 2 arguments: ctx, path")
+            .ThrowAsJavaScriptException();
+        return result;
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t path_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint64_t stroke_handle = 0;
+    if (info.Length() > 2 && !info[2].IsNull() && !info[2].IsUndefined()) {
+        stroke_handle = info[2].As<Napi::BigInt>().Uint64Value(&lossless);
+    }
+
+    fz_rect rect = fz_bound_path(ctx_handle, path_handle, stroke_handle);
+
+    result.Set("x0", Napi::Number::New(env, rect.x0));
+    result.Set("y0", Napi::Number::New(env, rect.y0));
+    result.Set("x1", Napi::Number::New(env, rect.x1));
+    result.Set("y1", Napi::Number::New(env, rect.y1));
+
+    return result;
+}
+
+/**
+ * Initialize Path module exports
+ */
+Napi::Object InitPath(Napi::Env env, Napi::Object exports) {
+    exports.Set("newPath", Napi::Function::New(env, NewPath));
+    exports.Set("dropPath", Napi::Function::New(env, DropPath));
+    exports.Set("pathMoveTo", Napi::Function::New(env, PathMoveTo));
+    exports.Set("pathLineTo", Napi::Function::New(env, PathLineTo));
+    exports.Set("pathCurveTo", Napi::Function::New(env, PathCurveTo));
+    exports.Set("pathClosePath", Napi::Function::New(env, PathClosePath));
+    exports.Set("pathRect", Napi::Function::New(env, PathRect));
+    exports.Set("pathBoundPath", Napi::Function::New(env, PathBoundPath));
+
+    return exports;
+}
+

package/native/pixmap.cc

@@ -0,0 +1,240 @@
+/**
+ * MicroPDF Pixmap Bindings
+ *
+ * N-API bindings for pixmap operations.
+ * Pixmaps are pixel buffers for rendering output.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Create a new pixmap
+ *
+ * @param ctx - Context handle
+ * @param colorspace - Colorspace handle (or 0 for alpha-only)
+ * @param w - Width in pixels
+ * @param h - Height in pixels
+ * @param alpha - Include alpha channel
+ * @returns Pixmap handle
+ */
+Napi::BigInt NewPixmap(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 5) {
+        Napi::TypeError::New(env, "Expected 5 arguments: ctx, colorspace, w, h, alpha")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cs_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    int32_t w = info[2].As<Napi::Number>().Int32Value();
+    int32_t h = info[3].As<Napi::Number>().Int32Value();
+    int32_t alpha = info[4].As<Napi::Boolean>().Value() ? 1 : 0;
+
+    uint64_t pixmap_handle = fz_new_pixmap(ctx_handle, cs_handle, w, h, alpha);
+
+    return Napi::BigInt::New(env, pixmap_handle);
+}
+
+/**
+ * Drop pixmap handle
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ */
+Napi::Value DropPixmap(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_pixmap(ctx_handle, pixmap_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Get pixmap width
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @returns Width in pixels
+ */
+Napi::Number PixmapWidth(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t width = fz_pixmap_width(ctx_handle, pixmap_handle);
+
+    return Napi::Number::New(env, width);
+}
+
+/**
+ * Get pixmap height
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @returns Height in pixels
+ */
+Napi::Number PixmapHeight(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t height = fz_pixmap_height(ctx_handle, pixmap_handle);
+
+    return Napi::Number::New(env, height);
+}
+
+/**
+ * Get pixmap samples (pixel data)
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @returns Buffer containing pixel data
+ */
+Napi::Buffer<uint8_t> PixmapSamples(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .ThrowAsJavaScriptException();
+        return Napi::Buffer<uint8_t>::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint8_t* data = nullptr;
+    size_t size = 0;
+
+    fz_pixmap_samples(ctx_handle, pixmap_handle, &data, &size);
+
+    if (data && size > 0) {
+        // Create a copy of the data for Node.js
+        return Napi::Buffer<uint8_t>::Copy(env, data, size);
+    }
+
+    return Napi::Buffer<uint8_t>::New(env, 0);
+}
+
+/**
+ * Get pixmap stride (bytes per row)
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @returns Stride in bytes
+ */
+Napi::Number PixmapStride(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    size_t stride = fz_pixmap_stride(ctx_handle, pixmap_handle);
+
+    return Napi::Number::New(env, static_cast<double>(stride));
+}
+
+/**
+ * Get number of components (including alpha)
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @returns Number of components
+ */
+Napi::Number PixmapComponents(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t n = fz_pixmap_components(ctx_handle, pixmap_handle);
+
+    return Napi::Number::New(env, n);
+}
+
+/**
+ * Clear pixmap to a color
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @param value - Clear value (0-255)
+ */
+Napi::Value ClearPixmap(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3) {
+        Napi::TypeError::New(env, "Expected 3 arguments: ctx, pixmap, value")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    int32_t value = info[2].As<Napi::Number>().Int32Value();
+
+    fz_clear_pixmap(ctx_handle, pixmap_handle, value);
+
+    return env.Undefined();
+}
+
+/**
+ * Initialize Pixmap module exports
+ */
+Napi::Object InitPixmap(Napi::Env env, Napi::Object exports) {
+    exports.Set("newPixmap", Napi::Function::New(env, NewPixmap));
+    exports.Set("dropPixmap", Napi::Function::New(env, DropPixmap));
+    exports.Set("pixmapWidth", Napi::Function::New(env, PixmapWidth));
+    exports.Set("pixmapHeight", Napi::Function::New(env, PixmapHeight));
+    exports.Set("pixmapSamples", Napi::Function::New(env, PixmapSamples));
+    exports.Set("pixmapStride", Napi::Function::New(env, PixmapStride));
+    exports.Set("pixmapComponents", Napi::Function::New(env, PixmapComponents));
+    exports.Set("clearPixmap", Napi::Function::New(env, ClearPixmap));
+
+    return exports;
+}
+