bookish-press 0.7.4 → 0.9.2

package/dist/epub/zip.test.js

@@ -0,0 +1,171 @@
+import { expect, test } from 'vitest';
+import Zip, { crc32 } from './zip';
+const decoder = new TextDecoder();
+/**
+ * A minimal ZIP reader, so the writer's output is verified by parsing it back
+ * rather than by asserting on bytes we'd have to keep in sync by hand.
+ */
+function read(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    // Find the end of central directory record, which is last.
+    let end = bytes.length - 22;
+    while (end >= 0 && view.getUint32(end, true) !== 0x06054b50)
+        end--;
+    if (end < 0)
+        throw new Error('No end of central directory record');
+    const count = view.getUint16(end + 8, true);
+    let offset = view.getUint32(end + 16, true);
+    const entries = [];
+    for (let i = 0; i < count; i++) {
+        if (view.getUint32(offset, true) !== 0x02014b50)
+            throw new Error(`Bad central header at ${offset}`);
+        const nameLength = view.getUint16(offset + 28, true);
+        const extraLength = view.getUint16(offset + 30, true);
+        const commentLength = view.getUint16(offset + 32, true);
+        entries.push({
+            method: view.getUint16(offset + 10, true),
+            crc: view.getUint32(offset + 16, true),
+            size: view.getUint32(offset + 24, true),
+            offset: view.getUint32(offset + 42, true),
+            path: decoder.decode(bytes.subarray(offset + 46, offset + 46 + nameLength)),
+        });
+        offset += 46 + nameLength + extraLength + commentLength;
+    }
+    return { entries, view, bytes };
+}
+/** Read one entry's bytes, inflating if necessary. */
+async function contentOf(archive, path) {
+    const entry = archive.entries.find((e) => e.path === path);
+    if (entry === undefined)
+        throw new Error(`No entry ${path}`);
+    const { view, bytes } = archive;
+    if (view.getUint32(entry.offset, true) !== 0x04034b50)
+        throw new Error(`Bad local header for ${path}`);
+    const nameLength = view.getUint16(entry.offset + 26, true);
+    const extraLength = view.getUint16(entry.offset + 28, true);
+    const compressedSize = view.getUint32(entry.offset + 18, true);
+    const start = entry.offset + 30 + nameLength + extraLength;
+    const data = bytes.subarray(start, start + compressedSize);
+    if (entry.method === 0)
+        return data;
+    return inflate(data);
+}
+/** Raw DEFLATE decompression, avoiding Blob.stream(), which jsdom lacks. */
+async function inflate(data) {
+    const stream = new DecompressionStream('deflate-raw');
+    const writer = stream.writable.getWriter();
+    const written = writer.write(data).then(() => writer.close());
+    const reader = stream.readable.getReader();
+    const chunks = [];
+    let length = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        length += value.length;
+    }
+    await written;
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+async function archiveOf(zip) {
+    return read(new Uint8Array(await (await zip.toBlob()).arrayBuffer()));
+}
+// The check value published in the zlib and PNG specifications.
+test('crc32 matches the specification check value', () => {
+    expect(crc32(new TextEncoder().encode('123456789'))).toBe(0xcbf43926);
+});
+test('crc32 of nothing is zero', () => {
+    expect(crc32(new Uint8Array(0))).toBe(0);
+});
+test('round trips text and binary content', async () => {
+    const binary = new Uint8Array([0, 1, 2, 253, 254, 255]);
+    const zip = new Zip();
+    zip.add('hello.txt', 'Hello, world!');
+    zip.add('nested/deep/bytes.bin', binary);
+    const archive = await archiveOf(zip);
+    expect(archive.entries.map((e) => e.path)).toEqual([
+        'hello.txt',
+        'nested/deep/bytes.bin',
+    ]);
+    expect(decoder.decode(await contentOf(archive, 'hello.txt'))).toBe('Hello, world!');
+    expect(await contentOf(archive, 'nested/deep/bytes.bin')).toEqual(binary);
+});
+test('round trips content that compresses well', async () => {
+    // Long enough that deflate definitely beats storing it.
+    const text = 'the quick brown fox '.repeat(500);
+    const zip = new Zip();
+    zip.add('repetitive.txt', text);
+    const archive = await archiveOf(zip);
+    expect(archive.entries[0].method).toBe(8);
+    expect(decoder.decode(await contentOf(archive, 'repetitive.txt'))).toBe(text);
+});
+test('stores rather than deflates when compression would not help', async () => {
+    const zip = new Zip();
+    // Incompressible: a short string has more deflate overhead than savings.
+    zip.add('tiny.txt', 'x');
+    const archive = await archiveOf(zip);
+    expect(archive.entries[0].method).toBe(0);
+});
+test('honors an explicit request to store', async () => {
+    const text = 'the quick brown fox '.repeat(500);
+    const zip = new Zip();
+    zip.add('repetitive.txt', text, true);
+    const archive = await archiveOf(zip);
+    expect(archive.entries[0].method).toBe(0);
+    expect(archive.entries[0].size).toBe(text.length);
+});
+test('records the uncompressed size and CRC of the original bytes', async () => {
+    const text = 'the quick brown fox '.repeat(500);
+    const zip = new Zip();
+    zip.add('repetitive.txt', text);
+    const archive = await archiveOf(zip);
+    expect(archive.entries[0].size).toBe(text.length);
+    expect(archive.entries[0].crc).toBe(crc32(new TextEncoder().encode(text)));
+});
+test('encodes non-ASCII paths and content as UTF-8', async () => {
+    const path = 'café/章.txt';
+    const content = 'Hello, 世界!';
+    const zip = new Zip();
+    zip.add(path, content);
+    const archive = await archiveOf(zip);
+    expect(archive.entries[0].path).toBe(path);
+    expect(decoder.decode(await contentOf(archive, path))).toBe(content);
+});
+// This is the constraint that makes a hand-rolled writer worth having: EPUB
+// requires `mimetype` to be the first entry and to be stored, so that readers
+// can identify the file by reading a fixed byte range at its head.
+test('an EPUB-shaped archive puts a stored mimetype first', async () => {
+    const zip = new Zip();
+    zip.add('mimetype', 'application/epub+zip', true);
+    zip.add('META-INF/container.xml', '<container/>');
+    const blob = await zip.toBlob('application/epub+zip');
+    const bytes = new Uint8Array(await blob.arrayBuffer());
+    const archive = read(bytes);
+    expect(archive.entries[0].path).toBe('mimetype');
+    expect(archive.entries[0].method).toBe(0);
+    expect(archive.entries[0].offset).toBe(0);
+    // Signature, then the name at 30, then the stored content right after it.
+    expect(decoder.decode(bytes.subarray(0, 2))).toBe('PK');
+    expect(decoder.decode(bytes.subarray(30, 38))).toBe('mimetype');
+    expect(decoder.decode(bytes.subarray(38, 58))).toBe('application/epub+zip');
+});
+test('an empty archive is still a valid one', async () => {
+    const archive = await archiveOf(new Zip());
+    expect(archive.entries).toEqual([]);
+});
+test('output is reproducible for a fixed timestamp', async () => {
+    const build = async () => {
+        const zip = new Zip(new Date(2026, 0, 1, 12, 0, 0));
+        zip.add('mimetype', 'application/epub+zip', true);
+        zip.add('a.txt', 'content');
+        return new Uint8Array(await (await zip.toBlob()).arrayBuffer());
+    };
+    expect(await build()).toEqual(await build());
+});

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export { default as Index } from "./components/page/Index.svelte";
 export { default as References } from "./components/page/References.svelte";
 export { default as Media } from "./components/page/Media.svelte";
 export { default as Print } from "./components/page/Print.svelte";
