@lexmata/micropdf 0.4.0

package/native/buffer.cc

@@ -0,0 +1,204 @@
+/**
+ * MicroPDF Buffer Bindings
+ *
+ * Node.js bindings for MicroPDF buffer operations.
+ */
+
+#include <napi.h>
+#include "include/micropdf.h"
+
+/**
+ * Buffer class wrapper
+ */
+class Buffer : public Napi::ObjectWrap<Buffer> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    Buffer(const Napi::CallbackInfo& info);
+    ~Buffer();
+
+private:
+    static Napi::FunctionReference constructor;
+    micropdf_buffer_t* buffer_;
+
+    // Methods
+    Napi::Value GetLength(const Napi::CallbackInfo& info);
+    Napi::Value GetData(const Napi::CallbackInfo& info);
+    Napi::Value Append(const Napi::CallbackInfo& info);
+    Napi::Value ToNodeBuffer(const Napi::CallbackInfo& info);
+
+    // Static methods
+    static Napi::Value FromNodeBuffer(const Napi::CallbackInfo& info);
+    static Napi::Value FromString(const Napi::CallbackInfo& info);
+};
+
+Napi::FunctionReference Buffer::constructor;
+
+Napi::Object Buffer::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+
+    Napi::Function func = DefineClass(env, "Buffer", {
+        InstanceMethod("length", &Buffer::GetLength),
+        InstanceMethod("getData", &Buffer::GetData),
+        InstanceMethod("append", &Buffer::Append),
+        InstanceMethod("toBuffer", &Buffer::ToNodeBuffer),
+        StaticMethod("fromBuffer", &Buffer::FromNodeBuffer),
+        StaticMethod("fromString", &Buffer::FromString),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Buffer", func);
+    return exports;
+}
+
+Buffer::Buffer(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Buffer>(info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        size_t capacity = info[0].As<Napi::Number>().Uint32Value();
+        buffer_ = micropdf_buffer_new(capacity);
+    } else {
+        buffer_ = micropdf_buffer_new(0);
+    }
+
+    if (buffer_ == nullptr) {
+        Napi::Error::New(env, "Failed to create buffer").ThrowAsJavaScriptException();
+    }
+}
+
+Buffer::~Buffer() {
+    if (buffer_ != nullptr) {
+        micropdf_buffer_free(buffer_);
+        buffer_ = nullptr;
+    }
+}
+
+Napi::Value Buffer::GetLength(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (buffer_ == nullptr) {
+        return Napi::Number::New(env, 0);
+    }
+    return Napi::Number::New(env, static_cast<double>(micropdf_buffer_len(buffer_)));
+}
+
+Napi::Value Buffer::GetData(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (buffer_ == nullptr) {
+        return env.Null();
+    }
+
+    size_t len = micropdf_buffer_len(buffer_);
+    const uint8_t* data = micropdf_buffer_data(buffer_);
+
+    if (data == nullptr || len == 0) {
+        return Napi::Buffer<uint8_t>::New(env, 0);
+    }
+
+    // Copy data to a new Node.js Buffer
+    return Napi::Buffer<uint8_t>::Copy(env, data, len);
+}
+
+Napi::Value Buffer::Append(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Expected Buffer or Uint8Array").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    if (buffer_ == nullptr) {
+        Napi::Error::New(env, "Buffer is null").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    if (info[0].IsBuffer()) {
+        Napi::Buffer<uint8_t> buf = info[0].As<Napi::Buffer<uint8_t>>();
+        micropdf_error_t err = micropdf_buffer_append(buffer_, buf.Data(), buf.Length());
+        if (err != MICROPDF_OK) {
+            Napi::Error::New(env, "Failed to append data").ThrowAsJavaScriptException();
+        }
+    } else if (info[0].IsTypedArray()) {
+        Napi::TypedArray arr = info[0].As<Napi::TypedArray>();
+        if (arr.TypedArrayType() == napi_uint8_array) {
+            Napi::Uint8Array u8arr = arr.As<Napi::Uint8Array>();
+            micropdf_error_t err = micropdf_buffer_append(buffer_, u8arr.Data(), u8arr.ElementLength());
+            if (err != MICROPDF_OK) {
+                Napi::Error::New(env, "Failed to append data").ThrowAsJavaScriptException();
+            }
+        }
+    } else {
+        Napi::TypeError::New(env, "Expected Buffer or Uint8Array").ThrowAsJavaScriptException();
+    }
+
+    return info.This();
+}
+
+Napi::Value Buffer::ToNodeBuffer(const Napi::CallbackInfo& info) {
+    return GetData(info);
+}
+
+Napi::Value Buffer::FromNodeBuffer(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsBuffer()) {
+        Napi::TypeError::New(env, "Expected Buffer").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Buffer<uint8_t> nodeBuf = info[0].As<Napi::Buffer<uint8_t>>();
+    micropdf_buffer_t* buf = micropdf_buffer_from_data(nodeBuf.Data(), nodeBuf.Length());
+
+    if (buf == nullptr) {
+        Napi::Error::New(env, "Failed to create buffer from data").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    // Create a new Buffer instance
+    Napi::Object obj = constructor.New({});
+    Buffer* wrapper = Napi::ObjectWrap<Buffer>::Unwrap(obj);
+
+    // Free the old buffer and set the new one
+    if (wrapper->buffer_ != nullptr) {
+        micropdf_buffer_free(wrapper->buffer_);
+    }
+    wrapper->buffer_ = buf;
+
+    return obj;
+}
+
+Napi::Value Buffer::FromString(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Expected string").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    std::string str = info[0].As<Napi::String>().Utf8Value();
+    micropdf_buffer_t* buf = micropdf_buffer_from_data(
+        reinterpret_cast<const uint8_t*>(str.data()),
+        str.length()
+    );
+
+    if (buf == nullptr) {
+        Napi::Error::New(env, "Failed to create buffer from string").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Object obj = constructor.New({});
+    Buffer* wrapper = Napi::ObjectWrap<Buffer>::Unwrap(obj);
+
+    if (wrapper->buffer_ != nullptr) {
+        micropdf_buffer_free(wrapper->buffer_);
+    }
+    wrapper->buffer_ = buf;
+
+    return obj;
+}
+
+// Export initialization function
+Napi::Object InitBuffer(Napi::Env env, Napi::Object exports) {
+    return Buffer::Init(env, exports);
+}
+

package/native/colorspace.cc

@@ -0,0 +1,166 @@
+/**
+ * MicroPDF Colorspace Bindings
+ *
+ * N-API bindings for colorspace operations.
+ * Colorspaces define color interpretation for images and graphics.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Get device gray colorspace handle
+ *
+ * @param ctx - Context handle
+ * @returns Colorspace handle (1)
+ */
+Napi::BigInt DeviceGray(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 cs_handle = fz_device_gray(ctx_handle);
+
+    return Napi::BigInt::New(env, cs_handle);
+}
+
+/**
+ * Get device RGB colorspace handle
+ *
+ * @param ctx - Context handle
+ * @returns Colorspace handle (2)
+ */
+Napi::BigInt DeviceRGB(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 cs_handle = fz_device_rgb(ctx_handle);
+
+    return Napi::BigInt::New(env, cs_handle);
+}
+
+/**
+ * Get device BGR colorspace handle
+ *
+ * @param ctx - Context handle
+ * @returns Colorspace handle (3)
+ */
+Napi::BigInt DeviceBGR(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 cs_handle = fz_device_bgr(ctx_handle);
+
+    return Napi::BigInt::New(env, cs_handle);
+}
+
+/**
+ * Get device CMYK colorspace handle
+ *
+ * @param ctx - Context handle
+ * @returns Colorspace handle (4)
+ */
+Napi::BigInt DeviceCMYK(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 cs_handle = fz_device_cmyk(ctx_handle);
+
+    return Napi::BigInt::New(env, cs_handle);
+}
+
+/**
+ * Get number of components in colorspace
+ *
+ * @param ctx - Context handle
+ * @param cs - Colorspace handle
+ * @returns Number of components (1 for Gray, 3 for RGB, 4 for CMYK)
+ */
+Napi::Number ColorspaceN(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, cs")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 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 n = fz_colorspace_n(ctx_handle, cs_handle);
+
+    return Napi::Number::New(env, n);
+}
+
+/**
+ * Get colorspace name
+ *
+ * @param ctx - Context handle
+ * @param cs - Colorspace handle
+ * @returns Colorspace name string
+ */
+Napi::String ColorspaceName(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, cs")
+            .ThrowAsJavaScriptException();
+        return Napi::String::New(env, "");
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cs_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    const char* name = fz_colorspace_name(ctx_handle, cs_handle);
+
+    return Napi::String::New(env, name ? name : "");
+}
+
+/**
+ * Initialize Colorspace module exports
+ */
+Napi::Object InitColorspace(Napi::Env env, Napi::Object exports) {
+    exports.Set("deviceGray", Napi::Function::New(env, DeviceGray));
+    exports.Set("deviceRGB", Napi::Function::New(env, DeviceRGB));
+    exports.Set("deviceBGR", Napi::Function::New(env, DeviceBGR));
+    exports.Set("deviceCMYK", Napi::Function::New(env, DeviceCMYK));
+    exports.Set("colorspaceN", Napi::Function::New(env, ColorspaceN));
+    exports.Set("colorspaceName", Napi::Function::New(env, ColorspaceName));
+    
+    return exports;
+}
+

package/native/context.cc

@@ -0,0 +1,84 @@
+/**
+ * Context FFI Bindings
+ *
+ * Implements N-API bindings for MuPDF context functions (fz_context).
+ * Context manages memory allocation, error handling, and resource tracking.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Create a new context
+ * JavaScript: createContext(): NativeContext
+ */
+Napi::Value CreateContext(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    fz_context ctx = fz_new_context(nullptr, nullptr, FZ_STORE_DEFAULT);
+    if (ctx == 0) {
+        Napi::Error::New(env, "Failed to create context").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("_handle", Napi::Number::New(env, ctx));
+    return obj;
+}
+
+/**
+ * Drop/free a context
+ * JavaScript: dropContext(ctx: NativeContext): void
+ */
+Napi::Value DropContext(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Expected context object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Object ctxObj = info[0].As<Napi::Object>();
+    if (!ctxObj.Has("_handle")) {
+        Napi::TypeError::New(env, "Invalid context object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    fz_context ctx = ctxObj.Get("_handle").As<Napi::Number>().Int32Value();
+    fz_drop_context(ctx);
+
+    return env.Undefined();
+}
+
+/**
+ * Clone a context (create a reference)
+ * JavaScript: cloneContext(ctx: NativeContext): NativeContext
+ */
+Napi::Value CloneContext(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Expected context object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object ctxObj = info[0].As<Napi::Object>();
+    fz_context ctx = ctxObj.Get("_handle").As<Napi::Number>().Int32Value();
+
+    fz_context newCtx = fz_clone_context(ctx);
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("_handle", Napi::Number::New(env, newCtx));
+    return obj;
+}
+
+/**
+ * Initialize context exports
+ */
+Napi::Object InitContext(Napi::Env env, Napi::Object exports) {
+    exports.Set("createContext", Napi::Function::New(env, CreateContext));
+    exports.Set("dropContext", Napi::Function::New(env, DropContext));
+    exports.Set("cloneContext", Napi::Function::New(env, CloneContext));
+    return exports;
+}
+

package/native/cookie.cc

@@ -0,0 +1,179 @@
+/**
+ * MicroPDF Cookie Bindings
+ *
+ * N-API bindings for cookie operations.
+ * Cookies provide progress tracking and cancellation for long-running operations.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Create a new cookie
+ *
+ * @param ctx - Context handle
+ * @returns Cookie handle
+ */
+Napi::BigInt NewCookie(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 cookie_handle = fz_new_cookie(ctx_handle);
+
+    return Napi::BigInt::New(env, cookie_handle);
+}
+
+/**
+ * Drop cookie handle
+ *
+ * @param ctx - Context handle
+ * @param cookie - Cookie handle
+ */
+Napi::Value DropCookie(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, cookie")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cookie_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_cookie(ctx_handle, cookie_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Abort operation via cookie
+ *
+ * @param ctx - Context handle
+ * @param cookie - Cookie handle
+ */
+Napi::Value AbortCookie(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, cookie")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cookie_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_abort_cookie(ctx_handle, cookie_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Get cookie progress
+ *
+ * @param ctx - Context handle
+ * @param cookie - Cookie handle
+ * @returns Object {progress, progressMax, errors}
+ */
+Napi::Object GetCookieProgress(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 2 arguments: ctx, cookie")
+            .ThrowAsJavaScriptException();
+        return result;
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cookie_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t progress = 0;
+    int32_t progress_max = 0;
+    int32_t errors = 0;
+
+    fz_cookie_progress(ctx_handle, cookie_handle, &progress, &progress_max, &errors);
+
+    result.Set("progress", Napi::Number::New(env, progress));
+    result.Set("progressMax", Napi::Number::New(env, progress_max));
+    result.Set("errors", Napi::Number::New(env, errors));
+
+    return result;
+}
+
+/**
+ * Check if cookie has been aborted
+ *
+ * @param ctx - Context handle
+ * @param cookie - Cookie handle
+ * @returns Boolean
+ */
+Napi::Boolean IsCookieAborted(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, cookie")
+            .ThrowAsJavaScriptException();
+        return Napi::Boolean::New(env, false);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cookie_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t is_aborted = fz_cookie_is_aborted(ctx_handle, cookie_handle);
+
+    return Napi::Boolean::New(env, is_aborted != 0);
+}
+
+/**
+ * Reset cookie state
+ *
+ * @param ctx - Context handle
+ * @param cookie - Cookie handle
+ */
+Napi::Value ResetCookie(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, cookie")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t cookie_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_reset_cookie(ctx_handle, cookie_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Initialize Cookie module exports
+ */
+Napi::Object InitCookie(Napi::Env env, Napi::Object exports) {
+    exports.Set("newCookie", Napi::Function::New(env, NewCookie));
+    exports.Set("dropCookie", Napi::Function::New(env, DropCookie));
+    exports.Set("abortCookie", Napi::Function::New(env, AbortCookie));
+    exports.Set("getCookieProgress", Napi::Function::New(env, GetCookieProgress));
+    exports.Set("isCookieAborted", Napi::Function::New(env, IsCookieAborted));
+    exports.Set("resetCookie", Napi::Function::New(env, ResetCookie));
+    
+    return exports;
+}
+
+