@fiduswriter/editor 0.1.20 → 0.1.21

package/src/document_template/exporter.js

@@ -1,97 +0,0 @@
-import download from "downloadjs"
-
-import {createSlug} from "@fiduswriter/document/exporter/tools/file"
-import {ZipFileCreator} from "fwtoolkit/file/zip"
-import {postJson} from "fwtoolkit"
-
-export class DocumentTemplateExporter {
-    constructor(
-        id,
-        getUrl = "/api/document/admin/get_template/",
-        download = true,
-        token = false
-    ) {
-        this.id = id
-        this.getUrl = getUrl
-        this.download = download
-        this.token = token
-
-        this.zipFileName = false
-        this.docVersion = false
-        this.textFiles = []
-        this.httpFiles = []
-    }
-
-    init() {
-        const params = this.token
-            ? {id: this.id, token: this.token}
-            : {id: this.id}
-        return postJson(this.getUrl, params).then(({json}) => {
-            this.docVersion = json.doc_version
-            this.zipFileName = `${createSlug(json.title)}.fidustemplate`
-            this.textFiles.push({
-                filename: "template.json",
-                contents: JSON.stringify(json.content)
-            })
-            const exportTemplates = []
-            json.export_templates.forEach(template => {
-                const filename = `exporttemplates/${template.fields.template_file.split("/").slice(-1)[0]}`
-                this.httpFiles.push({
-                    filename,
-                    url: template.fields.template_file
-                })
-                exportTemplates.push({
-                    file: filename,
-                    file_type: template.fields.file_type,
-                    title: template.fields.title
-                })
-            })
-            this.textFiles.push({
-                filename: "exporttemplates.json",
-                contents: JSON.stringify(exportTemplates)
-            })
-            const documentStyles = []
-            json.document_styles.forEach(docStyle => {
-                const style = {
-                    contents: docStyle.fields.contents,
-                    slug: docStyle.fields.slug,
-                    title: docStyle.fields.title,
-                    files: []
-                }
-                docStyle.fields.documentstylefile_set.forEach(docstyleFile => {
-                    const filename = `documentstyles/${docstyleFile[1]}`
-                    this.httpFiles.push({
-                        filename,
-                        url: docstyleFile[0]
-                    })
-                    style.files.push(filename)
-                })
-                documentStyles.push(style)
-            })
-            this.textFiles.push({
-                filename: "documentstyles.json",
-                contents: JSON.stringify(documentStyles)
-            })
-            if (this.download) {
-                return this.createZip()
-            }
-            return Promise.resolve()
-        })
-    }
-
-    createZip() {
-        this.textFiles.push({
-            filename: "filetype-version",
-            contents: this.docVersion
-        })
-        const zipper = new ZipFileCreator(
-            this.textFiles,
-            this.httpFiles,
-            undefined,
-            "application/fidustemplate+zip"
-        )
-        return zipper
-            .init()
-            .then(blob => download(blob, this.zipFileName, "application/zip"))
-    }
-}

package/src/exporter/native/copy.js

