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

package/dist/rasterizer/fake.js

@@ -0,0 +1,433 @@
+/**
+ * A deterministic PageRasterizer with no Skia, no native module and no PDF.
+ *
+ * It exists to drive the entire pipeline — planner, cadence, epoch swap, cache
+ * — in vitest and in a demo app, and to be the fixture that CATCHES
+ * REGISTRATION BUGS. The pattern is chosen for that second job:
+ *
+ *   - the checkerboard's cell size is in DOC units, not pixels, so two
+ *     correctly-placed pieces show one continuous board across their overlap
+ *     and a piece drawn at the wrong doc rect (or squashed by a src-rect
+ *     mistake) shows an obvious seam;
+ *   - the board is INFINITE in doc space and is not clipped to the page box, so
+ *     a detail piece that overflows the page edge still shows continuous
+ *     checks and an accidental clip is visible as a blank margin;
+ *   - each piece carries a 1px border, so a piece that has been inset or
+ *     stretched shows its border in the wrong place;
+ *   - each piece encodes its own doc rect into a corner swatch, so a test can
+ *     read back what a raster BELIEVES it is without any Skia in the loop.
+ *
+ * Everything here is a pure function of the request, so the same request always
+ * produces byte-identical output.
+ */
+import { PdfError } from '../types.js';
+/* ------------------------------------------------------------------ *
+ * Page sizes, in PDF points (1pt = 1/72in)
+ * ------------------------------------------------------------------ */
+export const LETTER = Object.freeze({ width: 612, height: 792 });
+/** ARCH D, 24x36in — the sheet the base-raster sizing rule is calibrated on. */
+export const ARCH_D = Object.freeze({ width: 1728, height: 2592 });
+/** ARCH E, 36x48in. */
+export const ARCH_E = Object.freeze({ width: 2592, height: 3456 });
+const DEFAULT_CHECKER_DOC_SIZE = 32;
+const DEFAULT_MAX_PIXELS = 64000000;
+function resolveConfig(options) {
+    const sizes = options.pageSizes && options.pageSizes.length > 0
+        ? options.pageSizes
+        : [LETTER];
+    const rotations = options.pageRotations && options.pageRotations.length > 0
+        ? options.pageRotations
+        : [0];
+    const pageCount = options.pageCount ?? options.pageSizes?.length ?? 3;
+    const pages = [];
+    for (let index = 0; index < pageCount; index++) {
+        // Both arrays are non-empty by construction above; the `??` only satisfies
+        // noUncheckedIndexedAccess.
+        const size = sizes[index % sizes.length] ?? LETTER;
+        const rotation = rotations[index % rotations.length] ?? 0;
+        pages.push({
+            index,
+            width: size.width,
+            height: size.height,
+            rotation,
+        });
+    }
+    return {
+        id: options.id ?? 'fake',
+        pages,
+        checkerDocSize: options.checkerDocSize ?? DEFAULT_CHECKER_DOC_SIZE,
+        format: options.format ?? 'rgba8888',
+        latencyMs: options.latencyMs ?? 0,
+        password: options.password,
+        fail: options.fail ?? {},
+        maxPixels: options.maxPixels ?? DEFAULT_MAX_PIXELS,
+        maxConcurrentRenders: Math.max(1, Math.floor(options.maxConcurrentRenders ?? 1) || 1),
+    };
+}
+/* ------------------------------------------------------------------ *
+ * Pixel geometry
+ * ------------------------------------------------------------------ */
+const BYTES_PER_PIXEL = 4;
+/**
+ * READ OFF THE PIXEL LOOP, NOT ASSUMED — and unfalsifiable by this fake's own
+ * tests, which is the honest thing to say about it.
+ *
+ * `writePixel` takes r, g, b and a as independent arguments and stores all four
+ * verbatim; nothing here ever scales a colour channel by an alpha. That is
+ * `'straight'` by construction, so that is what it declares.
+ *
+ * BUT: every `writePixel` call site below passes `a = 255`, and so does
+ * `encodeSwatchValue`. The only alpha the fake ever emits besides 255 is the ZERO
+ * of the untouched buffer under `background: 'transparent'`, and there the colour
+ * channels are zero too. Both `[r, g, b, 255]` and `[0, 0, 0, 0]` are byte-
+ * identical under the two encodings, so NO test driven by this fake can tell a
+ * wrong declaration here from a right one. The claim is made from the source, and
+ * the discriminating pixel evidence lives in `composition.test.ts`, whose
+ * fixtures build genuine partial alpha on purpose.
+ *
+ * If the fake is ever given antialiased edges or a translucent watermark, this
+ * becomes a real, checkable claim — and `'straight'` will still be the correct
+ * answer as long as `writePixel` keeps storing what it is handed.
+ */
+const FAKE_ALPHA = 'straight';
+/**
+ * The pixel size the fake renders a request at.
+ *
+ * Exported because RasterRequest carries no PixelSize — a backend derives it —
+ * and a test that wants to index into the output needs the same arithmetic.
+ * Rounding (rather than ceiling) keeps the raster closest to the nominal
+ * scale; either is safe, because `PdfRaster.docRect` is the request's doc rect
+ * regardless and `fit="fill"` absorbs the sub-pixel difference.
+ */
+export const fakePixelSize = (request) => ({
+    width: Math.max(1, Math.round(request.docRect.width * request.scale)),
+    height: Math.max(1, Math.round(request.docRect.height * request.scale)),
+});
+/* ------------------------------------------------------------------ *
+ * Colour
+ * ------------------------------------------------------------------ */
+function hsvToRgb(h, s, v) {
+    const c = v * s;
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = v - c;
+    let r = c;
+    let g = 0;
+    let b = 0;
+    switch (Math.floor(h / 60) % 6) {
+        case 0:
+            g = x;
+            break;
+        case 1:
+            r = x;
+            g = c;
+            break;
+        case 2:
+            r = 0;
+            g = c;
+            b = x;
+            break;
+        case 3:
+            r = 0;
+            g = x;
+            b = c;
+            break;
+        case 4:
+            r = x;
+            b = c;
+            break;
+        default:
+            b = x;
+            break;
+    }
+    return [
+        Math.round((r + m) * 255),
+        Math.round((g + m) * 255),
+        Math.round((b + m) * 255),
+    ];
+}
+/**
+ * A distinct flat colour per page. Golden-angle hue rotation puts consecutive
+ * pages maximally far apart in hue, so page 4 is never mistaken for page 5 in a
+ * screenshot of a scrolling document.
+ */
+export function fakePageColor(page) {
+    const hue = (((page * 137.508) % 360) + 360) % 360;
+    return hsvToRgb(hue, 0.82, 0.86);
+}
+const mix = (a, b, t) => Math.round(a + (b - a) * t);
+function writePixel(out, offset, r, g, b, a, format) {
+    if (format === 'bgra8888') {
+        out[offset] = b;
+        out[offset + 2] = r;
+    }
+    else {
+        out[offset] = r;
+        out[offset + 2] = b;
+    }
+    out[offset + 1] = g;
+    out[offset + 3] = a;
+}
+/* ------------------------------------------------------------------ *
+ * The corner swatch
+ * ------------------------------------------------------------------ */
+/**
+ * The swatch is RAW BYTES, not a colour: four pixels, each carrying one doc
+ * rect component as a 24-bit fixed-point value in channels 0..2 with channel 3
+ * held at 255. Because it is written without the format swizzle, the decoder is
+ * format-independent — it reads back the same numbers from an RGBA and a BGRA
+ * raster.
+ */
+const SWATCH_FIXED_POINT = 16;
+/** Bias so negative doc coordinates survive (±524288pt of range). */
+const SWATCH_BIAS = 0x800000;
+const SWATCH_ORIGIN_X = 1;
+const SWATCH_ROW = 1;
+const SWATCH_PIXELS = 4;
+/** Smallest raster that has room for the swatch inside its border. */
+const SWATCH_MIN_WIDTH = SWATCH_ORIGIN_X + SWATCH_PIXELS + 1;
+const SWATCH_MIN_HEIGHT = SWATCH_ROW + 2;
+function encodeSwatchValue(out, offset, value) {
+    const raw = Math.round(value * SWATCH_FIXED_POINT) + SWATCH_BIAS;
+    const clamped = Math.max(0, Math.min(0xffffff, raw));
+    out[offset] = (clamped >> 16) & 0xff;
+    out[offset + 1] = (clamped >> 8) & 0xff;
+    out[offset + 2] = clamped & 0xff;
+    out[offset + 3] = 255;
+}
+function encodeSwatch(out, rowBytes, width, height, docRect) {
+    if (width < SWATCH_MIN_WIDTH || height < SWATCH_MIN_HEIGHT) {
+        return;
+    }
+    const base = SWATCH_ROW * rowBytes + SWATCH_ORIGIN_X * BYTES_PER_PIXEL;
+    encodeSwatchValue(out, base, docRect.x);
+    encodeSwatchValue(out, base + BYTES_PER_PIXEL, docRect.y);
+    encodeSwatchValue(out, base + BYTES_PER_PIXEL * 2, docRect.width);
+    encodeSwatchValue(out, base + BYTES_PER_PIXEL * 3, docRect.height);
+}
+/**
+ * Read the doc rect a fake raster believes it covers, or null when the raster
+ * was too small to carry a swatch.
+ */
+export function decodeFakeDocRect(pixels) {
+    const { bytes, width, height, rowBytes } = pixels;
+    if (width < SWATCH_MIN_WIDTH || height < SWATCH_MIN_HEIGHT) {
+        return null;
+    }
+    const base = SWATCH_ROW * rowBytes + SWATCH_ORIGIN_X * BYTES_PER_PIXEL;
+    const read = (component) => {
+        const o = base + component * BYTES_PER_PIXEL;
+        // In range by the size guard above; `?? 0` satisfies
+        // noUncheckedIndexedAccess on TypedArray indexing.
+        const raw = ((bytes[o] ?? 0) << 16) |
+            ((bytes[o + 1] ?? 0) << 8) |
+            (bytes[o + 2] ?? 0);
+        return (raw - SWATCH_BIAS) / SWATCH_FIXED_POINT;
+    };
+    return {
+        x: read(0),
+        y: read(1),
+        width: read(2),
+        height: read(3),
+    };
+}
+/* ------------------------------------------------------------------ *
+ * Rendering
+ * ------------------------------------------------------------------ */
+function renderPixels(request, cfg) {
+    const { docRect, scale, page, background } = request;
+    const { width, height } = fakePixelSize(request);
+    if (width * height > cfg.maxPixels) {
+        throw new PdfError('out-of-memory', `Fake rasterizer refused a ${width}x${height} raster ` +
+            `(${width * height} pixels > maxPixels ${cfg.maxPixels}).`);
+    }
+    const rowBytes = width * BYTES_PER_PIXEL;
+    const bytes = new Uint8Array(rowBytes * height);
+    const [r, g, b] = fakePageColor(page);
+    // The pre-fill is load-bearing, and it is the same rule every real backend
+    // owes: nothing clears the buffer, and un-painted RGBA is transparent black.
+    // 'white' fills with a pale tint of the page colour (still page-identifying,
+    // still clearly "paper"); 'transparent' leaves the zeros, which is what
+    // makes a missing fill visible as black when the raster is composited.
+    if (background === 'white') {
+        const tintR = mix(r, 255, 0.85);
+        const tintG = mix(g, 255, 0.85);
+        const tintB = mix(b, 255, 0.85);
+        for (let o = 0; o < bytes.length; o += BYTES_PER_PIXEL) {
+            writePixel(bytes, o, tintR, tintG, tintB, 255, cfg.format);
+        }
+    }
+    // Dark checker cells, in DOC space. Pixel CENTRES are converted to doc
+    // coordinates — a corner-based conversion puts the sample exactly on a cell
+    // boundary whenever the piece origin happens to align with one, and the
+    // parity then flips on a floating-point tie.
+    const cell = cfg.checkerDocSize;
+    for (let py = 0; py < height; py++) {
+        const docY = docRect.y + (py + 0.5) / scale;
+        const cellY = Math.floor(docY / cell);
+        let offset = py * rowBytes;
+        for (let px = 0; px < width; px++, offset += BYTES_PER_PIXEL) {
+            const docX = docRect.x + (px + 0.5) / scale;
+            const cellX = Math.floor(docX / cell);
+            if (((cellX + cellY) & 1) === 1) {
+                writePixel(bytes, offset, r, g, b, 255, cfg.format);
+            }
+        }
+    }
+    // 1px border, opaque black on every background.
+    if (width >= 2 && height >= 2) {
+        const lastRow = (height - 1) * rowBytes;
+        for (let px = 0; px < width; px++) {
+            const o = px * BYTES_PER_PIXEL;
+            writePixel(bytes, o, 0, 0, 0, 255, cfg.format);
+            writePixel(bytes, lastRow + o, 0, 0, 0, 255, cfg.format);
+        }
+        const lastCol = (width - 1) * BYTES_PER_PIXEL;
+        for (let py = 0; py < height; py++) {
+            const row = py * rowBytes;
+            writePixel(bytes, row, 0, 0, 0, 255, cfg.format);
+            writePixel(bytes, row + lastCol, 0, 0, 0, 255, cfg.format);
+        }
+    }
+    encodeSwatch(bytes, rowBytes, width, height, docRect);
+    return {
+        bytes,
+        width,
+        height,
+        rowBytes,
+        format: cfg.format,
+        alpha: FAKE_ALPHA,
+    };
+}
+/* ------------------------------------------------------------------ *
+ * Cancellation
+ * ------------------------------------------------------------------ */
+/**
+ * `signal.reason`, IF THIS PLATFORM HAS IT — and React Native does not.
+ *
+ * `reason` is spec'd on AbortSignal and present on web and under node, but React
+ * Native polyfills the whole class from `abort-controller@3.0.0`
+ * (`Libraries/Core/setUpXHR.js` registers
+ * `require('abort-controller/dist/abort-controller').AbortController` as the
+ * global). That polyfill predates the reason/throwIfAborted addition: its
+ * `abort()` takes no argument and its signal exposes only `aborted`, `onabort`
+ * and the two EventTarget methods. So on the package's primary target `reason`
+ * is `undefined` no matter what the caller aborted with.
+ *
+ * The runtime `in` check is therefore load-bearing rather than defensive, and it
+ * is what keeps this honest without a cast: TypeScript's unlisted-property `in`
+ * narrowing gives `signal.reason` the type `unknown`, which is exactly what
+ * `PdfError`'s `cause` accepts. Reading it straight through typechecked only
+ * because `@types/node` was in the tree and `react-native` was not — the RN
+ * types (`src/types/globals.d.ts`) declare the polyfill's real shape and reject
+ * it, which is how this gap surfaced.
+ */
+const abortReason = (signal) => 'reason' in signal ? signal.reason : undefined;
+const abortError = (signal) => new PdfError('cancelled', 'Fake rasterizer render was aborted.', {
+    cause: signal === undefined ? undefined : abortReason(signal),
+});
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw abortError(signal);
+    }
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(abortError(signal));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/* ------------------------------------------------------------------ *
+ * The rasterizer
+ * ------------------------------------------------------------------ */
+function renderFailure(cfg, request) {
+    const configured = cfg.fail.render;
+    if (!configured) {
+        return null;
+    }
+    return typeof configured === 'function' ? configured(request) : configured;
+}
+function checkPassword(cfg, source) {
+    if (cfg.password === undefined) {
+        return;
+    }
+    if (source.password === undefined) {
+        throw new PdfError('password-required', 'Fake document is protected.');
+    }
+    if (source.password !== cfg.password) {
+        throw new PdfError('password-incorrect', 'Fake document password rejected.');
+    }
+}
+function createHandle(cfg) {
+    let closed = false;
+    const requirePage = (page) => {
+        const geometry = cfg.pages[page];
+        if (!geometry) {
+            throw new PdfError('not-found', `Fake document has ${cfg.pages.length} pages; asked for ${page}.`);
+        }
+        return geometry;
+    };
+    const requireOpen = () => {
+        if (closed) {
+            throw new PdfError('backend-failure', 'Fake rasterizer handle is closed.');
+        }
+    };
+    return {
+        pageCount: cfg.pages.length,
+        pageGeometry: requirePage,
+        async render(request, signal) {
+            throwIfAborted(signal);
+            requireOpen();
+            requirePage(request.page);
+            if (cfg.latencyMs > 0) {
+                await delay(cfg.latencyMs, signal);
+            }
+            // Re-check after the await: a real backend that finished its synchronous
+            // draw during this window would still be expected to drop the result.
+            throwIfAborted(signal);
+            requireOpen();
+            const failure = renderFailure(cfg, request);
+            if (failure) {
+                throw new PdfError(failure, `Fake rasterizer failed page ${request.page} by configuration.`);
+            }
+            return renderPixels(request, cfg);
+        },
+        close() {
+            closed = true;
+        },
+    };
+}
+export function createFakeRasterizer(options = {}) {
+    const cfg = resolveConfig(options);
+    const capabilities = {
+        annotations: true,
+        // Honest: the pixel loop is synchronous and uninterruptible. The only
+        // window in which the signal can land is the artificial latency, so with no
+        // latency configured the fake is exactly as interruptible as PDFKit —
+        // which is to say, between requests only.
+        interruptibleRender: cfg.latencyMs > 0,
+        text: false,
+        search: false,
+        links: false,
+        maxConcurrentRenders: cfg.maxConcurrentRenders,
+    };
+    return {
+        id: cfg.id,
+        capabilities,
+        open(source) {
+            return new Promise(resolve => {
+                if (cfg.fail.open) {
+                    throw new PdfError(cfg.fail.open, `Fake rasterizer failed open() by configuration (${cfg.fail.open}).`);
+                }
+                checkPassword(cfg, source);
+                resolve(createHandle(cfg));
+            });
+        },
+    };
+}

