@papyrus-sdk/ui-react-native 0.2.35-beta.9 → 0.2.36

package/runtime/syncComicRuntime.mjs

@@ -24,11 +24,13 @@ const runtimeBodyStart = runtime.indexOf("\n(function () {", runtime.indexOf(com
 if (runtimeBodyStart < 0) {
   throw new Error("Main runtime body not found");
 }
-const runtimeBody = runtime.slice(runtimeBodyStart + 1).trim();
+const readerSource=await readFile(resolve(runtimeDirectory,"epubReader.js"),"utf8");
+const readerRuntime=replaceMarkedSource(runtime,"/* @papyrus-epub-reader:start */","/* @papyrus-epub-reader:end */",`\n${readerSource}\n`);
+const runtimeBody = readerRuntime.slice(readerRuntime.indexOf("\n(function () {",readerRuntime.indexOf(comicRuntimeEnd))+1).trim();
 await writeFile(
   runtimePath,
   replaceMarkedSource(
-    runtime,
+    readerRuntime,
     "/* @papyrus-comic-runtime:start */",
     "/* @papyrus-comic-runtime:end */",
     `\n${source.trim()}\n`
@@ -37,12 +39,13 @@ await writeFile(
 
 const htmlPath = resolve(runtimeDirectory, "index.html");
 const html = await readFile(htmlPath, "utf8");
-const htmlWithComicRuntime = replaceMarkedSource(
+let htmlWithComicRuntime = replaceMarkedSource(
   html,
   "<!-- @papyrus-comic-runtime:start -->",
   "<!-- @papyrus-comic-runtime:end -->",
   `\n    <script>\n${source}\n    </script>\n`
 );
+htmlWithComicRuntime=htmlWithComicRuntime.replace(/<!-- @papyrus-epub-reader:start -->[\s\S]*?<!-- @papyrus-epub-reader:end -->\n?/g,"");
 const htmlComicRuntimeEnd = "<!-- @papyrus-comic-runtime:end -->";
 const htmlBodyStart = htmlWithComicRuntime.indexOf(
   "<script>",

package/runtime/comicRuntime.test.ts

@@ -1,241 +0,0 @@
-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");
-  });
-
-  it("loads local EPUB files through the native chunk bridge", () => {
-    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).toContain("sourceToArrayBuffer(source),");
-    expect(html).toContain("sourceToArrayBuffer(source),");
-    expect(runtime).not.toContain("data = source.uri;");
-    expect(html).not.toContain("data = source.uri;");
-  });
-
-  it("passes an exact ArrayBuffer to epub.js for base64 sources", () => {
-    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).toContain("const toExactArrayBuffer = (bytes) =>");
-    expect(html).toContain("const toExactArrayBuffer = (bytes) =>");
-    expect(runtime).toContain("data = toExactArrayBuffer(decodeBase64(source.data));");
-    expect(html).toContain("data = toExactArrayBuffer(decodeBase64(source.data));");
-  });
-
-  it("correlates EPUB diagnostics and load terminals by request id", () => {
-    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"
-    );
-    for (const artifact of [runtime, html]) {
-      expect(artifact).toContain("epub.load.start");
-      expect(artifact).toContain("epub.book.ready");
-      expect(artifact).toContain("epub.display.start");
-      expect(artifact).toContain("epub.load.ready");
-      expect(artifact).toContain("epub.load.error");
-      expect(artifact).toContain("epub.load.timeout");
-      expect(artifact).toContain("loadId");
-      expect(artifact).toContain("document.ready");
-      expect(artifact).toContain("document.error");
-      expect(artifact).toContain("withEpubStageTimeout");
-    }
-  });
-
-  it("invalidates a pending EPUB load when another document starts", () => {
-    const runtime = readFileSync(
-      resolve(process.cwd(), "packages/ui-react-native/runtime/runtime.js"),
-      "utf8"
-    );
-    const loadStart = runtime.indexOf("if (kind === 'load')");
-    const generationInvalidation = runtime.indexOf(
-      "epubLoadGeneration += 1",
-      loadStart
-    );
-    const currentTypeAssignment = runtime.indexOf(
-      "currentType = payload.type",
-      loadStart
-    );
-
-    expect(generationInvalidation).toBeGreaterThan(loadStart);
-    expect(generationInvalidation).toBeLessThan(currentTypeAssignment);
-    expect(runtime).toContain(
-      "const loadEpub = async (source, loadId, generation) =>"
-    );
-    expect(runtime).toContain(
-      "const result = await loadEpub(payload.source, id, generation);"
-    );
-  });
-
-  it("rejects a stale EPUB load after outline resolution", () => {
-    const runtime = readFileSync(
-      resolve(process.cwd(), "packages/ui-react-native/runtime/runtime.js"),
-      "utf8"
-    );
-    const outlineStart = runtime.indexOf("const outline = await withEpubStageTimeout(");
-    const outlineGuard = runtime.indexOf(
-      "if (!isCurrentLoad()) throw new Error('EPUB load superseded by a newer load');",
-      outlineStart
-    );
-    const readyEvent = runtime.indexOf(
-      "sendEpubDiagnostic('epub.load.ready'",
-      outlineStart
-    );
-
-    expect(outlineStart).toBeGreaterThan(-1);
-    expect(outlineGuard).toBeGreaterThan(outlineStart);
-    expect(outlineGuard).toBeLessThan(readyEvent);
-  });
-
-  it("uses continuous scrolling for EPUB rendition", () => {
-    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).toContain("manager: 'continuous'");
-    expect(html).toContain("manager: 'continuous'");
-    expect(runtime).toContain("flow: 'scrolled-continuous'");
-    expect(html).toContain("flow: 'scrolled-continuous'");
-    expect(runtime).toContain("rendition.on('relocated'");
-    expect(html).toContain("rendition.on('relocated'");
-    expect(runtime).toContain("sendEvent('VIEWER_SCROLL'");
-    expect(html).toContain("sendEvent('VIEWER_SCROLL'");
-    expect(runtime).toContain("sendEvent('VIEWER_TAP'");
-    expect(html).toContain("sendEvent('VIEWER_TAP'");
-    expect(runtime).not.toContain("flow: 'paginated'");
-    expect(html).not.toContain("flow: 'paginated'");
-  });
-
-  it("observes the real EPUB manager queue without changing queue semantics", () => {
-    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"
-    );
-
-    for (const artifact of [runtime, html]) {
-      expect(artifact).toContain("const originalCheck = typeof manager.check");
-      expect(artifact).toContain("manager.check = function (...args)");
-      expect(artifact).toContain("const originalEnqueue = queue && typeof queue.enqueue");
-      expect(artifact).toContain("queue.enqueue = function (...args)");
-      expect(artifact).toContain("manager.queue.enqueue");
-      expect(artifact).toContain("queue.enqueue = originalEnqueue");
-      expect(artifact).toContain("manager.check.request");
-      expect(artifact).toContain("manager.check.start");
-      expect(artifact).toContain("manager.check.end");
-      expect(artifact).toContain("epubSelectionCleanups");
-      expect(artifact).toContain("__papyrusSelectionCleanup");
-      expect(artifact).toContain("setSelectionActive(false)");
-      expect(artifact).not.toContain("String(task)");
-    }
-  });
-});