+export { default as DownloadEPUB } from "./components/page/DownloadEPUB.svelte";
 export { default as Unknown } from "./components/page/Unknown.svelte";
 export { default as Glossary } from "./components/page/Glossary.svelte";
 export { default as Edition } from "./components/page/Edition.svelte";

package/dist/index.js

@@ -9,6 +9,7 @@ export { default as Index } from './components/page/Index.svelte';
 export { default as References } from './components/page/References.svelte';
 export { default as Media } from './components/page/Media.svelte';
 export { default as Print } from './components/page/Print.svelte';
+export { default as DownloadEPUB } from './components/page/DownloadEPUB.svelte';
 export { default as Unknown } from './components/page/Unknown.svelte';
 export { default as Glossary } from './components/page/Glossary.svelte';
 export { default as Edition } from './components/page/Edition.svelte';

package/dist/models/Firebase.js

@@ -4,6 +4,7 @@ import { connectFirestoreEmulator, getFirestore } from 'firebase/firestore';
 import { connectFunctionsEmulator, getFunctions } from 'firebase/functions';
 import { connectStorageEmulator, getStorage } from 'firebase/storage';
 import { PUBLIC_READER, PUBLIC_CONTEXT, PUBLIC_FIREBASE_API_KEY, PUBLIC_FIREBASE_AUTH_DOMAIN, PUBLIC_FIREBASE_PROJECT_ID, PUBLIC_FIREBASE_STORAGE_BUCKET, PUBLIC_FIREBASE_MESSAGING_SENDER_ID, PUBLIC_FIREBASE_APP_ID, } from '$env/static/public';
