@papyrus-sdk/ui-react-native 0.2.20 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papyrus-sdk/ui-react-native",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "license": "MIT",
   "keywords": [
     "papyrus",
@@ -39,7 +39,7 @@
     "url": "https://github.com/solrachix/Papyrus/issues"
   },
   "scripts": {
-    "build": "tsup"
+    "build": "node runtime/syncComicRuntime.mjs && tsup"
   },
   "dependencies": {
     "react-native-svg": "^15.5.0"

package/runtime/comicRuntime.js

@@ -0,0 +1,107 @@
+(function (root, factory) {
+  if (typeof module === "object" && module.exports) {
+    module.exports = factory();
+  } else {
+    root.PapyrusComicRuntime = Object.assign(
+      factory(),
+      root.PapyrusComicRuntime || {}
+    );
+  }
+})(typeof self === "object" ? self : this, function () {
+  var IMAGE_EXTENSIONS = /\.(?:gif|jpe?g|png|svg|webp)$/i;
+
+  function isComicImageName(name) {
+    return typeof name === "string" && IMAGE_EXTENSIONS.test(name);
+  }
+
+  function naturalCompare(left, right) {
+    var leftParts = String(left).split(/(\d+)/);
+    var rightParts = String(right).split(/(\d+)/);
+    var length = Math.max(leftParts.length, rightParts.length);
+
+    for (var index = 0; index < length; index += 1) {
+      var leftPart = leftParts[index] || "";
+      var rightPart = rightParts[index] || "";
+      if (leftPart === rightPart) continue;
+
+      var leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : null;
+      var rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : null;
+      if (leftNumber !== null && rightNumber !== null) {
+        return leftNumber - rightNumber;
+      }
+      return leftPart.localeCompare(rightPart, undefined, {
+        numeric: true,
+        sensitivity: "base",
+      });
+    }
+
+    return 0;
+  }
+
+  function sortComicPageNames(names) {
+    return names.slice().sort(naturalCompare);
+  }
+
+  function patchCbrWorkerSource(workerSource, wasmUrl) {
+    return workerSource.replace(
+      /new URL\("libarchive\.wasm",import\.meta\.url\)\.href/g,
+      JSON.stringify(wasmUrl)
+    );
+  }
+
+  function getComicPreviewSize(width, height, maxWidth, maxHeight) {
+    var safeWidth = Math.max(1, Number(width) || 1);
+    var safeHeight = Math.max(1, Number(height) || 1);
+    var widthLimit = maxWidth || 240;
+    var heightLimit = maxHeight || 360;
+    var scale = Math.min(1, widthLimit / safeWidth, heightLimit / safeHeight);
+    return {
+      width: Math.max(1, Math.round(safeWidth * scale)),
+      height: Math.max(1, Math.round(safeHeight * scale)),
+    };
+  }
+
+  function getComicPageAspectRatio(width, height) {
+    var safeWidth = Math.max(1, Number(width) || 1);
+    var safeHeight = Math.max(1, Number(height) || 1);
+    return safeWidth + " / " + safeHeight;
+  }
+
+  function getProtectedComicPageIndexes(
+    currentPage,
+    visiblePageIndexes,
+    loadingPageIndexes
+  ) {
+    var protectedIndexes = new Set([
+      currentPage - 1,
+      currentPage,
+      currentPage - 2,
+    ]);
+    (visiblePageIndexes || []).forEach(function (pageIndex) {
+      protectedIndexes.add(pageIndex);
+    });
+    (loadingPageIndexes || []).forEach(function (pageIndex) {
+      protectedIndexes.add(pageIndex);
+    });
+    return protectedIndexes;
+  }
+
+  function isCurrentComicPageLoad(
+    loadGeneration,
+    currentGeneration,
+    entry,
+    currentEntry
+  ) {
+    return loadGeneration === currentGeneration && entry === currentEntry;
+  }
+
+  return {
+    isComicImageName: isComicImageName,
+    sortComicPageNames: sortComicPageNames,
+    patchCbrWorkerSource: patchCbrWorkerSource,
+    getComicPreviewSize: getComicPreviewSize,
+    getComicPageAspectRatio: getComicPageAspectRatio,
+    getProtectedComicPageIndexes: getProtectedComicPageIndexes,
+    isCurrentComicPageLoad: isCurrentComicPageLoad,
+  };
+});

package/runtime/comicRuntime.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  getComicPreviewSize,
+  getComicPageAspectRatio,
+  getProtectedComicPageIndexes,
+  isCurrentComicPageLoad,
+  isComicImageName,
+  patchCbrWorkerSource,
+  sortComicPageNames,
+} from "./comicRuntime";
+
+describe("mobile comic runtime helpers", () => {
+  it("keeps only supported comic image entries", () => {
+    expect(isComicImageName("pages/001.jpg")).toBe(true);
+    expect(isComicImageName("pages/002.webp")).toBe(true);
+    expect(isComicImageName("pages/readme.txt")).toBe(false);
+    expect(isComicImageName("pages/")).toBe(false);
+  });
+
+  it("sorts page names naturally", () => {
+    expect(
+      sortComicPageNames(["page-10.jpg", "page-2.jpg", "page-1.jpg"])
+    ).toEqual(["page-1.jpg", "page-2.jpg", "page-10.jpg"]);
+  });
+
+  it("patches the shipped CBR worker to use the packaged WASM asset", () => {
+    const worker = readFileSync(
+      resolve(
+        process.cwd(),
+        "packages/engine-cbr-mobile/runtime/worker-bundle.js.txt"
+      ),
+      "utf8"
+    );
+
+    const patched = patchCbrWorkerSource(worker, "/assets/libarchive.wasm");
+
+    expect(patched).not.toContain(
+      'new URL("libarchive.wasm",import.meta.url).href'
+    );
+    expect(patched).toContain(JSON.stringify("/assets/libarchive.wasm"));
+  });
+
+  it("caps comic previews without upscaling them", () => {
+    expect(getComicPreviewSize(1600, 2400)).toEqual({ width: 240, height: 360 });
+    expect(getComicPreviewSize(120, 180)).toEqual({ width: 120, height: 180 });
+  });
+
+  it("keeps the page geometry when a cached image URL is evicted", () => {
+    expect(getComicPageAspectRatio(1200, 1800)).toBe("1200 / 1800");
+    expect(getComicPageAspectRatio(0, 0)).toBe("1 / 1");
+  });
+
+  it("protects visible and pending pages from URL eviction", () => {
+    expect(
+      Array.from(getProtectedComicPageIndexes(1, [3, 4], [5])).sort(
+        (left, right) => left - right
+      )
+    ).toEqual([-1, 0, 1, 3, 4, 5]);
+  });
+
+  it("rejects page extraction completions from an older document", () => {
+    const entry = { name: "old.jpg" };
+    const currentEntry = { name: "new.jpg" };
+
+    expect(isCurrentComicPageLoad(2, 3, entry, currentEntry)).toBe(false);
+    expect(isCurrentComicPageLoad(3, 3, entry, currentEntry)).toBe(false);
+    expect(isCurrentComicPageLoad(3, 3, entry, entry)).toBe(true);
+  });
+
+  it("embeds the tested helpers in the shipped runtimes", () => {
+    const runtime = readFileSync(
+      resolve(process.cwd(), "packages/ui-react-native/runtime/runtime.js"),
+      "utf8"
+    );
+    const html = readFileSync(
+      resolve(process.cwd(), "packages/ui-react-native/runtime/index.html"),
+      "utf8"
+    );
+
+    expect(runtime.match(/function getComicPageAspectRatio/g)).toHaveLength(1);
+    expect(html.match(/function getComicPageAspectRatio/g)).toHaveLength(1);
+    expect(html).toContain("root.PapyrusComicRuntime");
+    expect(runtime).toContain("getProtectedComicPageIndexes");
+    expect(html).toContain("getProtectedComicPageIndexes");
+    expect(runtime).toContain("file-chunk-request");
+    expect(html).toContain("file-chunk-request");
+  });
+});