@reekon-tools/react-native-pdf-canvas 0.1.0 → 0.2.0

package/native/tests/test_service.cpp

@@ -0,0 +1,130 @@
+// The facade both bindings marshal to.
+
+#include <thread>
+
+#include "fixtures.h"
+#include "harness.h"
+#include "pdfcanvas/service.h"
+#include "pdfcanvas/slots.h"
+#include "pixels_util.h"
+
+using namespace pdfcanvas;
+
+namespace {
+
+Source fileSource(const fixtures::Bytes& bytes, const std::string& name) {
+  Source source;
+  source.path = fixtures::writeTemp(bytes, name);
+  return source;
+}
+
+}  // namespace
+
+TEST(serviceOpensRendersAndCloses) {
+  Service service;
+  const auto opened = service.open(fileSource(fixtures::quadrants(200, 100), "svc-open.pdf"));
+  CHECK(opened.handle > 0);
+  CHECK_EQ(opened.pages.size(), size_t{1});
+  CHECK_NEAR(opened.pages[0].width, 200, 0.01);
+  CHECK_EQ(service.openCount(), size_t{1});
+
+  auto raster = service.render(opened.handle, px::request(0, 0, 0, 200, 100, 1), 1, false);
+  CHECK_EQ(raster.width, 200);
+  CHECK_PIXEL(raster, 10, 90, px::kRed);
+
+  service.close(opened.handle);
+  CHECK_EQ(service.openCount(), size_t{0});
+  EXPECT_ERROR(service.render(opened.handle, px::request(0, 0, 0, 10, 10, 1), 2, false),
+               ErrorCode::BackendFailure);
+  service.close(opened.handle);  // idempotent
+}
+
+TEST(handlesAreDistinctAndIndependent) {
+  Service service;
+  const auto a = service.open(fileSource(fixtures::coloredPages({{1, 0, 0}}, 40, 40), "svc-a.pdf"));
+  const auto b = service.open(fileSource(fixtures::coloredPages({{0, 0, 1}}, 40, 40), "svc-b.pdf"));
+  CHECK(a.handle != b.handle);
+  CHECK_PIXEL(service.render(a.handle, px::request(0, 0, 0, 40, 40, 1), 1, false), 20, 20, px::kRed);
+  CHECK_PIXEL(service.render(b.handle, px::request(0, 0, 0, 40, 40, 1), 1, false), 20, 20, px::kBlue);
+  service.close(a.handle);
+  CHECK_PIXEL(service.render(b.handle, px::request(0, 0, 0, 40, 40, 1), 2, false), 20, 20, px::kBlue);
+}
+
+TEST(serviceRendersIntoASlotWhenAsked) {
+  slots::releaseAll();
+  Service service;
+  const auto opened = service.open(fileSource(fixtures::grid(100, 100), "svc-slot.pdf"));
+  auto heap = service.render(opened.handle, px::request(0, 0, 0, 100, 100, 2), 1, false);
+  auto slotted = service.render(opened.handle, px::request(0, 0, 0, 100, 100, 2), 2, true);
+  CHECK(!heap.inSlot());
+  CHECK(slotted.inSlot());
+  auto buffer = slots::take(slotted.slot);
+  REQUIRE(buffer != nullptr);
+  CHECK(std::vector<uint8_t>(buffer->data(), buffer->data() + buffer->size()) == heap.bytes);
+  CHECK_EQ(slots::count(), size_t{0});
+}
+
+TEST(aRegisteredCancellationIsHonouredAndCleanedUp) {
+  Service service;
+  const auto opened = service.open(fileSource(fixtures::quadrants(40, 40), "svc-cancel.pdf"));
+  service.registerCancellation(opened.handle, 7);
+  service.cancel(opened.handle, 7);
+  EXPECT_ERROR(service.render(opened.handle, px::request(0, 0, 0, 40, 40, 1), 7, false), ErrorCode::Cancelled);
+  // The signal was consumed: the same token renders fine afterwards.
+  CHECK_EQ(service.render(opened.handle, px::request(0, 0, 0, 40, 40, 1), 7, false).width, 40);
+  // A cancel for a token that was never registered is a no-op, not an insert.
+  service.cancel(opened.handle, 999);
+  service.cancel(12345, 1);
+}
+
+TEST(cancelReachesARenderInFlightOnAnotherThread) {
+  Service service;
+  const auto opened = service.open(
+      fileSource(fixtures::grid(fixtures::kArchDW, fixtures::kArchDH, 4), "svc-cancel-inflight.pdf"));
+  service.registerCancellation(opened.handle, 1);
+  bool cancelled = false;
+  bool finished = false;
+  std::thread worker([&] {
+    try {
+      (void)service.render(opened.handle,
+                           px::request(0, 0, 0, fixtures::kArchDW, fixtures::kArchDH, 3), 1, false);
+      finished = true;
+    } catch (const PdfError& error) {
+      cancelled = error.code() == ErrorCode::Cancelled;
+    }
+  });
+  std::this_thread::sleep_for(std::chrono::milliseconds(2));
+  service.cancel(opened.handle, 1);
+  worker.join();
+  // Either the render was quick enough to finish, or it was cancelled mid-draw;
+  // what must not happen is a third outcome.
+  CHECK(cancelled || finished);
+}
+
+TEST(invalidateClosesEverythingAndRefusesAfterwards) {
+  slots::releaseAll();
+  Service service;
+  const auto a = service.open(fileSource(fixtures::quadrants(40, 40), "svc-inv-a.pdf"));
+  const auto b = service.open(fileSource(fixtures::quadrants(40, 40), "svc-inv-b.pdf"));
+  (void)service.render(a.handle, px::request(0, 0, 0, 40, 40, 1), 1, true);
+  CHECK_EQ(slots::count(), size_t{1});
+  CHECK_EQ(service.openCount(), size_t{2});
+
+  service.invalidate();
+  CHECK(service.isInvalidated());
+  CHECK_EQ(service.openCount(), size_t{0});
+  CHECK_EQ(slots::count(), size_t{0});
+  EXPECT_ERROR(service.render(b.handle, px::request(0, 0, 0, 40, 40, 1), 2, false), ErrorCode::BackendFailure);
+  EXPECT_ERROR(service.open(fileSource(fixtures::quadrants(40, 40), "svc-inv-c.pdf")), ErrorCode::BackendFailure);
+  service.invalidate();  // idempotent
+}
+
+TEST(openErrorsCarryTheirCodeThroughTheService) {
+  Service service;
+  Source missing;
+  missing.path = fixtures::tempDir() + "/nope.pdf";
+  EXPECT_ERROR(service.open(missing), ErrorCode::NotFound);
+  Source locked = fileSource(fixtures::encrypted(), "svc-locked.pdf");
+  EXPECT_ERROR(service.open(locked), ErrorCode::PasswordRequired);
+  CHECK_EQ(service.openCount(), size_t{0});
+}

