@fiduswriter/books-document 0.1.1

package/src/importer/native/index.ts

@@ -0,0 +1,233 @@
+/**
+ * Native `.fidusbook` importer.
+ *
+ * Uses `NativeImporter` from `@fiduswriter/document/importer/native` for each
+ * chapter and delegates creation of the book record to a `BookImporterBackend`.
+ */
+
+import type {NativeImporterBackend} from "@fiduswriter/document"
+import {NativeImporter} from "@fiduswriter/document/importer/native"
+import {addAlert} from "fwtoolkit"
+
+import type {BookImporterBackend, Chapter, User} from "../../types.js"
+import {readFidusBookFile} from "./reader.js"
+
+export {FIDUSBOOK_VERSION} from "./reader.js"
+export {readFidusBookFile, FidusBookReader} from "./reader.js"
+
+export class NativeBookImporter {
+    file: Blob
+    user: User
+    path: string
+    nativeBackend: NativeImporterBackend
+    bookBackend: BookImporterBackend
+
+    ok: boolean
+    statusText: string
+    bookId: number | null
+
+    constructor(
+        file: Blob,
+        user: User,
+        nativeBackend: NativeImporterBackend,
+        bookBackend: BookImporterBackend,
+        path = "/"
+    ) {
+        this.file = file
+        this.user = user
+        this.path = path.endsWith("/") ? path : path + "/"
+        this.nativeBackend = nativeBackend
+        this.bookBackend = bookBackend
+
+        this.ok = false
+        this.statusText = ""
+        this.bookId = null
+    }
+
+    /**
+     * Entry point.  Validates the file is a ZIP, then delegates to the reader.
+     */
+    init(): Promise<NativeBookImporter> {
+        return new Promise(resolve => {
+            const reader = new FileReader()
+            reader.onloadend = () => {
+                if (
+                    reader.result &&
+                    (reader.result as string).length > 60 &&
+                    (reader.result as string).substring(0, 2) === "PK"
+                ) {
+                    this.readZip().then(() => resolve(this))
+                } else {
+                    this.statusText = gettext(
+                        "The uploaded file does not appear to be a Fidusbook file."
+                    )
+                    resolve(this)
+                }
+            }
+            reader.readAsText(this.file.slice(0, 64))
+        })
+    }
+
+    async readZip(): Promise<void> {
+        let textFiles: Array<{filename: string; content: string}> = []
+        let binaryFiles: Array<{filename: string; content: Blob}> = []
+
+        try {
+            const JSZip = (await import("jszip")).default
+            const zipfs = await JSZip.loadAsync(this.file)
+
+            const filenames: string[] = []
+            zipfs.forEach(filename => filenames.push(filename))
+
+            await Promise.all(
+                filenames
+                    .filter(f => !f.endsWith("/"))
+                    .map(async filename => {
+                        const isText =
+                            filename.endsWith(".json") ||
+                            filename === "filetype-version" ||
+                            filename === "mimetype"
+                        const content = await zipfs.files[filename].async(
+                            isText ? "string" : "blob"
+                        )
+                        if (isText) {
+                            textFiles.push({
+                                filename,
+                                content: content as string
+                            })
+                        } else {
+                            binaryFiles.push({
+                                filename,
+                                content: content as Blob
+                            })
+                        }
+                    })
+            )
+        } catch (error) {
+            this.statusText = gettext(
+                "The uploaded file does not appear to be a Fidusbook file."
+            )
+            return
+        }
+
+        return this.processFidusbookFile(textFiles, binaryFiles)
+    }
+
+    async processFidusbookFile(
+        textFiles: Array<{filename: string; content: string}>,
+        binaryFiles: Array<{filename: string; content: Blob}>
+    ): Promise<void> {
+        const versionEntry = textFiles.find(
+            f => f.filename === "filetype-version"
+        )
+        const filetypeVersion = Number.parseFloat(versionEntry?.content || "")
+
+        if (
+            filetypeVersion < 1.0 ||
+            filetypeVersion > 1.0
+        ) {
+            this.statusText =
+                gettext(
+                    "The Fidusbook file version is not supported by this server: "
+                ) + (versionEntry?.content || "")
+            return
+        }
+
+        const mimetypeEntry = textFiles.find(f => f.filename === "mimetype")
+        if (
+            mimetypeEntry &&
+            mimetypeEntry.content !== "application/fidusbook+zip"
+        ) {
+            this.statusText = gettext(
+                "The uploaded file does not appear to be a Fidusbook file."
+            )
+            return
+        }
+
+        const bookData = JSON.parse(
+            textFiles.find(f => f.filename === "book.json")?.content || "{}"
+        ) as Record<string, any>
+
+        const sortedChapters = [...(bookData.chapters as Array<{chapter_index: number; number: number; part?: string}>)].sort(
+            (a, b) => a.chapter_index - b.chapter_index
+        )
+
+        const importedDocIds: Record<number, number> = {}
+
+        for (const chapter of sortedChapters) {
+            const ci = chapter.chapter_index
+
+            const docFile = textFiles.find(
+                f => f.filename === `chapters/${ci}/document.json`
+            )
+            const imagesFile = textFiles.find(
+                f => f.filename === `chapters/${ci}/images.json`
+            )
+            const bibFile = textFiles.find(
+                f => f.filename === `chapters/${ci}/bibliography.json`
+            )
+
+            if (!docFile || !imagesFile || !bibFile) {
+                addAlert(
+                    "error",
+                    gettext("Fidusbook file is missing data for chapter ") +
+                        (sortedChapters.indexOf(chapter) + 1)
+                )
+                throw new Error(`Missing chapter data for index ${ci}`)
+            }
+
+            const docJson = JSON.parse(docFile.content) as Record<string, any>
+            const imagesJson = JSON.parse(imagesFile.content) as Record<string, any>
+            const bibJson = JSON.parse(bibFile.content) as Record<string, any>
+
+            const chapterPrefix = `chapters/${ci}/images/`
+            const chapterOtherFiles = binaryFiles
+                .filter(f => f.filename.startsWith(chapterPrefix))
+                .map(f => ({
+                    filename: `images/${f.filename.slice(chapterPrefix.length)}`,
+                    content: f.content
+                }))
+
+            const safeBookTitle = (bookData.title as string) || "Untitled"
+            const chapterPath = `${this.path}${safeBookTitle}/${(docJson.title as string) || "Untitled"}`
+
+            const importer = new NativeImporter(
+                docJson,
+                bibJson,
+                {db: imagesJson},
+                chapterOtherFiles,
+                this.user,
+                this.nativeBackend,
+                {
+                    requestedPath: chapterPath
+                }
+            )
+
+            let doc
+            try {
+                ;({doc} = await importer.init())
+            } catch (error) {
+                addAlert(
+                    "error",
+                    gettext("Could not import chapter ") +
+                        ((docJson.title as string) ||
+                            sortedChapters.indexOf(chapter) + 1)
+                )
+                throw error
+            }
+
+            importedDocIds[ci] = doc.id as number
+        }
+
+        const chapters: Chapter[] = sortedChapters.map(chapter => ({
+            text: importedDocIds[chapter.chapter_index],
+            number: chapter.number,
+            part: chapter.part || ""
+        }))
+
+        const book = await this.bookBackend.createBook(bookData as any, chapters, false)
+        this.bookId = book.id || null
+        this.ok = true
+        this.statusText = `"${bookData.title}" ${gettext("successfully imported.")}`
+    }
+}