@@ -1,191 +0,0 @@
-import {SaveCopy as GenericSaveCopy} from "@fiduswriter/document/exporter/native"
-import {addAlert, addProgress, gettext, postJson, shortFileTitle} from "fwtoolkit"
-import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
-import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
-import {NativeImporter} from "@fiduswriter/document/importer/native"
-
-async function maybeDecryptImage(imageEntry, sourceKey) {
-    if (!sourceKey || !imageEntry.file) {
-        return
-    }
-    if (imageEntry.file_type !== "application/octet-stream") {
-        return
-    }
-    const fileBuffer = await imageEntry.file.arrayBuffer()
-    const bytes = new Uint8Array(fileBuffer)
-    let binary = ""
-    const chunkSize = 65536
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-        const chunk = bytes.subarray(i, i + chunkSize)
-        binary += String.fromCharCode.apply(null, chunk)
-    }
-    const base64 = btoa(binary)
-    const decrypted = await E2EEEncryptor.decryptBufferToBase64(base64, sourceKey)
-    const mime = imageEntry.original_file_type || "image/png"
-    const byteCharacters = atob(decrypted)
-    const byteNumbers = new Array(byteCharacters.length)
-    for (let i = 0; i < byteCharacters.length; i++) {
-        byteNumbers[i] = byteCharacters.charCodeAt(i)
-    }
-    const byteArray = new Uint8Array(byteNumbers)
-    imageEntry.file = new Blob([byteArray], {type: mime})
-    imageEntry.file_type = mime
-}
-
-function createNativeImporterBackend(user, e2eeOptions) {
-    return {
-        createDoc: (template, importId, path, e2ee, files) => {
-            const jsonData = {
-                template: template.content,
-                export_templates: template.exportTemplates,
-                document_styles: template.documentStyles,
-                import_id: importId
-                    ? importId
-                    : template.content.attrs.import_id,
-                template_title: template.content.attrs.template,
-                path
-            }
-            if (e2ee?.enabled) {
-                jsonData.e2ee = true
-                if (e2ee.salt) {
-                    jsonData.e2ee_salt = e2ee.salt
-                }
-                if (e2ee.iterations) {
-                    jsonData.e2ee_iterations = e2ee.iterations
-                }
-            }
-            return postJson("/api/document/import/create/", jsonData, files)
-                .then(({json}) => ({
-                    id: json.id,
-                    path: json.path,
-                    e2ee: json.e2ee,
-                    template: json.template
-                }))
-                .catch(error => {
-                    addAlert("error", gettext("Could not create document"))
-                    throw error
-                })
-        },
-        saveImages: async (images, docId, e2ee) => {
-            const isE2EE = e2ee?.enabled
-            const endpoint = isE2EE
-                ? "/api/document/e2ee_image/"
-                : "/api/document/import/image/"
-            const imageTranslationTable = {}
-            await Promise.all(
-                Object.values(images.db).map(async imageEntry => {
-                    await maybeDecryptImage(imageEntry, e2ee?.sourceKey)
-                    const encryptedFile =
-                        e2ee?.enabled && e2ee.key
-                            ? await E2EEEncryptor.encryptImage(
-                                  imageEntry.file,
-                                  e2ee.key
-                              )
-                            : imageEntry.file
-                    const jsonData = {
-                        doc_id: docId,
-                        title: imageEntry.title,
-                        copyright: imageEntry.copyright,
-                        checksum: imageEntry.checksum
-                    }
-                    const files = {
-                        image: {
-                            file: encryptedFile,
-                            filename: imageEntry.image.split("/").pop()
-                        }
-                    }
-                    const {json} = await postJson(endpoint, jsonData, files)
-                    imageTranslationTable[imageEntry.id] = json.id
-                })
-            )
-            return imageTranslationTable
-        },
-        saveDocument: async (saveData, e2ee) => {
-            if (e2ee?.enabled && e2ee.key) {
-                saveData.content = await E2EEEncryptor.encryptObject(
-                    saveData.content,
-                    e2ee.key
-                )
-                saveData.comments = await E2EEEncryptor.encryptObject(
-                    saveData.comments || {},
-                    e2ee.key
-                )
-                saveData.bibliography = await E2EEEncryptor.encryptObject(
-                    saveData.bibliography,
-                    e2ee.key
-                )
-                saveData.title = await E2EEEncryptor.encrypt(
-                    saveData.title,
-                    e2ee.key
-                )
-            }
-            return postJson("/api/document/import/", saveData)
-                .then(({json}) => ({added: json.added, updated: json.updated}))
-                .catch(error => {
-                    addAlert(
-                        "error",
-                        `${gettext("Could not save ")} ${shortFileTitle(
-                            saveData.title,
-                            ""
-                        )}`
-                    )
-                    throw error
-                })
-        },
-        encryptImage: E2EEEncryptor.encryptImage.bind(E2EEEncryptor),
-        encryptObject: E2EEEncryptor.encryptObject.bind(E2EEEncryptor),
-        encrypt: E2EEEncryptor.encrypt.bind(E2EEEncryptor),
-        storeKeyInSession: E2EEKeyManager.storeKeyInSession.bind(E2EEKeyManager)
-    }
-}
-
-export class SaveCopy extends GenericSaveCopy {
-    constructor(
-        doc,
-        bibDB,
-        imageDB,
-        newUser,
-        importId = null,
-        e2eeOptions = null
-    ) {
-        const title = shortFileTitle(doc.title, doc.path || "")
-        const task = addProgress(
-            "info",
-            `${title}: ${gettext("Creating copy...")}`,
-            {autoClose: 6000}
-        )
-        const progressCallback = (message, percentage) =>
-            task.update(percentage, message)
-        const e2ee = {
-            decryptObject: E2EEEncryptor.decryptObject.bind(E2EEEncryptor),
-            encryptObject: E2EEEncryptor.encryptObject.bind(E2EEEncryptor),
-            encrypt: E2EEEncryptor.encrypt.bind(E2EEEncryptor),
-            encryptImage: E2EEEncryptor.encryptImage.bind(E2EEEncryptor),
-            generateSalt: E2EEKeyManager.generateSalt.bind(E2EEKeyManager),
-            deriveKey: E2EEKeyManager.deriveKey.bind(E2EEKeyManager)
-        }
-
-        const importDocument = (doc, bibDB, imageDB, httpIncludes, options) =>
-            new NativeImporter(
-                doc,
-                bibDB,
-                imageDB,
-                httpIncludes,
-                options.user,
-                createNativeImporterBackend(options.user, options.e2eeOptions),
-                {
-                    importId: options.importId,
-                    requestedPath: options.requestedPath,
-                    e2eeOptions: options.e2eeOptions
-                }
-            ).init()
-
-        super(doc, bibDB, imageDB, newUser, {
-            importId,
-            e2eeOptions,
-            e2ee,
-            importDocument,
-            progressCallback
-        })
-    }
-}