package/runtime/documentLoadRuntime.test.ts

@@ -1,172 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { JSDOM } from "jsdom";
-import { describe, expect, it, vi } from "vitest";
-
-type RuntimeMessage = {
-  type?: string;
-  id?: string;
-  name?: string;
-  kind?: string;
-  ok?: boolean;
-  data?: { pageCount?: number };
-  error?: { message?: string } | string;
-  loadId?: string;
-};
-
-const runtimeSource = readFileSync(
-  resolve(process.cwd(), "packages/ui-react-native/runtime/runtime.js"),
-  "utf8",
-);
-
-const createRuntime = () => {
-  const messages: RuntimeMessage[] = [];
-  const dom = new JSDOM(
-    '<!doctype html><html><body><div id="viewer"></div></body></html>',
-    { runScripts: "outside-only", url: "http://localhost/" },
-  );
-  dom.window.ReactNativeWebView = {
-    postMessage: (raw: string) => messages.push(JSON.parse(raw)),
-  } as never;
-  dom.window.eval(runtimeSource);
-
-  const send = (message: Record<string, unknown>) => {
-    dom.window.dispatchEvent(
-      new dom.window.MessageEvent("message", { data: JSON.stringify(message) }),
-    );
-  };
-
-  return { dom, messages, send };
-};
-
-const waitFor = async (
-  predicate: () => boolean,
-  timeoutMs = 1000,
-): Promise<void> => {
-  const deadline = Date.now() + timeoutMs;
-  while (!predicate()) {
-    if (Date.now() >= deadline) throw new Error("runtime message timeout");
-    await new Promise((resolve) => setTimeout(resolve, 0));
-  }
-};
-
-describe("document loading runtime", () => {
-  it("publishes an empty TXT document as a completed one-page load", async () => {
-    const runtime = createRuntime();
-
-    runtime.send({
-      id: "empty-1",
-      kind: "load",
-      payload: { type: "text", source: { kind: "text", text: "" } },
-    });
-    await waitFor(() =>
-      runtime.messages.some(
-        (message) => message.type === "response" && message.id === "empty-1",
-      ),
-    );
-
-    expect(runtime.messages).toContainEqual({
-      type: "event",
-      name: "document.ready",
-      payload: { loadId: "empty-1", pageCount: 1 },
-    });
-    expect(runtime.messages).toContainEqual(
-      expect.objectContaining({ type: "response", id: "empty-1", ok: true }),
-    );
-  });
-
-  it("reports an invalid TXT source instead of leaving loading pending", async () => {
-    const runtime = createRuntime();
-
-    runtime.send({
-      id: "invalid-1",
-      kind: "load",
-      payload: { type: "text", source: null },
-    });
-    await waitFor(() =>
-      runtime.messages.some(
-        (message) => message.type === "response" && message.id === "invalid-1",
-      ),
-    );
-
-    expect(runtime.messages).toContainEqual(
-      expect.objectContaining({
-        type: "event",
-        name: "document.error",
-        payload: expect.objectContaining({ loadId: "invalid-1" }),
-      }),
-    );
-    expect(runtime.messages).toContainEqual(
-      expect.objectContaining({ type: "response", id: "invalid-1", ok: false }),
-    );
-  });
-
-  it("marks a pending TXT load stale when another format starts", async () => {
-    const runtime = createRuntime();
-    let resolveText: ((value: string) => void) | undefined;
-    const fetchText = vi.fn(
-      () =>
-        new Promise<string>((resolve) => {
-          resolveText = resolve;
-        }),
-    );
-    runtime.dom.window.fetch = vi.fn(async () => ({
-      text: fetchText,
-    })) as never;
-
-    runtime.send({
-      id: "text-a",
-      kind: "load",
-      payload: {
-        type: "text",
-        source: { kind: "uri", uri: "http://localhost/a.txt" },
-      },
-    });
-    await waitFor(() => fetchText.mock.calls.length === 1);
-
-    runtime.send({
-      id: "new-document-b",
-      kind: "load",
-      payload: {
-        type: "text",
-        source: { kind: "text", text: "new document" },
-      },
-    });
-    await waitFor(() =>
-      runtime.messages.some(
-        (message) => message.type === "response" && message.id === "new-document-b",
-      ),
-    );
-
-    resolveText?.("old document");
-    await waitFor(() =>
-      runtime.messages.some(
-        (message) => message.type === "response" && message.id === "text-a",
-      ),
-    );
-
-    expect(runtime.messages).toContainEqual({
-      type: "event",
-      name: "document.ready",
-      payload: { loadId: "new-document-b", pageCount: 1 },
-    });
-    expect(runtime.messages).toContainEqual(
-      expect.objectContaining({
-        type: "event",
-        name: "document.stale",
-        payload: expect.objectContaining({ loadId: "text-a" }),
-      }),
-    );
-    expect(runtime.messages).toContainEqual(
-      expect.objectContaining({ type: "response", id: "new-document-b", ok: true }),
-    );
-    expect(runtime.messages).toContainEqual(
-      expect.objectContaining({ type: "response", id: "text-a", ok: false }),
-    );
-    expect(
-      runtime.messages.filter(
-        (message) => message.type === "event" && message.name === "document.ready",
-      ),
-    ).toHaveLength(1);
-  });
-});