package/dist/rasterizer/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Rasterizer pieces that are the same on every platform.
+ *
+ * `getDefaultRasterizer` is NOT here — it is the one thing that differs, and it
+ * lives in `./index.native.ts` and `./index.web.ts`. Those two files re-export
+ * everything below, so a platform entry point only ever imports one of them.
+ *
+ * Note that a relative import written with an explicit `.js` extension is
+ * resolved LITERALLY by Metro — its platform-extension search appends to the
+ * whole request string, so `./index.js` looks for `index.js.native.js` and then
+ * falls through to the real `index.js`. That is why the platform split is done
+ * by naming the file at the import site (and by the package's `exports`
+ * conditions at the root) rather than by trusting `./index.js` to resolve to
+ * `./index.native.js`. It is also why `export * from './index.js'` inside
+ * `index.native.ts` is not circular.
+ *
+ * The deterministic fake backend is deliberately NOT re-exported here: it is
+ * reachable only through the `./testing` subpath, so it never lands in an app
+ * bundle that merely imports the package.
+ *
+ * NEITHER IS THE INGEST SEAM, ANY MORE. `export * from './ingest.js'` used to
+ * sit here, which gave `ingestRaster` / `imageFromPixels` / `rasterByteLength`
+ * two public homes and made `./rasterizer` a Skia-touching subpath. They live on
+ * `./skia` now — a BREAKING move for anyone importing them from here, and the
+ * point of it is that "which subpath needs a Skia runtime" has one answer. What
+ * this subpath still is: the platform backend registry and the shared backend
+ * helpers, which touch no Skia at all.
+ */
+import type { PageRasterizer } from '../types.js';
+/**
+ * A PageRasterizer that exists only to fail informatively.
+ *
+ * The failure is deferred to `open()` on purpose. Throwing at import time would
+ * take the pure core, the Skia ingest path and the fake backend down with it,
+ * and all three are fully usable today — a host that injects its own
+ * `PageRasterizer` never touches this object at all.
+ */
+export declare function createMissingBackendRasterizer(id: string, missing: string): PageRasterizer;

