@fiduswriter/document 0.1.0-alpha.1

package/src/importer/pandoc/helpers.js

@@ -0,0 +1,84 @@
+export const applyMarkToNodes = (nodes, markType, attrs = null) => {
+    return nodes.map(node => {
+        if (node.type === "text") {
+            const mark = attrs ? {type: markType, attrs} : {type: markType}
+            return {
+                ...node,
+                marks: [...(node.marks || []), mark]
+            }
+        }
+        return node
+    })
+}
+
+export const mergeTextNodes = nodes => {
+    const mergedNodes = []
+    let currentNode = null
+
+    const areSameMarks = (marks1 = [], marks2 = []) => {
+        if (marks1.length !== marks2.length) {
+            return false
+        }
+        // Sort marks by type to ensure consistent comparison
+        const sortedMarks1 = [...marks1].sort((a, b) =>
+            a.type.localeCompare(b.type)
+        )
+        const sortedMarks2 = [...marks2].sort((a, b) =>
+            a.type.localeCompare(b.type)
+        )
+        return sortedMarks1.every((mark, index) => {
+            const mark2 = sortedMarks2[index]
+            if (mark.type !== mark2.type) {
+                return false
+            }
+            if (!mark.attrs && !mark2.attrs) {
+                return true
+            }
+            return JSON.stringify(mark.attrs) === JSON.stringify(mark2.attrs)
+        })
+    }
+
+    nodes.forEach(node => {
+        if (node.type === "text") {
+            if (
+                currentNode &&
+                currentNode.type === "text" &&
+                areSameMarks(currentNode.marks, node.marks)
+            ) {
+                // Merge with previous node
+                currentNode.text += node.text
+            } else {
+                // Start new node
+                if (currentNode) {
+                    mergedNodes.push(currentNode)
+                }
+                currentNode = {...node}
+            }
+        } else {
+            if (currentNode) {
+                mergedNodes.push(currentNode)
+            }
+            mergedNodes.push(node)
+            currentNode = null
+        }
+    })
+
+    if (currentNode) {
+        mergedNodes.push(currentNode)
+    }
+
+    return mergedNodes
+}
+
+export const applyAnnotation = (nodes, type) => {
+    return nodes.map(node => ({
+        ...node,
+        marks: [
+            ...(node.marks || []),
+            {
+                type: "annotation_tag",
+                attrs: {type, key: "", value: ""}
+            }
+        ]
+    }))
+}

package/src/importer/zip_analyzer.js

@@ -0,0 +1,102 @@
+export class ZipAnalyzer {
+    constructor(zip, formats = []) {
+        this.zip = zip
+        this.formats = formats
+
+        this.analysis = null
+    }
+
+    analyze() {
+        if (this.analysis) {
+            return this.analysis
+        }
+
+        let convertibleFile = null
+        const imageFiles = []
+        let bibFile = null
+
+        // Analyze all files in the ZIP
+        this.zip.forEach((relativePath, zipEntry) => {
+            if (!zipEntry.dir) {
+                const fileName = relativePath.split("/").pop()
+                const extension = fileName.split(".").pop().toLowerCase()
+
+                if (extension === "bib") {
+                    bibFile = zipEntry
+                } else if (
+                    [
+                        "avif",
+                        "avifs",
+                        "png",
+                        "jpg",
+                        "jpeg",
+                        "gif",
+                        "svg",
+                        "webp"
+                    ].includes(extension)
+                ) {
+                    imageFiles.push({path: relativePath, entry: zipEntry})
+                } else if (this.formats.includes(extension)) {
+                    // Store the first convertible file found
+                    if (!convertibleFile) {
+                        convertibleFile = {
+                            path: relativePath,
+                            entry: zipEntry,
+                            fileName,
+                            format: extension
+                        }
+                    }
+                }
+            }
+        })
+
+        this.analysis = {
+            hasConvertible: Boolean(convertibleFile),
+            format: convertibleFile ? convertibleFile.format : null,
+            convertibleFile,
+            imageFiles,
+            bibFile
+        }
+
+        return this.analysis
+    }
+
+    async getContents() {
+        if (!this.analysis) {
+            await this.analyze()
+        }
+
+        const contents = {
+            images: {},
+            bibliography: null,
+            mainContent: null
+        }
+
+        // Load main content file
+        if (this.analysis.hasConvertible) {
+            const mainBlob =
+                await this.analysis.convertibleFile.entry.async("blob")
+            contents.mainContent = new File(
+                [mainBlob],
+                this.analysis.convertibleFile.fileName
+            )
+        }
+
+        // Load images
+        const imagePromises = this.analysis.imageFiles.map(
+            async ({path, entry}) => {
+                const blob = await entry.async("blob")
+                contents.images[path] = blob
+                return {filename: path, blob}
+            }
+        )
+        await Promise.all(imagePromises)
+
+        // Load bibliography if present
+        if (this.analysis.bibFile) {
+            contents.bibliography = await this.analysis.bibFile.async("text")
+        }
+
+        return contents
+    }
+}