package/src/importer/native/reader.ts

@@ -0,0 +1,165 @@
+/**
+ * Pure reader for `.fidusbook` archives.
+ *
+ * Reads the ZIP file, validates the mimetype/version, and returns the raw
+ * book metadata plus a `documentList` shaped like the one used by the
+ * exporters.  No server interaction.
+ */
+
+import type {DocumentListEntry} from "../../types.js"
+
+export const FIDUSBOOK_VERSION = "1.0"
+export const MIN_FIDUSBOOK_VERSION = 1.0
+export const MAX_FIDUSBOOK_VERSION = 1.0
+
+interface ArchiveFile {
+    filename: string
+    content: string | Blob
+}
+
+export interface FidusBookReaderResult {
+    book: Record<string, unknown>
+    documentList: DocumentListEntry[]
+}
+
+/**
+ * Read a `.fidusbook` archive and return its contents.
+ *
+ * @param file - A File/Blob/ArrayBuffer containing the archive.
+ * @returns The parsed book and document list.
+ */
+export async function readFidusBookFile(
+    file: Blob | ArrayBuffer
+): Promise<FidusBookReaderResult> {
+    const JSZip = (await import("jszip")).default
+    const zipfs = await JSZip.loadAsync(file)
+
+    const filenames: string[] = []
+    zipfs.forEach(filename => filenames.push(filename))
+
+    if (
+        !filenames.includes("book.json") ||
+        !filenames.includes("filetype-version")
+    ) {
+        throw new Error("The file does not appear to be a Fidusbook file.")
+    }
+
+    const textFiles: ArchiveFile[] = []
+    const binaryFiles: ArchiveFile[] = []
+
+    await Promise.all(
+        filenames
+            .filter(f => !f.endsWith("/"))
+            .map(async filename => {
+                const isText =
+                    filename.endsWith(".json") ||
+                    filename === "filetype-version" ||
+                    filename === "mimetype"
+                const content = await zipfs.files[filename].async(
+                    isText ? "string" : "blob"
+                )
+                const entry = {filename, content}
+                if (isText) {
+                    textFiles.push(entry as ArchiveFile)
+                } else {
+                    binaryFiles.push(entry as ArchiveFile)
+                }
+            })
+    )
+
+    const versionEntry = textFiles.find(f => f.filename === "filetype-version")
+    const filetypeVersion = Number.parseFloat(versionEntry?.content as string)
+
+    if (
+        filetypeVersion < MIN_FIDUSBOOK_VERSION ||
+        filetypeVersion > MAX_FIDUSBOOK_VERSION
+    ) {
+        throw new Error(
+            `The Fidusbook file version is not supported by this reader: ${String(
+                versionEntry?.content
+            )}`
+        )
+    }
+
+    const mimetypeEntry = textFiles.find(f => f.filename === "mimetype")
+    if (
+        mimetypeEntry &&
+        mimetypeEntry.content !== "application/fidusbook+zip"
+    ) {
+        throw new Error("The file does not appear to be a Fidusbook file.")
+    }
+
+    const bookData = JSON.parse(
+        textFiles.find(f => f.filename === "book.json")?.content as string
+    ) as Record<string, unknown>
+
+    const sortedChapters = [...(bookData.chapters as Array<{chapter_index: number}>)].sort(
+        (a, b) => a.chapter_index - b.chapter_index
+    )
+
+    const documentList: DocumentListEntry[] = []
+
+    for (const chapter of sortedChapters) {
+        const ci = chapter.chapter_index
+
+        const docFile = textFiles.find(
+            f => f.filename === `chapters/${ci}/document.json`
+        )
+        const imagesFile = textFiles.find(
+            f => f.filename === `chapters/${ci}/images.json`
+        )
+        const bibFile = textFiles.find(
+            f => f.filename === `chapters/${ci}/bibliography.json`
+        )
+
+        if (!docFile || !imagesFile || !bibFile) {
+            throw new Error(`Missing chapter data for index ${ci}`)
+        }
+
+        const docJson = JSON.parse(docFile.content as string) as Record<string, unknown>
+        const imagesJson = JSON.parse(imagesFile.content as string) as Record<string, {image: string; file?: Blob}>
+        const bibJson = JSON.parse(bibFile.content as string) as Record<string, unknown>
+
+        const chapterPrefix = `chapters/${ci}/images/`
+        const chapterImages: Record<string, Blob> = {}
+        binaryFiles
+            .filter(f => f.filename.startsWith(chapterPrefix))
+            .forEach(f => {
+                chapterImages[
+                    `images/${f.filename.slice(chapterPrefix.length)}`
+                ] = f.content as Blob
+            })
+
+        Object.entries(imagesJson).forEach(([, image]) => {
+            if (chapterImages[image.image]) {
+                image.file = chapterImages[image.image]
+            }
+        })
+
+        documentList.push({
+            id: (docJson.id as number) || 0,
+            title: (docJson.title as string) || "",
+            path: (docJson.path as string) || "",
+            content: (docJson.content || {
+                type: "doc",
+                content: []
+            }) as DocumentListEntry["content"],
+            settings: (docJson.settings || {}) as DocumentListEntry["settings"],
+            comments: (docJson.comments || {}) as DocumentListEntry["comments"],
+            images: imagesJson as DocumentListEntry["images"],
+            bibliography: bibJson as DocumentListEntry["bibliography"],
+            rawContent: docJson.rawContent as DocumentListEntry["rawContent"],
+            e2ee: docJson.e2ee as boolean | undefined,
+            e2ee_salt: docJson.e2ee_salt as string | undefined,
+            e2ee_iterations: docJson.e2ee_iterations as number | undefined
+        } as DocumentListEntry)
+    }
+
+    return {book: bookData, documentList}
+}
+
+export class FidusBookReader {
+    async read(file: Blob | ArrayBuffer): Promise<FidusBookReaderResult> {
+        return readFidusBookFile(file)
+    }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export {FIDUSBOOK_VERSION} from "./schema/index.js"
+export type {
+    Book,
+    BookBaseMetadata,
+    BookCoverImage,
+    BookExporterOptions,
+    BookImporterBackend,
+    BookMetadata,
+    BookSettings,
+    BookStyle,
+    BookStyles,
+    BookTexTemplateParams,
+    BitsTemplateParams,
+    Chapter,
+    DocumentListEntry,
+    E2EEStrategy,
+    ChapterLoader,
+    FidusBookArchive
+} from "./types.js"

package/src/modules.d.ts

@@ -0,0 +1,11 @@
+declare module "pretty" {
+    function pretty(html: string, options?: {ocd?: boolean}): string
+    export default pretty
+}
+
+declare module "@vivliostyle/print" {
+    export function printHTML(
+        html: string,
+        config?: Record<string, unknown>
+    ): void
+}

package/src/schema/index.ts

@@ -0,0 +1,4 @@
+export * from "@fiduswriter/document/schema"
+
+/** The current Fidus Writer book archive version. */
+export const FIDUSBOOK_VERSION = "1.0"

package/src/types.ts

@@ -0,0 +1,188 @@
+/**
+ * Core types for the @fiduswriter/books-document package.
+ */
+
+import type {Schema} from "prosemirror-model"
+import type {
+    BibDB,
+    CSL,
+    ExportDoc,
+    ExportMetadata,
+    ImageDB,
+    User
+} from "@fiduswriter/document"
+
+export type {CSL, User} from "@fiduswriter/document"
+
+/** A single chapter entry inside a book. */
+export interface Chapter {
+    /** Document ID of the chapter. */
+    text: number
+    /** Display number / order of the chapter. */
+    number: number
+    /** Optional part title. */
+    part?: string
+    /** Archive storage index (used by the native importer). */
+    chapter_index?: number
+}
+
+/** Book metadata block. */
+export interface BookMetadata {
+    subtitle?: string
+    author?: string
+    version?: string
+    publisher?: string
+    copyright?: string
+    description?: string
+    isbn?: string
+    publication_date?: string
+    series_title?: string
+    series_position?: string
+    keywords?: string
+    [key: string]: unknown
+}
+
+/** Book settings block. */
+export interface BookSettings {
+    language: string
+    book_style?: string
+    papersize?: string
+    [key: string]: unknown
+}
+
+/** A book record. */
+export interface Book {
+    id?: number
+    title: string
+    path?: string
+    metadata: BookMetadata
+    settings: BookSettings
+    chapters: Chapter[]
+    cover_image?: number
+    cover_image_data?: BookCoverImage
+    updated?: number
+    added?: number
+    docx_template?: string
+    odt_template?: string
+    rights?: string
+    [key: string]: unknown
+}
+
+/** Cover image description stored in a book. */
+export interface BookCoverImage {
+    title?: string
+    checksum?: string
+    file_type?: string
+    image?: string
+    [key: string]: unknown
+}
+
+/** A single book style with its associated media files. */
+export interface BookStyle {
+    slug: string
+    contents: string
+    bookstylefile_set: Array<[string, string]>
+    [key: string]: unknown
+}
+
+export type BookStyles = BookStyle[]
+
+/** A document entry as held in the book's document list. */
+export interface DocumentListEntry extends ExportDoc {
+    /** Raw ProseMirror content (used by DOCX/ODT exporters). */
+    rawContent?: Record<string, unknown>
+    /** Whether the document is end-to-end encrypted. */
+    e2ee?: boolean
+    /** Base64-encoded salt for E2EE key derivation. */
+    e2ee_salt?: string
+    /** PBKDF2 iterations for E2EE key derivation. */
+    e2ee_iterations?: number
+    images?: ImageDB["db"]
+    bibliography?: BibDB["db"]
+}
+
+/** Options shared by book exporters. */
+export interface BookExporterOptions {
+    /** ProseMirror schema used for E2EE decryption. */
+    schema?: Schema
+    /** CSL engine provider. */
+    csl?: CSL
+    /** Book styles data. */
+    bookStyles?: BookStyles
+    /** Logged-in user. */
+    user?: User
+    /** Document list entries for the book's chapters. */
+    documentList?: DocumentListEntry[]
+    /** Last-modified timestamp (seconds since epoch). */
+    updated?: number
+    /** Whether to produce multiple HTML files (HTML exporter only). */
+    multiDoc?: boolean
+    /** Use relative URLs for linked assets (HTML exporter only). */
+    relativeUrls?: boolean
+}
+
+/** Strategy for loading missing chapter data before export. */
+export interface ChapterLoader {
+    loadChapters(
+        chapterIds: number[],
+        documentList: DocumentListEntry[],
+        schema?: Schema,
+        rawContent?: boolean
+    ): Promise<void>
+}
+
+/** Strategy for handling end-to-end encrypted chapters. */
+export interface E2EEStrategy {
+    ensurePassphraseUnlocked(): Promise<boolean>
+    getDocumentPassword(docId: number): Promise<string | null>
+    resolvePasswordToKey(
+        password: string,
+        salt: Uint8Array,
+        iterations: number
+    ): Promise<CryptoKey>
+    decryptObject(encrypted: string, key: CryptoKey): Promise<unknown>
+    decryptImageToUrl(encrypted: string, key: CryptoKey): Promise<string>
+    storePasswordInSession?(docId: number, password: string): void
+}
+
+/** Backend used by NativeBookImporter to create the book record. */
+export interface BookImporterBackend {
+    /**
+     * Create a book record from the imported book data and chapter documents.
+     *
+     * @param bookData - The raw book object from book.json.
+     * @param chapters - The chapters with their final document IDs.
+     * @param coverImageId - ID of the imported cover image, or false.
+     * @returns A promise resolving to the created book record.
+     */
+    createBook(
+        bookData: Record<string, unknown>,
+        chapters: Chapter[],
+        coverImageId: number | false
+    ): Promise<Book>
+}
+
+/** Raw archive content returned by FidusBookReader. */
+export interface FidusBookArchive {
+    book: Record<string, unknown>
+    documentList: DocumentListEntry[]
+}
+
+/** Parameters passed to the book.tex template. */
+export interface BookTexTemplateParams {
+    book: Book
+    preamble: string
+    epilogue: string
+}
+
+/** Parameters passed to the BITS book template. */
+export interface BitsTemplateParams {
+    front: string
+    body: string
+    back: string
+}
+
+/** Base metadata used by DOCX/ODT book exporters. */
+export interface BookBaseMetadata extends ExportMetadata {
+    language: string
+}