@caipira/vue-reader 0.0.1

package/dist/services/wasm/wasm-streamer.js

@@ -0,0 +1,157 @@
+import { HttpFetcher, Link, Manifest, Publication } from '@readium/shared';
+const config = {
+    swScope: '/epub-streamer/',
+    swUrl: '/sw.js',
+    wasmUrl: '/wasm/epub-streamer-server.wasm?v=1',
+};
+let swRegistration = null;
+let swReady = null;
+const buildSwRegistrationUrl = () => {
+    const joiner = config.swUrl.includes('?') ? '&' : '?';
+    return `${config.swUrl}${joiner}wasmUrl=${encodeURIComponent(config.wasmUrl)}`;
+};
+const setWasmStreamerConfig = (next) => {
+    const changed = (next.swScope !== undefined && next.swScope !== config.swScope) ||
+        (next.swUrl !== undefined && next.swUrl !== config.swUrl) ||
+        (next.wasmUrl !== undefined && next.wasmUrl !== config.wasmUrl);
+    if (!changed) {
+        return;
+    }
+    if (next.swScope !== undefined) {
+        config.swScope = next.swScope;
+    }
+    if (next.swUrl !== undefined) {
+        config.swUrl = next.swUrl;
+    }
+    if (next.wasmUrl !== undefined) {
+        config.wasmUrl = next.wasmUrl;
+    }
+    swRegistration = null;
+    swReady = null;
+};
+async function ensureController(timeoutMs = 8000) {
+    if (navigator.serviceWorker.controller)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            navigator.serviceWorker.removeEventListener('controllerchange', onChange);
+            reject(new Error('Service Worker did not take control of the page'));
+        }, timeoutMs);
+        const onChange = () => {
+            if (!navigator.serviceWorker.controller)
+                return;
+            clearTimeout(timer);
+            navigator.serviceWorker.removeEventListener('controllerchange', onChange);
+            resolve();
+        };
+        navigator.serviceWorker.addEventListener('controllerchange', onChange);
+    });
+}
+function resolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+/**
+ * Ensure the Service Worker is registered.
+ *
+ * Register the root-level SW script so it can control the whole page.
+ * The passthrough callback in sw.js ensures only requests under
+ * /epub-streamer/webpub/ reach the Go handler; everything else goes to the
+ * network normally.
+ */
+async function ensureSW() {
+    if (swReady)
+        return swReady;
+    swReady = (async () => {
+        swRegistration = await navigator.serviceWorker.register(buildSwRegistrationUrl(), {
+            scope: '/',
+        });
+        await navigator.serviceWorker.ready;
+        if (!navigator.serviceWorker.controller) {
+            await ensureController();
+        }
+        return swRegistration;
+    })();
+    return swReady;
+}
+/**
+ * Tell the Service Worker / WASM module to load a publication from a URL.
+ * The WASM module fetches the EPUB from the given URL, parses it, and
+ * makes it available via the streamer endpoints.
+ */
+async function loadPublication(bookId, epubUrl) {
+    await ensureSW();
+    const sw = swRegistration.active;
+    if (!sw)
+        throw new Error('Service Worker not active');
+    const { promise, resolve, reject } = resolvers();
+    const timeout = setTimeout(() => {
+        navigator.serviceWorker.removeEventListener('message', handler);
+        reject(new Error('Timeout waiting for SW load response'));
+    }, 30000);
+    const handler = (e) => {
+        if (e.data?.type === 'load:done' && e.data.bookId === bookId) {
+            clearTimeout(timeout);
+            navigator.serviceWorker.removeEventListener('message', handler);
+            if (e.data.success) {
+                resolve();
+            }
+            else {
+                reject(new Error(e.data.error || 'Failed to load publication'));
+            }
+        }
+    };
+    navigator.serviceWorker.addEventListener('message', handler);
+    sw.postMessage({ type: 'load', bookId, epubUrl });
+    return promise;
+}
+/**
+ * Create a Readium Publication backed by the WASM streamer.
+ *
+ * The HttpFetcher resolves resource requests against the base URL,
+ * which points into the SW scope. The SW intercepts these and
+ * the Go WASM handler serves them.
+ */
+async function createPublication(bookId) {
+    const baseUrl = new URL(`${config.swScope}webpub/${bookId}/`, window.location.origin).toString();
+    const fetcher = new HttpFetcher(undefined, baseUrl);
+    const manifestResource = fetcher.get(new Link({
+        href: 'manifest.json',
+        type: 'application/webpub+json',
+    }));
+    const manifestData = (await manifestResource.readAsJSON());
+    const manifest = Manifest.deserialize(manifestData);
+    if (!manifest)
+        throw new Error('Failed to parse manifest');
+    // Set the self link so pub.baseURL resolves to the streamer's base URL.
+    // This is critical for the <base> tag injected into the navigator iframe:
+    // without it, relative URLs in EPUB content (images, CSS, etc.) would
+    // resolve against "/" instead of "/epub-streamer/webpub/{bookId}/",
+    // bypassing the service worker and returning 404 from the origin server.
+    manifest.setSelfLink(baseUrl + 'manifest.json');
+    return new Publication({ manifest, fetcher });
+}
+/**
+ * Unload a publication from the WASM streamer (cleanup).
+ */
+async function unloadPublication(bookId) {
+    const sw = swRegistration?.active;
+    if (!sw)
+        return;
+    const { promise, resolve } = resolvers();
+    const handler = (e) => {
+        if (e.data?.type === 'unload:done' && e.data.bookId === bookId) {
+            navigator.serviceWorker.removeEventListener('message', handler);
+            resolve();
+        }
+    };
+    navigator.serviceWorker.addEventListener('message', handler);
+    sw.postMessage({ type: 'unload', bookId });
+    return promise;
+}
+export { ensureSW, loadPublication, createPublication, unloadPublication, setWasmStreamerConfig, };