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

package/ios/Sources/PdfCanvasCore/PdfCanvasRasterizer.m

@@ -1,548 +0,0 @@
-#import "PdfCanvasRasterizer.h"
-
-#import <PDFKit/PDFKit.h>
-#import <math.h>
-
-#import "PdfCanvasDocumentPool.h"
-#import "PdfCanvasPageTransform.h"
-
-static const NSInteger kPdfCanvasMaxRasterPixels = 64000000;
-
-/* ------------------------------------------------------------------ *
- * Private surfaces
- * ------------------------------------------------------------------ */
-
-@interface PdfCanvasRasterizer ()
-+ (nullable instancetype)withPool:(PdfCanvasDocumentPool *)pool
-                            error:(NSError *_Nullable *_Nullable)error;
-- (instancetype)initWithPool:(PdfCanvasDocumentPool *)pool
-                       pages:(NSArray<PdfCanvasPageGeometry *> *)pages;
-- (nullable PdfCanvasRasterPixels *)
-    renderLeased:(PdfCanvasDocumentLease *)lease
-         request:(PdfCanvasRasterRequest *)request
-        geometry:(PdfCanvasPageGeometry *)geometry
-             pxW:(NSInteger)pxW
-             pxH:(NSInteger)pxH
-          signal:(nullable PdfCanvasCancellation *)signal
-            sink:(nullable id<PdfCanvasPixelSink>)sink
-           error:(NSError *_Nullable *_Nullable)error;
-- (BOOL)drawWithCoreGraphics:(PdfCanvasDocumentLease *)lease
-                     request:(PdfCanvasRasterRequest *)request
-                    geometry:(PdfCanvasPageGeometry *)geometry
-                     context:(CGContextRef)ctx
-                       error:(NSError *_Nullable *_Nullable)error;
-- (BOOL)drawWithPdfKit:(PdfCanvasDocumentLease *)lease
-               request:(PdfCanvasRasterRequest *)request
-              geometry:(PdfCanvasPageGeometry *)geometry
-               context:(CGContextRef)ctx
-                 error:(NSError *_Nullable *_Nullable)error;
-@end
-
-/**
- * The one bitmap configuration this library creates, stated once.
- *
- * `kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big` is RGBA with
- * premultiplied alpha — `PdfCanvasFormatRGBA8888`, and `AlphaType.Premul` after
- * `ingest.ts` maps it.
- *
- * PREMULTIPLIED IS NOT A CHOICE. MEASURED: `CGBitmapContextCreate` REFUSES
- * `kCGImageAlphaLast` and `kCGImageAlphaFirst` — straight alpha, either byte order
- * — returning NULL, while `premultipliedLast | 32Big`,
- * `premultipliedFirst | 32Little` and `noneSkipLast` are all accepted. So the only
- * two things an 8-bit RGBA context can be are premultiplied or alpha-less, and
- * alpha-less would break `background: 'transparent'`, which is in the
- * `RasterRequest` contract. This is the cell the spec's alpha table had marked
- * NOT MEASURED; `src/rasterizer/ios.ts` declares the answer and
- * `alphaIsPremultiplied` in the Swift suite reads the bytes back off an
- * antialiased edge to confirm it (a 62%-covered opaque-white edge reads
- * `[a, a, a, a]`, not `[255, 255, 255, a]`).
- *
- * RGBA RATHER THAN THE APPLE-NATIVE BGRA, deliberately. Both are accepted, and
- * BGRA is the platform's preferred order — but cost is flat in scale on this
- * engine, so rasterizing dominates and the byte order is not where the time goes,
- * whereas matching Android's order means one fewer axis for a cross-platform pixel
- * test to account for.
- */
-static const CGBitmapInfo kPdfCanvasBitmapInfo =
-    (CGBitmapInfo)kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big;
-
-/**
- * sRGB, named explicitly rather than `CGColorSpaceCreateDeviceRGB()`.
- *
- * `Skia.Image.MakeImage` is handed an `SkImageInfo` with no colour space, which
- * Skia treats as legacy/sRGB, and Android's `ARGB_8888` bitmaps are sRGB. A
- * wide-gamut context here would make the identical PDF read differently on iOS
- * than on Android with nothing in the pipeline saying so — the numbers would
- * simply be different, and every cross-platform pixel comparison would drift.
- */
-static CGColorSpaceRef PdfCanvasColorSpace(void) {
-  static CGColorSpaceRef space;
-  static dispatch_once_t once;
-  dispatch_once(&once, ^{
-    space = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
-  });
-  return space;
-}
-
-@implementation PdfCanvasRasterizer {
-  PdfCanvasDocumentPool *_pool;
-  NSArray<PdfCanvasPageGeometry *> *_pages;
-  BOOL _closed;
-}
-
-+ (NSInteger)maxRasterPixels {
-  return kPdfCanvasMaxRasterPixels;
-}
-
-+ (NSString *)rotationSupport {
-  return @"supported";
-}
-
-/* ---------------------------------------------------------------- *
- * Opening
- * ---------------------------------------------------------------- */
-
-+ (nullable instancetype)openFileURL:(NSURL *)url
-                            password:(nullable NSString *)password
-                            poolSize:(NSInteger)poolSize
-                               error:(NSError *_Nullable *_Nullable)error {
-  PdfCanvasDocumentPool *pool = [PdfCanvasDocumentPool openFileURL:url
-                                                         password:password
-                                                             size:poolSize
-                                                            error:error];
-  return pool == nil ? nil : [self withPool:pool error:error];
-}
-
-+ (nullable instancetype)openData:(NSData *)data
-                         password:(nullable NSString *)password
-                         poolSize:(NSInteger)poolSize
-                            error:(NSError *_Nullable *_Nullable)error {
-  PdfCanvasDocumentPool *pool = [PdfCanvasDocumentPool openData:data
-                                                      password:password
-                                                          size:poolSize
-                                                         error:error];
-  return pool == nil ? nil : [self withPool:pool error:error];
-}
-
-+ (nullable instancetype)withPool:(PdfCanvasDocumentPool *)pool
-                            error:(NSError *_Nullable *_Nullable)error {
-  PdfCanvasDocumentLease *lease = [pool leaseWithError:error];
-  if (lease == nil) {
-    [pool close];
-    return nil;
-  }
-  NSMutableArray<PdfCanvasPageGeometry *> *pages =
-      [NSMutableArray arrayWithCapacity:(NSUInteger)pool.pageCount];
-  for (NSInteger i = 0; i < pool.pageCount; i++) {
-    // CGPDFDocumentGetPage is 1-BASED. Every other index in this package is
-    // 0-based, so the conversion happens here, once, and nowhere else.
-    CGPDFPageRef page = CGPDFDocumentGetPage(lease.cgDocument, (size_t)(i + 1));
-    if (page == NULL) {
-      [pool returnLease:lease];
-      [pool close];
-      // A page the document's own page count promised and cannot produce. Failing
-      // the OPEN rather than papering over it with a zero size is deliberate: a
-      // `PageGeometry` is what the layout function turns into the document's whole
-      // coordinate space, so a wrong one is not a missing page, it is every page
-      // after it in the wrong place.
-      return PdfCanvasFail(
-          error, PdfCanvasErrorCodeCorrupt,
-          [NSString stringWithFormat:
-                        @"Could not read page %ld of %ld — the page tree "
-                        @"promises it and CoreGraphics cannot produce it.",
-                        (long)i, (long)pool.pageCount],
-          nil);
-    }
-    [pages addObject:[[PdfCanvasPageGeometry alloc]
-                             initWithIndex:i
-                                   cropBox:PdfCanvasEffectiveCropBox(page)
-                           rotationDegrees:CGPDFPageGetRotationAngle(page)]];
-  }
-  [pool returnLease:lease];
-  return [[self alloc] initWithPool:pool pages:pages];
-}
-
-- (instancetype)initWithPool:(PdfCanvasDocumentPool *)pool
-                       pages:(NSArray<PdfCanvasPageGeometry *> *)pages {
-  self = [super init];
-  if (self != nil) {
-    _pool = pool;
-    _pages = pages;
-  }
-  return self;
-}
-
-/* ---------------------------------------------------------------- *
- * Cheap accessors
- * ---------------------------------------------------------------- */
-
-- (NSInteger)pageCount {
-  return (NSInteger)_pages.count;
-}
-
-- (NSInteger)poolSize {
-  return _pool.size;
-}
-
-- (BOOL)isClosed {
-  return _closed || _pool.isClosed;
-}
-
-- (nullable PdfCanvasPageGeometry *)pageGeometryAtIndex:(NSInteger)index
-                                                  error:
-                                                      (NSError *_Nullable
-                                                           *_Nullable)error {
-  if (index < 0 || index >= (NSInteger)_pages.count) {
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeNotFound,
-        [NSString stringWithFormat:@"Document has %lu pages; asked for %ld.",
-                                   (unsigned long)_pages.count, (long)index],
-        nil);
-  }
-  return _pages[(NSUInteger)index];
-}
-
-/* ---------------------------------------------------------------- *
- * Rendering
- * ---------------------------------------------------------------- */
-
-- (nullable PdfCanvasRasterPixels *)render:(PdfCanvasRasterRequest *)request
-                              cancellation:
-                                  (nullable PdfCanvasCancellation *)signal
-                                      sink:(nullable id<PdfCanvasPixelSink>)sink
-                                     error:(NSError *_Nullable *_Nullable)error {
-  if (!PdfCanvasCheckCancelled(signal, @"before start", error)) {
-    return nil;
-  }
-  if (self.isClosed) {
-    return PdfCanvasFail(error, PdfCanvasErrorCodeBackendFailure,
-                         @"Document handle is closed.", nil);
-  }
-
-  // Validates the page index before anything expensive is allocated or leased.
-  PdfCanvasPageGeometry *geometry = [self pageGeometryAtIndex:request.page
-                                                        error:error];
-  if (geometry == nil) {
-    return nil;
-  }
-
-  if (!(request.scale > 0) || !isfinite(request.scale)) {
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeBackendFailure,
-        [NSString stringWithFormat:@"Scale must be finite and positive: %g.",
-                                   request.scale],
-        nil);
-  }
-  if (!(request.docWidth > 0) || !(request.docHeight > 0) ||
-      !isfinite(request.docWidth) || !isfinite(request.docHeight)) {
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeBackendFailure,
-        [NSString stringWithFormat:@"Doc rect has no area: %gx%g.",
-                                   request.docWidth, request.docHeight],
-        nil);
-  }
-  if (!isfinite(request.docX) || !isfinite(request.docY)) {
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeBackendFailure,
-        [NSString stringWithFormat:@"Doc rect origin is not finite: %g,%g.",
-                                   request.docX, request.docY],
-        nil);
-  }
-
-  const NSInteger pxW = request.pixelWidth;
-  const NSInteger pxH = request.pixelHeight;
-  const long long pixels = (long long)pxW * (long long)pxH;
-  if (pixels > kPdfCanvasMaxRasterPixels) {
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeOutOfMemory,
-        [NSString stringWithFormat:
-                      @"Refused a %ldx%ld raster (%lld pixels > %ld).",
-                      (long)pxW, (long)pxH, pixels,
-                      (long)kPdfCanvasMaxRasterPixels],
-        nil);
-  }
-
-  PdfCanvasDocumentLease *lease = [_pool leaseWithError:error];
-  if (lease == nil) {
-    return nil;
-  }
-  @try {
-    // The lease can block for the length of another render, so this is the check
-    // that actually saves work when a raster is superseded mid-queue.
-    if (!PdfCanvasCheckCancelled(signal, @"after pool wait", error)) {
-      return nil;
-    }
-    if (self.isClosed) {
-      return PdfCanvasFail(error, PdfCanvasErrorCodeBackendFailure,
-                           @"Document handle is closed.", nil);
-    }
-    return [self renderLeased:lease
-                     request:request
-                    geometry:geometry
-                        pxW:pxW
-                        pxH:pxH
-                      signal:signal
-                        sink:sink
-                       error:error];
-  } @finally {
-    [_pool returnLease:lease];
-  }
-}
-
-- (nullable PdfCanvasRasterPixels *)
-    renderLeased:(PdfCanvasDocumentLease *)lease
-         request:(PdfCanvasRasterRequest *)request
-        geometry:(PdfCanvasPageGeometry *)geometry
-             pxW:(NSInteger)pxW
-             pxH:(NSInteger)pxH
-          signal:(nullable PdfCanvasCancellation *)signal
-            sink:(nullable id<PdfCanvasPixelSink>)sink
-           error:(NSError *_Nullable *_Nullable)error {
-  // TIGHT, and `CGBitmapContextCreate` constrains what else is possible: MEASURED,
-  // it refuses a `bytesPerRow` that is not a multiple of 4 at 32 bits per pixel.
-  // `width * 4` always is.
-  const NSInteger rowBytes = pxW * 4;
-  const NSUInteger byteCount = (NSUInteger)(rowBytes * pxH);
-
-  // RESERVE BEFORE DRAWING, and fall back before drawing too. A sink refusal here
-  // costs nothing; on Android the equivalent refusal can only be discovered after
-  // the raster exists, which is why that code has a heap path it falls into
-  // afterwards.
-  id<PdfCanvasPixelSink> destination = sink;
-  void *bytes = destination == nil
-                    ? NULL
-                    : [destination pdfCanvasReserveBytes:byteCount];
-  if (bytes == NULL) {
-    destination = [[PdfCanvasHeapSink alloc] init];
-    bytes = [destination pdfCanvasReserveBytes:byteCount];
-  }
-  if (bytes == NULL) {
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeOutOfMemory,
-        [NSString stringWithFormat:
-                      @"Could not allocate %lu bytes for a %ldx%ld raster.",
-                      (unsigned long)byteCount, (long)pxW, (long)pxH],
-        nil);
-  }
-
-  CGContextRef ctx = CGBitmapContextCreate(
-      bytes, (size_t)pxW, (size_t)pxH, 8, (size_t)rowBytes,
-      PdfCanvasColorSpace(), kPdfCanvasBitmapInfo);
-  if (ctx == NULL) {
-    [destination pdfCanvasAbandon];
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeBackendFailure,
-        [NSString stringWithFormat:
-                      @"CGBitmapContextCreate refused %ldx%ld at rowBytes %ld.",
-                      (long)pxW, (long)pxH, (long)rowBytes],
-        nil);
-  }
-
-  // THE FILL IS NOT OPTIONAL AND IT IS NOT DEFENSIVE. Neither engine clears the
-  // destination, and a zeroed RGBA buffer is transparent BLACK — which composites
-  // under the app's annotation layers as a black page, not a blank one. Ingest
-  // cannot repair it afterwards: it has no way to tell "the PDF painted black
-  // here" from "nothing painted here".
-  //
-  // `memset` rather than `CGContextFillRect`: 0xFF across the whole buffer is
-  // exactly opaque white in this configuration, it costs one pass with no CG
-  // state involved, and it covers any row padding a future alignment change might
-  // add. The transparent case needs nothing, because both sinks reserve zeroed
-  // memory — which is a documented part of the sink contract rather than luck.
-  if (request.background == PdfCanvasBackgroundWhite) {
-    memset(bytes, 0xFF, byteCount);
-  }
-
-  CGContextSetInterpolationQuality(ctx, kCGInterpolationHigh);
-  CGContextSetShouldAntialias(ctx, true);
-  // Explicitly OFF. Subpixel text positioning changes glyph rasterization in a
-  // way that depends on the destination's pixel grid, and every seam in this
-  // package is two rasters of the same geometry into differently-sized surfaces.
-  // Leaving it on would widen the sub-pixel disagreement the overlap rule already
-  // has to tolerate. It has no effect on a bitmap context on iOS in any case, so
-  // this is a statement of intent that costs nothing.
-  CGContextSetShouldSubpixelPositionFonts(ctx, false);
-  CGContextSetShouldSubpixelQuantizeFonts(ctx, false);
-
-  CGContextConcatCTM(
-      ctx, PdfCanvasDocToRasterTransform(request.docX, request.docY,
-                                         request.scale, pxH));
-
-  BOOL drawn = NO;
-  if (request.annotations) {
-    drawn = [self drawWithPdfKit:lease
-                        request:request
-                       geometry:geometry
-                        context:ctx
-                          error:error];
-  } else {
-    drawn = [self drawWithCoreGraphics:lease
-                              request:request
-                             geometry:geometry
-                              context:ctx
-                                error:error];
-  }
-  // FLUSHED BEFORE THE BYTES ARE READ BY ANYBODY. A bitmap context is documented
-  // to be safe to read after the drawing calls return, but a flush is what makes
-  // that true across an OS that may have deferred work, and it is free relative
-  // to the draw. It must happen before the context is released, not after.
-  CGContextFlush(ctx);
-  CGContextRelease(ctx);
-
-  if (!drawn) {
-    [destination pdfCanvasAbandon];
-    return nil;
-  }
-
-  // Post-check. This saves no drawing — the pixels above are already finished — it
-  // only stops a superseded raster being handed back and ingested into Skia, which
-  // is the expensive half on the JS side.
-  //
-  // THE ABANDON IS NOT OPTIONAL. A heap-backed raster would simply be collected,
-  // but a slot-backed one is about to be published to a process-wide map where
-  // nothing else will ever look for it. A superseded epoch produces a stream of
-  // these, so leaking here is megabytes per gesture. The check stays AFTER the
-  // draw rather than moving in front of it so the cancel window it covers does not
-  // shrink.
-  if (!PdfCanvasCheckCancelled(signal, @"after render", error)) {
-    [destination pdfCanvasAbandon];
-    return nil;
-  }
-
-  const int64_t slot = [destination pdfCanvasPublish];
-  NSData *heapBytes = [destination isKindOfClass:PdfCanvasHeapSink.class]
-                          ? ((PdfCanvasHeapSink *)destination).data
-                          : nil;
-  if (slot == 0 && heapBytes == nil) {
-    // A sink that reserved successfully, published no identifier, and is not the
-    // heap sink — so the raster exists and there is no way to reach it. Unreachable
-    // with the two sinks that exist, and named here anyway: without this the failure
-    // surfaces two layers up as "the native module returned neither `base64` nor
-    // `pixelsSlot`", which sends a reader looking at the bridge instead of at their
-    // sink.
-    [destination pdfCanvasAbandon];
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeBackendFailure,
-        @"A PdfCanvasPixelSink published slot 0 without being a PdfCanvasHeapSink, "
-        @"so the finished raster is unreachable. A sink must either return a "
-        @"non-zero identifier from pdfCanvasPublish or expose its bytes the way "
-        @"PdfCanvasHeapSink does.",
-        nil);
-  }
-  return [[PdfCanvasRasterPixels alloc] initWithSink:destination
-                                                slot:slot
-                                               bytes:heapBytes
-                                               width:pxW
-                                              height:pxH
-                                            rowBytes:rowBytes
-                                              format:PdfCanvasFormatRGBA8888];
-}
-
-/**
- * The tile path: content stream only, no annotations.
- *
- * `CGContextDrawPDFPage` applies NEITHER the crop box origin NOR `/Rotate`
- * (measured — see `PdfCanvasPageTransform.h`), so both are in the transform, and
- * the clip is what keeps content outside the crop box out of the raster. The clip
- * is applied AFTER the page transform, so its rect is in PDF user space.
- */
-- (BOOL)drawWithCoreGraphics:(PdfCanvasDocumentLease *)lease
-                     request:(PdfCanvasRasterRequest *)request
-                    geometry:(PdfCanvasPageGeometry *)geometry
-                     context:(CGContextRef)ctx
-                       error:(NSError *_Nullable *_Nullable)error {
-  CGPDFPageRef page =
-      CGPDFDocumentGetPage(lease.cgDocument, (size_t)(request.page + 1));
-  if (page == NULL) {
-    PdfCanvasFail(
-        error, PdfCanvasErrorCodeNotFound,
-        [NSString stringWithFormat:@"No page %ld in this document.",
-                                   (long)request.page],
-        nil);
-    return NO;
-  }
-  CGContextConcatCTM(
-      ctx, PdfCanvasPdfToDocTransform(geometry.cropBox,
-                                      geometry.rotationDegrees));
-  CGContextClipToRect(ctx, geometry.cropBox);
-  CGContextDrawPDFPage(ctx, page);
-  return YES;
-}
-
-/**
- * The annotation path: PDFKit, which composites appearance streams.
- *
- * NOTHING HERE ROTATES ANYTHING. PDFKit applies `/Rotate` and normalises the box
- * origin itself, so the only transform is a y-flip — and it must be through the
- * POST-ROTATION height, which is `geometry.heightPoints` and emphatically not
- * `-[PDFPage boundsForBox:].size.height`. That method does not apply `/Rotate`
- * while `drawWithBox:` does, and flipping by the wrong one draws the page rotated,
- * off-centre and clipped with no error anywhere. See `PdfCanvasPageTransform.h`.
- *
- * NO CLIP. PDFKit draws the box it is given and nothing outside it, so the clip
- * the CoreGraphics path needs would be redundant here — and a clip in the wrong
- * space (this one is doc space, not PDF user space) would silently cut the page.
- */
-- (BOOL)drawWithPdfKit:(PdfCanvasDocumentLease *)lease
-               request:(PdfCanvasRasterRequest *)request
-              geometry:(PdfCanvasPageGeometry *)geometry
-               context:(CGContextRef)ctx
-                 error:(NSError *_Nullable *_Nullable)error {
-  PDFDocument *document = [lease pdfKitDocumentWithError:error];
-  if (document == nil) {
-    return NO;
-  }
-  PDFPage *page = [document pageAtIndex:(NSUInteger)request.page];
-  if (page == nil) {
-    PdfCanvasFail(
-        error, PdfCanvasErrorCodeNotFound,
-        [NSString stringWithFormat:@"PDFKit has no page %ld in this document.",
-                                   (long)request.page],
-        nil);
-    return NO;
-  }
-  CGContextConcatCTM(
-      ctx, PdfCanvasDocToPdfKitTransform(geometry.heightPoints));
-  [page drawWithBox:kPDFDisplayBoxCropBox toContext:ctx];
-  return YES;
-}
-
-/* ---------------------------------------------------------------- *
- * Teardown
- * ---------------------------------------------------------------- */
-
-- (void)close {
-  if (_closed) {
-    return;
-  }
-  _closed = YES;
-  [_pool close];
-}
-
-@end
-
-/* ------------------------------------------------------------------ *
- * The crop box
- * ------------------------------------------------------------------ */
-
-CGRect PdfCanvasEffectiveCropBox(CGPDFPageRef page) {
-  const CGRect media = CGPDFPageGetBoxRect(page, kCGPDFMediaBox);
-  const CGRect crop = CGPDFPageGetBoxRect(page, kCGPDFCropBox);
-  // INTERSECTED, per the PDF spec: "the crop box shall be intersected with the
-  // media box". CoreGraphics returns the media box when there is no crop box, so
-  // the common case is a no-op, and it does NOT do the intersection itself — a
-  // file whose crop box overhangs its media box would otherwise produce a page
-  // larger than the paper, and every rect the layout function derives from it
-  // would be wrong by the overhang.
-  //
-  // A degenerate result falls back to the media box rather than to an empty rect:
-  // a zero-area page would make `fitScale` produce a non-finite number and the
-  // planner would emit nothing at all, which presents as a blank document with no
-  // error. CGRectIntersection returns CGRectNull for non-overlapping rects, and
-  // CGRectNull's width and height are 0.
-  const CGRect intersected = CGRectIntersection(media, crop);
-  if (CGRectIsNull(intersected) || CGRectIsEmpty(intersected)) {
-    return media;
-  }
-  return intersected;
-}

