@fiduswriter/document 0.1.0-alpha.3 → 0.1.0-alpha.5

package/src/schema/common/{figure.js → figure.ts}

@@ -1,11 +1,31 @@
+import type {NodeSpec} from "prosemirror-model"
+
 import {parseTracks} from "./track.js"
 
-export function randomFigureId() {
+export function randomFigureId(): string {
     return "F" + Math.round(Math.random() * 10000000) + 1
 }
 
 let imageDBBroken = false
 
+interface ImageDBEntry {
+    file_type?: string
+    image?: string
+    original_file_type?: string
+}
+
+interface ImageDB {
+    db: Record<number, ImageDBEntry>
+    mod?: {
+        editor?: {
+            e2ee?: {
+                key?: CryptoKey
+            }
+        }
+    }
+    getDB?: () => Promise<unknown>
+}
+
 export const figure = {
     inline: false,
     allowGapCursor: false,
@@ -24,11 +44,11 @@ export const figure = {
     parseDOM: [
         {
             tag: "figure",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     category: dom.dataset.category,
                     caption: !!dom.dataset.captionHidden,
-                    id: dom.id,
+                    id: dom.id || false,
                     track: parseTracks(dom.dataset.track),
                     aligned: dom.dataset.aligned,
                     width: dom.dataset.width,
@@ -38,7 +58,7 @@ export const figure = {
         }
     ],
     toDOM(node) {
-        const attrs = {
+        const attrs: Record<string, unknown> = {
             id: node.attrs.id,
             class: `aligned-${node.attrs.aligned} image-width-${node.attrs.width}`,
             "data-aligned": node.attrs.aligned,
@@ -53,6 +73,10 @@ export const figure = {
         }
         return ["figure", attrs, 0]
     }
+} satisfies NodeSpec
+
+function errorImageUrl(): string {
+    return typeof staticUrl !== "undefined" ? staticUrl("img/error.avif") : "/static/img/error.avif"
 }
 
 export const image = {
@@ -64,8 +88,8 @@ export const image = {
     parseDOM: [
         {
             tag: "img",
-            getAttrs(dom) {
-                const image = Number.parseInt(dom.dataset.image)
+            getAttrs(dom: HTMLElement) {
+                const image = Number.parseInt(dom.dataset.image || "")
                 return {
                     image: isNaN(image) ? false : image
                 }
@@ -75,8 +99,8 @@ export const 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
+            dom.dataset.image = String(node.attrs.image)
+            const imageDB = (node.type.schema.cached as {imageDB?: ImageDB}).imageDB
             if (imageDB) {
                 const imageEntry = imageDB.db[node.attrs.image]
                 if (imageEntry?.image) {
@@ -89,25 +113,21 @@ export const image = {
                             import("../../editor/e2ee/encryptor.js").then(
                                 ({E2EEEncryptor}) => {
                                     E2EEEncryptor.decryptImageToUrl(
-                                        imageEntry.image,
+                                        imageEntry.image as string,
                                         key,
-                                        imageEntry.original_file_type ||
-                                            "image/png"
+                                        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")
-                                            )
+                                            dom.setAttribute("src", errorImageUrl())
                                         })
                                 }
                             )
                         } else {
-                            dom.setAttribute("src", (typeof staticUrl !== "undefined" ? staticUrl("img/error.avif") : "/static/img/error.avif"))
+                            dom.setAttribute("src", errorImageUrl())
                         }
                     } else {
                         const imgSrc = imageEntry.image
@@ -120,9 +140,9 @@ export const image = {
                     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"))
+                        dom.setAttribute("src", errorImageUrl())
                     } else {
-                        imageDB.getDB().then(() => {
+                        imageDB.getDB?.().then(() => {
                             const refreshedEntry = imageDB.db[node.attrs.image]
                             if (refreshedEntry?.image) {
                                 dom.setAttribute("src", refreshedEntry.image)
@@ -137,7 +157,7 @@ export const image = {
         }
         return dom
     }
-}
+} satisfies NodeSpec
 
 export const figure_equation = {
     selectable: false,
@@ -150,7 +170,7 @@ export const figure_equation = {
     parseDOM: [
         {
             tag: "div.figure-equation[data-equation]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     equation: dom.dataset.equation
                 }
@@ -167,13 +187,13 @@ export const figure_equation = {
                     node.attrs.equation,
                     {
                         mathstyle: "displaystyle"
-                    }
+                    } as unknown as Record<string, unknown>
                 )
             })
         }
         return dom
     }
-}
+} satisfies NodeSpec
 
 export const figure_caption = {
     isolating: true,
@@ -187,4 +207,4 @@ export const figure_caption = {
             ["span", {class: "text"}, 0]
         ]
     }
-}
+} satisfies NodeSpec

package/src/schema/common/{heading.js → heading.ts}

@@ -1,10 +1,12 @@
+import type {NodeSpec} from "prosemirror-model"
+
 import {addTracks, parseTracks} from "./track.js"
 
-export const randomHeadingId = () => {
+export const randomHeadingId = (): string => {
     return `H${Math.round(Math.random() * 10000000) + 1}`
 }
 
-const createHeading = level => ({
+const createHeading = (level: number): NodeSpec => ({
     group: "block heading",
     content: "inline*",
     marks: "_",
@@ -20,16 +22,16 @@ const createHeading = level => ({
     parseDOM: [
         {
             tag: `h${level}`,
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    id: dom.id,
+                    id: dom.id || false,
                     track: parseTracks(dom.dataset.track)
                 }
             }
         }
     ],
     toDOM(node) {
-        const attrs = {id: node.attrs.id}
+        const attrs: Record<string, unknown> = {id: node.attrs.id}
         addTracks(node, attrs)
         return [`h${level}`, attrs, 0]
     }

package/src/schema/common/{list.js → list.ts}

@@ -1,3 +1,5 @@
+import type {NodeSpec} from "prosemirror-model"
+
 import {addTracks, parseTracks} from "./track.js"
 
 // :: NodeSpec
@@ -16,11 +18,11 @@ export const ordered_list = {
     parseDOM: [
         {
             tag: "ol",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    id: dom.id,
+                    id: dom.id || false,
                     order: dom.hasAttribute("start")
-                        ? +dom.getAttribute("start")
+                        ? Number.parseInt(dom.getAttribute("start") || "1")
                         : 1,
                     track: parseTracks(dom.dataset.track)
                 }
@@ -28,16 +30,16 @@ export const ordered_list = {
         }
     ],
     toDOM(node) {
-        const attrs = {id: node.attrs.id}
+        const attrs: Record<string, unknown> = {id: node.attrs.id}
         if (node.attrs.order !== 1) {
             attrs.start = node.attrs.order
         }
         addTracks(node, attrs)
         return ["ol", attrs, 0]
     }
-}
+} satisfies NodeSpec
 
-export function randomListId() {
+export function randomListId(): string {
     return "L" + Math.round(Math.random() * 10000000) + 1
 }
 
@@ -53,20 +55,20 @@ export const bullet_list = {
     parseDOM: [
         {
             tag: "ul",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    id: dom.id,
+                    id: dom.id || false,
                     track: parseTracks(dom.dataset.track)
                 }
             }
         }
     ],
     toDOM(node) {
-        const attrs = {id: node.attrs.id}
+        const attrs: Record<string, unknown> = {id: node.attrs.id}
         addTracks(node, attrs)
         return ["ul", attrs, 0]
     }
-}
+} satisfies NodeSpec
 
 // :: NodeSpec
 // A list item (`<li>`) spec.
@@ -79,7 +81,7 @@ export const list_item = {
     parseDOM: [
         {
             tag: "li",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     track: parseTracks(dom.dataset.track)
                 }
@@ -87,9 +89,9 @@ export const list_item = {
         }
     ],
     toDOM(node) {
-        const attrs = {}
+        const attrs: Record<string, unknown> = {}
         addTracks(node, attrs)
         return ["li", attrs, 0]
     },
     defining: true
-}
+} satisfies NodeSpec

package/src/schema/common/{reference.js → reference.ts}

@@ -1,3 +1,5 @@
+import type {MarkSpec, NodeSpec} from "prosemirror-model"
+
 export const cross_reference = {
     inline: true,
     group: "inline",
@@ -12,10 +14,10 @@ export const cross_reference = {
     parseDOM: [
         {
             tag: "span.cross-reference[data-id][data-title]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    id: dom.dataset.id,
-                    title: dom.dataset.title
+                    id: dom.dataset.id || false,
+                    title: dom.dataset.title ?? null
                 }
             }
         }
@@ -31,7 +33,7 @@ export const cross_reference = {
             node.attrs.title ? node.attrs.title : gettext("Missing Target")
         ]
     }
-}
+} satisfies NodeSpec
 
 export const link = {
     attrs: {
@@ -44,10 +46,10 @@ export const link = {
     parseDOM: [
         {
             tag: "a[href]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    href: dom.getAttribute("href"),
-                    title: dom.getAttribute("title")
+                    href: dom.getAttribute("href") || "",
+                    title: dom.getAttribute("title") || ""
                 }
             }
         }
@@ -64,9 +66,9 @@ export const link = {
                   }
         return ["a", attrs, 0]
     }
-}
+} satisfies MarkSpec
 
-export const randomAnchorId = () => {
+export const randomAnchorId = (): string => {
     return `A${Math.round(Math.random() * 10000000) + 1}`
 }
 
@@ -81,9 +83,9 @@ export const anchor = {
     parseDOM: [
         {
             tag: "span.anchor[data-id]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    id: dom.dataset.id
+                    id: dom.dataset.id || false
                 }
             }
         }
@@ -97,4 +99,4 @@ export const anchor = {
             }
         ]
     }
-}
+} satisfies MarkSpec

package/src/schema/common/{table.js → table.ts}

@@ -1,3 +1,4 @@
+import type {NodeSpec} from "prosemirror-model"
 import {tableNodes} from "prosemirror-tables"
 
 import {parseTracks} from "./track.js"
@@ -19,12 +20,12 @@ export const table = {
     parseDOM: [
         {
             tag: "table",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 const track = parseTracks(dom.dataset.track),
-                    width = dom.dataset.width,
-                    aligned = width === "100" ? "center" : dom.dataset.aligned,
-                    layout = dom.dataset.layout,
-                    id = dom.id || dom.dataset.id
+                    width = dom.dataset.width || "100",
+                    aligned = width === "100" ? "center" : dom.dataset.aligned || "center",
+                    layout = dom.dataset.layout || "fixed",
+                    id = dom.id || dom.dataset.id || false
                 return {
                     track,
                     width,
@@ -38,7 +39,7 @@ export const table = {
         }
     ],
     toDOM(node) {
-        const attrs = {
+        const attrs: Record<string, unknown> = {
             id: node.attrs.id,
             class: `table-${node.attrs.width} table-${node.attrs.aligned} table-${node.attrs.layout}`,
             "data-width": node.attrs.width,
@@ -54,7 +55,7 @@ export const table = {
         }
         return ["table", attrs, 0]
     }
-}
+} satisfies NodeSpec
 
 export const table_caption = {
     content: "inline*",
@@ -66,10 +67,11 @@ export const table_caption = {
             ["span", {class: "text"}, 0]
         ]
     }
-}
+} satisfies NodeSpec
 
 const origTableNodes = tableNodes({
-    cellContent: "block+"
+    cellContent: "block+",
+    cellAttributes: {}
 })
 
 export const table_body = Object.assign({}, origTableNodes["table"], {
@@ -77,7 +79,7 @@ export const table_body = Object.assign({}, origTableNodes["table"], {
     toDOM() {
         return ["tbody", 0]
     }
-})
+}) satisfies NodeSpec
 
 export const table_row = {
     content: "(table_cell | table_header)+",
@@ -86,18 +88,18 @@ export const table_row = {
     toDOM() {
         return ["tr", 0]
     }
-}
+} satisfies NodeSpec
 
 export const table_header = Object.assign(
     {marks: "annotation"},
     origTableNodes["table_header"]
-)
+) satisfies NodeSpec
 
 export const table_cell = Object.assign(
     {marks: "annotation"},
     origTableNodes["table_cell"]
-)
+) satisfies NodeSpec
 
-export function randomTableId() {
+export function randomTableId(): string {
     return "T" + Math.round(Math.random() * 10000000) + 1
 }

package/src/schema/common/track.ts

@@ -0,0 +1,201 @@
+import type {MarkSpec, NodeSpec} from "prosemirror-model"
+
+export interface Track {
+    type: "insertion" | "deletion" | "block_change"
+    user: number
+    username: string
+    date: number
+    approved?: boolean
+    before?: unknown
+}
+
+export function parseTracks(str: string | undefined): Track[] {
+    if (!str) {
+        return []
+    }
+    let tracks: unknown
+    try {
+        tracks = JSON.parse(str)
+    } catch (_error) {
+        return []
+    }
+    if (!Array.isArray(tracks)) {
+        return []
+    }
+    return tracks.filter(
+        (track): track is Track =>
+            typeof track === "object" &&
+            track !== null &&
+            Object.prototype.hasOwnProperty.call(track, "user") &&
+            Object.prototype.hasOwnProperty.call(track, "username") &&
+            Object.prototype.hasOwnProperty.call(track, "date")
+    )
+}
+
+export function addTracks(node: {attrs: {track?: Track[]}}, attrs: Record<string, unknown>): void {
+    if (node.attrs.track?.length) {
+        attrs["data-track"] = JSON.stringify(node.attrs.track)
+    }
+}
+
+export const deletion = {
+    attrs: {
+        user: {
+            default: 0
+        },
+        username: {
+            default: ""
+        },
+        date: {
+            default: 0
+        }
+    },
+    inclusive: false,
+    group: "track",
+    parseDOM: [
+        {
+            tag: "span.deletion",
+            getAttrs(dom: HTMLElement) {
+                return {
+                    user: Number.parseInt(dom.dataset.user || "0"),
+                    username: dom.dataset.username || "",
+                    date: Number.parseInt(dom.dataset.date || "0")
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: `deletion user-${node.attrs.user}`,
+                "data-user": node.attrs.user,
+                "data-username": node.attrs.username,
+                "data-date": node.attrs.date
+            }
+        ]
+    }
+} satisfies MarkSpec
+
+function parseFormatList(str: string | undefined): string[] {
+    if (!str) {
+        return []
+    }
+    let formatList: unknown
+    try {
+        formatList = JSON.parse(str)
+    } catch (_error) {
+        return []
+    }
+    if (!Array.isArray(formatList)) {
+        return []
+    }
+    return formatList.filter((format): format is string => typeof format === "string")
+}
+
+export const format_change = {
+    attrs: {
+        user: {
+            default: 0
+        },
+        username: {
+            default: ""
+        },
+        date: {
+            default: 0
+        },
+        before: {
+            default: []
+        },
+        after: {
+            default: []
+        }
+    },
+    inclusive: false,
+    group: "track",
+    parseDOM: [
+        {
+            tag: "span.format-change",
+            getAttrs(dom: HTMLElement) {
+                return {
+                    user: Number.parseInt(dom.dataset.user || "0"),
+                    username: dom.dataset.username || "",
+                    date: Number.parseInt(dom.dataset.date || "0"),
+                    before: parseFormatList(dom.dataset.before),
+                    after: parseFormatList(dom.dataset.after)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: `format-change user-${node.attrs.user}`,
+                "data-user": node.attrs.user,
+                "data-username": node.attrs.username,
+                "data-date": node.attrs.date,
+                "data-before": JSON.stringify(node.attrs.before),
+                "data-after": JSON.stringify(node.attrs.after)
+            }
+        ]
+    }
+} satisfies MarkSpec
+
+export const insertion = {
+    attrs: {
+        user: {
+            default: 0
+        },
+        username: {
+            default: ""
+        },
+        date: {
+            default: 0
+        },
+        approved: {
+            default: true
+        }
+    },
+    inclusive: false,
+    group: "track",
+    parseDOM: [
+        {
+            tag: "span.insertion",
+            getAttrs(dom: HTMLElement) {
+                return {
+                    user: Number.parseInt(dom.dataset.user || "0"),
+                    username: dom.dataset.username || "",
+                    date: Number.parseInt(dom.dataset.date || "0"),
+                    inline: true,
+                    approved: false
+                }
+            }
+        },
+        {
+            tag: "span.approved-insertion",
+            getAttrs(dom: HTMLElement) {
+                return {
+                    user: Number.parseInt(dom.dataset.user || "0"),
+                    username: dom.dataset.username || "",
+                    date: Number.parseInt(dom.dataset.date || "0"),
+                    inline: true,
+                    approved: true
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: node.attrs.approved
+                    ? "approved-insertion"
+                    : `insertion user-${node.attrs.user}`,
+                "data-user": node.attrs.user,
+                "data-username": node.attrs.username,
+                "data-date": node.attrs.date
+            }
+        ]
+    }
+} satisfies MarkSpec