@fiduswriter/document 0.1.0-alpha.4 → 0.1.0-alpha.6

package/src/schema/document/{content.js → content.ts}

@@ -1,8 +1,10 @@
 import {escapeText} from "fwtoolkit"
+import type {MarkSpec, NodeSpec} from "prosemirror-model"
+
 import {parseTracks} from "../common/index.js"
 import {fnNodeToHtml, htmlToFnNode} from "../footnotes_convert.js"
 
-export const randomCodeBlockId = () => {
+export const randomCodeBlockId = (): string => {
     return `C${Math.round(Math.random() * 10000000) + 1}`
 }
 
@@ -21,12 +23,12 @@ export const contributor = {
     parseDOM: [
         {
             tag: "span.contributor",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    firstname: dom.dataset.firstname,
-                    lastname: dom.dataset.lastname,
-                    email: dom.dataset.email,
-                    institution: dom.dataset.institution,
+                    firstname: dom.dataset.firstname || false,
+                    lastname: dom.dataset.lastname || false,
+                    email: dom.dataset.email || false,
+                    institution: dom.dataset.institution || false,
                     id_type: dom.dataset.id_type || false,
                     id_value: dom.dataset.id_value || false
                 }
@@ -36,17 +38,17 @@ export const contributor = {
     toDOM(node) {
         const dom = document.createElement("span")
         dom.classList.add("contributor")
-        dom.dataset.firstname = node.attrs.firstname
-        dom.dataset.lastname = node.attrs.lastname
-        dom.dataset.email = node.attrs.email
-        dom.dataset.institution = node.attrs.institution
+        dom.dataset.firstname = node.attrs.firstname || ""
+        dom.dataset.lastname = node.attrs.lastname || ""
+        dom.dataset.email = node.attrs.email || ""
+        dom.dataset.institution = node.attrs.institution || ""
         if (node.attrs.id_type) {
             dom.dataset.id_type = node.attrs.id_type
         }
         if (node.attrs.id_value) {
             dom.dataset.id_value = node.attrs.id_value
         }
-        const content = []
+        const content: string[] = []
         if (node.attrs.firstname) {
             content.push(escapeText(node.attrs.firstname))
         }
@@ -71,7 +73,7 @@ export const contributor = {
 
         return dom
     }
-}
+} satisfies NodeSpec
 
 export const tag = {
     inline: true,
@@ -84,7 +86,7 @@ export const tag = {
     parseDOM: [
         {
             tag: "span.tag",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     tag: dom.innerText
                 }
@@ -94,7 +96,7 @@ export const tag = {
     toDOM(node) {
         return ["span", {class: "tag"}, node.attrs.tag]
     }
-}
+} satisfies NodeSpec
 
 export const footnote = {
     inline: true,
@@ -111,9 +113,9 @@ export const footnote = {
     parseDOM: [
         {
             tag: "span.footnote-marker[data-footnote]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    footnote: htmlToFnNode(dom.dataset.footnote)
+                    footnote: htmlToFnNode(dom.dataset.footnote || "")
                 }
             }
         }
@@ -125,7 +127,7 @@ export const footnote = {
         dom.innerHTML = " "
         return dom
     }
-}
+} satisfies NodeSpec
 
 export const code_block = {
     content: "text*",
@@ -154,7 +156,7 @@ export const code_block = {
         {
             tag: "pre",
             preserveWhitespace: "full",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     track: parseTracks(dom.dataset.track),
                     language: dom.dataset.language || "",
@@ -166,7 +168,7 @@ export const code_block = {
         }
     ],
     toDOM(node) {
-        const attrs = {}
+        const attrs: Record<string, unknown> = {}
         if (node.attrs.track.length) {
             attrs["data-track"] = JSON.stringify(node.attrs.track)
         }
@@ -184,4 +186,4 @@ export const code_block = {
         }
         return ["pre", attrs, ["code", 0]]
     }
-}
+} satisfies NodeSpec

package/src/schema/document/{structure.js → structure.ts}

@@ -1,3 +1,5 @@
+import type {NodeSpec} from "prosemirror-model"
+
 export const doc = {
     content: "title part*",
     selectable: false,
@@ -200,7 +202,7 @@ export const doc = {
     parseDOM: [
         {
             tag: "div.doc",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     papersize: dom.dataset.papersize,
                     citationstyle: dom.dataset.citationstyle,
@@ -221,9 +223,13 @@ export const doc = {
             0
         ]
     }
-}
+} satisfies NodeSpec
 
-const partSpec = (type, content, attrs = {}) => ({
+const partSpec = (
+    type: string,
+    content: string,
+    extraAttrs: Record<string, {default: unknown}> = {}
+): NodeSpec => ({
     content,
     group: "part",
     marks: "annotation track",
@@ -259,12 +265,12 @@ const partSpec = (type, content, attrs = {}) => ({
                 default: false
             }
         },
-        attrs
+        extraAttrs
     ),
     parseDOM: [
         {
             tag: `div.doc-${type}`,
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     hidden: dom.dataset.hidden === "true" ? true : false
                 }
@@ -272,7 +278,7 @@ const partSpec = (type, content, attrs = {}) => ({
         }
     ],
     toDOM(node) {
-        const attrs = {
+        const attrs: Record<string, unknown> = {
             class: `doc-part doc-${type} ${node.attrs.id ? `doc-${node.attrs.id}` : "doc-no-id"}`
         }
         if (node.attrs.hidden) {
@@ -400,7 +406,7 @@ export const table_of_contents = {
         dom.innerHTML = `<h1 class="toc">${node.attrs.title}</h1>`
         return dom
     }
-}
+} satisfies NodeSpec
 
 export const separator_part = {
     marks: "annotation track",
@@ -422,7 +428,7 @@ export const separator_part = {
         dom.classList.add(`doc-${node.attrs.id}`)
         return dom
     }
-}
+} satisfies NodeSpec
 
 export const title = {
     content: "text*",
@@ -449,4 +455,4 @@ export const title = {
             0
         ]
     }
-}
+} satisfies NodeSpec

package/src/schema/{export.js → export.ts}

@@ -1,12 +1,14 @@
 import {docSchema} from "./document/index.js"
 
 export class SchemaExport {
+    schema: typeof docSchema
+
     constructor() {
         this.schema = docSchema
     }
 
-    init() {
-        const spec = {
+    init(): string {
+        const spec: {nodes: Record<string, unknown>; marks: Record<string, unknown>} = {
             nodes: {},
             marks: {}
         }

package/src/schema/{footnotes.js → footnotes.ts}

@@ -1,4 +1,5 @@
 import OrderedMap from "orderedmap"
+import type {Node, NodeSpec} from "prosemirror-model"
 import {Schema} from "prosemirror-model"
 import {marks, nodes} from "prosemirror-schema-basic"
 import {tableNodes} from "prosemirror-tables"
@@ -32,18 +33,18 @@ import {
     underline
 } from "./common/index.js"
 
-const footnotecontainer = {
+const footnotecontainer: NodeSpec = {
     group: "part",
     selectable: false,
     content: "(block|table_block)+",
     marks: "annotation",
     parseDOM: [{tag: "div.footnote-container"}],
-    toDOM(_node) {
+    toDOM(_node: Node) {
         return ["div", {class: "footnote-container"}, 0]
     }
 }
 
-const doc = {
+const doc: NodeSpec = {
     content: "part*",
     selectable: false
 }
@@ -91,20 +92,22 @@ const spec = {
 spec.nodes = spec.nodes.append(
     tableNodes({
         tableGroup: "table_block",
-        cellContent: "block+"
+        cellContent: "block+",
+        cellAttributes: {}
     })
 )
 
+const tableSpec = spec.nodes.get("table") || {}
 spec.nodes = spec.nodes.update(
     "table",
-    Object.assign({}, spec.nodes.get("table"), {
+    Object.assign({}, tableSpec, {
         attrs: {
             track: {default: []}
         },
         parseDOM: [
             {
                 tag: "table",
-                getAttrs(dom) {
+                getAttrs(dom: HTMLElement) {
                     return {
                         track: dom.dataset.track
                             ? JSON.parse(dom.dataset.track)
@@ -113,8 +116,8 @@ spec.nodes = spec.nodes.update(
                 }
             }
         ],
-        toDOM(node) {
-            const attrs = {}
+        toDOM(node: Node) {
+            const attrs: Record<string, unknown> = {}
             if (node.attrs.track.length) {
                 attrs["data-track"] = JSON.stringify(node.attrs.track)
             }

package/src/schema/{footnotes_convert.js → footnotes_convert.ts}

@@ -3,20 +3,22 @@ import {DOMParser, DOMSerializer, Node} from "prosemirror-model"
 import {fnSchema} from "./footnotes.js"
 
 // Convert the footnote HTML stored with the marker to a PM node representation of the footnote.
-export const htmlToFnNode = content => {
+export const htmlToFnNode = (content: string): unknown[] => {
     const footnoteDOM = document.createElement("div")
     footnoteDOM.classList.add("footnote-container")
     footnoteDOM.innerHTML = content
     const node = DOMParser.fromSchema(fnSchema).parse(footnoteDOM, {
         preserveWhitespace: true,
-        topNode: false
+        topNode: false as unknown as Node
     })
-    const json = node.firstChild.toJSON().content
-
-    return json
+    const firstChild = node.firstChild
+    if (!firstChild) {
+        return []
+    }
+    return firstChild.toJSON().content
 }
 
-export const fnNodeToPmNode = fnContents => {
+export const fnNodeToPmNode = (fnContents: unknown[]): Node => {
     const footnote = {
         type: "footnotecontainer",
         content: fnContents
@@ -24,8 +26,9 @@ export const fnNodeToPmNode = fnContents => {
     return Node.fromJSON(fnSchema, footnote)
 }
 
-export const fnNodeToHtml = jsonString => {
+export const fnNodeToHtml = (jsonString: unknown[]): string => {
     const pmNode = fnNodeToPmNode(jsonString),
         serializer = DOMSerializer.fromSchema(fnSchema)
-    return serializer.serializeNode(pmNode).innerHTML
+    const dom = serializer.serializeNode(pmNode)
+    return dom instanceof HTMLElement ? dom.innerHTML : ""
 }

package/src/schema/{i18n.js → i18n.ts}

@@ -581,7 +581,10 @@ const EXERCISE_SOLUTION = {
     uk: "Розв'язок"
 }
 
-export const CATS = {
+export const CATS: Record<
+    string,
+    Record<string, string>
+> = {
     figure: FIGURE,
     equation: EQUATION,
     table: TABLE,
@@ -593,3 +596,6 @@ export const CATS = {
     exercise: EXERCISE,
     exercise_solution: EXERCISE_SOLUTION
 }
+
+export const getCat = (category: string, language: string): string =>
+    CATS[category]?.[language] || CATS[category]?.["en-US"] || category

package/src/schema/{mini_json.js → mini_json.ts}

@@ -1,17 +1,18 @@
 import deepEqual from "fast-deep-equal"
+import type {Mark, Node, Schema} from "prosemirror-model"
 
-export function toMiniJSON(node) {
+export function toMiniJSON(node: Node): Record<string, unknown> {
     // Similar to the ProseMirror internal toJSON function,
     // but leaving out attributes that have default values and dealing with
     // attributes that are objects.
     // Adapted from https://github.com/ProseMirror/prosemirror-model/blob/6d970507cd0da48653d3b72f2731a71a144a364b/src/node.js#L340-L351
-    const obj = {type: node.type.name}
+    const obj: Record<string, unknown> = {type: node.type.name}
     for (const attr in node.attrs) {
-        if (!deepEqual(node.type.attrs[attr].default, node.attrs[attr])) {
+        if (!deepEqual((node.type as any).attrs[attr].default, node.attrs[attr])) {
             if (!obj.attrs) {
                 obj.attrs = {}
             }
-            obj.attrs[attr] = ["string", "number", "boolean"].includes(
+            ;(obj.attrs as Record<string, unknown>)[attr] = ["string", "number", "boolean"].includes(
                 typeof node.attrs[attr]
             )
                 ? node.attrs[attr]
@@ -19,9 +20,7 @@ export function toMiniJSON(node) {
         }
     }
     if (node.content.size) {
-        obj.content = node.content.content.map(childNode =>
-            toMiniJSON(childNode)
-        )
+        obj.content = node.content.content.map(childNode => toMiniJSON(childNode))
     }
 
     if (node.marks.length) {
@@ -35,15 +34,15 @@ export function toMiniJSON(node) {
     return obj
 }
 
-function toMiniMarkJSON(mark) {
+function toMiniMarkJSON(mark: Mark): Record<string, unknown> {
     // Adapted from https://github.com/ProseMirror/prosemirror-model/blob/6d970507cd0da48653d3b72f2731a71a144a364b/src/mark.js#L76-L83
-    const obj = {type: mark.type.name}
+    const obj: Record<string, unknown> = {type: mark.type.name}
     for (const attr in mark.attrs) {
-        if (!deepEqual(mark.type.attrs[attr].default, mark.attrs[attr])) {
+        if (!deepEqual((mark.type as any).attrs[attr].default, mark.attrs[attr])) {
             if (!obj.attrs) {
                 obj.attrs = {}
             }
-            obj.attrs[attr] = ["string", "number", "boolean"].includes(
+            ;(obj.attrs as Record<string, unknown>)[attr] = ["string", "number", "boolean"].includes(
                 typeof mark.attrs[attr]
             )
                 ? mark.attrs[attr]
@@ -53,7 +52,7 @@ function toMiniMarkJSON(mark) {
     return obj
 }
 
-export function toFullJSON(miniJson, schema) {
+export function toFullJSON(miniJson: Record<string, unknown>, schema: Schema): Record<string, unknown> {
     if (!miniJson.type) {
         miniJson.type = "doc"
     }

package/src/schema/{text.js → text.ts}

@@ -1,10 +1,14 @@
-export function getNonDeletedTextContent(topNode) {
+import type {Node} from "prosemirror-model"
+
+import type {Track} from "./common/track.js"
+
+export function getNonDeletedTextContent(topNode: Node): string {
     let text = ""
     topNode.descendants(node => {
         if (
             node.marks.find(mark => mark.type.name === "deletion") ||
             (node.attrs &&
-                (node.attrs.track?.find(track => track.type === "deletion") ||
+                (node.attrs.track?.find((track: Track) => track.type === "deletion") ||
                     node.attrs.hidden))
         ) {
             return

package/src/types.ts

@@ -74,30 +74,78 @@ export interface FidusDoc {
 
 /** A fully populated document object passed to exporters. */
 export interface ExportDoc {
+    id: string | number
     title: string
     path?: string
-    content: FidusNode[]
+    content: FidusNode
     settings: DocSettings
     comments?: Record<string, CommentData>
     version?: string
 }
 
+/** A document contributor extracted from a contributors_part node. */
+export interface Contributor {
+    firstname?: string
+    lastname?: string
+    institution?: string
+    role?: string
+    email?: string
+    id_type?: string
+    id_value?: string
+    [key: string]: unknown
+}
+
+/** Metadata bundle assembled by exporters and passed to metadata handlers. */
+export interface ExportMetadata {
+    title: string
+    authors: Contributor[]
+    contributors: Contributor[]
+    keywords: string[]
+    language?: string
+    citationStyle?: string
+}
+
+/** A user reference passed to importers. */
+export interface User {
+    id: number
+    name?: string
+    avatar?: string
+    username?: string
+}
+
 /** A single comment thread. */
 export interface CommentData {
-    id: number
+    id?: number
     user: number
     username: string
     date: number
     resolved?: boolean
-    comments: Array<{user: number; username: string; date: number; comment: string}>
+    comment: FidusNode[]
+    answers?: Array<{
+        id?: string
+        user: number
+        username: string
+        date: number
+        answer: FidusNode[]
+    }>
 }
 
 /** A bibliographic database entry (format depends on the CSL engine). */
 export interface BibDBEntry {
+    entry_key?: string
+    bib_type?: string
+    fields?: Record<string, JSONValue>
     [key: string]: JSONValue | undefined
 }
 
-export type BibDB = Record<string, BibDBEntry>
+/** Flat map of bibliography entries keyed by internal ID. */
+export type BibDBEntries = Record<string, BibDBEntry>
+
+/** Bibliography database wrapper used by importers/exporters. */
+export interface BibDB {
+    db: BibDBEntries
+    getDB?: () => Promise<void>
+}
 
 /** An entry in the image database. */
 export interface ImageDBEntry {
@@ -109,12 +157,69 @@ export interface ImageDBEntry {
     [key: string]: unknown
 }
 
-export type ImageDB = Record<string, ImageDBEntry>
+/** Flat map of image entries keyed by internal ID. */
+export type ImageDBEntries = Record<string, ImageDBEntry>
 
-/** A CSL/CSL-M stylesheet reference. */
+/** Image database wrapper used by importers/exporters. */
+export interface ImageDB {
+    db: ImageDBEntries
+}
+
+/** A parsed CSL/CSL-M stylesheet node. */
+export interface CSLStyleNode {
+    name: string
+    attrs?: Record<string, unknown>
+    children?: CSLStyleNode[]
+}
+
+/** A parsed CSL/CSL-M stylesheet. */
+export interface CSLStyle {
+    children: CSLStyleNode[]
+}
+
+/** A CSL/CSL-M stylesheet reference / engine provider. */
 export interface CSL {
     citationType?: string
-    [key: string]: JSONValue | undefined
+    getStyle?: (styleId: string) => Promise<CSLStyle>
+    getEngine?: (
+        sys: unknown,
+        styleId: string,
+        lang: string
+    ) => Promise<CiteprocInstance>
+    getEngineSync?: (
+        sys: unknown,
+        styleId: string,
+        lang: string
+    ) => CiteprocInstance | undefined
+}
+
+/** A minimal citeproc-js engine interface. */
+export interface CiteprocInstance {
+    updateItems: (ids: string[]) => void
+    appendCitationCluster: (
+        citation: unknown,
+        flag?: boolean
+    ) => Array<[number, string]>
+    makeCitationCluster: (items: unknown[]) => string
+    cslXml: {dataObj: {attrs: {class: string}}}
+    citation: {opt: {layout_delimiter?: string}}
+    makeBibliography: () => BibliographyResult
+    sys?: unknown
+}
+
+/** citeproc-js makeBibliography() result tuple. */
+export interface BibliographyResult extends Array<unknown> {
+    0: {
+        entry_ids: string[]
+        bibstart: string
+        bibend: string
+        entryspacing: number
+        linespacing: number
+        hangingindent?: boolean
+        maxoffset: number
+        "second-field-align"?: "margin" | "flush"
+    }
+    1: string[]
 }
 
 /** Common constructor options for exporters. */
@@ -134,3 +239,76 @@ export interface NativeDomNode {
     a?: Array<[string, string]>
     c?: NativeDomNode[]
 }
+
+/** A document template extracted from document content. */
+export interface Template {
+    content: FidusNode
+    exportTemplates: Array<Record<string, JSONValue>>
+    documentStyles: Array<Record<string, JSONValue>>
+    files?: Array<{filename: string; content: Blob | ArrayBuffer | string}>
+}
+
+/** Files bundled with a document template. */
+export interface TemplateFiles {
+    textFiles: Array<{filename: string; contents: string}>
+    httpFiles: Array<{url: string; filename: string}>
+}
+
+/** Backend callbacks used by the generic NativeImporter. */
+export interface NativeImporterBackend {
+    createDoc: (
+        template: Template,
+        importId: string | number | null,
+        requestedPath: string,
+        e2eeOptions: E2EEOptions | null,
+        files: Record<string, File[]>
+    ) => Promise<{id: number; path: string; e2ee?: boolean}>
+    saveImages: (
+        images: ImageDB,
+        docId: number,
+        e2eeOptions: E2EEOptions | null
+    ) => Promise<Record<number | string, number>>
+    saveDocument: (
+        saveData: Record<string, unknown>,
+        e2eeOptions: E2EEOptions | null
+    ) => Promise<{added: number; updated: number}>
+    extractTemplate?: (doc: FidusNode) => Template
+    decryptBufferToBase64?: (base64: string, key: CryptoKey) => Promise<string>
+    encryptImage?: (file: Blob, key: CryptoKey) => Promise<Blob>
+    encryptObject?: (obj: unknown, key: CryptoKey) => Promise<unknown>
+    encrypt?: (text: string, key: CryptoKey) => Promise<unknown>
+    storeKeyInSession?: (docId: number, key: CryptoKey) => void
+}
+
+/** E2EE options used during import/export/copy. */
+export interface E2EEOptions {
+    enabled?: boolean
+    key?: CryptoKey
+    sourceKey?: CryptoKey
+    targetE2EE?: boolean
+    targetPassword?: string
+    salt?: string
+    iterations?: number
+}
+
+/** Callback that uploads a native revision blob. */
+export type UploadRevision = (blob: Blob, doc: Record<string, unknown>) => unknown
+
+/** E2EE helper object used by SaveCopy. */
+export interface SaveCopyE2EE {
+    decryptObject: (encrypted: unknown, key: CryptoKey) => Promise<unknown>
+    encryptObject: (obj: unknown, key: CryptoKey) => Promise<unknown>
+    encrypt: (text: string, key: CryptoKey) => Promise<unknown>
+    encryptImage: (file: Blob, key: CryptoKey) => Promise<Blob>
+    generateSalt: () => Uint8Array
+    deriveKey: (password: string, salt: Uint8Array, iterations: number) => Promise<CryptoKey>
+}
+
+/** Callback used by SaveCopy to import a copied document. */
+export type ImportDocument = (
+    doc: Record<string, unknown>,
+    bibDB: BibDB,
+    imageDB: ImageDB,
+    httpIncludes: Array<{url: string; filename: string}>,
+    options: Record<string, unknown>
+) => Promise<{doc: Record<string, unknown>; docInfo: Record<string, unknown>}>