@lexmata/micropdf 0.4.0

package/native/stream.cc

@@ -0,0 +1,239 @@
+/**
+ * MicroPDF Stream Bindings
+ *
+ * N-API bindings for stream (input) operations.
+ * Streams provide sequential data reading from files or memory.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Open stream from file
+ *
+ * @param ctx - Context handle
+ * @param filename - Path to file
+ * @returns Stream handle
+ */
+Napi::BigInt OpenFile(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, filename")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    std::string filename = info[1].As<Napi::String>().Utf8Value();
+
+    uint64_t stream_handle = fz_open_file(ctx_handle, filename.c_str());
+
+    return Napi::BigInt::New(env, stream_handle);
+}
+
+/**
+ * Open stream from memory buffer
+ *
+ * @param ctx - Context handle
+ * @param data - Buffer containing data
+ * @returns Stream handle
+ */
+Napi::BigInt OpenMemory(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, data")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    Napi::Buffer<uint8_t> buffer = info[1].As<Napi::Buffer<uint8_t>>();
+
+    uint64_t stream_handle = fz_open_memory(
+        ctx_handle,
+        buffer.Data(),
+        buffer.Length()
+    );
+
+    return Napi::BigInt::New(env, stream_handle);
+}
+
+/**
+ * Drop stream handle
+ *
+ * @param ctx - Context handle
+ * @param stream - Stream handle
+ */
+Napi::Value DropStream(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, stream")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t stream_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_stream(ctx_handle, stream_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Read data from stream
+ *
+ * @param ctx - Context handle
+ * @param stream - Stream handle
+ * @param buffer - Buffer to read into
+ * @returns Number of bytes read
+ */
+Napi::Number Read(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3) {
+        Napi::TypeError::New(env, "Expected 3 arguments: ctx, stream, buffer")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t stream_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    Napi::Buffer<uint8_t> buffer = info[2].As<Napi::Buffer<uint8_t>>();
+
+    size_t bytes_read = fz_read(
+        ctx_handle,
+        stream_handle,
+        buffer.Data(),
+        buffer.Length()
+    );
+
+    return Napi::Number::New(env, bytes_read);
+}
+
+/**
+ * Read single byte from stream
+ *
+ * @param ctx - Context handle
+ * @param stream - Stream handle
+ * @returns Byte value (0-255) or -1 on EOF
+ */
+Napi::Number ReadByte(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, stream")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, -1);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t stream_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t byte = fz_read_byte(ctx_handle, stream_handle);
+
+    return Napi::Number::New(env, byte);
+}
+
+/**
+ * Check if stream is at end-of-file
+ *
+ * @param ctx - Context handle
+ * @param stream - Stream handle
+ * @returns Boolean indicating EOF
+ */
+Napi::Boolean IsEOF(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, stream")
+            .ThrowAsJavaScriptException();
+        return Napi::Boolean::New(env, true);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t stream_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t is_eof = fz_is_eof(ctx_handle, stream_handle);
+
+    return Napi::Boolean::New(env, is_eof != 0);
+}
+
+/**
+ * Seek to position in stream
+ *
+ * @param ctx - Context handle
+ * @param stream - Stream handle
+ * @param offset - Offset to seek to
+ * @param whence - 0=SEEK_SET, 1=SEEK_CUR, 2=SEEK_END
+ */
+Napi::Value Seek(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4) {
+        Napi::TypeError::New(env, "Expected 4 arguments: ctx, stream, offset, whence")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t stream_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    int64_t offset = info[2].As<Napi::Number>().Int64Value();
+    int32_t whence = info[3].As<Napi::Number>().Int32Value();
+
+    fz_seek(ctx_handle, stream_handle, offset, whence);
+
+    return env.Undefined();
+}
+
+/**
+ * Get current position in stream
+ *
+ * @param ctx - Context handle
+ * @param stream - Stream handle
+ * @returns Current position
+ */
+Napi::Number Tell(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, stream")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t stream_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int64_t position = fz_tell(ctx_handle, stream_handle);
+
+    return Napi::Number::New(env, position);
+}
+
+/**
+ * Initialize Stream module exports
+ */
+Napi::Object InitStream(Napi::Env env, Napi::Object exports) {
+    exports.Set("openFile", Napi::Function::New(env, OpenFile));
+    exports.Set("openMemory", Napi::Function::New(env, OpenMemory));
+    exports.Set("dropStream", Napi::Function::New(env, DropStream));
+    exports.Set("read", Napi::Function::New(env, Read));
+    exports.Set("readByte", Napi::Function::New(env, ReadByte));
+    exports.Set("isEOF", Napi::Function::New(env, IsEOF));
+    exports.Set("seek", Napi::Function::New(env, Seek));
+    exports.Set("tell", Napi::Function::New(env, Tell));
+
+    return exports;
+}
+

package/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@lexmata/micropdf",
+  "version": "0.4.0",
+  "description": "Node.js bindings for the MicroPDF library",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./easy": {
+      "import": "./dist/easy.js",
+      "types": "./dist/easy.d.ts"
+    },
+    "./simple": {
+      "import": "./dist/simple.js",
+      "types": "./dist/simple.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "native",
+    "prebuilds",
+    "binding.gyp",
+    "scripts"
+  ],
+  "keywords": [
+    "pdf",
+    "mupdf",
+    "document",
+    "parser",
+    "native",
+    "rust"
+  ],
+  "author": "Lexmata",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/lexmata/micropdf.git"
+  },
+  "bugs": {
+    "url": "https://bitbucket.org/lexmata/micropdf/issues"
+  },
+  "homepage": "https://bitbucket.org/lexmata/micropdf",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "optionalDependencies": {
+    "node-addon-api": "^8.3.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@jazzer.js/core": "^2.1.0",
+    "@types/node": "^22.10.1",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
+    "@vitest/coverage-v8": "^2.1.8",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsdoc": "^50.6.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-security": "^3.0.1",
+    "eslint-plugin-sonarjs": "^2.0.4",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "node-gyp": "^10.3.1",
+    "prebuildify": "^6.0.1",
+    "prettier": "^3.4.2",
+    "tinybench": "^6.0.0",
+    "typedoc": "^0.28.15",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "binary": {
+    "module_name": "micropdf",
+    "module_path": "./prebuilds/{platform}-{arch}",
+    "host": "https://bitbucket.org/lexmata/micropdf/downloads/",
+    "remote_path": "v{version}",
+    "package_name": "micropdf-{platform}-{arch}.tar.gz"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js || true",
+    "build": "npm run build:ts",
+    "build:native": "node-gyp rebuild",
+    "build:full": "npm run build:native && npm run build:ts",
+    "build:ts": "tsc",
+    "build:from-rust": "node scripts/build-from-rust.js && npm run build:native",
+    "prebuild": "prebuildify --napi --strip",
+    "prebuild:all": "prebuildify --napi --strip --target 18.0.0 --target 20.0.0 --target 22.0.0",
+    "docs": "typedoc",
+    "docs:serve": "cd ../docs/api/nodejs && python3 -m http.server 8080",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:integration": "vitest run test/integration",
+    "test:integration:watch": "vitest test/integration",
+    "lint": "eslint . --ext .ts,.js",
+    "lint:fix": "eslint . --ext .ts,.js --fix",
+    "format": "prettier --write \"**/*.{ts,js,json,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,md}\"",
+    "quality": "npm run lint && npm run format:check && npm run build:ts && npm run test",
+    "clean": "node-gyp clean && rm -rf dist",
+    "bench": "tsx bench/run.ts",
+    "bench:buffer": "tsx -e \"import('./bench/buffer.bench.js').then(m => m.bench.run().then(() => console.table(m.bench.table())))\"",
+    "bench:geometry": "tsx -e \"import('./bench/geometry.bench.js').then(m => m.bench.run().then(() => console.table(m.bench.table())))\"",
+    "fuzz": "npm run fuzz:pdf && npm run fuzz:buffer && npm run fuzz:geometry",
+    "fuzz:pdf": "jazzer fuzz/targets/pdf-parse.fuzz.ts --sync -t 300",
+    "fuzz:buffer": "jazzer fuzz/targets/buffer.fuzz.ts --sync -t 300",
+    "fuzz:geometry": "jazzer fuzz/targets/geometry.fuzz.ts --sync -t 300",
+    "fuzz:quick": "jazzer fuzz/targets/pdf-parse.fuzz.ts --sync -t 60 && jazzer fuzz/targets/buffer.fuzz.ts --sync -t 60 && jazzer fuzz/targets/geometry.fuzz.ts --sync -t 60",
+    "fuzz:extended": "jazzer fuzz/targets/pdf-parse.fuzz.ts --sync -t 3600 && jazzer fuzz/targets/buffer.fuzz.ts --sync -t 3600 && jazzer fuzz/targets/geometry.fuzz.ts --sync -t 3600",
+    "fuzz:deep": "jazzer fuzz/targets/pdf-parse.fuzz.ts --sync -t 86400"
+  }
+}

