@fiduswriter/document 0.1.0-alpha.1

package/src/schema/common/heading.js

@@ -0,0 +1,43 @@
+import {addTracks, parseTracks} from "./track.js"
+
+export const randomHeadingId = () => {
+    return `H${Math.round(Math.random() * 10000000) + 1}`
+}
+
+const createHeading = level => ({
+    group: "block heading",
+    content: "inline*",
+    marks: "_",
+    defining: true,
+    attrs: {
+        id: {
+            default: false
+        },
+        track: {
+            default: []
+        }
+    },
+    parseDOM: [
+        {
+            tag: `h${level}`,
+            getAttrs(dom) {
+                return {
+                    id: dom.id,
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {id: node.attrs.id}
+        addTracks(node, attrs)
+        return [`h${level}`, attrs, 0]
+    }
+})
+
+export const heading1 = createHeading(1)
+export const heading2 = createHeading(2)
+export const heading3 = createHeading(3)
+export const heading4 = createHeading(4)
+export const heading5 = createHeading(5)
+export const heading6 = createHeading(6)

package/src/schema/common/index.js

@@ -0,0 +1,40 @@
+export {annotation_tag, comment, randomCommentId} from "./annotate.js"
+export {
+    paragraph,
+    blockquote,
+    horizontal_rule,
+    underline,
+    sup,
+    sub,
+    code
+} from "./base.js"
+export {citation} from "./citation.js"
+export {equation} from "./equation.js"
+export {
+    figure,
+    image,
+    figure_equation,
+    figure_caption,
+    randomFigureId
+} from "./figure.js"
+export {
+    heading1,
+    heading2,
+    heading3,
+    heading4,
+    heading5,
+    heading6,
+    randomHeadingId
+} from "./heading.js"
+export {ordered_list, bullet_list, list_item, randomListId} from "./list.js"
+export {cross_reference, anchor, link, randomAnchorId} from "./reference.js"
+export {
+    table,
+    table_caption,
+    table_body,
+    table_row,
+    table_cell,
+    table_header,
+    randomTableId
+} from "./table.js"
+export {deletion, insertion, format_change, parseTracks} from "./track.js"

package/src/schema/common/list.js

@@ -0,0 +1,95 @@
+import {addTracks, parseTracks} from "./track.js"
+
+// :: NodeSpec
+// An ordered list [node spec](#model.NodeSpec). Has a single
+// attribute, `order`, which determines the number at which the list
+// starts counting, and defaults to 1. Represented as an `<ol>`
+// element.
+export const ordered_list = {
+    group: "block",
+    content: "list_item+",
+    attrs: {
+        id: {default: false},
+        order: {default: 1},
+        track: {default: []}
+    },
+    parseDOM: [
+        {
+            tag: "ol",
+            getAttrs(dom) {
+                return {
+                    id: dom.id,
+                    order: dom.hasAttribute("start")
+                        ? +dom.getAttribute("start")
+                        : 1,
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {id: node.attrs.id}
+        if (node.attrs.order !== 1) {
+            attrs.start = node.attrs.order
+        }
+        addTracks(node, attrs)
+        return ["ol", attrs, 0]
+    }
+}
+
+export function randomListId() {
+    return "L" + Math.round(Math.random() * 10000000) + 1
+}
+
+// :: NodeSpec
+// A bullet list node spec, represented in the DOM as `<ul>`.
+export const bullet_list = {
+    group: "block",
+    content: "list_item+",
+    attrs: {
+        id: {default: false},
+        track: {default: []}
+    },
+    parseDOM: [
+        {
+            tag: "ul",
+            getAttrs(dom) {
+                return {
+                    id: dom.id,
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {id: node.attrs.id}
+        addTracks(node, attrs)
+        return ["ul", attrs, 0]
+    }
+}
+
+// :: NodeSpec
+// A list item (`<li>`) spec.
+export const list_item = {
+    content: "block+",
+    marks: "annotation",
+    attrs: {
+        track: {default: []}
+    },
+    parseDOM: [
+        {
+            tag: "li",
+            getAttrs(dom) {
+                return {
+                    track: parseTracks(dom.dataset.track)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {}
+        addTracks(node, attrs)
+        return ["li", attrs, 0]
+    },
+    defining: true
+}

package/src/schema/common/reference.js

@@ -0,0 +1,100 @@
+export const cross_reference = {
+    inline: true,
+    group: "inline",
+    attrs: {
+        id: {
+            default: false
+        },
+        title: {
+            default: null // title === null means that the target is gone
+        }
+    },
+    parseDOM: [
+        {
+            tag: "span.cross-reference[data-id][data-title]",
+            getAttrs(dom) {
+                return {
+                    id: dom.dataset.id,
+                    title: dom.dataset.title
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: `cross-reference${node.attrs.title ? "" : " missing-target"}`,
+                "data-id": node.attrs.id,
+                "data-title": node.attrs.title
+            },
+            node.attrs.title ? node.attrs.title : gettext("Missing Target")
+        ]
+    }
+}
+
+export const link = {
+    attrs: {
+        href: {},
+        title: {
+            default: ""
+        }
+    },
+    inclusive: false,
+    parseDOM: [
+        {
+            tag: "a[href]",
+            getAttrs(dom) {
+                return {
+                    href: dom.getAttribute("href"),
+                    title: dom.getAttribute("title")
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const {href, title} = node.attrs
+        const attrs =
+            title || href.charAt(0) !== "#"
+                ? {href, title}
+                : {
+                      href,
+                      title: gettext("Missing target"),
+                      class: "missing-target"
+                  }
+        return ["a", attrs, 0]
+    }
+}
+
+export const randomAnchorId = () => {
+    return `A${Math.round(Math.random() * 10000000) + 1}`
+}
+
+export const anchor = {
+    attrs: {
+        id: {
+            default: false
+        }
+    },
+    inclusive: false,
+    group: "annotation",
+    parseDOM: [
+        {
+            tag: "span.anchor[data-id]",
+            getAttrs(dom) {
+                return {
+                    id: dom.dataset.id
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: "anchor",
+                "data-id": node.attrs.id
+            }
+        ]
+    }
+}

package/src/schema/common/table.js

@@ -0,0 +1,103 @@
+import {tableNodes} from "prosemirror-tables"
+
+import {parseTracks} from "./track.js"
+
+export const table = {
+    inline: false,
+    group: "block",
+    tableRole: "table",
+    attrs: {
+        id: {default: false},
+        track: {default: []},
+        width: {default: "100"},
+        aligned: {default: "center"},
+        layout: {default: "fixed"},
+        category: {default: "none"},
+        caption: {default: false}
+    },
+    content: "table_caption table_body",
+    parseDOM: [
+        {
+            tag: "table",
+            getAttrs(dom) {
+                const track = parseTracks(dom.dataset.track),
+                    width = dom.dataset.width,
+                    aligned = width === "100" ? "center" : dom.dataset.aligned,
+                    layout = dom.dataset.layout,
+                    id = dom.id || dom.dataset.id
+                return {
+                    track,
+                    width,
+                    aligned,
+                    layout,
+                    id,
+                    category: dom.dataset.category,
+                    caption: !!dom.dataset.captionHidden
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {
+            id: node.attrs.id,
+            class: `table-${node.attrs.width} table-${node.attrs.aligned} table-${node.attrs.layout}`,
+            "data-width": node.attrs.width,
+            "data-aligned": node.attrs.aligned,
+            "data-layout": node.attrs.layout,
+            "data-category": node.attrs.category
+        }
+        if (node.attrs.track.length) {
+            attrs["data-track"] = JSON.stringify(node.attrs.track)
+        }
+        if (!node.attrs.caption) {
+            attrs["data-caption-hidden"] = true
+        }
+        return ["table", attrs, 0]
+    }
+}
+
+export const table_caption = {
+    content: "inline*",
+    parseDOM: [{tag: "caption span.text"}],
+    toDOM() {
+        return [
+            "caption",
+            ["span", {class: "label"}],
+            ["span", {class: "text"}, 0]
+        ]
+    }
+}
+
+const origTableNodes = tableNodes({
+    cellContent: "block+"
+})
+
+export const table_body = Object.assign({}, origTableNodes["table"], {
+    parseDOM: [{tag: "tbody"}],
+    toDOM() {
+        return ["tbody", 0]
+    }
+})
+
+export const table_row = {
+    content: "(table_cell | table_header)+",
+    tableRole: "row",
+    parseDOM: [{tag: "tr"}],
+    toDOM() {
+        return ["tr", 0]
+    }
+}
+
+export const table_header = Object.assign(
+    {marks: "annotation"},
+    origTableNodes["table_header"]
+)
+
+export const table_cell = Object.assign(
+    {marks: "annotation"},
+    origTableNodes["table_cell"]
+)
+
+export function randomTableId() {
+    return "T" + Math.round(Math.random() * 10000000) + 1
+}

package/src/schema/common/track.js

@@ -0,0 +1,190 @@
+export function parseTracks(str) {
+    if (!str) {
+        return []
+    }
+    let tracks
+    try {
+        tracks = JSON.parse(str)
+    } catch (_error) {
+        return []
+    }
+    if (!Array.isArray(tracks)) {
+        return []
+    }
+    return tracks.filter(
+        (
+            track // ensure required fields are present
+        ) =>
+            track.hasOwnProperty("user") &&
+            track.hasOwnProperty("username") &&
+            track.hasOwnProperty("date")
+    )
+}
+
+export function addTracks(node, attrs) {
+    if (node.attrs.track?.length) {
+        attrs["data-track"] = JSON.stringify(node.attrs.track)
+    }
+}
+
+export const deletion = {
+    attrs: {
+        user: {
+            default: 0
+        },
+        username: {
+            default: ""
+        },
+        date: {
+            default: 0
+        }
+    },
+    inclusive: false,
+    group: "track",
+    parseDOM: [
+        {
+            tag: "span.deletion",
+            getAttrs(dom) {
+                return {
+                    user: Number.parseInt(dom.dataset.user),
+                    username: dom.dataset.username,
+                    date: Number.parseInt(dom.dataset.date)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: `deletion user-${node.attrs.user}`,
+                "data-user": node.attrs.user,
+                "data-username": node.attrs.username,
+                "data-date": node.attrs.date
+            }
+        ]
+    }
+}
+
+function parseFormatList(str) {
+    if (!str) {
+        return []
+    }
+    let formatList
+    try {
+        formatList = JSON.parse(str)
+    } catch (_error) {
+        return []
+    }
+    if (!Array.isArray(formatList)) {
+        return []
+    }
+    return formatList.filter(format => typeof format === "string") // ensure there are only strings in list
+}
+
+export const format_change = {
+    attrs: {
+        user: {
+            default: 0
+        },
+        username: {
+            default: ""
+        },
+        date: {
+            default: 0
+        },
+        before: {
+            default: []
+        },
+        after: {
+            default: []
+        }
+    },
+    inclusive: false,
+    group: "track",
+    parseDOM: [
+        {
+            tag: "span.format-change",
+            getAttrs(dom) {
+                return {
+                    user: Number.parseInt(dom.dataset.user),
+                    username: dom.dataset.username,
+                    date: Number.parseInt(dom.dataset.date),
+                    before: parseFormatList(dom.dataset.before),
+                    after: parseFormatList(dom.dataset.after)
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: `format-change user-${node.attrs.user}`,
+                "data-user": node.attrs.user,
+                "data-username": node.attrs.username,
+                "data-date": node.attrs.date,
+                "data-before": JSON.stringify(node.attrs.before),
+                "data-after": JSON.stringify(node.attrs.after)
+            }
+        ]
+    }
+}
+
+export const insertion = {
+    attrs: {
+        user: {
+            default: 0
+        },
+        username: {
+            default: ""
+        },
+        date: {
+            default: 0
+        },
+        approved: {
+            default: true
+        }
+    },
+    inclusive: false,
+    group: "track",
+    parseDOM: [
+        {
+            tag: "span.insertion",
+            getAttrs(dom) {
+                return {
+                    user: Number.parseInt(dom.dataset.user),
+                    username: dom.dataset.username,
+                    date: Number.parseInt(dom.dataset.date),
+                    inline: true,
+                    approved: false
+                }
+            }
+        },
+        {
+            tag: "span.approved-insertion",
+            getAttrs(dom) {
+                return {
+                    user: Number.parseInt(dom.dataset.user),
+                    username: dom.dataset.username,
+                    date: Number.parseInt(dom.dataset.date),
+                    inline: true,
+                    approved: true
+                }
+            }
+        }
+    ],
+    toDOM(node) {
+        return [
+            "span",
+            {
+                class: node.attrs.approved
+                    ? "approved-insertion"
+                    : `insertion user-${node.attrs.user}`,
+                "data-user": node.attrs.user,
+                "data-username": node.attrs.username,
+                "data-date": node.attrs.date
+            }
+        ]
+    }
+}

package/src/schema/const.js

@@ -0,0 +1,58 @@
+export const LANGUAGES = [
+    ["af-ZA", gettext("Afrikaans"), "ltr"],
+    ["sq-AL", gettext("Albanian"), "ltr"],
+    ["ar", gettext("Arabic"), "rtl"],
+    ["ast", gettext("Asturian"), "ltr"],
+    ["be", gettext("Belarusian"), "ltr"],
+    ["br", gettext("Breton"), "ltr"],
+    ["bg", gettext("Bulgarian"), "ltr"],
+    ["ca", gettext("Catalan"), "ltr"],
+    ["ca-ES-Valencia", gettext("Catalan (Valencia)"), "ltr"],
+    ["zh-CN", gettext("Chinese (Simplified)"), "ltr"],
+    ["da", gettext("Danish"), "ltr"],
+    ["nl", gettext("Dutch"), "ltr"],
+    ["en-AU", gettext("English (Australia)"), "ltr"],
+    ["en-CA", gettext("English (Canada)"), "ltr"],
+    ["en-NZ", gettext("English (New Zealand)"), "ltr"],
+    ["en-ZA", gettext("English (South Africa)"), "ltr"],
+    ["en-GB", gettext("English (United Kingdom)"), "ltr"],
+    ["en-US", gettext("English (United States)"), "ltr"],
+    ["eo", gettext("Esperanto"), "ltr"],
+    ["fr", gettext("French"), "ltr"],
+    ["gl", gettext("Galician"), "ltr"],
+    ["de-DE", gettext("German (Germany)"), "ltr"],
+    ["de-AU", gettext("German (Austria)"), "ltr"],
+    ["de-CH", gettext("German (Switzerland)"), "ltr"],
+    ["el", gettext("Greek"), "ltr"],
+    ["he", gettext("Hebrew"), "rtl"],
+    ["is", gettext("Icelandic"), "ltr"],
+    ["it", gettext("Italian"), "ltr"],
+    ["ja", gettext("Japanese"), "ltr"],
+    ["km", gettext("Khmer"), "ltr"],
+    ["lt", gettext("Lithuanian"), "ltr"],
+    ["ml", gettext("Malayalam"), "ltr"],
+    ["nb-NO", gettext("Norwegian (bokmål)"), "ltr"],
+    ["nn-NO", gettext("Norwegian (nynorsk)"), "ltr"],
+    ["fa", gettext("Persian"), "rtl"],
+    ["pl", gettext("Polish"), "ltr"],
+    ["pt-BR", gettext("Portuguese (Brazil)"), "ltr"],
+    ["pt-PT", gettext("Portuguese (Portugal)"), "ltr"],
+    ["ro", gettext("Romanian"), "ltr"],
+    ["ru", gettext("Russian"), "ltr"],
+    ["tr", gettext("Turkish"), "ltr"],
+    ["sr-SP-Cy", gettext("Serbian (Cyrillic)"), "ltr"],
+    ["sr-SP-Lt", gettext("Serbian (Latin)"), "ltr"],
+    ["sk", gettext("Slovak"), "ltr"],
+    ["sl", gettext("Slovenian"), "ltr"],
+    ["es", gettext("Spanish"), "ltr"],
+    ["sv", gettext("Swedish"), "ltr"],
+    ["ta", gettext("Tamil"), "ltr"],
+    ["tl", gettext("Tagalog"), "ltr"],
+    ["uk", gettext("Ukrainian"), "ltr"]
+]
+
+export const PAPER_SIZES = [
+    /* [Fidus Writer value, CSS value]*/
+    ["A4", "A4"],
+    ["US Letter", "letter"]
+]