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

package/native/tests/test_document.cpp

@@ -329,6 +329,184 @@ TEST(openBytesMatchesOpenFile) {
   CHECK_EQ(px::compare(a, b).differing, 0);
 }
 
+/* ------------------------------------------------------------------ *
+ * Host rotation — on top of the document's /Rotate
+ * ------------------------------------------------------------------ */
+
+namespace {
+
+RasterRequest turned(RasterRequest request, int rotation) {
+  request.rotation = rotation;
+  return request;
+}
+
+/// `upright` turned `rotation` degrees clockwise, pixel for pixel — the
+/// reference a rotated render is held to. Per case rather than
+/// transpose-plus-flip, so the DIRECTION is stated and not derived: a core
+/// turning pages anticlockwise would still be "a rotation".
+RasterPixels turnClockwise(const RasterPixels& upright, int rotation) {
+  const bool swap = rotation != 180;
+  RasterPixels out;
+  out.width = swap ? upright.height : upright.width;
+  out.height = swap ? upright.width : upright.height;
+  out.rowBytes = out.width * 4;
+  out.bytes.assign(static_cast<size_t>(out.rowBytes) * static_cast<size_t>(out.height), 0);
+  for (int y = 0; y < out.height; y++) {
+    for (int x = 0; x < out.width; x++) {
+      int sx = 0;
+      int sy = 0;
+      if (rotation == 90) {
+        sx = y;
+        sy = upright.height - 1 - x;
+      } else if (rotation == 180) {
+        sx = upright.width - 1 - x;
+        sy = upright.height - 1 - y;
+      } else {
+        sx = upright.width - 1 - y;
+        sy = x;
+      }
+      const uint8_t* from = upright.bytes.data() + static_cast<size_t>(sy) * upright.rowBytes +
+                            static_cast<size_t>(sx) * 4;
+      uint8_t* to = out.bytes.data() + static_cast<size_t>(y) * out.rowBytes + static_cast<size_t>(x) * 4;
+      std::copy(from, from + 4, to);
+    }
+  }
+  return out;
+}
+
+/// The registration page's pattern: bars 2.5pt wide on 13.3 / 11.1pt
+/// intervals, so every edge sits on a fraction of a device pixel at every
+/// scale and no rect can align with it by accident. Axis-aligned throughout.
+std::string fractionalBars() {
+  std::string content = "1 0 0 rg 0 0 100 50 re f\n0 0 1 rg 100 50 100 50 re f\n0.2 0.2 0.25 rg\n";
+  for (double x = 3.7; x < 200; x += 13.3) content += std::to_string(x) + " 0 2.5 100 re f\n";
+  for (double y = 2.9; y < 100; y += 11.1) content += "0 " + std::to_string(y) + " 200 2.5 re f\n";
+  return content;
+}
+
+}  // namespace
+
+/// CATCHES: the rotate argument ignored, applied anticlockwise, or applied
+/// without swapping the page box PDFium is handed — which squashes the turned
+/// page into the upright box. Quadrants, so every corner is a channel-order
+/// test too. Doc (y-down): TL blue, TR black, BL red, BR green.
+TEST(aHostRotationTurnsThePageClockwise) {
+  auto document = openFixture(fixtures::quadrants(200, 100), "host-rotate.pdf");
+
+  // The whole page, in the TURNED page's doc space: 100x200 at 90 and 270.
+  auto r90 = document->render(turned(px::request(0, 0, 0, 100, 200, 2), 90), nullptr, nullptr);
+  CHECK_EQ(r90.width, 200);
+  CHECK_EQ(r90.height, 400);
+  CHECK_PIXEL(r90, 20, 20, kRed);      // BL -> TL
+  CHECK_PIXEL(r90, 180, 20, kBlue);    // TL -> TR
+  CHECK_PIXEL(r90, 180, 380, kBlack);  // TR -> BR
+  CHECK_PIXEL(r90, 20, 380, kGreen);   // BR -> BL
+
+  auto r180 = document->render(turned(px::request(0, 0, 0, 200, 100, 2), 180), nullptr, nullptr);
+  CHECK_EQ(r180.width, 400);
+  CHECK_EQ(r180.height, 200);
+  CHECK_PIXEL(r180, 20, 20, kGreen);   // BR -> TL
+  CHECK_PIXEL(r180, 380, 20, kRed);    // BL -> TR
+  CHECK_PIXEL(r180, 380, 180, kBlue);  // TL -> BR
+  CHECK_PIXEL(r180, 20, 180, kBlack);  // TR -> BL
+
+  auto r270 = document->render(turned(px::request(0, 0, 0, 100, 200, 2), 270), nullptr, nullptr);
+  CHECK_EQ(r270.width, 200);
+  CHECK_EQ(r270.height, 400);
+  CHECK_PIXEL(r270, 20, 20, kBlack);   // TR -> TL
+  CHECK_PIXEL(r270, 180, 20, kGreen);  // BR -> TR
+  CHECK_PIXEL(r270, 180, 380, kRed);   // BL -> BR
+  CHECK_PIXEL(r270, 20, 380, kBlue);   // TL -> BL
+}
+
+/// Pixel for pixel, not just the corners, on fractionally placed axis-aligned
+/// ink: a quarter turn keeps every edge axis-aligned at a mirrored fractional
+/// offset, whose coverage the rasterizer accumulates to the identical value —
+/// so the turned render must EQUAL the upright one turned, with no tolerance.
+/// (The web backend measures the same against the same PDFium build.)
+TEST(aRotatedRasterIsTheUprightRasterTurned) {
+  auto document = openFixture(fixtures::page({0, 0, 200, 100}, nullptr, 0, fractionalBars()), "host-rotate-exact.pdf");
+  auto upright = px::renderWhole(*document, 0, 2);
+  for (int rotation : {90, 180, 270}) {
+    const bool swap = rotation != 180;
+    auto rotated = document->render(
+        turned(px::request(0, 0, 0, swap ? 100 : 200, swap ? 200 : 100, 2), rotation), nullptr, nullptr);
+    auto expected = turnClockwise(upright, rotation);
+    CHECK_EQ(rotated.width, expected.width);
+    CHECK_EQ(rotated.height, expected.height);
+    const auto diff = px::compare(rotated, expected);
+    CHECK_MSG(diff.differing == 0, std::to_string(rotation) + ": " + std::to_string(diff.differing) + "/" +
+                                       std::to_string(diff.total) + " pixels differ, maxDelta " +
+                                       std::to_string(diff.maxDelta));
+  }
+}
+
+/// The registration property survives the turn: a tile of a rotated page is
+/// that region of the rotated whole page. The detail layer only ever draws
+/// tiles, so a rotation that held for whole-page renders alone would ship
+/// soft, misregistered detail. Same `maxDelta <= 1` allowance as the upright
+/// property, for the same diagonal-edge reason.
+TEST(aRotatedTileRegistersAgainstTheRotatedPage) {
+  auto document = openFixture(fixtures::grid(200, 100), "host-rotate-tile.pdf");
+  const double scale = 4.0;
+  auto whole = document->render(turned(px::request(0, 0, 0, 100, 200, scale), 90), nullptr, nullptr);
+  auto tile = document->render(turned(px::request(0, 37, 23, 41, 64, scale), 90), nullptr, nullptr);
+  CHECK_EQ(tile.width, 164);
+  CHECK_EQ(tile.height, 256);
+  const auto diff = px::compare(tile, whole, static_cast<int>(37 * scale), static_cast<int>(23 * scale));
+  const std::string summary = std::to_string(diff.differing) + "/" + std::to_string(diff.total) +
+                              " pixels differ, maxDelta " + std::to_string(diff.maxDelta);
+  CHECK_MSG(diff.maxDelta <= 1, summary);
+  CHECK_MSG(diff.differing * 100 < diff.total * 2, summary);
+}
+
+/// The host's rotation STACKS on the document's own /Rotate rather than
+/// replacing it: a page saved with /Rotate 90 and shown turned another 270 is
+/// upright, and draws exactly as the same content saved unrotated.
+TEST(hostRotationStacksOnTheDocumentsRotate) {
+  auto saved = openFixture(fixtures::rotated(90), "host-stack-saved.pdf");  // PDFium reports 792x612
+  auto plain = openFixture(fixtures::rotated(0), "host-stack-plain.pdf");   // 612x792
+  CHECK_NEAR(saved->geometry(0).width, 792, 0.01);
+  // Turned 270 by the host, the saved page is 612x792 in doc space again.
+  auto unwound = saved->render(turned(px::request(0, 0, 0, 612, 792, 0.5), 270), nullptr, nullptr);
+  auto upright = px::renderWhole(*plain, 0, 0.5);
+  CHECK_EQ(unwound.width, 306);
+  CHECK_EQ(unwound.height, 396);
+  CHECK_EQ(px::compare(unwound, upright).differing, 0);
+  // And the markers sit where the unrotated fixture puts them.
+  CHECK_PIXEL(unwound, 20, 20, kRed);
+  CHECK_PIXEL(unwound, 20, 380, kBlue);
+}
+
+/// Form fields turn with the page: `FPDF_FFLDraw` takes the same rotate
+/// argument and the same swapped box as the content pass, so a widget lands
+/// where the turned content says and not where the upright page had it.
+TEST(formFieldsTurnWithThePage) {
+  auto document = openFixture(fixtures::formFieldPage(), "host-rotate-form.pdf");
+  auto with = document->render(turned(px::request(0, 0, 0, 200, 200, 1, true), 90), nullptr, nullptr);
+  // The widget's centre, doc (100,125), turned a quarter clockwise on a
+  // 200x200 page: (200 - 125, 100) = (75, 100).
+  const px::Pixel inside = px::at(with, 75, 100);
+  CHECK_MSG(!inside.near(kWhite), "the turned widget must paint at (75,100); got " + inside.str() + "\n" + px::map(with));
+  // (150,100) came from upright (100,50), above the widget: plain page.
+  CHECK_PIXEL(with, 150, 100, kWhite);
+  // The content's red marker, upright at doc (10..40, 160..190), turns to
+  // (10..40, 10..40).
+  CHECK_PIXEL(with, 25, 25, kRed);
+}
+
+/// Refused, not folded: `45 / 90` is 0 in integer arithmetic, and a request
+/// that asked for a turn must not quietly come back upright.
+TEST(aRotationThatIsNotAQuarterTurnIsRefused) {
+  auto document = openFixture(fixtures::quadrants(40, 40), "host-rotate-bad.pdf");
+  for (int bad : {45, -90, 360, 1}) {
+    EXPECT_ERROR(document->render(turned(px::request(0, 0, 0, 40, 40, 1), bad), nullptr, nullptr),
+                 ErrorCode::BackendFailure);
+  }
+  // And the page is still usable afterwards.
+  CHECK_EQ(px::renderWhole(*document, 0).width, 40);
+}
+
 /* ------------------------------------------------------------------ *
  * Failures
  * ------------------------------------------------------------------ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/react-native-pdf-canvas",
-  "version": "0.2.0",
+  "version": "0.3.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": "Apache-2.0",

package/scripts/fetch-pdfium.mjs

@@ -283,13 +283,56 @@ async function android() {
  * ios
  * ------------------------------------------------------------------ */
 