package/dist/rasterizer/index.js

@@ -0,0 +1,69 @@
+/**
+ * Rasterizer pieces that are the same on every platform.
+ *
+ * `getDefaultRasterizer` is NOT here — it is the one thing that differs, and it
+ * lives in `./index.native.ts` and `./index.web.ts`. Those two files re-export
+ * everything below, so a platform entry point only ever imports one of them.
+ *
+ * Note that a relative import written with an explicit `.js` extension is
+ * resolved LITERALLY by Metro — its platform-extension search appends to the
+ * whole request string, so `./index.js` looks for `index.js.native.js` and then
+ * falls through to the real `index.js`. That is why the platform split is done
+ * by naming the file at the import site (and by the package's `exports`
+ * conditions at the root) rather than by trusting `./index.js` to resolve to
+ * `./index.native.js`. It is also why `export * from './index.js'` inside
+ * `index.native.ts` is not circular.
+ *
+ * The deterministic fake backend is deliberately NOT re-exported here: it is
+ * reachable only through the `./testing` subpath, so it never lands in an app
+ * bundle that merely imports the package.
+ *
+ * NEITHER IS THE INGEST SEAM, ANY MORE. `export * from './ingest.js'` used to
+ * sit here, which gave `ingestRaster` / `imageFromPixels` / `rasterByteLength`
+ * two public homes and made `./rasterizer` a Skia-touching subpath. They live on
+ * `./skia` now — a BREAKING move for anyone importing them from here, and the
+ * point of it is that "which subpath needs a Skia runtime" has one answer. What
+ * this subpath still is: the platform backend registry and the shared backend
+ * helpers, which touch no Skia at all.
+ */
+import { PdfError } from '../types.js';
+const NO_CAPABILITIES = {
+    annotations: false,
+    interruptibleRender: false,
+    text: false,
+    search: false,
+    links: false,
+    maxConcurrentRenders: 1,
+};
+/**
+ * A PageRasterizer that exists only to fail informatively.
+ *
+ * The failure is deferred to `open()` on purpose. Throwing at import time would
+ * take the pure core, the Skia ingest path and the fake backend down with it,
+ * and all three are fully usable today — a host that injects its own
+ * `PageRasterizer` never touches this object at all.
+ */
+export function createMissingBackendRasterizer(id, missing) {
+    const message = `${missing} @reekon-tools/react-native-pdf-canvas ships three things that ` +
+        'are known to work with no native module at all: the pure core, the Skia ' +
+        'ingest path and a deterministic fake backend. Both native backends exist ' +
+        'and are proven on device, so seeing this means the module is genuinely ' +
+        'absent from the build rather than unimplemented — on iOS check that ' +
+        '`PdfCanvas` is in ios/Podfile.lock and re-run `pod install`; on Android ' +
+        'check that autolinking registered `PdfCanvasPackage` (this package ships ' +
+        'the `packageImportPath` it needs, because the binding lives outside ' +
+        '`src/main`). The web rasterizer EXISTS but must be configured, because ' +
+        'how a worker is built and where `pdfium.wasm` lives are your bundler’s ' +
+        'business and not something this package can discover — see ' +
+        '`configureWebPdfium`. Otherwise pass a `rasterizer` explicitly — either ' +
+        'your own PageRasterizer, or `createFakeRasterizer()` from ' +
+        "'@reekon-tools/react-native-pdf-canvas/testing'. See README.md, " +
+        '"Backends".';
+    return {
+        id,
+        capabilities: NO_CAPABILITIES,
+        open() {
+            return Promise.reject(new PdfError('backend-failure', message));
+        },
+    };
+}