package/src/index.js

@@ -0,0 +1 @@
+export {FW_DOCUMENT_VERSION} from "./schema/index.js"

package/src/mathlive/opf_includes.js

@@ -0,0 +1,24 @@
+// This file is auto-generated. CHANGES WILL BE OVERWRITTEN! Re-generate by running ./manage.py bundle_mathlive.
+export const mathliveOpfIncludes = `
+<item id="mathlive-0" href="css/mathlive.css" media-type="text/css" />
+<item id="mathlive-1" href="css/media/KaTeX_Caligraphic-Bold.woff2" media-type="font/woff2" />
+<item id="mathlive-2" href="css/media/KaTeX_Fraktur-Bold.woff2" media-type="font/woff2" />
+<item id="mathlive-3" href="css/media/KaTeX_SansSerif-Bold.woff2" media-type="font/woff2" />
+<item id="mathlive-4" href="css/media/KaTeX_Size1-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-5" href="css/media/KaTeX_Fraktur-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-6" href="css/media/KaTeX_SansSerif-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-7" href="css/media/KaTeX_Main-Italic.woff2" media-type="font/woff2" />
+<item id="mathlive-8" href="css/media/KaTeX_Size4-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-9" href="css/media/KaTeX_Caligraphic-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-10" href="css/media/KaTeX_AMS-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-11" href="css/media/KaTeX_SansSerif-Italic.woff2" media-type="font/woff2" />
+<item id="mathlive-12" href="css/media/KaTeX_Size3-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-13" href="css/media/KaTeX_Size2-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-14" href="css/media/KaTeX_Script-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-15" href="css/media/KaTeX_Main-Bold.woff2" media-type="font/woff2" />
+<item id="mathlive-16" href="css/media/KaTeX_Math-BoldItalic.woff2" media-type="font/woff2" />
+<item id="mathlive-17" href="css/media/KaTeX_Main-BoldItalic.woff2" media-type="font/woff2" />
+<item id="mathlive-18" href="css/media/KaTeX_Main-Regular.woff2" media-type="font/woff2" />
+<item id="mathlive-19" href="css/media/KaTeX_Math-Italic.woff2" media-type="font/woff2" />
+<item id="mathlive-20" href="css/media/KaTeX_Typewriter-Regular.woff2" media-type="font/woff2" />
+`

package/src/schema/common/annotate.js