package/runtime/epubAnnotations.test.ts

@@ -1,31 +0,0 @@
-import {createRequire} from 'node:module';
-import {describe,it,expect} from 'vitest';
-const annotations = createRequire(import.meta.url)('./epubAnnotations.js');
-const anchor = {version:1,kind:'epub-cfi',cfiRange:'epubcfi(/6/2!/4/2:0)',href:'chapter.xhtml',quote:'word'};
-describe('EPUB contextual anchors',()=>{
- it('rejects malformed CFI and unsafe hrefs',()=>{expect(annotations.validAnchor(anchor)).toBe(true);expect(annotations.validAnchor({...anchor,cfiRange:'bad'})).toBe(false);expect(annotations.validAnchor({...anchor,href:'javascript:alert(1)'})).toBe(false);});
- it('recovers uniquely in chapter text preserving UTF16 and excludes overlays',()=>{document.body.innerHTML='<p>A 😀 word end</p><div data-papyrus-overlay>word</div>';expect(annotations.recoverRange(document,anchor)?.toString()).toBe('word');});
- it('leaves ambiguous quotes unresolved unless context distinguishes them',()=>{document.body.innerHTML='<p>one word two word end</p>';expect(annotations.recoverRange(document,anchor)).toBeNull();expect(annotations.recoverRange(document,{...anchor,prefix:'two '})?.toString()).toBe('word');});
- it('verifies exact CFI quote before controlled recovery',()=>{document.body.innerHTML='<p>other word</p>';const bad=document.createRange();bad.selectNodeContents(document.body);expect(annotations.resolveRange({document,range:()=>bad},anchor)?.toString()).toBe('word');});
-});
-
-it('renders true strikeout, grouped notes and reconciles 120 stable IDs after reflow',()=>{
- document.body.innerHTML='<p>word</p>';
- const range=document.createRange();range.selectNodeContents(document.querySelector('p')!);
- let top=20;Object.defineProperty(range,'getClientRects',{value:()=>[{left:10,right:50,top,bottom:top+20,width:40,height:20}]});
- let queue:FrameRequestCallback[]=[];
- const originalRAF=window.requestAnimationFrame;window.requestAnimationFrame=cb=>{queue.push(cb);return queue.length;};
- let snapshot=Array.from({length:120},(_,i)=>({id:`n${i}`,anchor,color:'#ff0000',markupStyle:'strikeout',noteContent:`note ${i}`}));
- const taps:string[]=[];
- const renderer=annotations.install({document,window,range:()=>range},{href:'chapter.xhtml',documentId:undefined,annotations:()=>snapshot,labels:()=>({comment:'Nota'}),isCurrent:()=>true,onTap:(id:string)=>taps.push(id)});
- const flush=()=>{const tasks=queue;queue=[];tasks.forEach(cb=>cb(0));};flush();
- expect(document.querySelectorAll('[data-annotation-id]')).toHaveLength(120);
- expect(document.querySelectorAll('[data-papyrus-overlay] button')).toHaveLength(1);
- const group=document.querySelector('[data-annotation-id="n0"]')!;
- expect((group.firstChild as HTMLElement).style.top).toBe('30px');
- expect((group.lastChild as HTMLElement).textContent).toBe('120');
- (group.lastChild as HTMLElement).click();expect(taps).toEqual(['n0']);
- top=80;renderer.schedule();flush();expect(document.querySelector('[data-annotation-id="n0"]')).toBe(group);expect((group.firstChild as HTMLElement).style.top).toBe('90px');
- snapshot=[];renderer.schedule();flush();expect(document.querySelectorAll('[data-annotation-id]')).toHaveLength(0);
- renderer.destroy();expect(document.querySelector('[data-papyrus-overlay]')).toBeNull();window.requestAnimationFrame=originalRAF;
-});