package/src/footnotes/index.js

@@ -1,16 +0,0 @@
-import {ModFootnoteEditor} from "./editor.js"
-import {ModFootnoteLayout} from "./layout.js"
-
-export class ModFootnotes {
-    constructor(editor) {
-        editor.mod.footnotes = this
-        this.editor = editor
-        new ModFootnoteEditor(this)
-        new ModFootnoteLayout(this)
-    }
-
-    init() {
-        this.fnEditor.init()
-        this.layout.init()
-    }
-}

package/src/menus/figure/utils.js

@@ -1,5 +0,0 @@
-export const figureMenuAction = (value, figureDialog) => {
-    const buttonDOM = document.querySelector(".figure-width")
-    buttonDOM.firstElementChild.innerText = `${value} %`
-    figureDialog.width = value
-}

package/src/state_plugins/citation_render.js

@@ -1,88 +0,0 @@
-import {Plugin, PluginKey} from "prosemirror-state"
-import {ReplaceAroundStep, ReplaceStep} from "prosemirror-transform"
-
-const key = new PluginKey("citationRender")
-
-export const citationRenderPlugin = options =>
-    new Plugin({
-        key,
-        state: {
-            init() {
-                return {action: false}
-            },
-            apply(tr, _prev, oldState, _state) {
-                const meta = tr.getMeta(key)
-                if (meta) {
-                    // There has been an update, return values from meta instead
-                    // of previous values
-                    return meta
-                }
-                let {action} = this.getState(oldState)
-
-                if (action || tr.getMeta("settings")) {
-                    return {action} // We already need to reset the bibliography or another setting is used. Don't bother checking for more reasons to do so.
-                }
-                tr.steps.forEach((step, index) => {
-                    if (
-                        step instanceof ReplaceStep ||
-                        step instanceof ReplaceAroundStep
-                    ) {
-                        if (step.from !== step.to) {
-                            tr.docs[index].nodesBetween(
-                                step.from,
-                                step.to,
-                                node => {
-                                    if (node.type.name === "citation") {
-                                        // A citation was replaced. We need to reset
-                                        action = "reset"
-                                    } else if (
-                                        !action &&
-                                        node.type.name === "footnote"
-                                    ) {
-                                        action = "numbers"
-                                    }
-                                }
-                            )
-                        }
-                        if (step.slice?.content) {
-                            step.slice.content.descendants(node => {
-                                if (node.type.name === "citation") {
-                                    // A citation was added. We need to reset
-                                    action = "reset"
-                                } else if (
-                                    !action &&
-                                    node.type.name === "footnote"
-                                ) {
-                                    action = "numbers"
-                                }
-                            })
-                        }
-                    }
-                })
-
-                return {action}
-            }
-        },
-        view(_view) {
-            options.editor.mod.citations.resetCitations()
-            return {
-                update: (view, _prevState) => {
-                    const {action} = key.getState(view.state)
-                    if (action === "reset") {
-                        options.editor.mod.citations.resetCitations()
-                        const tr = view.state.tr.setMeta(key, {action: false})
-                        view.dispatch(tr)
-                    } else if (action === "numbers") {
-                        options.editor.mod.citations.footnoteNumberOverride()
-                        const tr = view.state.tr.setMeta(key, {action: false})
-                        view.dispatch(tr)
-                    } else if (view.dom.querySelector(".citation:empty")) {
-                        options.editor.mod.citations.resetCitations()
-                    }
-                },
-                destroy: () => {
-                    options.editor.mod.citations.resetCitations()
-                }
-            }
-        }
-    })

package/src/state_plugins/footnote_markers.js