+/**
+ * The minimum iOS version a Mach-O was built for, read from its LC_BUILD_VERSION
+ * (`minos`) via `vtool`. A fat binary prints one block per architecture; every
+ * slice must agree or the number is meaningless, so disagreement is an error.
+ *
+ * THIS IS THE FLOOR, NOT A GUESS. App Store processing compares the
+ * `MinimumOSVersion` a framework's Info.plist declares against what its binary
+ * was actually built for and rejects the upload (ITMS-90208) when the plist
+ * claims a lower floor. The first PDFium release of this package hardcoded
+ * 13.0 — a number inherited from the CoreGraphics era and from the upstream
+ * xcframework script this mirrors — while the dylib said 17.0, and the very
+ * first TestFlight upload was rejected. The plist is now written from the
+ * binary, and the manifest's declared value is checked against it, so the two
+ * cannot drift apart again.
+ */
+function machOMinimumOS(binary) {
+  const text = execFileSync('xcrun', ['vtool', '-show-build', binary], {
+    encoding: 'utf8',
+  });
+  const found = new Set();
+  for (const line of text.split('\n')) {
+    const m = /^\s*minos\s+(\d+(?:\.\d+)*)\s*$/.exec(line);
+    if (m) found.add(m[1]);
+  }
+  if (found.size === 0) {
+    throw new Error(
+      `${binary} has no LC_BUILD_VERSION minos; cannot determine its iOS floor.`,
+    );
+  }
+  if (found.size > 1) {
+    throw new Error(
+      `${binary} slices disagree about their iOS floor: ${[...found].join(', ')}.`,
+    );
+  }
+  return [...found][0];
+}
+
 /**
  * Wraps a bare dylib as an iOS `PDFium.framework` (shallow bundle) so it can be
  * embedded and code-signed like any other framework. Mirrors what
  * espresso3389/pdfium-xcframework's build.sh does, minus the macOS/Catalyst
  * slices this package does not ship.
  */