package/runtime/epubScrollDiagnostics.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  createEpubScrollStallDetector,
-  getEpubScrollDirection,
-} from "./epubScrollDiagnostics";
-
-describe("EPUB scroll diagnostics", () => {
-  it("classifies upward movement from the scroll offset", () => {
-    expect(getEpubScrollDirection(400, 420)).toBe("up");
-    expect(getEpubScrollDirection(420, 400)).toBe("down");
-    expect(getEpubScrollDirection(400, 400)).toBe("none");
-  });
-
-  it("reports a reverse-scroll stall only after valid consecutive moves", () => {
-    const detector = createEpubScrollStallDetector({
-      minConsecutiveSamples: 3,
-      minDurationMs: 150,
-      movementThresholdPx: 4,
-      offsetEpsilonPx: 1,
-    });
-
-    expect(
-      detector.push({
-        timestamp: 0,
-        scrollTop: 420,
-        previousScrollTop: 420,
-        deltaY: 18,
-        scrollHeight: 2000,
-        clientHeight: 600,
-        scrollEnabled: true,
-        selectionActive: false,
-        gestureLock: false,
-        spineIndex: 4,
-        progress: 0.3,
-      })
-    ).toBeNull();
-
-    expect(
-      detector.push({
-        timestamp: 70,
-        scrollTop: 420,
-        previousScrollTop: 420,
-        deltaY: 18,
-        scrollHeight: 2000,
-        clientHeight: 600,
-        scrollEnabled: true,
-        selectionActive: false,
-        gestureLock: false,
-        spineIndex: 4,
-        progress: 0.3,
-      })
-    ).toBeNull();
-
-    const stall = detector.push({
-      timestamp: 180,
-      scrollTop: 420,
-      previousScrollTop: 420,
-      deltaY: 18,
-      scrollHeight: 2000,
-      clientHeight: 600,
-      scrollEnabled: true,
-      selectionActive: false,
-      gestureLock: false,
-      spineIndex: 4,
-      progress: 0.3,
-    });
-
-    expect(stall).toMatchObject({
-      name: "epub.scroll.stall",
-      direction: "up",
-      scrollTop: 420,
-      consecutiveSamples: 3,
-      durationMs: 180,
-      spineIndex: 4,
-    });
-  });
-
-  it("ignores top, disabled, selected, and genuinely moving samples", () => {
-    const detector = createEpubScrollStallDetector();
-    const base = {
-      timestamp: 0,
-      scrollTop: 0,
-      previousScrollTop: 0,
-      deltaY: 20,
-      scrollHeight: 2000,
-      clientHeight: 600,
-      scrollEnabled: true,
-      selectionActive: false,
-      gestureLock: false,
-      spineIndex: 0,
-      progress: 0,
-    };
-
-    expect(detector.push(base)).toBeNull();
-    expect(detector.push({ ...base, timestamp: 100, scrollEnabled: false })).toBeNull();
-    expect(detector.push({ ...base, timestamp: 200, selectionActive: true })).toBeNull();
-    expect(
-      detector.push({
-        ...base,
-        timestamp: 300,
-        scrollTop: 380,
-        previousScrollTop: 400,
-      })
-    ).toBeNull();
-  });
-
-});