@@ -1,238 +0,0 @@
-import {Plugin, PluginKey} from "prosemirror-state"
-
-const key = new PluginKey("footnoteMarkers")
-
-export const findFootnoteMarkers = (fromPos, toPos, doc) => {
-    const footnoteMarkers = []
-    doc.nodesBetween(fromPos, toPos, (node, pos) => {
-        if (!node.isInline) {
-            return
-        }
-        if (node.type.name === "footnote") {
-            const from = pos
-            const to = pos + node.nodeSize
-            const footnoteMarker = {from, to}
-            footnoteMarkers.push(footnoteMarker)
-        }
-    })
-    return footnoteMarkers
-}
-
-const getAddedRanges = tr => {
-    /* find ranges of the current document that have been added by means of
-     * a transaction.
-     */
-    let ranges = []
-    tr.steps.forEach((step, index) => {
-        if (step.jsonID === "replace" || step.jsonID === "replaceWrap") {
-            ranges.push({from: step.from, to: step.to})
-        }
-        const map = tr.mapping.maps[index]
-        ranges = ranges.map(range => ({
-            from: map.map(range.from, -1),
-            to: map.map(range.to, 1)
-        }))
-    })
-
-    const nonOverlappingRanges = []
-
-    ranges.forEach(range => {
-        let addedRange = false
-        nonOverlappingRanges.forEach(noRange => {
-            if (
-                !addedRange &&
-                range.from <= noRange.from &&
-                range.to >= noRange.from
-            ) {
-                noRange.from = range.from
-                noRange.to = noRange.to > range.to ? noRange.to : range.to
-                addedRange = true
-            } else if (
-                !addedRange &&
-                range.from <= noRange.to &&
-                range.to >= noRange.to
-            ) {
-                noRange.from =
-                    noRange.from < range.from ? noRange.from : range.from
-                noRange.to = range.to
-                addedRange = true
-            }
-        })
-        if (!addedRange) {
-            nonOverlappingRanges.push(range)
-        }
-    })
-
-    return nonOverlappingRanges
-}
-
-export const getFootnoteMarkerContents = state => {
-    const fnState = key.getState(state)
-    if (!fnState || !fnState.fnMarkers) {
-        return []
-    }
-    const fnMarkers = fnState.fnMarkers
-    return fnMarkers.map(
-        fnMarker => state.doc.nodeAt(fnMarker.from).attrs.footnote
-    )
-}
-
-export const updateFootnoteMarker = (state, tr, index, content) => {
-    const {fnMarkers} = key.getState(state)
-
-    const footnote = fnMarkers[index]
-    const node = state.doc.nodeAt(footnote.from)
-    if (node.attrs.footnote === content) {
-        return
-    }
-    tr.setNodeMarkup(footnote.from, node.type, {
-        footnote: content
-    })
-    tr.setMeta("fromFootnote", true)
-    return
-}
-
-export const getFootnoteMarkers = state => {
-    const {fnMarkers} = key.getState(state)
-    return fnMarkers
-}
-
-export const footnoteMarkersPlugin = options =>
-    new Plugin({
-        key,
-        state: {
-            init(_config, state) {
-                const fnMarkers = []
-                state.doc.descendants((node, pos) => {
-                    if (node.type.name === "footnote") {
-                        fnMarkers.push({
-                            from: pos,
-                            to: pos + node.nodeSize
-                        })
-                    }
-                })
-
-                return {
-                    fnMarkers
-                }
-            },
-            apply(tr, _prev, oldState, state) {
-                const meta = tr.getMeta(key)
-                if (meta) {
-                    // There has been an update of a footnote marker,
-                    // return values from meta instead of previous values
-                    // to prevent deletion of decoration
-                    return meta
-                }
-
-                let {fnMarkers} = this.getState(oldState)
-
-                if (!tr.docChanged) {
-                    return {
-                        fnMarkers
-                    }
-                }
-
-                const remote = tr.getMeta("remote"),
-                    fromFootnote = tr.getMeta("fromFootnote"),
-                    ranges = getAddedRanges(tr),
-                    deletedFootnotesIndexes = []
-                fnMarkers = fnMarkers
-                    .map(marker => ({
-                        from: tr.mapping.map(marker.from, 1),
-                        to: tr.mapping.map(marker.to, -1)
-                    }))
-                    .filter((marker, index) => {
-                        if (marker.from !== marker.to - 1) {
-                            // Add in reverse order as highest numbers need to be deleted
-                            // first so that index numbers of lower numbers continue
-                            // to be valid when these are deleted. Only relevant when
-                            // several footnotes are deleted simultaneously.
-                            deletedFootnotesIndexes.unshift(index)
-                            return false
-                        }
-                        return true
-                    })
-                if (fromFootnote) {
-                    return {fnMarkers}
-                }
-                const footTr =
-                    options.editor.mod.footnotes.fnEditor.view.state.tr
-
-                footTr.setMeta("fromMain", true)
-
-                deletedFootnotesIndexes.forEach(index =>
-                    options.editor.mod.footnotes.fnEditor.removeFootnote(
-                        index,
-                        footTr
-                    )
-                )
-                ranges.forEach(range => {
-                    let newFootnotes = findFootnoteMarkers(
-                        range.from,
-                        range.to,
-                        tr.doc
-                    )
-                    if (newFootnotes.length) {
-                        const firstFn = newFootnotes[0]
-                        let offset = fnMarkers.findIndex(
-                            marker => marker.from > firstFn.from
-                        )
-                        if (offset < 0) {
-                            offset = fnMarkers.length
-                        }
-                        if (remote) {
-                            newFootnotes = newFootnotes.filter(
-                                // In case of remote trasnactions, we cannot mark them as coming from footnote, so we
-                                // will need to remove duplicates instead.
-                                newMarker =>
-                                    fnMarkers.find(
-                                        oldMarker =>
-                                            oldMarker.from === newMarker.from
-                                    )
-                                        ? false
-                                        : true
-                            )
-                        } else {
-                            newFootnotes.forEach((footnote, index) => {
-                                const fnContent = state.doc.nodeAt(
-                                    footnote.from
-                                ).attrs.footnote
-                                options.editor.mod.footnotes.fnEditor.renderFootnote(
-                                    fnContent,
-                                    offset + index,
-                                    footTr
-                                )
-                            })
-                        }
-                        fnMarkers = fnMarkers
-                            .concat(newFootnotes)
-                            .sort((a, b) => (a.from > b.from ? 1 : -1))
-                    }
-                })
-
-                const footMeta = tr.getMeta("toFoot")
-
-                if (footMeta) {
-                    Object.entries(footMeta).forEach(([key, value]) => {
-                        footTr.setMeta(key, value)
-                    })
-                }
-
-                if (footTr.docChanged || footMeta) {
-                    tr.setMeta("footTr", footTr)
-                }
-
-                return {
-                    fnMarkers
-                }
-            }
-        },
-        view(_editorView) {
-            return {
-                update: (_view, _prevState) => {
-                    options.editor.mod.footnotes.layout.updateDOM()
-                }
-            }
-        }
-    })