package/ios/Sources/PdfCanvasCore/include/PdfCanvasCancellation.h

@@ -1,48 +0,0 @@
-#import <Foundation/Foundation.h>
-
-#import "PdfCanvasErrorCode.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * Best-effort cancellation, and the emphasis is on BEST-EFFORT.
- *
- * `CGContextDrawPDFPage` and `-[PDFPage drawWithBox:toContext:]` are synchronous
- * and uninterruptible once entered. There is no cancel token, no progress
- * callback, and no safe way to kill the thread — CoreGraphics is mid-way through
- * writing into a buffer this process owns, and on the fast transport that buffer
- * is about to become a JS `ArrayBuffer`. So this class cannot stop a render; it
- * can only stop the NEXT one starting, which is exactly the shape the TS contract
- * already assumes for this platform — `RasterPolicy.minEpochIntervalMs` names
- * PDFKit in its own doc comment as the reason it exists.
- *
- * Concretely, a cancel is observed at four points and no others: on entry, after
- * the pool lease (the wait can be long when every document is busy), immediately
- * before the draw, and immediately after it. The last one does not save any work —
- * the pixels are already drawn — it only stops a superseded raster being handed
- * back and ingested into Skia, and it is the one that must release the slot.
- *
- * `_Atomic(bool)` rather than a lock: it is written by the JS thread through
- * `cancel(handle, token)` and read by a render worker, and there is nothing to
- * order it against. C11 atomics are available in a plain `.m` file, which keeps
- * `PdfCanvasCore` free of C++ and therefore importable from Swift.
- */
-@interface PdfCanvasCancellation : NSObject
-
-- (void)cancel;
-@property(nonatomic, readonly, getter=isCancelled) BOOL cancelled;
-
-@end
-
-/**
- * Returns NO and fills `error` with a `cancelled` code when the signal is set.
- *
- * @param stage named in the message so a cancellation reported from the
- *     post-render check is distinguishable from one that saved real work.
- */
-FOUNDATION_EXPORT BOOL PdfCanvasCheckCancelled(
-    PdfCanvasCancellation *_Nullable signal,
-    NSString *stage,
-    NSError *_Nullable *_Nullable error);
-
-NS_ASSUME_NONNULL_END