package/dist/rasterizer/index.native.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The native default rasterizer.
+ *
+ * BOTH PLATFORMS ARE WIRED. `createAndroidRasterizer` and `createIosRasterizer`
+ * are pure and injectable, and this file is the only place a real native module
+ * is resolved. On any build where the module is absent — a host that skipped
+ * autolinking, a platform neither branch knows — the self-describing placeholder
+ * is returned exactly as before, failing at `open()` rather than at import, so
+ * the pure core, the Skia ingest path and the fake backend all keep working.
+ *
+ * ONE NATIVE MODULE NAME FOR BOTH PLATFORMS (`PdfCanvas`), one wire format, and
+ * therefore one lookup. What differs is which adapter wraps it, because the
+ * capabilities and the alpha encoding differ — see `./native-bridge.ts`.
+ */
+import type { PageRasterizer } from '../types.js';
+export * from './index.js';
+export * from './android.js';
+export * from './ios.js';
+export declare const getDefaultRasterizer: () => PageRasterizer;

package/dist/rasterizer/index.native.js

@@ -0,0 +1,80 @@
+/**
+ * The native default rasterizer.
+ *
+ * BOTH PLATFORMS ARE WIRED. `createAndroidRasterizer` and `createIosRasterizer`
+ * are pure and injectable, and this file is the only place a real native module
+ * is resolved. On any build where the module is absent — a host that skipped
+ * autolinking, a platform neither branch knows — the self-describing placeholder
+ * is returned exactly as before, failing at `open()` rather than at import, so
+ * the pure core, the Skia ingest path and the fake backend all keep working.
+ *
+ * ONE NATIVE MODULE NAME FOR BOTH PLATFORMS (`PdfCanvas`), one wire format, and
+ * therefore one lookup. What differs is which adapter wraps it, because the
+ * capabilities and the alpha encoding differ — see `./native-bridge.ts`.
+ */
+import { createAndroidRasterizer } from './android.js';
+import { createIosRasterizer } from './ios.js';
+import { createMissingBackendRasterizer } from './index.js';
+export * from './index.js';
+export * from './android.js';
+export * from './ios.js';
+const MISSING = createMissingBackendRasterizer('missing-native', 'The PdfCanvas native module was not found. On iOS that means the pod is ' +
+    'not in the build (run `pod install` after adding the package, and check ' +
+    'that `PdfCanvas` appears in Podfile.lock); on Android it means ' +
+    'autolinking did not register PdfCanvasPackage.');
+/**
+ * `require`, not `import`, and wrapped in a try.
+ *
+ * A static `import` of `react-native` would make this module unloadable under
+ * vitest and in a browser bundle, taking the pure core down with it — the exact
+ * failure the placeholder exists to avoid. Metro resolves a `require` call
+ * statically, so the RN bundle is unaffected.
+ *
+ * `NativeModules` rather than `TurboModuleRegistry`: this module has no codegen
+ * spec, and `TurboModuleRegistry.get` returns null for a legacy module on the
+ * old architecture. `NativeModules` resolves under both, because the new
+ * architecture's interop layer backfills it — measured on Android inside a
+ * bridgeless RN 0.86 app where `global.__turboModuleProxy` was `undefined` and
+ * `NativeModules.PdfCanvas` still had every method.
+ */
+function loadNativeModule() {
+    try {
+        const rn = require('react-native');
+        const os = rn.Platform?.OS;
+        if (os !== 'android' && os !== 'ios')
+            return null;
+        const found = rn.NativeModules?.['PdfCanvas'];
+        if (!found)
+            return null;
+        return { os, module: found };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolved ONCE, at module scope.
+ *
+ * Stable reference on purpose — a rasterizer identity change is a reason to
+ * reopen a document, so the default must not be a fresh object per call.
+ *
+ * IT ALSO NEGOTIATES THE TRANSPORT, which is why "once" matters more than
+ * tidiness: `createNativeRasterizer` probes the JSI path at construction, and on
+ * iOS that probe is what installs `__pdfCanvasTakePixels` into this runtime. A
+ * fresh rasterizer per call would re-run the probe, and each run parks a slot.
+ *
+ * NAME COLLISION, deliberate and unresolved here: `react/usePdfDocument.ts`
+ * exports a registry accessor with this same name and a DIFFERENT meaning
+ * (`PageRasterizer | null`, whatever `setDefaultRasterizer` last installed).
+ * The root index must therefore not `export *` from this module. Do NOT wire
+ * the MISSING placeholder into that registry either: an empty registry produces
+ * "No PageRasterizer available", which is a better first error than a backend
+ * that opens and then always fails.
+ */
+const resolved = loadNativeModule();
+const DEFAULT = resolved === null
+    ? MISSING
+    : resolved.os === 'ios'
+        ? createIosRasterizer(resolved.module)
+        : createAndroidRasterizer(resolved.module);
+export const getDefaultRasterizer = () => DEFAULT;