@@ -0,0 +1,76 @@
+// Annotation tag is not used by the core Fidus Writer editor, but can be used by plugins that need to add annotation capability.
+export const annotation_tag = {
+    attrs: {
+        type: {
+            default: "" // Make this a string unique to your plugin so that you avoid handling tags of other plugins. For example 'rdfa' for an rdfa-tagging plugin.
+        },
+        key: {
+            default: "" // key or variable/tag name
+        },
+        value: {
+            default: "" // value of variable/tag
+        }
+    },
+    inclusive: false,
+    excludes: "", // allows several tags on the same content.
+    group: "annotation",
+    parseDOM: [
+        {
+            tag: "span.annotation-tag[data-type]",
+            getAttrs(dom) {
+                return {
+                    type: dom.dataset.type,
+                    key: dom.dataset.key ? dom.dataset.key : "",
+                    value: dom.dataset.value ? dom.dataset.value : ""
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {
+            class: "annotation-tag",
+            "data-type": node.attrs.type
+        }
+        if (node.attrs.key?.length) {
+            attrs["data-key"] = node.attrs.key
+        }
+        if (node.attrs.value?.length) {
+            attrs["data-value"] = node.attrs.value
+        }
+        return ["span", attrs]
+    }
+}
+
+export const comment = {
+    attrs: {
+        id: {
+            default: false
+        }
+    },
+    inclusive: false,
+    excludes: "",
+    group: "annotation",
+    parseDOM: [
+        {
+            tag: "span.comment[data-id]",
+            getAttrs(dom) {
+                return {
+                    id: Number.parseInt(dom.dataset.id)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: "comment",
+                "data-id": node.attrs.id
+            }
+        ]
+    }
+}
+
+export function randomCommentId() {
+    return String(Math.floor(Math.random() * 0xffffffff))
+}

package/src/schema/common/base.js

@@ -0,0 +1,118 @@
+import {parseTracks} from "./track.js"
+
+// :: NodeSpec A plain paragraph textblock. Represented in the DOM
+// as a `<p>` element.
+export const paragraph = {
+    group: "block",
+    content: "inline*",
+    attrs: {
+        track: {
+            default: []
+        }
+    },
+    parseDOM: [
+        {
+            tag: "p",
+            getAttrs(dom) {
+                return {
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs =
+            node.attrs.track && node.attrs.track.length
+                ? {"data-track": JSON.stringify(node.attrs.track)}
+                : {}
+        return ["p", attrs, 0]
+    }
+}
+
+// :: NodeSpec A blockquote (`<blockquote>`) wrapping one or more blocks.
+export const blockquote = {
+    content: "block+",
+    group: "block",
+    attrs: {
+        track: {
+            default: []
+        }
+    },
+    marks: "annotation",
+    defining: true,
+    parseDOM: [
+        {
+            tag: "blockquote",
+            getAttrs(dom) {
+                return {
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs =
+            node.attrs.track && node.attrs.track.length
+                ? {"data-track": JSON.stringify(node.attrs.track)}
+                : {}
+        return ["blockquote", attrs, 0]
+    }
+}
+
+// :: NodeSpec A horizontal rule (`<hr>`).
+export const horizontal_rule = {
+    group: "block",
+    attrs: {
+        track: {
+            default: []
+        }
+    },
+    parseDOM: [
+        {
+            tag: "hr",
+            getAttrs(dom) {
+                return {
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs =
+            node.attrs.track && node.attrs.track.length
+                ? {"data-track": JSON.stringify(node.attrs.track)}
+                : {}
+        return ["hr", attrs]
+    }
+}
+
+export const underline = {
+    parseDOM: [{tag: "span.underline"}],
+    toDOM() {
+        return ["span", {class: "underline"}, 0]
+    }
+}
+
+export const sup = {
+    parseDOM: [{tag: "sup"}],
+    toDOM() {
+        return ["sup", 0]
+    },
+    excludes: "sub"
+}
+
+export const sub = {
+    parseDOM: [{tag: "sub"}],
+    toDOM() {
+        return ["sub", 0]
+    },
+    excludes: "sup"
+}
+
+export const code = {
+    parseDOM: [{tag: "code"}],
+    toDOM() {
+        return ["code", 0]
+    },
+    excludes: "strong em underline link sup sub"
+}

package/src/schema/common/citation.js

@@ -0,0 +1,62 @@
+function parseReferences(str) {
+    if (!str) {
+        return []
+    }
+    let references
+    try {
+        references = JSON.parse(str)
+    } catch (_error) {
+        return []
+    }
+    if (!Array.isArray(references)) {
+        return []
+    }
+    return references
+        .filter(
+            ref => ref.hasOwnProperty("id") // ensure there is an id.
+        )
+        .map(ref => {
+            const mRef = {id: ref.id}
+            if (ref.locator) {
+                mRef.locator = ref.locator
+            }
+            if (ref.prefix) {
+                mRef.prefix = ref.prefix
+            }
+            return mRef
+        })
+}
+
+export const citation = {
+    inline: true,
+    group: "inline",
+    attrs: {
+        format: {
+            default: "autocite" // "autocite" or "textcite"
+        },
+        references: {
+            default: [] // array of {id[, locator][, prefix]}
+        }
+    },
+    parseDOM: [
+        {
+            tag: "span.citation",
+            getAttrs(dom) {
+                return {
+                    format: dom.dataset.format || "",
+                    references: parseReferences(dom.dataset.references)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: "citation",
+                "data-format": node.attrs.format,
+                "data-references": JSON.stringify(node.attrs.references)
+            }
+        ]
+    }
+}

package/src/schema/common/equation.js

@@ -0,0 +1,31 @@
+export const equation = {
+    inline: true,
+    group: "inline",
+    attrs: {
+        equation: {
+            default: ""
+        }
+    },
+    parseDOM: [
+        {
+            tag: "span.equation",
+            getAttrs(dom) {
+                return {
+                    equation: dom.dataset.equation
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const dom = document.createElement("span")
+        dom.dataset.equation = node.attrs.equation
+        dom.classList.add("equation")
+        import("mathlive").then(MathLive => {
+            dom.innerHTML = MathLive.convertLatexToMarkup(node.attrs.equation, {
+                mathstyle: "textstyle"
+            })
+        })
+        dom.setAttribute("contenteditable", "false")
+        return dom
+    }
+}

package/src/schema/common/figure.js

@@ -0,0 +1,190 @@
+import {parseTracks} from "./track.js"
+
+export function randomFigureId() {
+    return "F" + Math.round(Math.random() * 10000000) + 1
+}
+
+let imageDBBroken = false
+
+export const figure = {
+    inline: false,
+    allowGapCursor: false,
+    selectable: true,
+    group: "block",
+    attrs: {
+        category: {default: "none"},
+        caption: {default: false},
+        id: {default: false},
+        track: {default: []},
+        aligned: {default: "center"},
+        width: {default: "100"}
+    },
+    content:
+        "figure_caption image|figure_caption figure_equation|image figure_caption|figure_equation figure_caption",
+    parseDOM: [
+        {
+            tag: "figure",
+            getAttrs(dom) {
+                return {
+                    category: dom.dataset.category,
+                    caption: !!dom.dataset.captionHidden,
+                    id: dom.id,
+                    track: parseTracks(dom.dataset.track),
+                    aligned: dom.dataset.aligned,
+                    width: dom.dataset.width,
+                    diff: dom.dataset.diff
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {
+            id: node.attrs.id,
+            class: `aligned-${node.attrs.aligned} image-width-${node.attrs.width}`,
+            "data-aligned": node.attrs.aligned,
+            "data-width": node.attrs.width,
+            "data-category": node.attrs.category
+        }
+        if (!node.attrs.caption) {
+            attrs["data-caption-hidden"] = true
+        }
+        if (node.attrs.track?.length) {
+            attrs["data-track"] = JSON.stringify(node.attrs.track)
+        }
+        return ["figure", attrs, 0]
+    }
+}
+
+export const image = {
+    selectable: false,
+    draggable: false,
+    attrs: {
+        image: {default: false}
+    },
+    parseDOM: [
+        {
+            tag: "img",
+            getAttrs(dom) {
+                const image = Number.parseInt(dom.dataset.image)
+                return {
+                    image: isNaN(image) ? false : image
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const dom = document.createElement("img")
+        if (node.attrs.image !== false) {
+            dom.dataset.image = node.attrs.image
+            const imageDB = node.type.schema.cached.imageDB
+            if (imageDB) {
+                const imageEntry = imageDB.db[node.attrs.image]
+                if (imageEntry?.image) {
+                    const isEncrypted =
+                        imageEntry.file_type === "application/octet-stream"
+                    if (isEncrypted) {
+                        const editor = imageDB.mod?.editor
+                        const key = editor?.e2ee?.key
+                        if (key) {
+                            import("../../editor/e2ee/encryptor.js").then(
+                                ({E2EEEncryptor}) => {
+                                    E2EEEncryptor.decryptImageToUrl(
+                                        imageEntry.image,
+                                        key,
+                                        imageEntry.original_file_type ||
+                                            "image/png"
+                                    )
+                                        .then(url => {
+                                            dom.setAttribute("src", url)
+                                            dom.dataset.imageSrc = url
+                                        })
+                                        .catch(() => {
+                                            dom.setAttribute(
+                                                "src",
+                                                (typeof staticUrl !== "undefined" ? staticUrl("img/error.avif") : "/static/img/error.avif")
+                                            )
+                                        })
+                                }
+                            )
+                        } else {
+                            dom.setAttribute("src", (typeof staticUrl !== "undefined" ? staticUrl("img/error.avif") : "/static/img/error.avif"))
+                        }
+                    } else {
+                        const imgSrc = imageEntry.image
+                        dom.setAttribute("src", imgSrc)
+                        dom.dataset.imageSrc = imgSrc
+                    }
+                } else {
+                    /* The image was not present in the imageDB -- possibly because a collaborator just added it.
+                    Try to reload the imageDB, but only once. If the image cannot be found in the updated
+                    imageDB, do not attempt at reloading the imageDB if an image cannot be
+                    found. */
+                    if (imageDBBroken) {
+                        dom.setAttribute("src", (typeof staticUrl !== "undefined" ? staticUrl("img/error.avif") : "/static/img/error.avif"))
+                    } else {
+                        imageDB.getDB().then(() => {
+                            const refreshedEntry = imageDB.db[node.attrs.image]
+                            if (refreshedEntry?.image) {
+                                dom.setAttribute("src", refreshedEntry.image)
+                                dom.dataset.imageSrc = refreshedEntry.image
+                            } else {
+                                imageDBBroken = true
+                            }
+                        })
+                    }
+                }
+            }
+        }
+        return dom
+    }
+}
+
+export const figure_equation = {
+    selectable: false,
+    draggable: false,
+    attrs: {
+        equation: {
+            default: false
+        }
+    },
+    parseDOM: [
+        {
+            tag: "div.figure-equation[data-equation]",
+            getAttrs(dom) {
+                return {
+                    equation: dom.dataset.equation
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const dom = document.createElement("div")
+        dom.dataset.equation = node.attrs.equation
+        dom.classList.add("figure-equation")
+        if (node.attrs.equation !== false) {
+            import("mathlive").then(MathLive => {
+                dom.innerHTML = MathLive.convertLatexToMarkup(
+                    node.attrs.equation,
+                    {
+                        mathstyle: "displaystyle"
+                    }
+                )
+            })
+        }
+        return dom
+    }
+}
+
+export const figure_caption = {
+    isolating: true,
+    defining: true,
+    content: "inline*",
+    parseDOM: [{tag: "figcaption span.text"}],
+    toDOM() {
+        return [
+            "figcaption",
+            ["span", {class: "label"}],
+            ["span", {class: "text"}, 0]
+        ]
+    }
+}