package/native/tests/test_slots.cpp

@@ -0,0 +1,250 @@
+// The REAL slot store — the storage the device runs, not a double.
+//
+// Every failure mode here is a leak or a use-after-free rather than a wrong
+// pixel, so a device session does not show any of them: 48 tiles rendered
+// correctly with the store leaking every superseded raster would look exactly
+// like 48 tiles rendered correctly.
+
+#include <cstring>
+#include <set>
+#include <thread>
+#include <vector>
+
+#include "fixtures.h"
+#include "harness.h"
+#include "pdfcanvas/document.h"
+#include "pdfcanvas/jsi.h"
+#include "pdfcanvas/slots.h"
+#include "pixels_util.h"
+
+using namespace pdfcanvas;
+
+namespace {
+
+struct DrainStore {
+  DrainStore() { slots::releaseAll(); }
+  ~DrainStore() { slots::releaseAll(); }
+};
+
+std::vector<uint8_t> takeBytes(int64_t slot) {
+  auto buffer = slots::take(slot);
+  if (buffer == nullptr) return {};
+  return std::vector<uint8_t>(buffer->data(), buffer->data() + buffer->size());
+}
+
+}  // namespace
+
+TEST(probeBytesMatchTheSharedList) {
+  const std::array<uint8_t, 8> expected{0x00, 0x01, 0x02, 0xFD, 0xFE, 0xFF, 0x2A, 0x07};
+  CHECK(slots::probeBytes() == expected);
+}
+
+TEST(theProbeRoundTrips) {
+  DrainStore drain;
+  const int64_t slot = slots::storeProbe();
+  CHECK(slot > 0);
+  CHECK_EQ(slots::count(), size_t{1});
+  const auto taken = takeBytes(slot);
+  CHECK(std::equal(taken.begin(), taken.end(), slots::probeBytes().begin(), slots::probeBytes().end()));
+  CHECK_EQ(slots::count(), size_t{0});
+}
+
+TEST(aSlotIsTakenExactlyOnce) {
+  DrainStore drain;
+  const int64_t slot = slots::storeProbe();
+  CHECK(slots::take(slot) != nullptr);
+  CHECK(slots::take(slot) == nullptr);
+}
+
+TEST(slotIdsAreMonotonicAndNeverReused) {
+  DrainStore drain;
+  std::vector<int64_t> ids;
+  for (int i = 0; i < 8; i++) ids.push_back(slots::storeProbe());
+  for (size_t i = 1; i < ids.size(); i++) CHECK(ids[i] > ids[i - 1]);
+  const int64_t first = ids.front();
+  slots::release(first);
+  CHECK(slots::storeProbe() > ids.back());
+}
+
+TEST(releaseDropsOneSlotAndIsIdempotent) {
+  DrainStore drain;
+  const int64_t a = slots::storeProbe();
+  const int64_t b = slots::storeProbe();
+  CHECK_EQ(slots::count(), size_t{2});
+  CHECK(slots::release(a));
+  CHECK(!slots::release(a));
+  CHECK_EQ(slots::count(), size_t{1});
+  CHECK(slots::take(b) != nullptr);
+  CHECK(!slots::release(0));
+  CHECK(!slots::release(-1));
+}
+
+TEST(releaseAllDrainsTheStore) {
+  DrainStore drain;
+  for (int i = 0; i < 16; i++) slots::storeProbe();
+  CHECK_EQ(slots::count(), size_t{16});
+  slots::releaseAll();
+  CHECK_EQ(slots::count(), size_t{0});
+  slots::releaseAll();
+}
+
+/// RESERVE DOES NOT PUBLISH — the safety property of the whole store. A buffer
+/// reachable from the map before it is filled can be freed by `releaseAll()` on
+/// another thread while PDFium is still writing into it.
+TEST(aReservedBufferIsNotInTheStoreUntilPublished) {
+  DrainStore drain;
+  SlotSink sink;
+  uint8_t* bytes = sink.reserve(4096);
+  REQUIRE(bytes != nullptr);
+  CHECK_EQ(slots::count(), size_t{0});
+  slots::releaseAll();
+  std::memset(bytes, 0xAB, 4096);
+  const int64_t slot = sink.publish();
+  CHECK(slot > 0);
+  CHECK_EQ(slots::count(), size_t{1});
+  const auto taken = takeBytes(slot);
+  CHECK_EQ(taken.size(), size_t{4096});
+  CHECK_EQ(static_cast<int>(taken.front()), 0xAB);
+}
+
+TEST(reservedMemoryIsZeroed) {
+  SlotSink sink;
+  uint8_t* bytes = sink.reserve(8192);
+  REQUIRE(bytes != nullptr);
+  bool allZero = true;
+  for (size_t i = 0; i < 8192; i++) allZero = allZero && bytes[i] == 0;
+  CHECK(allZero);
+  sink.abandon();
+}
+
+TEST(aSinkRefusesASecondOrEmptyReservation) {
+  DrainStore drain;
+  SlotSink sink;
+  CHECK(sink.reserve(1024) != nullptr);
+  CHECK(sink.reserve(1024) == nullptr);
+  SlotSink empty;
+  CHECK(empty.reserve(0) == nullptr);
+  CHECK_EQ(empty.publish(), int64_t{0});
+  CHECK_EQ(slots::count(), size_t{0});
+  sink.abandon();
+}
+
+TEST(abandonAfterPublishTakesItBackOut) {
+  DrainStore drain;
+  SlotSink sink;
+  REQUIRE(sink.reserve(64) != nullptr);
+  const int64_t slot = sink.publish();
+  CHECK_EQ(slots::count(), size_t{1});
+  sink.abandon();
+  CHECK_EQ(slots::count(), size_t{0});
+  CHECK(slots::take(slot) == nullptr);
+  sink.abandon();  // idempotent
+}
+
+/// THE HEADLINE: bytes taken out of a slot are byte-identical to the same
+/// raster rendered to the heap. PDFium is handed a pointer into the slot buffer
+/// and writes the tile in place, so if the buffer, stride or publish were wrong
+/// the result would be a plausible-looking wrong image rather than an error.
+TEST(slotBytesAreIdenticalToTheHeapPathForARealRaster) {
+  DrainStore drain;
+  Source source;
+  source.path = fixtures::writeTemp(fixtures::grid(400, 300), "slots-fidelity.pdf");
+  auto document = Document::open(source);
+  const auto req = px::request(0, 37, 23, 64, 41, 4);
+  auto heap = document->render(req, nullptr, nullptr);
+  CHECK(!heap.inSlot());
+
+  SlotSink sink;
+  auto slotted = document->render(req, nullptr, &sink);
+  CHECK(slotted.inSlot());
+  CHECK(slotted.bytes.empty());
+  CHECK_EQ(slotted.width, heap.width);
+  CHECK_EQ(slotted.height, heap.height);
+  CHECK_EQ(slotted.rowBytes, heap.rowBytes);
+  CHECK_EQ(slots::count(), size_t{1});
+  const auto taken = takeBytes(slotted.slot);
+  CHECK_EQ(taken.size(), heap.bytes.size());
+  CHECK(taken == heap.bytes);
+}
+
+TEST(slotBytesMatchTheHeapPathOnATransparentBackground) {
+  DrainStore drain;
+  Source source;
+  source.path = fixtures::writeTemp(fixtures::page({0, 0, 100, 100}, nullptr, 0, "1 0 0 rg 0 0 40 40 re f\n"),
+                                    "slots-transparent.pdf");
+  auto document = Document::open(source);
+  const auto req = px::request(0, 0, 0, 100, 100, 2, false, Background::Transparent);
+  auto heap = document->render(req, nullptr, nullptr);
+  SlotSink sink;
+  auto slotted = document->render(req, nullptr, &sink);
+  const auto taken = takeBytes(slotted.slot);
+  CHECK(taken == heap.bytes);
+  const size_t corner = 10 * static_cast<size_t>(heap.rowBytes) + 190 * 4;
+  CHECK_EQ(static_cast<int>(taken[corner + 3]), 0);
+}
+
+/// A raster the render ABANDONS leaves nothing in the store: the path is a
+/// cancellation observed after the draw finished.
+TEST(anAbandonedRasterLeavesNoSlotBehind) {
+  DrainStore drain;
+  Source source;
+  source.path = fixtures::writeTemp(fixtures::grid(200, 200), "slots-abandon.pdf");
+  auto document = Document::open(source);
+  Cancellation signal;
+  // Enough polls to get through the draw, then the post-render check sees it.
+  signal.cancelAfterPolls(1);
+  SlotSink sink;
+  EXPECT_ERROR(document->render(px::request(0, 0, 0, 200, 200, 2), &signal, &sink), ErrorCode::Cancelled);
+  CHECK_EQ(slots::count(), size_t{0});
+}
+
+/// A sink that REFUSES falls the render through to the heap: a slower correct
+/// tile beats a lost one.
+TEST(aRefusedReservationFallsBackToTheHeap) {
+  struct Refusing final : PixelSink {
+    uint8_t* reserve(size_t) override { return nullptr; }
+    int64_t publish() override { return 0; }
+    void abandon() override {}
+  } refusing;
+  Source source;
+  source.path = fixtures::writeTemp(fixtures::quadrants(40, 40), "slots-refuse.pdf");
+  auto document = Document::open(source);
+  auto raster = document->render(px::request(0, 0, 0, 40, 40, 1), nullptr, &refusing);
+  CHECK(!raster.inSlot());
+  CHECK_EQ(raster.bytes.size(), size_t{40 * 40 * 4});
+  CHECK_PIXEL(raster, 5, 35, px::kRed);
+}
+
+TEST(concurrentPublishAndTakeKeepTheirOwnBytes) {
+  DrainStore drain;
+  std::vector<int64_t> ids(64, 0);
+  std::vector<std::thread> workers;
+  for (int i = 0; i < 64; i++) {
+    workers.emplace_back([i, &ids] {
+      SlotSink sink;
+      uint8_t* bytes = sink.reserve(1024);
+      if (bytes == nullptr) return;
+      std::memset(bytes, i & 0xFF, 1024);
+      ids[static_cast<size_t>(i)] = sink.publish();
+    });
+  }
+  for (auto& worker : workers) worker.join();
+  CHECK_EQ(std::set<int64_t>(ids.begin(), ids.end()).size(), size_t{64});
+  CHECK_EQ(slots::count(), size_t{64});
+  int good = 0;
+  for (int i = 0; i < 64; i++) {
+    const auto taken = takeBytes(ids[static_cast<size_t>(i)]);
+    if (taken.size() == 1024 && taken.front() == static_cast<uint8_t>(i & 0xFF)) good++;
+  }
+  CHECK_EQ(good, 64);
+  CHECK_EQ(slots::count(), size_t{0});
+}
+
+/// `installTakePixels` reports false in this build, honestly. This is the
+/// configuration that lets every test above run, and a `true` would be a lie
+/// that made the JS side arm a transport it cannot redeem.
+TEST(installDeclinesWithoutAJsiRuntime) {
+  CHECK(!installTakePixels(nullptr));
+  int dummy = 0;
+  CHECK(!installTakePixels(&dummy));
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@reekon-tools/react-native-pdf-canvas",
-  "version": "0.1.0",
-  "description": "PDF pages as Skia images, drawn at exact doc-space rects inside somebody else's transform. Owns no canvas, no gestures, no viewport state.",
+  "version": "0.2.0",
+  "description": "PDF pages as Skia images, drawn at exact doc-space rects inside somebody else's transform. One PDFium engine on iOS, Android and web. Owns no canvas, no gestures, no viewport state.",
   "author": "REEKON Tools",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://gitlab.com/reekon-tools/software/rock-pro/react-native-pdf-canvas.git"
@@ -12,17 +12,41 @@
     "access": "public"
   },
   "type": "module",
