@kerebron/extension-odt 0.0.13 → 0.1.0

package/esm/extension-odt/src/OdtParser.js

@@ -1,4 +1,5 @@
 import { Mark, } from 'prosemirror-model';
+const COURIER_FONTS = ['Courier New', 'Courier', 'Roboto Mono'];
 function attrs(spec, token, style) {
     if (spec.getAttrs)
         return spec.getAttrs(token, style);
@@ -24,11 +25,16 @@ function resolveStyle(stylesTree, automaticStyles, name) {
     }
     style['styles'] = [name];
     if (style['@parent-style-name']) {
-        const parenStyle = resolveStyle(stylesTree, automaticStyles, style['@parent-style-name']);
-        if (parenStyle) {
-            const styles = [...style['styles'], ...parenStyle['styles']];
+        const parentStyle = resolveStyle(stylesTree, automaticStyles, style['@parent-style-name']);
+        if (parentStyle) {
+            const styles = [...style['styles'], ...parentStyle['styles']];
+            for (const key in style) {
+                if (typeof style[key] === 'undefined') {
+                    delete style[key];
+                }
+            }
             style = {
-                ...parenStyle,
+                ...parentStyle,
                 ...style,
                 styles,
             };
@@ -37,13 +43,19 @@ function resolveStyle(stylesTree, automaticStyles, name) {
     return style;
 }
 class OdtParseState {
-    constructor(schema, stylesTree, automaticStyles) {
+    constructor(schema, tokens, stylesTree, automaticStyles) {
         Object.defineProperty(this, "schema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: schema
         });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokens
+        });
         Object.defineProperty(this, "stylesTree", {
             enumerable: true,
             configurable: true,
@@ -62,6 +74,18 @@ class OdtParseState {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "textMarks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "nextTextMarks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         this.stack = [];
         this.openNode(schema.topNodeType, null);
     }
@@ -78,17 +102,26 @@ class OdtParseState {
         if (!text)
             return;
         let top = this.top(), nodes = top.content, last = nodes[nodes.length - 1];
-        let node = this.schema.text(text, top.marks), merged;
-        // if (last && (merged = maybeMerge(last, node))) {
-        //   nodes[nodes.length - 1] = merged;
-        // } else
-        // console.log('addtext', top.type.name, "'" + text + "'");
+        let marks = top.marks;
+        for (const textMark of this.textMarks) {
+            const markType = this.schema.marks[textMark.markName];
+            const mark = markType.create(textMark.markAttributes || {});
+            marks = mark.addToSet(marks);
+        }
+        for (const textMark of this.nextTextMarks) {
+            const markType = this.schema.marks[textMark.markName];
+            const mark = markType.create(textMark.markAttributes || {});
+            marks = mark.addToSet(marks);
+        }
+        this.nextTextMarks.clear();
+        let node = this.schema.text(text, marks), merged;
         nodes.push(node);
     }
     // Adds the given mark to the set of active marks.
     openMark(mark) {
         let top = this.top();
         top.marks = mark.addToSet(top.marks);
+        return mark.type;
     }
     // Removes the given mark from the set of active marks.
     closeMark(mark) {
@@ -96,9 +129,12 @@ class OdtParseState {
         top.marks = mark.removeFromSet(top.marks);
     }
     // Add a node at the current position.
-    addNode(type, attrs, content) {
+    addNode(type, attrs, content, marks = Mark.none) {
         let top = this.top();
-        let node = type.createAndFill(attrs, content, top ? top.marks : []);
+        if (top?.marks) {
+            marks = [...top.marks, ...marks];
+        }
+        let node = type.createAndFill(attrs, content, marks);
         if (!node)
             return null;
         this.push(node);
@@ -106,37 +142,58 @@ class OdtParseState {
     }
     // Wrap subsequent content in a node of the given type.
     openNode(type, attrs) {
-        // console.log('openNode', type.name, attrs);
         this.stack.push({
             type: type,
             attrs: attrs,
             content: [],
-            marks: Mark.none,
+            marks: Mark.none
         });
     }
     // Close and return the node that is currently on top of the stack.
-    closeNode() {
+    closeNode(marks = Mark.none) {
         let info = this.stack.pop();
-        // console.log('closeNode', info.type.name, info.attrs);
-        return this.addNode(info.type, info.attrs, info.content);
+        return this.addNode(info.type, info.attrs, info.content, marks);
     }
     handleElement(nodeType, element) {
-        const spec = tokens[nodeType];
+        const spec = this.tokens[nodeType];
         if (!spec) {
             console.warn('No spec for:', nodeType, element, this.stack.map((item) => item.type.name));
             return;
         }
-        // console.log('handleElement', nodeType, this.stack.length);
+        if (spec.custom) {
+            spec.custom(this, element);
+            return;
+        }
         const children = spec.children ? spec.children(element) : [];
-        // console.log('ccc', nodeType, children);
-        let style;
-        if ('object' === typeof element && element['@style-name']) {
-            style = resolveStyle(this.stylesTree, this.automaticStyles, element['@style-name']);
+        const style = ('object' === typeof element && element['@style-name']) ? resolveStyle(this.stylesTree, this.automaticStyles, element['@style-name']) : {};
+        const markToClose = [];
+        const textProperties = style && style['text-properties'] || {};
+        const marks = [];
+        if (COURIER_FONTS.indexOf(textProperties['@font-name'] || '') > -1) {
+            this.textMarks.add({
+                markName: 'code',
+                markAttributes: {}
+            });
+            const markType = this.schema.mark('code');
+            marks.push(markType);
+        }
+        // if (style.textProperties?.fontStyle === 'italic' && style.textProperties?.fontWeight === 'bold') {
+        //   const block = this.chunks.createNode('BI');
+        //   this.chunks.append(currentTagNode, block);
+        //   currentTagNode = block;
+        // } else
+        if (textProperties['@font-style'] === 'italic') {
+            const markType = this.schema.marks['em'];
+            markToClose.push(this.openMark(markType.create(attrs(spec, element, style))));
+        }
+        else if (textProperties['@font-weight'] === 'bold') {
+            const markType = this.schema.marks['strong'];
+            markToClose.push(this.openMark(markType.create(attrs(spec, element, style))));
         }
         if (spec.block) {
             let block = spec.block;
             if ('string' !== typeof block) {
-                block = block(element, style);
+                block = block(element, style)[0];
             }
             let nodeType = this.schema.nodeType(block);
             this.openNode(nodeType, attrs(spec, element, style));
@@ -146,12 +203,12 @@ class OdtParseState {
                 });
             }
             // this.addText(withoutTrailingNewline(tok.content));
-            this.closeNode();
+            this.closeNode(marks);
         }
         else if (spec.node) {
         }
         else if (spec.mark) {
-            let markType = this.schema.marks[spec.mark];
+            const markType = this.schema.marks[spec.mark];
             this.openMark(markType.create(attrs(spec, element, style)));
             if (children) {
                 iterateChildren(children, (nodeType, node) => {
@@ -170,6 +227,13 @@ class OdtParseState {
                 });
             }
         }
+        while (markToClose.length > 0) {
+            const markType = markToClose.pop();
+            this.closeMark(markType);
+        }
+        if (COURIER_FONTS.indexOf(textProperties['@font-name'] || '') > -1) {
+            this.textMarks.forEach(x => x.markName === 'code' ? this.textMarks.delete(x) : x);
+        }
     }
 }
 function iterateChildren(nodes, callback) {
@@ -207,105 +271,303 @@ function iterateEnum($value) {
         return item;
     });
 }
-const tokens = {
-    'body': {
-        children: (odtElement) => iterateEnum(odtElement.text?.$value),
-    },
-    'p': {
-        block: (odtElement, style) => {
-            if (style.styles.find((item) => item.startsWith('Heading_20_'))) {
-                return 'heading';
-            }
-            return 'paragraph';
-        },
-        getAttrs: (odtElement, style) => {
-            const heading = style.styles.find((item) => item.startsWith('Heading_20_'));
-            if (heading) {
-                return {
-                    level: parseInt(heading.substring('Heading_20_'.length)),
-                };
-            }
-        },
-        children: (odtElement) => iterateEnum(odtElement.$value),
-    },
-    'span': {
-        children: (odtElement) => iterateEnum(odtElement.$value),
-    },
-    'list': {
-        block: 'ordered_list',
-        children: (odtElement) => odtElement['list-item'].map((item) => ({ 'list-item': item })),
-    },
-    'list-item': {
-        block: 'list_item',
-        children: (odtElement) => iterateEnum(odtElement.$value),
-    },
-    'table': {
-        block: 'table',
-        children: (odtElement) => odtElement['table-row'].map((item) => ({ 'table-row': item })),
-    },
-    'table-row': {
-        block: 'table_row',
-        children: (odtElement) => odtElement['table-cell'].map((item) => ({ 'table-cell': item })),
-    },
-    'table-cell': {
-        block: 'table_cell',
-        children: (odtElement) => iterateEnum(odtElement.$value),
-    },
-    'a': {
-        mark: 'link',
-        getAttrs: (tok) => ({
-            href: tok['@href'],
-            // title: tok.attrGet('title') || null,
-        }),
-        children: (odtElement) => odtElement['span'].map(item => ({ 'span': item }))
-    },
-    '$value': {
-        children: (odtElement) => iterateEnum(odtElement),
-    },
-    '$text': {
-        // TODO: fix trimming: https://github.com/tafia/quick-xml/issues/285
-        text: (odtElement) => String(odtElement || ''),
-    },
-    's': {
-        text: (odtElement) => {
-            const chars = odtElement['@c'] || 1;
-            return '               '.substring(0, chars);
-        },
-    },
-    'tab': {
-        text: (odtElement) => '\t',
-    },
-    'table-of-content': {
-        block: 'paragraph',
-        children: (odtElement) => odtElement['index-body']['p'] || [],
-    },
-    'frame': {
-        ignore: true,
-    },
-    'rect': {
-        ignore: true,
-    },
-    'bookmark': {
-        ignore: true,
-    },
-    'annotation': {
-        ignore: true,
-    },
-};
+class ListNumbering {
+    constructor() {
+        Object.defineProperty(this, "levels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "levelNodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        for (let i = 0; i < 20; i++) {
+            this.levels[i] = 1;
+        }
+    }
+    clearAbove(level) {
+        for (let i = level + 1; i < 20; i++) {
+            this.levels[i] = 1;
+        }
+    }
+    setLevelNode(level, node) {
+        this.levelNodes[level] = node;
+    }
+}
 export class OdtParser {
-    constructor(schema) {
+    constructor(schema, config = {}) {
         Object.defineProperty(this, "schema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: schema
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "listStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "listNumberings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "lastNumbering", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "preserveMinLevel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 999
+        });
         // this.tokenHandlers = tokenHandlers(schema, tokens);
     }
     parse(files) {
         const contentTree = files.contentTree;
         const stylesTree = files.stylesTree;
-        const state = new OdtParseState(this.schema, stylesTree, contentTree['automatic-styles']);
+        const automaticStyles = contentTree['automatic-styles'];
+        const tokens = {
+            'body': {
+                children: (odtElement) => iterateEnum(odtElement.text?.$value),
+            },
+            'p': {
+                block: (odtElement, style) => {
+                    if (style.styles.find((item) => item.startsWith('Heading_20_'))) {
+                        return ['heading'];
+                    }
+                    return ['paragraph'];
+                },
+                getAttrs: (odtElement, style) => {
+                    const heading = style.styles.find((item) => item.startsWith('Heading_20_'));
+                    if (heading) {
+                        return {
+                            level: parseInt(heading.substring('Heading_20_'.length)),
+                        };
+                    }
+                },
+                children: (odtElement) => iterateEnum(odtElement.$value),
+            },
+            'span': {
+                children: (odtElement) => iterateEnum(odtElement.$value),
+            },
+            'list': {
+                custom: (state, odtElement) => {
+                    const list = {
+                        level: this.listStack.length + 1,
+                        odtElement
+                    };
+                    this.listStack.push(list);
+                    let style = {};
+                    let listId = null;
+                    for (let i = this.listStack.length - 1; i >= 0; i--) {
+                        const element = this.listStack[i].odtElement;
+                        if (!listId) {
+                            if (element['@id']) {
+                                listId = element['@id'];
+                            }
+                        }
+                        if (!style['@style-name']) {
+                            style = ('object' === typeof element && element['@style-name']) ? resolveStyle(stylesTree, automaticStyles, element['@style-name']) : {};
+                        }
+                    }
+                    let nodeTypeName = 'bullet_list';
+                    const attrs = {};
+                    if (style) {
+                        const numLevelStyle = style['list-level-style-number'].find(levelStyle => parseInt(levelStyle['@level']) === list.level);
+                        if (numLevelStyle) {
+                            attrs['type'] = numLevelStyle['@num-format'] || '1';
+                            nodeTypeName = 'ordered_list';
+                        }
+                    }
+                    let listNumbering = null;
+                    if (listId && this.listNumberings.has(listId)) {
+                        listNumbering = this.listNumberings.get(listId);
+                    }
+                    let isContinue = false;
+                    if (odtElement['@continue-list'] && this.listNumberings.has(odtElement['@continue-list'])) {
+                        listNumbering = this.listNumberings.get(odtElement['@continue-list']);
+                        isContinue = true;
+                    }
+                    if (odtElement['@continue-numbering']) {
+                        listNumbering = this.lastNumbering;
+                        isContinue = true;
+                    }
+                    if (!listNumbering) {
+                        listNumbering = new ListNumbering();
+                    }
+                    if (isContinue) {
+                        this.preserveMinLevel = 999;
+                    }
+                    if (listId) {
+                        this.listNumberings.set(listId, listNumbering);
+                    }
+                    this.lastNumbering = listNumbering;
+                    if (this.preserveMinLevel <= list.level) {
+                        listNumbering.clearAbove(list.level - 1);
+                    }
+                    if (nodeTypeName === 'ordered_list') {
+                        attrs['start'] = listNumbering.levels[list.level] || 1;
+                    }
+                    let nodeType = this.schema.nodeType(nodeTypeName);
+                    state.openNode(nodeType, attrs);
+                    const children = odtElement['list-item'].map((item) => ({ 'list-item': item }));
+                    if (children) {
+                        iterateChildren(children, (nodeType, node) => {
+                            state.handleElement(nodeType, node);
+                        });
+                        listNumbering.levels[list.level] += children.length;
+                    }
+                    state.closeNode();
+                    if (this.preserveMinLevel >= list.level) {
+                        this.preserveMinLevel = list.level;
+                    }
+                    this.listStack.pop();
+                }
+            },
+            'list-item': {
+                block: 'list_item',
+                children: (odtElement) => iterateEnum(odtElement.$value),
+            },
+            'table': {
+                block: 'table',
+                children: (odtElement) => odtElement['table-row'].map((item) => ({ 'table-row': item })),
+            },
+            'table-row': {
+                block: 'table_row',
+                children: (odtElement) => odtElement['table-cell'].map((item) => ({ 'table-cell': item })),
+            },
+            'table-cell': {
+                block: 'table_cell',
+                children: (odtElement) => iterateEnum(odtElement.$value),
+            },
+            'a': {
+                mark: 'link',
+                getAttrs: (tok) => {
+                    let href = tok['@href'];
+                    if (this.config.linkFromRewriter) {
+                        href = this.config.linkFromRewriter(href);
+                    }
+                    return {
+                        href,
+                        // title: tok.attrGet('title') || null,
+                    };
+                },
+                children: (odtElement) => iterateEnum(odtElement.$value),
+            },
+            '$value': {
+                children: (odtElement) => iterateEnum(odtElement),
+            },
+            '$text': {
+                // TODO: fix trimming: https://github.com/tafia/quick-xml/issues/285
+                text: (odtElement) => String(odtElement || ''),
+            },
+            's': {
+                text: (odtElement) => {
+                    const chars = odtElement['@c'] || 1;
+                    return '               '.substring(0, chars);
+                },
+            },
+            'tab': {
+                text: (odtElement) => '\t',
+            },
+            'line-break': {
+                block: 'br'
+            },
+            'soft-page-break': {
+                block: 'br'
+            },
+            'table-of-content': {
+                block: 'paragraph',
+                children: (odtElement) => odtElement['index-body']['p'] || [],
+            },
+            'change-start': {
+                custom(state) {
+                    state.textMarks.add({
+                        markName: 'change',
+                        markAttributes: {}
+                    });
+                }
+            },
+            'change-end': {
+                custom(state) {
+                    state.textMarks.forEach(x => x.markName === 'change' ? state.textMarks.delete(x) : x);
+                }
+            },
+            'frame': {
+                custom: (state, odtElement) => {
+                    if (odtElement.object && odtElement.object['@href']) { // TODO MathML
+                        // const fileName= drawFrame.object.href.replace(/\s/g, '_').replace(/^\.\//, '') + '.xml';
+                        // try {
+                        //   const mathMl = this.xmlMap[fileName];
+                        //   if (mathMl && mathMl.indexOf('<math ') > -1) {
+                        //     const node = this.chunks.createNode('MATHML');
+                        //     const latex = MathMLToLaTeX.convert(mathMl);
+                        //     this.chunks.appendText(node, latex);
+                        //     this.chunks.append(currentTagNode, node);
+                        //   }
+                        // } catch (err) {
+                        //   console.warn(err);
+                        // }
+                    }
+                    if (odtElement.image && odtElement.image['@href']) { // TODO links rewrite
+                        const nodeType = this.schema.nodeType('image');
+                        const alt = odtElement.description?.value || '';
+                        state.addNode(nodeType, {
+                            src: odtElement.image['@href'],
+                            alt
+                        }, []);
+                    }
+                }
+            },
+            'rect': {
+                ignore: true,
+            },
+            'bookmark': {
+                custom(state, element) {
+                    state.nextTextMarks.add({
+                        markName: 'bookmark',
+                        markAttributes: {
+                            id: element['@name']
+                        }
+                    });
+                }
+            },
+            'bookmark-start': {
+                custom(state, element) {
+                    state.textMarks.add({
+                        markName: 'bookmark',
+                        markAttributes: {
+                            id: element['@name']
+                        }
+                    });
+                }
+            },
+            'bookmark-end': {
+                custom(state, element) {
+                    state.textMarks.forEach(x => x.markName === 'bookmark' && x.markAttributes.id === element['@name'] ? state.textMarks.delete(x) : x);
+                }
+            },
+            'annotation': {
+                ignore: true,
+            },
+        };
+        const state = new OdtParseState(this.schema, tokens, stylesTree, contentTree['automatic-styles']);
         state.handleElement('body', contentTree.body);
         let doc;
         do {

package/esm/extension-odt/src/postprocess/convertCodeParagraphsToCodeBlocks.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'prosemirror-state';
+export declare const convertCodeParagraphsToCodeBlocks: Command;
+//# sourceMappingURL=convertCodeParagraphsToCodeBlocks.d.ts.map

package/esm/extension-odt/src/postprocess/convertCodeParagraphsToCodeBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertCodeParagraphsToCodeBlocks.d.ts","sourceRoot":"","sources":["../../../../src/extension-odt/src/postprocess/convertCodeParagraphsToCodeBlocks.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,OAAO,EAER,MAAM,mBAAmB,CAAC;AAqB3B,eAAO,MAAM,iCAAiC,EAAE,OA2E/C,CAAA"}

package/esm/extension-odt/src/postprocess/convertCodeParagraphsToCodeBlocks.js

@@ -0,0 +1,72 @@
+function onlyHasCodeMarkedText(paragraph, codeMarkType) {
+    if (paragraph.content.size === 0) {
+        return paragraph.marks.some(mark => mark.type.name === codeMarkType.name);
+    }
+    let allAreCodeMarked = true;
+    paragraph.content.forEach(child => {
+        if (!child.isText ||
+            !child.marks.some(mark => mark.type.name === codeMarkType.name)) {
+            allAreCodeMarked = false;
+        }
+    });
+    return allAreCodeMarked;
+}
+export const convertCodeParagraphsToCodeBlocks = (state, dispatch) => {
+    const doc = state.doc;
+    const schema = state.schema;
+    let tr = state.tr;
+    let paragraphsToMerge = null;
+    function flushCodeBlock() {
+        if (paragraphsToMerge === null) {
+            return;
+        }
+        const textNode = schema.text(paragraphsToMerge.innerText);
+        const codeBlock = schema.nodes.code_block.createAndFill(null, [textNode]);
+        const startPos = tr.mapping.map(paragraphsToMerge.startPos);
+        const endPos = tr.mapping.map(paragraphsToMerge.endPos);
+        tr.replaceRangeWith(startPos, endPos, codeBlock);
+        paragraphsToMerge = null;
+    }
+    function nodesToText(fragment) {
+        if (fragment.content.length === 0) {
+            return '';
+        }
+        let retVal = '';
+        fragment.content.forEach(node => {
+            if (node.isText) {
+                retVal += node.text;
+            }
+            else {
+                retVal = '@TODO: node.type ' + node.type;
+            }
+        });
+        return retVal;
+    }
+    doc.forEach((node, pos) => {
+        if (node.type.name === 'paragraph') {
+            const isCodeOnly = onlyHasCodeMarkedText(node, schema.marks.code);
+            const isEmpty = node.content.size === 0;
+            if (isCodeOnly) {
+                if (paragraphsToMerge === null) {
+                    paragraphsToMerge = { startPos: pos, endPos: pos + node.nodeSize, innerText: nodesToText(node.content) };
+                }
+                else {
+                    paragraphsToMerge = { startPos: paragraphsToMerge.startPos, endPos: pos + node.nodeSize,
+                        innerText: paragraphsToMerge.innerText + '\n' + nodesToText(node.content)
+                    };
+                }
+                return;
+            }
+        }
+        if (paragraphsToMerge !== null) {
+            flushCodeBlock();
+        }
+    });
+    if (paragraphsToMerge !== null) {
+        flushCodeBlock();
+    }
+    if (dispatch) {
+        dispatch(tr);
+    }
+    return tr.steps.length > 0;
+};