package/scripts/build-from-rust.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * Build MicroPDF native library from Rust source
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, copyFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+const rustDir = join(rootDir, '..', 'micropdf-rs');
+
+const platform = process.platform;
+const arch = process.arch;
+
+async function main() {
+  console.log('Building MicroPDF from Rust source');
+  console.log(`Platform: ${platform}-${arch}`);
+  console.log('');
+
+  // Check for Rust source
+  if (!existsSync(join(rustDir, 'Cargo.toml'))) {
+    console.error('Error: Rust source not found at', rustDir);
+    console.error('Make sure you have the complete micropdf repository');
+    process.exit(1);
+  }
+
+  // Check for cargo
+  try {
+    const version = execSync('cargo --version', { encoding: 'utf-8' });
+    console.log(`Found: ${version.trim()}`);
+  } catch {
+    console.error('Error: Rust/Cargo not found');
+    console.error('Install Rust from: https://rustup.rs');
+    process.exit(1);
+  }
+
+  // Build the Rust library
+  console.log('');
+  console.log('Building Rust library...');
+
+  try {
+    execSync('cargo build --release', {
+      cwd: rustDir,
+      stdio: 'inherit'
+    });
+  } catch (error) {
+    console.error('Rust build failed');
+    process.exit(1);
+  }
+
+  // Determine library name
+  const libDir = join(rootDir, 'native', 'lib', `${platform}-${arch}`);
+  let libName;
+
+  if (platform === 'win32') {
+    libName = 'micropdf.lib';
+  } else {
+    libName = 'libmicropdf.a';
+  }
+
+  // Create output directory
+  mkdirSync(libDir, { recursive: true });
+
+  // Copy the library
+  const srcLib = join(rustDir, 'target', 'release', libName);
+  const destLib = join(libDir, libName);
+
+  if (!existsSync(srcLib)) {
+    console.error(`Error: Built library not found at ${srcLib}`);
+    process.exit(1);
+  }
+
+  copyFileSync(srcLib, destLib);
+  console.log(`Library copied to: ${destLib}`);
+
+  // Also copy the C header if it exists
+  const headerSrc = join(rustDir, 'include', 'micropdf.h');
+  const headerDest = join(rootDir, 'native', 'include', 'micropdf.h');
+
+  if (existsSync(headerSrc)) {
+    copyFileSync(headerSrc, headerDest);
+    console.log(`Header copied to: ${headerDest}`);
+  }
+
+  console.log('');
+  console.log('Build complete!');
+  console.log('Run `npm run build:native` to build the Node.js addon');
+}
+
+main().catch((error) => {
+  console.error('Build failed:', error.message);
+  process.exit(1);
+});