+import { env } from '$env/dynamic/public';
 const isReader = PUBLIC_READER === 'true';
 // Some feedback about context
 if (!isReader && PUBLIC_CONTEXT !== 'prod')
@@ -24,13 +25,26 @@ export const auth = isReader ? undefined : getAuth(app);
 export const db = isReader ? undefined : getFirestore();
 export const storage = isReader ? undefined : getStorage(app);
 export const functions = isReader ? undefined : getFunctions(app);
+/** Emulator ports default to the firebase.json values but can be overridden
+ *  by env vars so test runs (see firebase.test.json) can use dedicated ports
+ *  that don't collide with other running emulator suites. Dynamic env isn't
+ *  available in every context (e.g. unit tests), hence the guard. */
+function emulatorPort(name, fallback) {
+    try {
+        return (env?.[name] ??
+            fallback);
+    }
+    catch {
+        return fallback;
+    }
+}
 if (!isReader && PUBLIC_CONTEXT === 'local') {
     if (db)
-        connectFirestoreEmulator(db, 'localhost', 8080);
+        connectFirestoreEmulator(db, 'localhost', parseInt(emulatorPort('PUBLIC_EMULATOR_FIRESTORE', '8080')));
     if (auth)
-        connectAuthEmulator(auth, 'http://localhost:9099');
+        connectAuthEmulator(auth, `http://localhost:${emulatorPort('PUBLIC_EMULATOR_AUTH', '9099')}`);
     if (storage)
-        connectStorageEmulator(storage, 'localhost', 9199);
+        connectStorageEmulator(storage, 'localhost', parseInt(emulatorPort('PUBLIC_EMULATOR_STORAGE', '9199')));
     if (functions)
-        connectFunctionsEmulator(functions, 'localhost', 5001);
+        connectFunctionsEmulator(functions, 'localhost', parseInt(emulatorPort('PUBLIC_EMULATOR_FUNCTIONS', '5001')));
 }

package/dist/models/book/Book.js