-  "sideEffects": false,
+  "//sideEffects": "NOT `false`. The four entry files below are `export *` re-exports plus a top-level resolver install, and a bundler applies `sideEffects` to the IMPORTED module: with `false`, Rollup never marks a module that declares no used binding as executed and drops the call (that is what broke every PDF canvas on the production web build while dev — esbuild, entry-point code always kept — stayed green). `src/**` is listed so the property is testable against source; see `__tests__/tree-shaking.test.ts`. `web-init` is not listed: its install is inside an exported function.",
+  "sideEffects": [
+    "./dist/index.web.js",
+    "./dist/index.native.js",
+    "./dist/skia/index.web.js",
+    "./dist/skia/index.native.js",
+    "./src/index.web.ts",
+    "./src/index.native.ts",
+    "./src/skia/index.web.ts",
+    "./src/skia/index.native.ts"
+  ],
   "//files-scripts": "`scripts` ships because the peer-floor check runs from a CONSUMER'S postinstall, before/without any build of `dist`.",
-  "//files": "`*.podspec` SHIPS OR iOS IS SILENTLY ABSENT. Autolinking reads the podspec out of the INSTALLED package, so a podspec that is not in this list means `pod install` finds nothing, `PdfCanvas` never appears in Podfile.lock, and `NativeModules.PdfCanvas` is undefined at runtime with no build error anywhere. `ios/Package.swift` and `ios/Tests` ship as part of `ios` and cost a few KB; they are what lets a consumer run the core's host tests against the exact version they installed.",
+  "//files": "`*.podspec` SHIPS OR iOS IS SILENTLY ABSENT: autolinking reads the podspec out of the INSTALLED package. `native` is the C++ core both bindings compile (native/core), its host test suite (native/tests) and the host CMake project — but NOT native/.pdfium (the fetched PDFium binaries, gitignored and re-fetched by scripts/fetch-pdfium.mjs on every platform) and NOT native/build. `scripts` ships because the peer-floor check and the PDFium fetch both run from a CONSUMER'S install: the fetch from build.gradle and from the podspec, before/without any build of `dist`. THE ANDROID ENTRIES ARE ENUMERATED RATHER THAN A BARE `android`, and that is load-bearing: a `files` entry is an ALLOWLIST that beats .gitignore, so `android` swept in build/, .cxx/, .gradle/ and local.properties (this machine's sdk.dir) the moment anyone had run a Gradle build or the compile gate — 869 files and 60 MB unpacked against 0.1.1's 161 and 1.4 MB. `!`-negations fix npm pack but NOT `yarn pack`, which is the packer this repo's packageManager selects, so the only form both honour is naming the paths. Mirror of how `native` is listed: core/tests/CMakeLists/.clangd by name, never the fetched .pdfium or the host build.",
   "files": [
     "dist",
     "ios",
-    "android",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/settings.gradle",
+    "android/consumer-rules.pro",
+    "android/gradle",
+    "android/gradlew",
+    "android/gradlew.bat",
+    "android/src",
+    "android/tools",
+    "native/core",
+    "native/tests",
+    "native/CMakeLists.txt",
+    "native/.clangd",
     "scripts",
     "react-native.config.js",
     "PdfCanvas.podspec",
-    "README.md"
+    "README.md",
+    "LICENSE",
+    "NOTICE"
   ],
   "bin": {
     "pdf-canvas-check-skia": "./scripts/check-skia-peer.mjs"
@@ -91,11 +115,17 @@
     "check-format": "prettier --check .",
     "check-exports": "attw --pack . --profile esm-only",
     "check-peers": "node scripts/check-skia-peer.mjs",
-    "ci": "yarn run check-format && yarn run typecheck && vitest run && yarn run build"
+    "ci": "yarn run check-format && yarn run typecheck && vitest run && yarn run build",
+    "pdfium:fetch": "node scripts/fetch-pdfium.mjs",
+    "native:configure": "cmake -S native -B native/build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+    "native:build": "cmake --build native/build",
+    "native:test": "node scripts/fetch-pdfium.mjs host && cmake -S native -B native/build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON && cmake --build native/build && ctest --test-dir native/build --output-on-failure",
+    "android:gate": "bash android/tools/compile-gate.sh"
   },
   "keywords": [
     "react-native",
     "pdf",
+    "pdfium",
     "skia",
     "reanimated"
   ],

package/react-native.config.js

@@ -19,8 +19,11 @@
  * the failure is silent: the pod is simply absent from `Podfile.lock` and
  * `NativeModules.PdfCanvas` is undefined at runtime.
  *
- * `ios` was `null` until the CoreGraphics/PDFKit backend landed. If it ever needs
- * to be null again, the message in `src/rasterizer/index.ts` is what a host sees.
+ * `ios` was `null` until the first iOS backend landed. If it ever needs to be
+ * null again, the message in `src/rasterizer/index.ts` is what a host sees.
+ * Note that the podspec FETCHES PDFium while it is evaluated (see the note at
+ * its top), so `pod install` needs either network access or the offline knobs
+ * `scripts/fetch-pdfium.mjs` documents.
  */
 const path = require('path');