@fiduswriter/editor 0.1.20 → 0.1.21

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

@@ -5,38 +5,50 @@ 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 acceptAll = (view, from = 0, to = false) => {
+export const acceptAll = (
+    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 === "deletion")) {
+        if (
+            (node.attrs.track as Array<{type: string}> | undefined)?.find(
+                track => track.type === "deletion"
+            )
+        ) {
             deleteNode(tr, node, pos, map, true)
             deletedNode = true
         } else if (node.marks?.find(mark => mark.type.name === "deletion")) {
             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 === "insertion")
+            (node.attrs.track as Array<{type: string}> | undefined)?.find(
+                track => track.type === "insertion"
+            )
         ) {
-            const track = node.attrs.track.filter(
+            const track = (node.attrs.track as Array<{type: string}>).filter(
                 track => track.type !== "insertion"
             )
             tr.setNodeMarkup(
@@ -50,14 +62,12 @@ export const acceptAll = (view, from = 0, to = false) => {
                 mark => mark.type.name === "insertion" && !mark.attrs.approved
             )
         ) {
-            const mark = node.marks.find(
-                    mark => mark.type.name === "insertion"
-                ),
-                attrs = Object.assign({}, mark.attrs, {approved: true})
+            const mark = node.marks.find(mark => mark.type.name === "insertion"),
+                attrs = Object.assign({}, mark?.attrs, {approved: true})
             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.insertion.create(attrs)
                 )
             )
@@ -69,18 +79,18 @@ export const acceptAll = (view, from = 0, to = false) => {
             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}>
+            ).find(track => track.type === "block_change")
             if (blockChangeTrack) {
-                const track = node.attrs.track.filter(
+                const track = (node.attrs.track as Array<{type: string}>).filter(
                     track => track !== blockChangeTrack
                 )
                 tr.setNodeMarkup(

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

@@ -1,26 +1,32 @@
 import {Mapping, RemoveMarkStep, Transform} from "prosemirror-transform"
+import type {Node} from "prosemirror-model"
 
 import {fnSchema} from "@fiduswriter/document/schema/footnotes"
 
 import {deleteNode} from "./delete.js"
 
-export function acceptAllNoInsertions(doc) {
+interface TrackAttr {
+    type: string
+    name?: string
+}
+
+export function acceptAllNoInsertions(doc: Node): Node {
     // Same as accept all and additionally remove insertion marks/tracks
     // and no dependence on view.
     const tr = new Transform(doc),
         map = new Mapping()
-    doc.descendants((node, pos) => {
+    doc.descendants((node: Node, pos: number) => {
         const deletionTrack = node.attrs.track
-                ? node.attrs.track.find(track => track.type === "deletion")
+                ? (node.attrs.track as TrackAttr[]).find(track => track.type === "deletion")
                 : node.marks.find(mark => mark.type.name === "deletion"),
             insertionTrack = node.attrs.track
-                ? node.attrs.track.find(track => track.type === "insertion")
+                ? (node.attrs.track as TrackAttr[]).find(track => track.type === "insertion")
                 : node.marks.find(mark => mark.type.name === "insertion"),
             formatChangeMark = node.marks.find(
                 mark => mark.type.name === "format_change"
             ),
             blockChangeTrack = node.attrs.track
-                ? node.attrs.track.find(track => track.name === "block_change")
+                ? (node.attrs.track as TrackAttr[]).find(track => track.name === "block_change")
                 : false
 
         if (node.type.name === "footnote" && node.attrs.footnote) {
@@ -40,7 +46,7 @@ export function acceptAllNoInsertions(doc) {
                     map.map(pos),
                     null,
                     Object.assign({}, node.attrs, {
-                        footnote: cleanFnDoc.firstChild.toJSON().content
+                        footnote: cleanFnDoc.firstChild?.toJSON().content
                     }),
                     node.marks
                 )
@@ -61,11 +67,11 @@ export function acceptAllNoInsertions(doc) {
                     new RemoveMarkStep(
                         map.map(pos),
                         map.map(pos + node.nodeSize),
-                        insertionTrack
+                        insertionTrack as import("prosemirror-model").Mark
                     )
                 )
             } else {
-                const track = node.attrs.track.filter(
+                const track = (node.attrs.track as TrackAttr[]).filter(
                     track => track !== insertionTrack
                 )
                 tr.setNodeMarkup(
@@ -86,8 +92,8 @@ export function acceptAllNoInsertions(doc) {
             )
         }
         if (blockChangeTrack) {
-            const track = node.attrs.track.filter(
-                track => track.type !== blockChangeTrack
+            const track = (node.attrs.track as TrackAttr[]).filter(
+                track => track.type !== (blockChangeTrack as TrackAttr).type
             )
             tr.setNodeMarkup(
                 map.map(pos),

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

@@ -1,15 +1,27 @@
-import {Slice} from "prosemirror-model"
-import {Selection, TextSelection} from "prosemirror-state"
+import {Node, Slice} from "prosemirror-model"
+import {EditorState, Selection, TextSelection, Transaction} from "prosemirror-state"
 import {CellSelection} from "prosemirror-tables"
 import {
     AddMarkStep,
     Mapping,
     RemoveMarkStep,
     ReplaceAroundStep,
-    ReplaceStep
+    ReplaceStep,
+    Step
 } from "prosemirror-transform"
+import type {Track} from "@fiduswriter/document"
 
-function markInsertion(tr, from, to, user, date1, date10, approved) {
+import type {Editor, EditorUser} from "../types.js"
+
+function markInsertion(
+    tr: Transaction,
+    from: number,
+    to: number,
+    user: EditorUser,
+    date1: number,
+    date10: number,
+    approved: boolean
+): void {
     const insertionMark = tr.doc.type.schema.marks.insertion.create({
         user: user.id,
         username: user.username,
@@ -43,16 +55,16 @@ function markInsertion(tr, from, to, user, date1, date10, approved) {
         } else if (["table_row", "table_cell"].includes(node.type.name)) {
             return false
         }
-        if (node.attrs.track) {
-            const track = []
-            if (!approved) {
-                track.push({
-                    type: "insertion",
-                    user: user.id,
-                    username: user.username,
-                    date: date1
-                })
-            }
+        const track = (node.attrs.track as Track[] | undefined)?.slice() || []
+        if (!approved) {
+            track.push({
+                type: "insertion",
+                user: user.id,
+                username: user.username,
+                date: date1
+            })
+        }
+        if (node.attrs.track || !approved) {
             tr.setNodeMarkup(
                 pos,
                 null,
@@ -64,10 +76,18 @@ function markInsertion(tr, from, to, user, date1, date10, approved) {
             // A table or figure was inserted. We don't add track marks to elements inside of it.
             return false
         }
+        return true
     })
 }
 
-function markDeletion(tr, from, to, user, date1, date10) {
+function markDeletion(
+    tr: Transaction,
+    from: number,
+    to: number,
+    user: EditorUser,
+    date1: number,
+    date10: number
+): Mapping {
     const deletionMark = tr.doc.type.schema.marks.deletion.create({
         user: user.id,
         username: user.username,
@@ -77,7 +97,7 @@ function markDeletion(tr, from, to, user, date1, date10) {
     let listItem = false
     const deletionMap = new Mapping()
     // Add deletion mark to block nodes (figures, text blocks) and find already deleted inline nodes (and leave them alone)
-    tr.doc.nodesBetween(from, to, (node, pos, _parent, _index) => {
+    tr.doc.nodesBetween(from, to, (node, pos) => {
         if (pos < from && node.type.name === "table_cell") {
             firstTableCellChild = true
             return true
@@ -113,19 +133,18 @@ function markDeletion(tr, from, to, user, date1, date10) {
                 deletionMark
             )
         } else if (
-            !node.attrs.track?.find(
+            !(node.attrs.track as Track[] | undefined)?.find(
                 trackAttr => trackAttr.type === "deletion"
             ) &&
             !["bullet_list", "ordered_list"].includes(node.type.name)
         ) {
-            if (
-                node.attrs.track?.find(
-                    trackAttr =>
-                        trackAttr.type === "insertion" &&
-                        trackAttr.user === user.id
-                )
-            ) {
-                let removeStep
+            const insertionTrack = (node.attrs.track as Track[] | undefined)?.find(
+                trackAttr =>
+                    trackAttr.type === "insertion" &&
+                    trackAttr.user === user.id
+            )
+            if (insertionTrack) {
+                let removeStep: ReplaceStep | undefined
                 // user has created element. so (s)he is allowed to delete it again.
                 if (node.isTextblock && to < pos + node.nodeSize) {
                     // The node is a textblock. So we need to merge into the last possible
@@ -149,7 +168,7 @@ function markDeletion(tr, from, to, user, date1, date10) {
                     )
                 }
 
-                if (!tr.maybeStep(removeStep).failed) {
+                if (removeStep && !tr.maybeStep(removeStep).failed) {
                     deletionMap.appendMap(removeStep.getMap())
                 }
                 if (node.type.name === "list_item" && listItem) {
@@ -162,9 +181,9 @@ function markDeletion(tr, from, to, user, date1, date10) {
                     // The first child of the first list item (likely a par) will not be merged with the paragraph
                     // before it.
                     listItem = false
-                    return
+                    return true
                 }
-                const track = node.attrs.track.slice()
+                const track = (node.attrs.track as Track[]).slice()
                 track.push({
                     type: "deletion",
                     user: user.id,
@@ -182,43 +201,63 @@ function markDeletion(tr, from, to, user, date1, date10) {
                 return false
             }
         }
+        return true
     })
 
     return deletionMap
 }
 
-function markWrapping(tr, pos, oldNode, newNode, user, date1) {
-    let track = oldNode.attrs.track.slice(),
-        blockTrack = track.find(track => track.type === "block_change")
+function markWrapping(
+    tr: Transaction,
+    pos: number,
+    oldNode: Node,
+    newNode: Node | null,
+    user: EditorUser,
+    date1: number
+): void {
+    const oldTrack = oldNode.attrs.track as Track[] | undefined
+    if (!oldTrack || !newNode) {
+        return
+    }
+    let track = oldTrack.slice()
+    let blockTrack = track.find(track => track.type === "block_change")
 
     if (blockTrack) {
         track = track.filter(track => track !== blockTrack)
+        const before = blockTrack.before as {
+            type: string
+            attrs: Record<string, unknown>
+        }
         if (
-            blockTrack.before.type !== newNode.type.name ||
-            blockTrack.before.attrs.level !== newNode.attrs.level
+            before.type !== newNode.type.name ||
+            before.attrs.level !== newNode.attrs.level
         ) {
             blockTrack = {
                 type: "block_change",
                 user: user.id,
                 username: user.username,
                 date: date1,
-                before: blockTrack.before
+                before
             }
             track.push(blockTrack)
         }
     } else {
+        const before = {
+            type: oldNode.type.name,
+            attrs: Object.assign({}, oldNode.attrs) as Record<string, unknown>
+        }
+        if (before.attrs.id) {
+            delete before.attrs.id
+        }
+        if (before.attrs.track) {
+            delete before.attrs.track
+        }
         blockTrack = {
             type: "block_change",
             user: user.id,
             username: user.username,
             date: date1,
-            before: {type: oldNode.type.name, attrs: oldNode.attrs}
-        }
-        if (blockTrack.before.attrs.id) {
-            delete blockTrack.before.attrs.id
-        }
-        if (blockTrack.before.attrs.track) {
-            delete blockTrack.before.attrs.track
+            before
         }
         track.push(blockTrack)
     }
@@ -227,16 +266,21 @@ function markWrapping(tr, pos, oldNode, newNode, user, date1) {
     }
 }
 
-export function amendTransaction(tr, state, editor) {
+export function amendTransaction(
+    tr: Transaction,
+    state: EditorState,
+    editor: Editor
+): Transaction {
+    const trMeta = (tr as unknown as {meta?: Record<string, unknown>}).meta
     if (
         !tr.steps.length ||
-        (tr.meta &&
-            !Object.keys(tr.meta).every(
+        (trMeta &&
+            !Object.keys(trMeta).every(
                 // Only replace TRs that have no metadata or only inputType metadata
                 metadata => ["inputType", "uiEvent", "paste"].includes(metadata)
             )) ||
         // don't replace history TRs
-        ["historyUndo", "historyRedo"].includes(tr.getMeta("inputType"))
+        ["historyUndo", "historyRedo"].includes(tr.getMeta("inputType") as string)
     ) {
         // None of the transactions change the doc, or all are remote, come from footnotes,
         // are footnote creations, history or fixing IDs. Give up.
@@ -248,14 +292,20 @@ export function amendTransaction(tr, state, editor) {
             editor.user,
             !editor.view.state.doc.attrs.tracked &&
                 !["write-tracked", "review-tracked"].includes(
-                    editor.docInfo.access_rights
+                    editor.docInfo.access_rights as string
                 ),
             Date.now() - editor.clientTimeAdjustment
         )
     }
 }
 
-export function trackedTransaction(tr, state, user, approved, date) {
+export function trackedTransaction(
+    tr: Transaction,
+    state: EditorState,
+    user: EditorUser,
+    approved: boolean,
+    date: number
+): Transaction {
     const newTr = state.tr,
         map = new Mapping(),
         date10 = Math.floor(date / 600000) * 10, // 10 minute interval
@@ -264,9 +314,9 @@ export function trackedTransaction(tr, state, user, approved, date) {
         // content of each cell and replacing it with an empty paragraph.
         cellDeleteTr =
             ["deleteContentBackward", "deleteContentForward"].includes(
-                tr.getMeta("inputType")
+                tr.getMeta("inputType") as string
             ) && state.selection instanceof CellSelection
-    tr.steps.forEach((originalStep, originalStepIndex) => {
+    tr.steps.forEach((originalStep: Step, originalStepIndex: number) => {
         const step = originalStep.map(map),
             doc = newTr.doc
         if (!step) {
@@ -280,13 +330,16 @@ export function trackedTransaction(tr, state, user, approved, date) {
                         step.to, // We insert all the same steps, but with "from"/"to" both set to "to" in order not to delete content. Mapped as needed.
                         step.to,
                         step.slice,
-                        step.structure
+                        (step as ReplaceStep & {structure?: boolean}).structure
                     )
                   : false
             // We didn't apply the original step in its original place. We adjust the map accordingly.
             const invertStep = originalStep
                 .invert(tr.docs[originalStepIndex])
                 .map(map)
+            if (!invertStep) {
+                return
+            }
             map.appendMap(invertStep.getMap())
             if (newStep) {
                 const trTemp = state.apply(newTr).tr
@@ -312,13 +365,13 @@ export function trackedTransaction(tr, state, user, approved, date) {
                     map.appendMap(condensedStep.getMap(), mirrorIndex)
                     if (!newTr.selection.eq(trTemp.selection)) {
                         newTr.setSelection(
-                            Selection.fromJSON(trTemp.selection.toJSON())
+                            Selection.fromJSON(newTr.doc, trTemp.selection.toJSON())
                         )
                     }
                 }
             }
             if (!approved && step.from !== step.to) {
-                map.appendMap(
+                map.appendMapping(
                     markDeletion(newTr, step.from, step.to, user, date1, date10)
                 )
             }
@@ -339,8 +392,11 @@ export function trackedTransaction(tr, state, user, approved, date) {
                 const invertStep = originalStep
                     .invert(tr.docs[originalStepIndex])
                     .map(map)
+                if (!invertStep) {
+                    return
+                }
                 map.appendMap(invertStep.getMap())
-                map.appendMap(
+                map.appendMapping(
                     markDeletion(
                         newTr,
                         step.from,
@@ -358,7 +414,7 @@ export function trackedTransaction(tr, state, user, approved, date) {
                 // Replaced one wrapping with another
                 newTr.step(step)
                 const oldNode = doc.nodeAt(step.from)
-                if (oldNode.attrs.track) {
+                if (oldNode?.attrs.track) {
                     markWrapping(
                         newTr,
                         step.from,
@@ -394,6 +450,7 @@ export function trackedTransaction(tr, state, user, approved, date) {
                             date10,
                             false
                         )
+                        return true
                     })
                 )
             }
@@ -411,6 +468,7 @@ export function trackedTransaction(tr, state, user, approved, date) {
                         step.mark
                     )
                 }
+
                 if (
                     ["em", "strong", "underline"].includes(
                         step.mark.type.name
@@ -420,22 +478,22 @@ export function trackedTransaction(tr, state, user, approved, date) {
                     const formatChangeMark = node.marks.find(
                         mark => mark.type.name === "format_change"
                     )
-                    let after, before
+                    let after: string[], before: string[]
                     if (formatChangeMark) {
                         if (
-                            formatChangeMark.attrs.before.includes(
+                            (formatChangeMark.attrs.before as string[]).includes(
                                 step.mark.type.name
                             )
                         ) {
-                            before = formatChangeMark.attrs.before.filter(
+                            before = (formatChangeMark.attrs.before as string[]).filter(
                                 markName => markName !== step.mark.type.name
                             )
-                            after = formatChangeMark.attrs.after
+                            after = formatChangeMark.attrs.after as string[]
                         } else {
-                            before = formatChangeMark.attrs.before
-                            after = formatChangeMark.attrs.after.concat(
-                                step.mark.type.name
-                            )
+                            before = formatChangeMark.attrs.before as string[]
+                            after = (
+                                formatChangeMark.attrs.after as string[]
+                            ).concat(step.mark.type.name)
                         }
                     } else {
                         before = []
@@ -461,6 +519,7 @@ export function trackedTransaction(tr, state, user, approved, date) {
                         )
                     }
                 }
+                return true
             })
         } else if (step instanceof RemoveMarkStep) {
             doc.nodesBetween(step.from, step.to, (node, pos) => {
@@ -486,22 +545,22 @@ export function trackedTransaction(tr, state, user, approved, date) {
                     const formatChangeMark = node.marks.find(
                         mark => mark.type.name === "format_change"
                     )
-                    let after, before
+                    let after: string[], before: string[]
                     if (formatChangeMark) {
                         if (
-                            formatChangeMark.attrs.after.includes(
+                            (formatChangeMark.attrs.after as string[]).includes(
                                 step.mark.type.name
                             )
                         ) {
-                            after = formatChangeMark.attrs.after.filter(
+                            after = (formatChangeMark.attrs.after as string[]).filter(
                                 markName => markName !== step.mark.type.name
                             )
-                            before = formatChangeMark.attrs.before
+                            before = formatChangeMark.attrs.before as string[]
                         } else {
-                            after = formatChangeMark.attrs.after
-                            before = formatChangeMark.attrs.before.concat(
-                                step.mark.type.name
-                            )
+                            after = formatChangeMark.attrs.after as string[]
+                            before = (
+                                formatChangeMark.attrs.before as string[]
+                            ).concat(step.mark.type.name)
                         }
                     } else {
                         after = []
@@ -527,6 +586,7 @@ export function trackedTransaction(tr, state, user, approved, date) {
                         )
                     }
                 }
+                return true
             })
         }
     })

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

@@ -1,13 +1,15 @@
-import {Slice} from "prosemirror-model"
+import {Slice, type Node} from "prosemirror-model"
 import {liftListItem} from "prosemirror-schema-list"
 import {EditorState, Selection, TextSelection} from "prosemirror-state"
-import {
-    ReplaceAroundStep,
-    ReplaceStep,
-    replaceStep
-} from "prosemirror-transform"
+import {ReplaceAroundStep, ReplaceStep, replaceStep} from "prosemirror-transform"
 
-export const deleteNode = (tr, node, nodePos, map, accept) => {
+export const deleteNode = (
+    tr: import("prosemirror-transform").Transform,
+    node: Node,
+    nodePos: number,
+    map: import("prosemirror-transform").Mapping,
+    accept: boolean
+): void => {
     // Delete a node either because a deletion has been accepted or an insertion rejected.
     const newNodePos = map.map(nodePos),
         trackType = accept ? "deletion" : "insertion"
@@ -22,18 +24,19 @@ export const deleteNode = (tr, node, nodePos, map, accept) => {
                 end = newNodePos + 1
             let allowMerge = true
             // Make sure there is no isolating nodes inbetween.
-            tr.doc.nodesBetween(start, end, (node, pos) => {
+            tr.doc.nodesBetween(start, end, (innerNode: Node, pos: number) => {
                 if (pos < start) {
                     return true
                 }
-                if (node.type.spec.isolating) {
+                if (innerNode.type.spec.isolating) {
                     allowMerge = false
                 }
+                return false
             })
             if (allowMerge) {
                 delStep = replaceStep(tr.doc, start, end)
             } else {
-                const track = node.attrs.track.filter(
+                const track = (node.attrs.track as Array<{type: string}>).filter(
                     track => track.type !== trackType
                 )
                 tr.setNodeMarkup(
@@ -45,7 +48,7 @@ export const deleteNode = (tr, node, nodePos, map, accept) => {
             }
         } else {
             // There is a block node right in front of it that cannot be removed. Give up. (table/figure/etc.)
-            const track = node.attrs.track.filter(
+            const track = (node.attrs.track as Array<{type: string}>).filter(
                 track => track.type !== trackType
             )
             tr.setNodeMarkup(
@@ -64,7 +67,7 @@ export const deleteNode = (tr, node, nodePos, map, accept) => {
     } else if (node.type === tr.doc.type.schema.nodes["list_item"]) {
         const state = EditorState.create({
             doc: tr.doc,
-            selection: Selection.findFrom(tr.doc.resolve(newNodePos), 1)
+            selection: Selection.findFrom(tr.doc.resolve(newNodePos), 1) || undefined
         })
         liftListItem(node.type)(state, newTr => {
             newTr.steps.forEach(step => {