bookish-press 0.8.2 → 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/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.js

@@ -658,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/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,7 +1,7 @@
 {
     "name": "bookish-press",
     "private": false,
-    "version": "0.8.2",
+    "version": "0.9.2",
     "type": "module",
     "description": "A platform for reading and writing readable, accessible, beautiful online books.",
     "license": "MIT",
@@ -15,6 +15,8 @@
         "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",