@fiduswriter/editor 0.1.20 → 0.1.22

package/src/track/{mod.js → mod.ts}

@@ -1,48 +1,61 @@
 import {findTarget} from "fwtoolkit"
+import type {EditorView} from "prosemirror-view"
+
 import {
     deactivateAllSelectedChanges,
     setSelectedChanges
-} from "../state_plugins/index.js"
+} from "../state_plugins/track/index.js"
+import type {Editor} from "../types.js"
 
 import {accept} from "./accept.js"
 import {acceptAll} from "./accept_all.js"
 import {reject} from "./reject.js"
 import {rejectAll} from "./reject_all.js"
 
+interface MarginBox {
+    view: string
+    type: string
+    pos: number
+}
+
 // Helper functions related to tracked changes
 export class ModTrack {
-    constructor(editor) {
+    editor: Editor
+
+    constructor(editor: Editor) {
         editor.mod.track = this
         this.editor = editor
         this.bindEvents()
     }
 
-    bindEvents() {
+    bindEvents(): void {
         // Bind all the click events related to track changes
         document.body.addEventListener("click", event => {
-            const el = {}
+            const el: {target?: HTMLElement} = {}
             switch (true) {
                 case findTarget(event, ".track-accept", el): {
                     let boxNumber = 0
-                    let seekItem = el.target.closest(".margin-box")
-                    while (seekItem.previousElementSibling) {
+                    let seekItem = el.target?.closest(".margin-box")
+                    while (seekItem?.previousElementSibling) {
                         boxNumber += 1
-                        seekItem = seekItem.previousElementSibling
+                        seekItem = seekItem.previousElementSibling as HTMLElement
                     }
-                    const box =
-                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    const box = (
+                        this.editor.mod.marginboxes as {marginBoxes: MarginBox[]}
+                    ).marginBoxes[boxNumber]
                     accept(
-                        el.target.dataset.type,
+                        (el.target as HTMLElement).dataset.type as string,
                         box.pos,
                         box.view === "main"
                             ? this.editor.view
-                            : this.editor.mod.footnotes.fnEditor.view
+                            : (this.editor.mod.footnotes as {fnEditor: {view: EditorView}}).fnEditor.view
                     )
                     // Activate the next margin box with the same number
-                    const newBox =
-                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    const newBox = (
+                        this.editor.mod.marginboxes as {marginBoxes: MarginBox[]}
+                    ).marginBoxes[boxNumber]
                     if (newBox) {
-                        this.editor.mod.track.activateTrack(
+                        ;(this.editor.mod.track as ModTrack).activateTrack(
                             newBox.view,
                             newBox.type,
                             newBox.pos
@@ -52,25 +65,27 @@ export class ModTrack {
                 }
                 case findTarget(event, ".track-reject", el): {
                     let boxNumber = 0
-                    let seekItem = el.target.closest(".margin-box")
-                    while (seekItem.previousElementSibling) {
+                    let seekItem = el.target?.closest(".margin-box")
+                    while (seekItem?.previousElementSibling) {
                         boxNumber += 1
-                        seekItem = seekItem.previousElementSibling
+                        seekItem = seekItem.previousElementSibling as HTMLElement
                     }
-                    const box =
-                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    const box = (
+                        this.editor.mod.marginboxes as {marginBoxes: MarginBox[]}
+                    ).marginBoxes[boxNumber]
                     reject(
-                        el.target.dataset.type,
+                        (el.target as HTMLElement).dataset.type as string,
                         box.pos,
                         box.view === "main"
                             ? this.editor.view
-                            : this.editor.mod.footnotes.fnEditor.view
+                            : (this.editor.mod.footnotes as {fnEditor: {view: EditorView}}).fnEditor.view
                     )
                     // Activate the next margin box with the same number
-                    const newBox =
-                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    const newBox = (
+                        this.editor.mod.marginboxes as {marginBoxes: MarginBox[]}
+                    ).marginBoxes[boxNumber]
                     if (newBox) {
-                        this.editor.mod.track.activateTrack(
+                        ;(this.editor.mod.track as ModTrack).activateTrack(
                             newBox.view,
                             newBox.type,
                             newBox.pos
@@ -84,15 +99,19 @@ export class ModTrack {
         })
     }
 
-    activateTrack(viewName, type, pos) {
-        this.editor.mod.comments.interactions.deactivateAll()
+    activateTrack(viewName: string, type: string, pos: number): void {
+        ;(
+            this.editor.mod.comments as {
+                interactions: {deactivateAll: () => void}
+            }
+        ).interactions.deactivateAll()
         const view =
             viewName === "main"
                 ? this.editor.view
-                : this.editor.mod.footnotes.fnEditor.view
+                : (this.editor.mod.footnotes as {fnEditor: {view: EditorView}}).fnEditor.view
         const otherView =
             viewName === "main"
-                ? this.editor.mod.footnotes.fnEditor.view
+                ? (this.editor.mod.footnotes as {fnEditor: {view: EditorView}}).fnEditor.view
                 : this.editor.view
         // remove all selected changes in other view
         otherView.dispatch(deactivateAllSelectedChanges(otherView.state.tr))
@@ -104,13 +123,13 @@ export class ModTrack {
         }
     }
 
-    rejectAll() {
-        rejectAll(this.editor.mod.footnotes.fnEditor.view)
+    rejectAll(): void {
+        rejectAll((this.editor.mod.footnotes as {fnEditor: {view: EditorView}}).fnEditor.view)
         rejectAll(this.editor.view)
     }
 
-    acceptAll() {
-        acceptAll(this.editor.mod.footnotes.fnEditor.view)
+    acceptAll(): void {
+        acceptAll((this.editor.mod.footnotes as {fnEditor: {view: EditorView}}).fnEditor.view)
         acceptAll(this.editor.view)
     }
 }

package/src/track/{reject.js → reject.ts}

@@ -1,20 +1,31 @@
 import {AddMarkStep, Mapping, RemoveMarkStep} from "prosemirror-transform"
+import type {Node} from "prosemirror-model"
+import type {EditorView} from "prosemirror-view"
 
-import {deactivateAllSelectedChanges} from "../state_plugins/index.js"
+import {deactivateAllSelectedChanges} from "../state_plugins/track/index.js"
 import {deleteNode} from "./delete.js"
 
-export const reject = (type, pos, view) => {
+export const reject = (
+    type: string,
+    pos: number,
+    view: EditorView
+): void => {
     const tr = view.state.tr.setMeta("track", true),
         map = new Mapping()
     let reachedEnd = false,
         inlineChange = false
-    const trackMark = view.state.doc
-        .nodeAt(pos)
-        .marks.find(mark => mark.type.name === type)
+    const nodeAtPos = view.state.doc.nodeAt(pos)
+    if (!nodeAtPos) {
+        return
+    }
+    const trackMark = nodeAtPos.marks.find(mark => mark.type.name === type)
+    if (!trackMark) {
+        return
+    }
     view.state.doc.nodesBetween(
         pos,
         view.state.doc.nodeSize - 2,
-        (node, nodePos) => {
+        (node: Node, nodePos: number) => {
             if (nodePos < pos) {
                 return true
             }
@@ -37,7 +48,7 @@ export const reject = (type, pos, view) => {
                 deleteNode(tr, node, nodePos, map, false)
             } else if (type === "deletion") {
                 if (node.attrs.track) {
-                    const track = node.attrs.track.filter(
+                    const track = (node.attrs.track as Array<{type: string}>).filter(
                         track => track.type !== "deletion"
                     )
                     tr.setNodeMarkup(
@@ -55,7 +66,7 @@ export const reject = (type, pos, view) => {
                     )
                 }
             } else if (type === "format_change") {
-                trackMark.attrs.before.forEach(oldMark =>
+                ;(trackMark.attrs.before as string[]).forEach(oldMark =>
                     tr.step(
                         new AddMarkStep(
                             map.map(nodePos),
@@ -64,14 +75,17 @@ export const reject = (type, pos, view) => {
                         )
                     )
                 )
-                trackMark.attrs.after.forEach(newMark => {
-                    tr.step(
-                        new RemoveMarkStep(
-                            map.map(nodePos),
-                            map.map(nodePos + node.nodeSize),
-                            node.marks.find(mark => mark.type.name === newMark)
+                ;(trackMark.attrs.after as string[]).forEach(newMark => {
+                    const mark = node.marks.find(mark => mark.type.name === newMark)
+                    if (mark) {
+                        tr.step(
+                            new RemoveMarkStep(
+                                map.map(nodePos),
+                                map.map(nodePos + node.nodeSize),
+                                mark
+                            )
                         )
-                    )
+                    }
                 })
                 tr.step(
                     new RemoveMarkStep(
@@ -81,10 +95,11 @@ export const reject = (type, pos, view) => {
                     )
                 )
             } else if (type === "block_change") {
-                const blockChangeTrack = node.attrs.track?.find(
-                        track => track.type === "block_change"
-                    ),
-                    track = node.attrs.track?.filter(
+                const blockChangeTrack = (node.attrs.track as Array<{
+                        type: string
+                        before: {type: string; attrs: Record<string, unknown>}
+                    }> | undefined)?.find(track => track.type === "block_change"),
+                    track = (node.attrs.track as Array<{type: string}> | undefined)?.filter(
                         track => track !== blockChangeTrack
                     )
                 if (!blockChangeTrack) {

package/src/track/{reject_all.js → reject_all.ts}

@@ -5,23 +5,33 @@ import {
     RemoveMarkStep,
     ReplaceStep
 } from "prosemirror-transform"
+import type {Node} from "prosemirror-model"
+import type {EditorView} from "prosemirror-view"
 
-import {deactivateAllSelectedChanges} from "../state_plugins/index.js"
+import {deactivateAllSelectedChanges} from "../state_plugins/track/index.js"
 
 import {deleteNode} from "./delete.js"
 
-export const rejectAll = (view, from = 0, to = false) => {
+export const rejectAll = (
+    view: EditorView,
+    from = 0,
+    to: number | false = false
+): void => {
     if (!to) {
         to = view.state.doc.content.size
     }
     const tr = view.state.tr.setMeta("track", true),
         map = new Mapping()
-    view.state.doc.nodesBetween(from, to, (node, pos) => {
+    view.state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
         if (pos < from && !node.isInline) {
             return true
         }
         let deletedNode = false
-        if (node.attrs.track?.find(track => track.type === "insertion")) {
+        if (
+            (node.attrs.track as Array<{type: string}> | undefined)?.find(
+                track => track.type === "insertion"
+            )
+        ) {
             deleteNode(tr, node, pos, map, false)
             deletedNode = true
         } else if (
@@ -31,14 +41,18 @@ export const rejectAll = (view, from = 0, to = false) => {
         ) {
             const delStep = new ReplaceStep(
                 map.map(Math.max(pos, from)),
-                map.map(Math.min(pos + node.nodeSize, to)),
+                map.map(Math.min(pos + node.nodeSize, to as number)),
                 Slice.empty
             )
             tr.step(delStep)
             map.appendMap(delStep.getMap())
             deletedNode = true
-        } else if (node.attrs.track?.find(track => track.type === "deletion")) {
-            const track = node.attrs.track.filter(
+        } else if (
+            (node.attrs.track as Array<{type: string}> | undefined)?.find(
+                track => track.type === "deletion"
+            )
+        ) {
+            const track = (node.attrs.track as Array<{type: string}>).filter(
                 track => track.type !== "deletion"
             )
             tr.setNodeMarkup(
@@ -50,7 +64,7 @@ export const rejectAll = (view, from = 0, to = false) => {
         } else if (node.marks?.find(mark => mark.type.name === "deletion")) {
             tr.removeMark(
                 map.map(Math.max(pos, from)),
-                map.map(Math.min(pos + node.nodeSize, to)),
+                map.map(Math.min(pos + node.nodeSize, to as number)),
                 view.state.schema.marks.deletion
             )
         }
@@ -59,41 +73,47 @@ export const rejectAll = (view, from = 0, to = false) => {
         )
 
         if (node.isInline && !deletedNode && formatChangeMark) {
-            formatChangeMark.attrs.before.forEach(oldMark =>
+            ;(formatChangeMark.attrs.before as string[]).forEach(oldMark =>
                 tr.step(
                     new AddMarkStep(
                         map.map(Math.max(pos, from)),
-                        map.map(Math.min(pos + node.nodeSize, to)),
+                        map.map(Math.min(pos + node.nodeSize, to as number)),
                         view.state.schema.marks[oldMark].create()
                     )
                 )
             )
-            formatChangeMark.attrs.after.forEach(newMark => {
-                tr.step(
-                    new RemoveMarkStep(
-                        map.map(Math.max(pos, from)),
-                        map.map(Math.min(pos + node.nodeSize, to)),
-                        node.marks.find(mark => mark.type.name === newMark)
+            ;(formatChangeMark.attrs.after as string[]).forEach(newMark => {
+                const mark = node.marks.find(mark => mark.type.name === newMark)
+                if (mark) {
+                    tr.step(
+                        new RemoveMarkStep(
+                            map.map(Math.max(pos, from)),
+                            map.map(Math.min(pos + node.nodeSize, to as number)),
+                            mark
+                        )
                     )
-                )
+                }
             })
 
             tr.step(
                 new RemoveMarkStep(
                     map.map(Math.max(pos, from)),
-                    map.map(Math.min(pos + node.nodeSize, to)),
+                    map.map(Math.min(pos + node.nodeSize, to as number)),
                     formatChangeMark
                 )
             )
         }
         if (!node.isInline && !deletedNode && node.attrs.track) {
-            const blockChangeTrack = node.attrs.track.find(
-                track => track.type === "block_change"
-            )
+            const blockChangeTrack = (
+                node.attrs.track as Array<{
+                    type: string
+                    before: {type: string; attrs: Record<string, unknown>}
+                }>
+            ).find(track => track.type === "block_change")
             if (blockChangeTrack) {
-                const track = node.attrs.track.filter(
-                    track => track !== blockChangeTrack
-                )
+                const track = (
+                    node.attrs.track as Array<{type: string}>
+                ).filter(track => track !== blockChangeTrack)
                 tr.setNodeMarkup(
                     map.map(pos),
                     view.state.schema.nodes[blockChangeTrack.before.type],

package/src/types.ts

@@ -0,0 +1,287 @@
+/**
+ * Shared types used across the @fiduswriter/editor package.
+ *
+ * These types describe the public shape of the Editor instance and the
+ * auxiliary objects attached to it. They are intentionally permissive for
+ * module-specific sub-objects (`mod.*`) while the individual modules are
+ * being converted to TypeScript.
+ */
+
+import type {Node, Schema} from "prosemirror-model"
+import type {Plugin, Transaction} from "prosemirror-state"
+import type {EditorView} from "prosemirror-view"
+import type {App as CommonApp, User} from "@fiduswriter/common"
+import type {
+    BibDB,
+    BibDBEntries,
+    CommentData,
+    CSL,
+    ImageDB,
+    ImageDBEntries
+} from "@fiduswriter/document"
+
+export type {BibDB, BibDBEntries, CommentData, CSL, ImageDB, ImageDBEntries}
+export type {User} from "@fiduswriter/common"
+
+/** Image database interface used by the editor (document and user DBs). */
+export interface EditorImageDB extends ImageDB {
+    saveImage(imageData: Record<string, unknown>): Promise<number>
+    setImage(id: number, imageData: Record<string, unknown>): void
+}
+
+/** Extended app object used by the editor page. */
+export interface App extends CommonApp {
+    isOffline(): boolean
+    csl: CSL
+    imageDB: EditorImageDB
+}
+
+export type {App as EditorApp}
+
+/** Document access role constants. */
+export type CommentOnlyRole = "review" | "comment"
+export type ReadOnlyRole = "read" | "read-without-comments"
+export type ReviewRole = "review" | "review-tracked"
+export type WriteRole = "write" | "write-tracked" | "review-tracked"
+export type AccessRole =
+    | "write"
+    | "write-tracked"
+    | "review"
+    | "review-tracked"
+    | "comment"
+    | "read"
+    | "read-without-comments"
+
+export const COMMENT_ONLY_ROLES: CommentOnlyRole[] = ["review", "comment"]
+export const READ_ONLY_ROLES: ReadOnlyRole[] = ["read", "read-without-comments"]
+export const REVIEW_ROLES: ReviewRole[] = ["review", "review-tracked"]
+export const WRITE_ROLES: WriteRole[] = [
+    "write",
+    "write-tracked",
+    "review-tracked"
+]
+
+/** Information about the currently edited document. */
+export interface DocInfo {
+    id: number | string
+    token?: string
+    session_id?: string
+    templateId?: number
+    rights: string
+    owner?: {
+        id: number
+        name?: string
+        type?: string
+        avatar?: string
+        contacts: Array<{id: number | string; type: string; name: string; avatar?: string}>
+    }
+    is_owner: boolean
+    confirmedDoc: Node | false
+    updated: Date | false
+    dir: "ltr" | "rtl"
+    path: string
+    access_rights?: AccessRole
+    wsBase?: string
+    version?: number
+    e2ee?: boolean
+}
+
+/** Aggregated editor module namespace (populated by individual modules). */
+export interface EditorMod {
+    [key: string]: unknown
+    collab?: {
+        doc: {
+            sendToCollaborators(): void
+            confirmVersion(n: number): void
+            receiveDiff(data: unknown): void
+            receiveSelectionChange(data: unknown): void
+            checkVersion(offline?: boolean): void
+            cancelCurrentlyCheckingVersion(): void
+            confirmDiff(rid: number): void
+            rejectDiff(rid: number): void
+            awaitingDiffResponse: boolean
+            footnoteRender: boolean
+        }
+        participants: Array<{id: number; name?: string; session_id?: string; sessionIds?: string[]}>
+        pastParticipants: Array<{id: number; name?: string}>
+        updateParticipantList(participants: unknown[]): void
+        chat: {
+            newMessage(message: unknown): void
+            showChat(participants: unknown[]): void
+        }
+    }
+    marginboxes?: {
+        updateDOM(): void
+        view(view: EditorView): void
+        init(): void
+    }
+    footnotes?: {
+        fnEditor: {
+            view: EditorView
+            renderAllFootnotes(): void
+            applyDiffs(diffs: unknown[], cid: unknown): void
+            schema: {cached: Record<string, unknown>}
+        }
+        init(): void
+        layout?: {updateDOM(): void}
+    }
+    comments?: {
+        store: {
+            reset(): void
+            loadComments(comments: unknown): void
+            unsentEvents(): unknown[]
+            eventsSent(events: unknown[]): void
+            receive(events: unknown[]): void
+            comments: Record<string, unknown>
+        }
+    }
+    documentTemplate?: {
+        documentStyles: Array<{slug: string}>
+        getCitationStyles(): Promise<unknown>
+        setStyles(styles: unknown): void
+        addDocPartSettings(): void
+        addCitationStylesMenuEntries(): void
+    }
+    citations?: {
+        init(): void
+        resetCitations(): void
+        layoutCitations(): void
+    }
+    navigator?: {
+        init(): void
+    }
+    track?: unknown
+    db?: {
+        bibDB: {
+            db: BibDBEntries
+            unsent: unknown[]
+            setDB(value: BibDB): void
+            unsentEvents(): unknown[]
+            eventsSent(events: unknown[]): void
+            receive(events: unknown[]): void
+            hasReference(ref: unknown): boolean
+            addReference(ref: unknown, id: number): number
+        }
+        imageDB: {
+            db: ImageDBEntries
+            unsent: unknown[]
+            setDB(value: ImageDB): void
+            unsentEvents(): unknown[]
+            eventsSent(events: unknown[]): void
+            receive(events: unknown[]): void
+        }
+        clean?(): void
+    }
+}
+
+/** End-to-end encryption state attached to an editor. */
+export interface EditorE2EE {
+    key?: CryptoKey
+    snapshotManager?: {
+        setKey(key: CryptoKey): void
+        sendInitialSnapshot(...args: unknown[]): void
+        handleRequestSnapshot(data: unknown): void
+        handleSnapshotReceived(data: unknown): void
+    }
+    encrypted?: boolean
+    encryptionSalt?: string
+    encryptionIterations?: number
+    password?: string
+    usesPassphrase?: boolean
+}
+
+/** Menu model registry created during editor construction. */
+export interface EditorMenu {
+    headerbarModel: unknown
+    headerView?: {update(): void; destroy(): void}
+    imageMenuModel: unknown
+    navigatorFilterModel: unknown
+    orderedListMenuModel: unknown
+    selectionMenuModel: unknown
+    imageEditModel: unknown
+    tableMenuModel: unknown
+    figureMenuModel: unknown
+    toolbarModel: unknown
+    toolbarViews?: Array<{update(): void; destroy(): void; onResize?(): void}>
+    figureWidthMenuModel: unknown
+    codeBlockMenuModel: unknown
+    selectionMenuViews?: Array<{destroy(): void}>
+}
+
+/** User object attached to the editor, extending the common user with an id. */
+export interface EditorUser extends User {
+    id: number
+    is_authenticated?: boolean
+}
+
+/** Constructor options for the Editor class. */
+export interface EditorOptions {
+    app: App
+    user: EditorUser
+}
+
+/** Editor plugin tuple used to build the ProseMirror state. */
+export type EditorPluginTuple =
+    | [Plugin | ((...args: unknown[]) => Plugin)]
+    | [
+          Plugin | ((...args: unknown[]) => Plugin),
+          () => Record<string, unknown>
+      ]
+
+/** Main Editor instance shape used by modules, state plugins and menus. */
+export interface Editor {
+    app: App
+    user: EditorUser
+    editorPlugins: EditorPluginTuple[]
+    citationDialogPlugins: EditorPluginTuple[] | null
+    mod: EditorMod
+    waitingForDocument: boolean
+    docInfo: DocInfo
+    schema: Schema & {cached: Record<string, unknown>}
+    menu: EditorMenu
+    client_id: number
+    clientTimeAdjustment: number
+    e2ee: EditorE2EE | null
+    pathEditable: boolean
+    statePlugins: EditorPluginTuple[]
+    view: EditorView
+    currentView: EditorView
+    dom: HTMLElement
+    ws?: {
+        connectionCount?: number
+        online?: boolean
+        connected?: boolean
+        ws?: WebSocket
+        init(): void
+        close(): void
+        send(data: string | (() => Record<string, unknown> | false | undefined)): void
+    }
+
+    init(): Promise<void>
+    startWebSocket(): void
+    getDoc(options?: {use_current_view?: boolean; changes?: string}): Record<string, unknown>
+    close(): void
+    scrollPosIntoView(pos: number, view: EditorView): void
+    scrollBibliographyIntoView(_target?: string): void
+    scrollIdIntoView(id: string): void
+}
+
+/** State plugin context object passed to most plugin constructors. */
+export interface EditorPluginContext {
+    editor: Editor
+    viewType?: string
+}
+
+/** Helper type for transaction inputType metadata. */
+export type InputType =
+    | "deleteContentBackward"
+    | "deleteContentForward"
+    | "historyUndo"
+    | "historyRedo"
+    | "insertText"
+    | "insertFromPaste"
+    | string
+
+export interface TransactionWithInputType extends Transaction {
+    setMeta(key: "inputType", value: InputType): this
+}

package/src/comments/index.js

@@ -1,11 +0,0 @@
-import {ModCommentInteractions} from "./interactions.js"
-import {ModCommentStore} from "./store.js"
-
-export class ModComments {
-    constructor(editor) {
-        editor.mod.comments = this
-        this.editor = editor
-        new ModCommentStore(this)
-        new ModCommentInteractions(this)
-    }
-}