package/src/state_plugins/jump_hidden_nodes.js

@@ -1,58 +0,0 @@
-import {GapCursor} from "prosemirror-gapcursor"
-import {Plugin, PluginKey, TextSelection} from "prosemirror-state"
-
-// A plugin that makes sure that the selecion is not put into a node that has been
-// hidden.
-
-const posHidden = $pos => {
-    let hidden = false
-    for (let i = $pos.depth; i > 0; i--) {
-        const node = $pos.node(i)
-        if (
-            node.attrs.hidden ||
-            (["table_caption", "figure_caption"].includes(node.type.name) &&
-                $pos.node(i - 1).attrs.caption === false)
-        ) {
-            hidden = true
-        }
-    }
-    return hidden
-}
-
-const key = new PluginKey("jump-hidden-nodes")
-export const jumpHiddenNodesPlugin = _options =>
-    new Plugin({
-        key,
-        appendTransaction: (trs, oldState, state) => {
-            if (state.selection.from !== state.selection.to) {
-                // Only applies to collapsed selection
-                return
-            }
-            const selectionSet = trs.find(tr => tr.selectionSet)
-
-            if (selectionSet && posHidden(state.selection.$from)) {
-                const dir =
-                    state.selection.from > oldState.selection.from ? 1 : -1
-                let newPos = state.selection.from,
-                    hidden = true,
-                    validTextSelection = false,
-                    validGapCursor = false,
-                    $pos
-                while (hidden || (!validGapCursor && !validTextSelection)) {
-                    newPos += dir
-                    if (newPos === 0 || newPos === state.doc.nodeSize) {
-                        // Could not find any valid position
-                        return
-                    }
-                    $pos = state.doc.resolve(newPos)
-                    validTextSelection = $pos.parent.inlineContent
-                    validGapCursor = GapCursor.valid($pos)
-                    hidden = posHidden($pos)
-                }
-                const selection = validTextSelection
-                    ? new TextSelection($pos)
-                    : new GapCursor($pos)
-                return state.tr.setSelection(selection)
-            }
-        }
-    })