bookish-press 0.11.0 → 0.11.2

package/dist/components/editor/Permissions.svelte

@@ -15,7 +15,13 @@ async function addEditor() {
 		const { createUser } = await import("../../models/CRUD");
 		const uid = await createUser(email);
 		if (uid === null) newEditorError = "couldn't add editor";
-		else change([...uids, uid]);
+		else {
+			// The server only reveals the emails of people who already
+			// share a saved book, and this one isn't saved yet. We know
+			// the email anyway, so show it now.
+			emails.update((known) => new Map(known).set(uid, email));
+			change([...uids, uid]);
+		}
 	} finally {
 		loading = undefined;
 	}

package/dist/epub/images.d.ts

@@ -74,6 +74,27 @@ export declare function resolveImageURL(url: string, base: string): string;
  * keeping its caption.
  */
 export declare function prepareImage(url: string, size: ImageSize, grayscale?: boolean): Promise<PreparedImage | undefined>;
+/**
+ * Whether to package the re-encoded image rather than the original.
+ *
+ * Keep whichever is smaller, since re-encoding can inflate a file: resizing a
+ * diagram resamples its hairlines into shades of grey, and the result can be
+ * larger than the crisp original. Three things override that:
+ *
+ * - An image far past the budget is shrunk regardless, because decoding it
+ *   costs a small reader memory it may not have.
+ * - Greyscale was asked for, and an image small enough to pass through would
+ *   otherwise come out in colour while everything around it was grey.
+ * - WebP is always converted. EPUB 3.3 allows it, but many e-readers still in
+ *   use predate that and show nothing, and bound books serve WebP by default.
+ */
+export declare function shouldUseReencoded(image: {
+    mediaType: string;
+    oversize: boolean;
+    grayscale: boolean;
+    originalBytes: number;
+    reencodedBytes: number;
+}): boolean;
 /**
  * Run tasks with a bounded number in flight, so a book with a hundred images
  * doesn't open a hundred connections at once.

package/dist/epub/images.js

@@ -138,20 +138,37 @@ export async function prepareImage(url, size, grayscale = false) {
     const reencoded = await reencode(bytes, mediaType, size, grayscale);
     if (reencoded === undefined)
         return passThrough(bytes, mediaType);
-    // Keep whichever is smaller, since re-encoding can inflate a file: resizing
-    // a diagram resamples its hairlines into shades of grey, and the result can
-    // be larger than the crisp original. But an image far past the budget is
-    // shrunk regardless, because decoding it costs a small reader memory it may
-    // not have, and a few extra kilobytes are the cheaper price.
-    //
-    // Greyscale overrides the size comparison too: it was asked for, and an
-    // image small enough to pass through untouched would otherwise come out in
-    // colour while everything around it was grey.
     const { oversize, ...prepared } = reencoded;
-    return oversize || grayscale || prepared.bytes.length < bytes.length
+    return shouldUseReencoded({
+        mediaType,
+        oversize,
+        grayscale,
+        originalBytes: bytes.length,
+        reencodedBytes: prepared.bytes.length,
+    })
         ? prepared
         : passThrough(bytes, mediaType);
 }
+/**
+ * Whether to package the re-encoded image rather than the original.
+ *
+ * Keep whichever is smaller, since re-encoding can inflate a file: resizing a
+ * diagram resamples its hairlines into shades of grey, and the result can be
+ * larger than the crisp original. Three things override that:
+ *
+ * - An image far past the budget is shrunk regardless, because decoding it
+ *   costs a small reader memory it may not have.
+ * - Greyscale was asked for, and an image small enough to pass through would
+ *   otherwise come out in colour while everything around it was grey.
+ * - WebP is always converted. EPUB 3.3 allows it, but many e-readers still in
+ *   use predate that and show nothing, and bound books serve WebP by default.
+ */
+export function shouldUseReencoded(image) {
+    return (image.mediaType === 'image/webp' ||
+        image.oversize ||
+        image.grayscale ||
+        image.reencodedBytes < image.originalBytes);
+}
 /**
  * Draw the image at its budgeted size and encode it, reporting whether the
  * original was far enough past the budget that it must be shrunk regardless of

package/dist/epub/images.test.js

@@ -1,5 +1,5 @@
 import { expect, test } from 'vitest';
-import { DEFAULT_SIZE, exceedsBudget, fitWithin, mapWithLimit, resolveImageURL, SIZES, } from './images';
+import { DEFAULT_SIZE, exceedsBudget, fitWithin, mapWithLimit, resolveImageURL, shouldUseReencoded, SIZES, } from './images';
 test('shrinks a landscape image to the width budget', () => {
     expect(fitWithin(2400, 1200, 1200, 1600)).toEqual({
         width: 1200,
@@ -129,3 +129,35 @@ test('a preset says nothing about colour', () => {
     for (const size of Object.values(SIZES))
         expect(size).not.toHaveProperty('grayscale');
 });
+const plain = {
+    oversize: false,
+    grayscale: false,
+    originalBytes: 1000,
+    reencodedBytes: 2000,
+};
+test('keeps a PNG or JPEG original when re-encoding would make it larger', () => {
+    expect(shouldUseReencoded({ ...plain, mediaType: 'image/png' })).toBe(false);
+    expect(shouldUseReencoded({ ...plain, mediaType: 'image/jpeg' })).toBe(false);
+});
+test('uses the re-encoded image when it is smaller', () => {
+    expect(shouldUseReencoded({
+        ...plain,
+        mediaType: 'image/png',
+        reencodedBytes: 500,
+    })).toBe(true);
+});
+test('always converts WebP, even when the conversion is larger', () => {
+    expect(shouldUseReencoded({ ...plain, mediaType: 'image/webp' })).toBe(true);
+});
+test('oversize and greyscale images are always re-encoded', () => {
+    expect(shouldUseReencoded({
+        ...plain,
+        mediaType: 'image/png',
+        oversize: true,
+    })).toBe(true);
+    expect(shouldUseReencoded({
+        ...plain,
+        mediaType: 'image/png',
+        grayscale: true,
+    })).toBe(true);
+});

package/dist/models/CRUD.js

@@ -1,4 +1,4 @@
-import { db, functions } from './Firebase';
+import { auth, db, functions } from './Firebase';
 import { collection, getDocs, getDoc, setDoc, doc, addDoc, query, where, deleteDoc, onSnapshot, } from 'firebase/firestore';
 import { httpsCallable } from 'firebase/functions';
 import Edition from './book/Edition';
@@ -78,6 +78,11 @@ export function listenToChapters(bookID, editionID, react) {
 export async function getUserEmails(uids) {
     if (!functions)
         throw Error("Can't publish, no connection to Firebase functions.");
+    // The function only answers signed-in users, and a page load can get here
+    // before Firebase has restored the sign-in, so wait for it.
+    await auth?.authStateReady();
+    if (!auth?.currentUser)
+        return null;
     const getUserEmails = httpsCallable(functions, 'getUserEmailsGen2');
     const result = await getUserEmails({
         uids,

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "bookish-press",
     "private": false,
-    "version": "0.11.0",
+    "version": "0.11.2",
     "type": "module",
     "description": "A platform for reading and writing readable, accessible, beautiful online books.",
     "license": "MIT",