@@ -91,7 +91,8 @@ export default class Book {
         return edition ? edition.ref.id : undefined;
     }
     getLatestPublishedEditionID() {
-        return this.editions.filter((ed) => ed.published !== null).at(-1)?.ref.id;
+        return this.editions.filter((ed) => ed.published !== null).at(-1)?.ref
+            .id;
     }
     getLatestEditionID() {
         return this.editions.toSorted((a, b) => b.number - a.number)[0]?.ref.id;

package/dist/models/book/BookMedia.js

@@ -1,6 +1,5 @@
 import { deleteObject, getDownloadURL, listAll, ref, uploadBytes, } from 'firebase/storage';
 import { storage } from '../Firebase';
-import { v4 as uuidv4 } from 'uuid';
 export default class BookMedia {
     book;
     _images;
@@ -84,7 +83,7 @@ export default class BookMedia {
         // Get the extension if there is one.
         const [name, extension] = file.name.split('.');
         // We use the file name given, but append a unique string to avoid collisions.
-        const imageName = `${name}-${uuidv4()}.${extension ?? ''}`;
+        const imageName = `${name}-${crypto.randomUUID()}.${extension ?? ''}`;
         // The canonical path format for Bookish images in the store is image/{bookid}/{imageid}
         // where {bookid} is the Firestore document ID of the book being edited and {imageid} is just a random id.
         const imageRef = ref(storage, `${this.getImagePath()}/${imageName}`);

package/dist/models/book/Chapter.js

@@ -161,8 +161,9 @@ export default class Chapter {
     }
     getWordCount(edition) {
         if (this._wordCount === undefined)
-            this._wordCount = this.getAST(edition)?.toText().split(/\s+/)
-                .length;
+            this._wordCount = this.getAST(edition)
+                ?.toText()
+                .split(/\s+/).length;
         return this._wordCount;
     }
     /** Either a number of minutes, or undefined if there's no text yet, or null if forthcoming. */

package/dist/models/book/ChapterID.d.ts

@@ -1,4 +1,4 @@
 export type ChapterIDKey = 'references' | 'search' | 'media' | 'index' | 'glossary' | 'unknown' | 'cover';
-export type TOCHeaderKey = 'chapters' | 'acknowledgements' | 'license' | 'print' | 'citation';
+export type TOCHeaderKey = 'chapters' | 'acknowledgements' | 'license' | 'print' | 'epub' | 'citation';
 declare const ChapterIDs: Record<string, ChapterIDKey>;
 export default ChapterIDs;

package/dist/models/book/Edition.d.ts

@@ -7,7 +7,7 @@ import type Definition from './Definition.js';
 import { type ChapterIDKey, type TOCHeaderKey } from './ChapterID.js';
 import type { DocumentReference } from 'firebase/firestore';
 import type Book from './Book';
-import type FormatNode from '../chapter/FormatNode';
+import FormatNode from '../chapter/FormatNode';
 import type { EditionInfo } from './Book';
 export type EditionSpecification = {
     bookRef: DocumentReference;

package/dist/models/book/Edition.js

@@ -3,6 +3,7 @@ import Parser from '../chapter/Parser';
 import EmbedNode from '../chapter/EmbedNode';
 import Reference from './Reference';
 import ChapterIDs, {} from './ChapterID.js';
+import FormatNode from '../chapter/FormatNode';
 export default class Edition {
     bookRef;
     editionRef;
@@ -48,8 +49,11 @@ export default class Edition {
         this.sources = Object.assign({}, sources);
         this.references = {};
         for (const [citationID, ref] of Object.entries(references)) {
+            // Pass through already-parsed references: strings parse to
+            // FormatNodes, and every copy-on-write constructor call re-runs
+            // this normalization, so FormatNodes must survive it too.
             this.references[citationID] =
-                ref instanceof Reference
+                ref instanceof Reference || ref instanceof FormatNode
                     ? ref
                     : Edition.parseReference(citationID, ref, this);
         }
@@ -654,6 +658,7 @@ export default class Edition {
             acknowledgements: 'Acknowledgements',
             license: 'License',
             print: 'Print',
+            epub: 'E-book',
             citation: 'Citation',
             chapters: 'Chapters',
             cover: 'Cover',

package/dist/models/chapter/BlocksNode.js

@@ -474,7 +474,9 @@ export default class BlocksNode extends BlockNode {
             if (first instanceof ParagraphNode &&
                 last instanceof ParagraphNode) {
                 // Replace the first paragraph with the second merged.
-                newBlocks = newBlocks.withNodeReplaced(first, first.withContent(first.getFormat().withSegmentsAppended(last.getFormat())));
+                newBlocks = newBlocks.withNodeReplaced(first, first.withContent(first
+                    .getFormat()
+                    .withSegmentsAppended(last.getFormat())));
                 if (newBlocks === undefined)
                     return;
                 // Remove the last paragraph.

package/dist/models/chapter/BlocksNode.test.js

@@ -29,7 +29,11 @@ const beforeBold = new TextNode('I am a ');
 const bold = new TextNode('bold');
 const afterBold = new TextNode(' word.');
 const boldChapter = new ChapterNode([
-    new ParagraphNode(0, new FormatNode('', [beforeBold, new FormatNode('*', [bold]), afterBold])),
+    new ParagraphNode(0, new FormatNode('', [
+        beforeBold,
+        new FormatNode('*', [bold]),
+        afterBold,
+    ])),
 ]);
 const itemOneTextNode = new TextNode('one');
 const itemOneFormat = new FormatNode('', [itemOneTextNode]);

package/dist/models/chapter/Node.test.js

@@ -13,11 +13,11 @@ const format = new FormatNode('', [textOne, textTwo, bold, textFive]);
 
 test('Replace descendants', () => {
     expect(
-        format.withNodeReplaced(textThree, new TextNode('hi'))?.toBookdown()
+        format.withNodeReplaced(textThree, new TextNode('hi'))?.toBookdown(),
     ).toBe('onetwo*hifour*five');
 
     expect(
-        format.withNodeReplaced(textFive, new TextNode('yo'))?.toBookdown()
+        format.withNodeReplaced(textFive, new TextNode('yo'))?.toBookdown(),
     ).toBe('onetwo*threefour*yo');
 });
 

package/dist/models/chapter/TextNode.js

@@ -49,12 +49,15 @@ export default class TextNode extends Node {
             .replace(/(:)([a-z])/g, '\\:$2');
     }
     toHTML() {
+        // Ampersands are escaped first, or the entities introduced below get
+        // escaped in turn ('<' would become '&amp;lt;'). The flags matter too:
+        // without them only the first occurrence of each character is escaped.
         return this.#text
-            .replace('<', '&lt;')
-            .replace('>', '&gt;')
-            .replace('&', '&amp;')
-            .replace('"', '&quot;')
-            .replace("'", '&#39;');
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
     }
     getChildren() {
         return [];

package/dist/models/chapter/TextNode.test.js

@@ -4,3 +4,11 @@ test('Insert character', () => {
     const text = new TextNode('Hello');
     expect(text.withCharacterAt('!', 5)?.toBookdown()).toBe('Hello!');
 });
+test('escapes every occurrence of a markup character, not just the first', () => {
+    expect(new TextNode('a < b < c').toHTML()).toBe('a &lt; b &lt; c');
+});
+test('escapes ampersands without escaping the entities it introduces', () => {
+    expect(new TextNode('<').toHTML()).toBe('&lt;');
+    expect(new TextNode('a & b').toHTML()).toBe('a &amp; b');
+    expect(new TextNode('&lt;').toHTML()).toBe('&amp;lt;');
+});

package/package.json

@@ -1,61 +1,75 @@
 {
     "name": "bookish-press",
     "private": false,
-    "version": "0.7.4",
+    "version": "0.9.2",
     "type": "module",
     "description": "A platform for reading and writing readable, accessible, beautiful online books.",
     "license": "MIT",
-    "repository": "https://github.com/amyjko/bookish.git",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/amyjko/bookish.git"
+    },
     "scripts": {
         "prepare": "svelte-kit sync",
         "//dev": "echo 'Run the Svelte/Vite local server to test locally. Use in combination with run emu to run locally.'",
         "dev": "vite dev",
         "preview": "npm run build && vite preview",
         "build": "npm run env && vite build",
+        "//demo": "echo 'Seeds a demo book that uses every feature into dedicated emulators and serves it at /demo. Read-only; no sign-in needed.'",
+        "demo": "bash scripts/demo.sh",
         "//emu": "echo 'This copies the local .env file and starts the emulator'",
         "emu": "firebase use dev && npm run env && firebase emulators:start",
         "package": "svelte-package --watch",
+        "package:build": "svelte-package",
         "test": "vitest",
+        "test:ci": "vitest run",
+        "//test:e2e": "echo 'Build the app and run the Playwright smoke tests against a preview server.'",
+        "test:e2e": "npm run build && playwright test",
+        "//test:e2e:emu": "echo 'Build the app and run the Playwright suite that signs in and edits against dedicated Firebase emulators (see firebase.test.json).'",
+        "test:e2e:emu": "PUBLIC_FIREBASE_PROJECT_ID=demo-bookish PUBLIC_FIREBASE_STORAGE_BUCKET=demo-bookish.appspot.com npm run build && bash scripts/test-emulators.sh 'npx playwright test --config playwright.emulator.config.ts'",
         "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+        "check:ci": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
         "//env": "echo 'This copies the .env file corresponding to the current Firebase project specified with firebase use, defaulting to local'",
         "env": "cp .env.${GCLOUD_PROJECT:-example} .env",
-        "//stage": "echo 'switch to the dev project, deploy, relying on Firebase's predeploy hook to run the build script above before release'",
-        "stage": "firebase use dev && cp .env.bookish-dev-21ac3 .env && firebase deploy",
-        "//release": "echo 'switch to the prod project, deploy, relying on Firebase's predeploy hook to run the build script above before release'",
-        "release": "firebase use prod && cp .env.bookish-prod .env && firebase deploy",
+        "//deploy:ssr": "echo 'Build the app with the current .env, then deploy the SSR server in build/ to Cloud Run for the given project. Used by stage and release.'",
+        "deploy:ssr": "vite build && gcloud run deploy bookish-ssr --source . --region us-central1 --allow-unauthenticated --quiet --project",
+        "//stage": "echo 'Switch to the dev project, build with the dev .env, deploy the SSR server to Cloud Run, then deploy hosting, rules, and functions.'",
+        "stage": "firebase use dev && cp .env.bookish-dev-21ac3 .env && npm run deploy:ssr -- bookish-dev-21ac3 && firebase deploy",
+        "//release": "echo 'Switch to the prod project, build with the prod .env, deploy the SSR server to Cloud Run, then deploy hosting, rules, and functions.'",
+        "release": "firebase use prod && cp .env.bookish-prod .env && npm run deploy:ssr -- bookish-prod && firebase deploy",
         "//merge": "merge dev into main, push to remote",
         "merge": "git checkout main && git merge dev && git push origin main && git checkout dev"
     },
     "devDependencies": {
+        "@playwright/test": "^1",
         "@sveltejs/adapter-node": "^5",
-        "@sveltejs/kit": "^2",
         "@sveltejs/package": "^2",
-        "@sveltejs/vite-plugin-svelte": "^3",
+        "@sveltejs/vite-plugin-svelte": "^6",
+        "@testing-library/svelte": "^5",
         "@types/prismjs": "^1.26",
         "@types/smoothscroll-polyfill": "^0",
-        "chalk": "^5.3.0",
-        "globals": "^16",
+        "firebase-tools": "^15.28.2",
+        "jsdom": "^29",
         "prettier": "^3",
-        "prettier-plugin-svelte": "^3",
-        "svelte-check": "^3",
-        "svelte-preprocess": "^5",
+        "prettier-plugin-svelte": "^4",
+        "svelte": "^5.57",
+        "svelte-check": "^4.7",
         "tslib": "^2",
         "typescript": "^5",
-        "uuid": "^11.1.0",
-        "vite": "^5",
-        "vitest": "^3"
+        "vite": "^7",
+        "vitest": "^4"
     },
     "dependencies": {
         "@sveltejs/kit": "^2",
         "ajv": "^8",
         "ajv-formats": "^3",
-        "firebase": "^11",
-        "firebase-admin": "^12.7.0",
-        "firebase-functions": "^6",
+        "firebase": "^12",
+        "firebase-admin": "^14",
         "prismjs": "^1.29",
-        "smoothscroll-polyfill": "^0.4",
-        "svelte": "^4",
-        "uuid": "^11"
+        "smoothscroll-polyfill": "^0.4"
+    },
+    "peerDependencies": {
+        "svelte": "^5.0.0"
     },
     "engines": {
         "node": "22"