package/runtime/epubSelectionMenu.test.ts

@@ -1,39 +0,0 @@
-import {readFileSync} from 'node:fs';
-import {JSDOM} from 'jsdom';
-import {describe,it,expect} from 'vitest';
-const source=readFileSync('packages/ui-react-native/runtime/runtime.js','utf8');
-function fixture() {
- const messages:any[]=[];
- const dom=new JSDOM('<div id="viewer"></div>',{runScripts:'outside-only'});
- dom.window.ReactNativeWebView={postMessage:(raw:string)=>messages.push(JSON.parse(raw))} as never;
- // Expose only the setup boundary in the test copy; execute the production handler.
- dom.window.eval(source.replace("sendMessage({ type: 'ready' });",`
- window.seedMenu=(session,payload,contents)=>{documentSessionId=session;nativeMenuSelection={payload,contents};};`));
- const chapter=new JSDOM('<p>one word and a phrase</p>');
- const text=chapter.window.document.querySelector('p')!.firstChild!;
- const range=chapter.window.document.createRange();range.setStart(text,4);range.setEnd(text,8);
- chapter.window.getSelection()!.addRange(range);
- const payload={documentSessionId:'current',text:'word',pageIndex:1,
-  anchor:{kind:'epub-cfi',version:1,cfiRange:'epubcfi(/6/2!/4/2:4)',href:'one.xhtml',quote:'word'}};
- (dom.window as any).seedMenu('current',payload,{document:chapter.window.document,window:chapter.window});
- const send=(key:string,session='current')=>dom.window.dispatchEvent(new dom.window.MessageEvent('message',
-  {data:JSON.stringify({type:'epub-selection-action',id:'selection-menu',key,documentSessionId:session})}));
- return {messages,chapter,send,dom};
-}
-describe('native EPUB menu dispatch',()=>{
- it('uses the chapter CFI snapshot even when root selection is empty',()=>{
-  const f=fixture();expect(f.dom.window.getSelection()!.toString()).toBe('');f.send('highlight');
-  expect(f.messages).toContainEqual(expect.objectContaining({name:'EPUB_SELECTION_ACTION',payload:expect.objectContaining({action:'highlight',text:'word',anchor:expect.objectContaining({href:'one.xhtml'})})}));
-  expect(f.chapter.window.getSelection()!.toString()).toBe('');
- });
- it('rejects stale document sessions and unknown actions',()=>{
-  const f=fixture();f.send('copy','old');f.send('deleteDocument');expect(f.messages).toHaveLength(0);
-  expect(f.chapter.window.getSelection()!.toString()).toBe('word');
- });
- it('selects all inside the chapter, without annotating the previous word',()=>{
-  const f=fixture();f.send('selectAll');expect(f.chapter.window.getSelection()!.toString()).toBe('one word and a phrase');expect(f.messages).toHaveLength(0);
- });
- it('consumes each action once',()=>{
-  const f=fixture();f.send('comment');f.send('comment');expect(f.messages).toHaveLength(1);
- });
-});