package/ios/Sources/PdfCanvasCore/include/PdfCanvasCore.h

@@ -1,26 +0,0 @@
-/**
- * The umbrella header for `PdfCanvasCore` — the React-free iOS rasterizer.
- *
- * It exists so that both build systems land on the same module: SwiftPM prefers
- * `include/<TargetName>.h` as a target's umbrella header when it is present (and
- * would otherwise synthesise an umbrella DIRECTORY module, whose contents depend
- * on the file listing), and CocoaPods needs a modulemap to make
- * `import PdfCanvasCore` work from Swift at all. One hand-written list is
- * deterministic; two generated ones are not.
- *
- * NOTHING HERE IMPORTS UIKit, JSI, OR REACT NATIVE, and that is enforced by the
- * fact that `ios/Package.swift` builds this target for macOS so `swift test` can
- * run it on a laptop. A UIKit import would break that build immediately, which is
- * the failure mode worth having.
- */
-
-#import "PdfCanvasCancellation.h"
-#import "PdfCanvasDocumentPool.h"
-#import "PdfCanvasErrorCode.h"
-#import "PdfCanvasPageGeometry.h"
-#import "PdfCanvasPageTransform.h"
-#import "PdfCanvasPixelSink.h"
-#import "PdfCanvasPreflight.h"
-#import "PdfCanvasRasterPixels.h"
-#import "PdfCanvasRasterRequest.h"
-#import "PdfCanvasRasterizer.h"