-function makeIosFramework(dylib, frameworkDir, headersDir, platform) {
+function makeIosFramework(
+  dylib,
+  frameworkDir,
+  headersDir,
+  platform,
+  minimumOSVersion,
+) {
   resetDir(frameworkDir);
   const binary = join(frameworkDir, 'PDFium');
   cpSync(dylib, binary);
@@ -328,7 +371,7 @@ function makeIosFramework(dylib, frameworkDir, headersDir, platform) {
     <string>${platform}</string>
   </array>
   <key>MinimumOSVersion</key>
-  <string>13.0</string>
+  <string>${minimumOSVersion}</string>
 </dict>
 </plist>
 `,
@@ -343,7 +386,18 @@ async function ios() {
     );
   }
   const out = join(outputRoot, 'ios');
-  const key = manifest.release;
+  const declaredMinOS = manifest.iosMinimumOSVersion;
+  if (
+    typeof declaredMinOS !== 'string' ||
+    !/^\d+(\.\d+)*$/.test(declaredMinOS)
+  ) {
+    throw new Error(
+      'pdfium-manifest.json must declare iosMinimumOSVersion (e.g. "17.0").',
+    );
+  }
+  // The floor is part of the stamp so an output assembled by an older script
+  // (which wrote a hardcoded plist) is rebuilt rather than trusted.
+  const key = `${manifest.release} ios-min=${declaredMinOS}`;
   if (isFresh(out, key)) {
     console.log(`[pdfium] ios: ${manifest.release} already present`);
     return;
@@ -362,6 +416,22 @@ async function ios() {
     extract(await fetchArtifact(name), dir);
     slices[name] = dir;
   }
+  // Every slice must have been built for the floor the manifest declares. A
+  // mismatch means the release was bumped without re-reading its args.gn: fix the
+  // manifest (and tell every consumer, whose deployment target must be >= it).
+  for (const name of Object.keys(slices)) {
+    const actual = machOMinimumOS(join(slices[name], 'lib', 'libpdfium.dylib'));
+    if (actual !== declaredMinOS) {
+      throw new Error(
+        `${name} in ${manifest.release} was built for iOS ${actual}, but ` +
+          `pdfium-manifest.json declares iosMinimumOSVersion "${declaredMinOS}". ` +
+          'Update the manifest to the real floor; consumers must raise their ' +
+          'deployment target to match before they can ship this release.',
+      );
+    }
+  }
+  console.log(`[pdfium] ios: every slice is built for iOS ${declaredMinOS}`);
+
   copyHeaders(
     join(slices['ios-device-arm64'], 'include'),
     join(out, 'include'),
@@ -393,12 +463,14 @@ async function ios() {
     deviceFramework,
     join(out, 'include'),
     'iPhoneOS',
+    declaredMinOS,
   );
   makeIosFramework(
     simulatorFat,
     simulatorFramework,
     join(out, 'include'),
     'iPhoneSimulator',
+    declaredMinOS,
   );
 
   const xcframework = join(out, 'PDFium.xcframework');

package/scripts/pdfium-manifest.json

@@ -3,6 +3,8 @@
   "release": "chromium/8044",
   "version": "144.0.8044.0",
   "baseUrl": "https://github.com/bblanchon/pdfium-binaries/releases/download",
+  "//iosMinimumOSVersion": "THE iOS FLOOR THIS RELEASE'S DYLIB WAS BUILT FOR (`ios_deployment_target` in the tarball's args.gn, `minos` in the Mach-O LC_BUILD_VERSION). It is declared here, not discovered, so that bumping the release forces whoever bumps it to look: fetch-pdfium.mjs reads the real value out of every iOS slice with `vtool` and refuses to assemble the framework if any slice disagrees with this line. The same value is written into PDFium.framework/Info.plist as MinimumOSVersion — App Store processing rejects a framework whose plist claims a lower floor than its binary (ITMS-90208) — and is the floor PdfCanvas.podspec declares, so a host app whose deployment target is lower fails at `pod install` with a CocoaPods platform error instead of at upload. bblanchon pins 17.0 for non-V8 builds since 2026-08-14; before that the floor tracked Chromium's default and was never below 17.4 in 2025-2026. A host that must ship below this value needs a PDFium built with a lower ios_deployment_target, not a smaller number here.",
+  "iosMinimumOSVersion": "17.0",
   "//artifacts": "Keyed by the bblanchon artifact name minus the `pdfium-` prefix and `.tgz` suffix. The android/ios/mac/win/linux entries are the plain (non-V8, non-XFA) builds: this package runs no JavaScript inside a PDF and XFA forms are out of scope, and the V8 builds are ~4x the size for nothing.",
   "artifacts": {
     "android-arm": {