package/scripts/install.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+/**
+ * MicroPDF Post-Install Script
+ *
+ * This script attempts to download prebuilt native bindings for the current
+ * platform if they're not already available. This allows users to install
+ * micropdf without needing Rust or a C++ compiler.
+ */
+
+import { existsSync, mkdirSync, createWriteStream, unlinkSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import https from 'https';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = join(__dirname, '..');
+
+// Platform mappings
+const platformMap = {
+  darwin: 'darwin',
+  linux: 'linux',
+  win32: 'win32'
+};
+
+const archMap = {
+  x64: 'x64',
+  arm64: 'arm64',
+  ia32: 'ia32'
+};
+
+const platform = platformMap[process.platform] || process.platform;
+const arch = archMap[process.arch] || process.arch;
+const prebuildDir = join(rootDir, 'prebuilds', `${platform}-${arch}`);
+const prebuildFile = join(prebuildDir, 'micropdf.node');
+
+// Version from package.json
+let version;
+try {
+  const pkg = await import(join(rootDir, 'package.json'), { with: { type: 'json' } });
+  version = pkg.default.version;
+} catch {
+  version = '0.4.0';
+}
+
+// Download URL
+const downloadBase = 'https://bitbucket.org/lexmata/micropdf/downloads';
+const archiveName = `micropdf-${platform}-${arch}.tar.gz`;
+const downloadUrl = `${downloadBase}/${archiveName}`;
+
+console.log(`[micropdf] Platform: ${platform}-${arch}`);
+console.log(`[micropdf] Version: ${version}`);
+
+// Check if prebuilt binary already exists
+if (existsSync(prebuildFile)) {
+  console.log('[micropdf] Prebuilt binary found, skipping download');
+  process.exit(0);
+}
+
+// Check if we should skip native build entirely
+if (
+  process.env.MICROPDF_SKIP_BUILD === '1' ||
+  process.env.npm_config_build_from_source === 'false'
+) {
+  console.log(
+    '[micropdf] Skipping native build (MICROPDF_SKIP_BUILD=1 or build_from_source=false)'
+  );
+  process.exit(0);
+}
+
+console.log(`[micropdf] No prebuilt binary found for ${platform}-${arch}`);
+console.log(`[micropdf] Attempting to download from: ${downloadUrl}`);
+
+/**
+ * Download a file from URL
+ */
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+
+    const request = https.get(url, { timeout: 30000 }, (response) => {
+      // Handle redirects
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        file.close();
+        unlinkSync(dest);
+        download(response.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        unlinkSync(dest);
+        reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+        return;
+      }
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+    });
+
+    request.on('error', (err) => {
+      file.close();
+      unlinkSync(dest);
+      reject(err);
+    });
+
+    request.on('timeout', () => {
+      request.destroy();
+      file.close();
+      unlinkSync(dest);
+      reject(new Error('Download timeout'));
+    });
+  });
+}
+
+/**
+ * Extract tar.gz archive
+ */
+function extractTarGz(archive, dest) {
+  try {
+    execSync(`tar -xzf "${archive}" -C "${dest}"`, { stdio: 'inherit' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const tempDir = join(rootDir, '.download-temp');
+  const archivePath = join(tempDir, archiveName);
+
+  try {
+    // Create temp directory
+    mkdirSync(tempDir, { recursive: true });
+
+    // Download archive
+    console.log('[micropdf] Downloading prebuilt binary...');
+    await download(downloadUrl, archivePath);
+
+    // Create prebuilds directory
+    mkdirSync(prebuildDir, { recursive: true });
+
+    // Extract archive
+    console.log('[micropdf] Extracting...');
+    if (extractTarGz(archivePath, join(rootDir, 'prebuilds'))) {
+      console.log('[micropdf] Prebuilt binary installed successfully!');
+    } else {
+      throw new Error('Extraction failed');
+    }
+
+    // Cleanup
+    unlinkSync(archivePath);
+  } catch (err) {
+    console.log(`[micropdf] Download failed: ${err.message}`);
+    console.log('[micropdf] Falling back to building from source...');
+    console.log('[micropdf] Note: This requires Rust and a C++ compiler');
+
+    // Try to build from source
+    try {
+      execSync('npm run build:native', { cwd: rootDir, stdio: 'inherit' });
+      console.log('[micropdf] Built from source successfully');
+    } catch {
+      console.log('[micropdf] Warning: Could not build native module');
+      console.log(
+        '[micropdf] The library will use pure JavaScript fallback (limited functionality)'
+      );
+    }
+
+    // Cleanup temp directory
+    try {
+      execSync(`rm -rf "${tempDir}"`, { stdio: 'ignore' });
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+main().catch(console.error);