@kerebron/extension-odt 0.2.1 → 0.3.1

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

@@ -1,15 +1,10 @@
 import { Mark, } from 'prosemirror-model';
+import { getBasicNodesHandlers, getInlineNodesHandlers, } from './node_handlers/basic_node_handlers.js';
+import { getListNodesHandlers } from './node_handlers/list_node_handlers.js';
+import { getTableNodesHandlers } from './node_handlers/table_node_handlers.js';
+import { ListTracker } from './lists.js';
 const COURIER_FONTS = ['Courier New', 'Courier', 'Roboto Mono'];
-function attrs(spec, token, style) {
-    if (spec.getAttrs)
-        return spec.getAttrs(token, style);
-    // For backwards compatibility when `attrs` is a Function
-    else if (spec.attrs instanceof Function)
-        return spec.attrs(token);
-    else
-        return spec.attrs;
-}
-function resolveStyle(stylesTree, automaticStyles, name) {
+export function resolveStyle(stylesTree, automaticStyles, name) {
     let style;
     if (!style) {
         style = stylesTree.styles['list-style'].find((item) => item['@name'] === name);
@@ -21,7 +16,9 @@ function resolveStyle(stylesTree, automaticStyles, name) {
         style = automaticStyles.style.find((item) => item['@name'] === name);
     }
     if (!style) {
-        style = {};
+        style = {
+            '@name': name,
+        };
     }
     style['styles'] = [name];
     if (style['@parent-style-name']) {
@@ -42,20 +39,47 @@ function resolveStyle(stylesTree, automaticStyles, name) {
     }
     return style;
 }
-class OdtParseState {
-    constructor(schema, tokens, stylesTree, automaticStyles) {
+export function tagEnum(item) {
+    if ('string' === typeof item) {
+        return {
+            tag: item, // '$text',
+            value: item,
+        };
+    }
+    if ('object' === typeof item) {
+        const entries = Object.entries(item);
+        if (entries.length === 1) {
+            return {
+                tag: entries[0][0],
+                value: entries[0][1],
+            };
+        }
+    }
+    throw new Error('Incorrect enum: ' + JSON.stringify(item));
+}
+export function iterateChildren(nodes, callback) {
+    for (const child of nodes) {
+        if ('Unknown' === child) {
+            continue;
+        }
+        const item = tagEnum(child);
+        callback(item);
+    }
+}
+export function iterateEnum($value) {
+    if (!$value) {
+        return [];
+    }
+    return $value.map(tagEnum);
+}
+export class OdtStashContext {
+    constructor(schema, handlers, 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,
@@ -68,236 +92,121 @@ class OdtParseState {
             writable: true,
             value: automaticStyles
         });
-        Object.defineProperty(this, "stack", {
+        Object.defineProperty(this, "ctxStash", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
-        Object.defineProperty(this, "textMarks", {
+        Object.defineProperty(this, "currentCtx", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Set()
+            value: void 0
         });
-        Object.defineProperty(this, "nextTextMarks", {
+        Object.defineProperty(this, "listTracker", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Set()
+            value: new ListTracker()
         });
-        this.stack = [];
-        this.openNode(schema.topNodeType, null);
-    }
-    top() {
-        return this.stack[this.stack.length - 1];
+        this.currentCtx = {
+            handlers,
+            content: [],
+            marks: [],
+            meta: {},
+        };
+        this.stash();
     }
-    push(elt) {
-        if (this.stack.length)
-            this.top().content.push(elt);
+    stash() {
+        this.ctxStash.push(this.currentCtx);
+        const funcs = {};
+        const handlers = { ...this.currentCtx.handlers };
+        const content = this.currentCtx.content;
+        const marks = this.currentCtx.marks;
+        this.currentCtx = {
+            ...structuredClone({
+                ...this.currentCtx,
+                content: undefined,
+                marks: undefined,
+                handlers: undefined,
+            }),
+            ...funcs,
+            content,
+            marks,
+            handlers,
+        };
+        return this.ctxStash.length - 1;
     }
-    // Adds the given text to the current position in the document,
-    // using the current marks as styling.
-    addText(text) {
-        if (!text)
-            return;
-        let top = this.top(), nodes = top.content, last = nodes[nodes.length - 1];
-        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);
+    unstash() {
+        const ctx = this.ctxStash.pop();
+        if (!ctx) {
+            throw new Error('Unstash failed');
         }
-        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;
+        this.currentCtx = ctx;
     }
-    // Removes the given mark from the set of active marks.
-    closeMark(mark) {
-        let top = this.top();
-        top.marks = mark.removeFromSet(top.marks);
+    openNode() {
+        this.stash();
+        this.current.content = [];
     }
-    // Add a node at the current position.
-    addNode(type, attrs, content, marks = Mark.none) {
-        let top = this.top();
-        if (top?.marks) {
-            marks = [...top.marks, ...marks];
+    closeNode(type, attrs = {}, marks = Mark.none) {
+        const node = this.createNode(type, attrs, marks);
+        this.unstash();
+        if (node) {
+            this.current.content.push(node);
         }
-        let node = type.createAndFill(attrs, content, marks);
-        if (!node)
-            return null;
-        this.push(node);
         return node;
     }
-    // Wrap subsequent content in a node of the given type.
-    openNode(type, attrs) {
-        this.stack.push({
-            type: type,
-            attrs: attrs,
-            content: [],
-            marks: Mark.none,
-        });
-    }
-    // Close and return the node that is currently on top of the stack.
-    closeNode(marks = Mark.none) {
-        let info = this.stack.pop();
-        return this.addNode(info.type, info.attrs, info.content, marks);
-    }
-    handleElement(nodeType, element) {
-        const spec = this.tokens[nodeType];
-        if (!spec) {
-            console.warn('No spec for:', nodeType, element, this.stack.map((item) => item.type.name));
-            return;
+    createNode(type, attrs = {}, marks = Mark.none) {
+        const nodeType = this.schema.nodes[type];
+        if (!nodeType) {
+            throw new Error('Invalid node type: ' + type);
         }
-        if (spec.custom) {
-            spec.custom(this, element);
-            return;
+        const node = nodeType.createAndFill(attrs, this.current.content, marks);
+        if (!node) {
+            throw new Error('Error creating node: ' + type);
         }
-        const children = spec.children ? spec.children(element) : [];
-        const style = ('object' === typeof element && element['@style-name'])
-            ? resolveStyle(this.stylesTree, this.automaticStyles, element['@style-name'])
-            : {};
-        const markToClose = [];
-        const textProperties = style && style['text-properties'] || {};
+        return node;
+    }
+    createText(text) {
+        if (!text)
+            return;
+        return this.schema.text(text, this.current.marks);
+    }
+    styleToMarks(style) {
         const marks = [];
+        const textProperties = style && style['text-properties'] || {};
         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)[0];
-            }
-            let nodeType = this.schema.nodeType(block);
-            this.openNode(nodeType, attrs(spec, element, style));
-            if (children) {
-                iterateChildren(children, (nodeType, node) => {
-                    this.handleElement(nodeType, node);
-                });
-            }
-            // this.addText(withoutTrailingNewline(tok.content));
-            this.closeNode(marks);
-        }
-        else if (spec.node) {
-        }
-        else if (spec.mark) {
-            const markType = this.schema.marks[spec.mark];
-            this.openMark(markType.create(attrs(spec, element, style)));
-            if (children) {
-                iterateChildren(children, (nodeType, node) => {
-                    this.handleElement(nodeType, node);
-                });
-            }
-            this.closeMark(markType);
-        }
-        else if (spec.text) {
-            this.addText(spec.text(element));
-        }
-        else {
-            if (children) {
-                iterateChildren(children, (nodeType, node) => {
-                    this.handleElement(nodeType, node);
-                });
-            }
-        }
-        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) {
-    for (const child of nodes) {
-        if ('Unknown' === child) {
-            continue;
-        }
-        let key = '';
-        let value = null;
-        if (typeof child === 'string') {
-            key = '$text';
-            value = child;
-        }
-        else {
-            const keys = Object.keys(child).filter((key) => key !== 'annotation');
-            key = keys[0];
-            value = child[key];
+            const markType = this.schema.mark('em');
+            marks.push(markType);
         }
-        if (!key) {
-            return;
+        if (textProperties['@font-weight'] === 'bold') {
+            const markType = this.schema.mark('strong');
+            marks.push(markType);
         }
-        callback(key, value);
+        return marks;
     }
-}
-function iterateEnum($value) {
-    if (!$value) {
-        return [];
-    }
-    return $value.map((item) => {
-        if ('string' === typeof item) {
-            return {
-                [item]: true,
-            };
+    handle(nodeType, value) {
+        if (!this.current.handlers[nodeType]) {
+            throw new Error('No handler for node: ' + nodeType);
         }
-        return item;
-    });
-}
-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;
+        if ('function' !== typeof this.current.handlers[nodeType]) {
+            throw new Error('Invalid handler for node: ' + nodeType);
         }
+        this.current.handlers[nodeType](this, value);
     }
-    clearAbove(level) {
-        for (let i = level + 1; i < 20; i++) {
-            this.levels[i] = 1;
-        }
+    getElementStyle(element) {
+        const style = ('object' === typeof element && element['@style-name'])
+            ? resolveStyle(this.stylesTree, this.automaticStyles, element['@style-name'])
+            : {};
+        return style;
     }
-    setLevelNode(level, node) {
-        this.levelNodes[level] = node;
+    get current() {
+        return this.currentCtx;
     }
 }
 export class OdtParser {
@@ -314,278 +223,67 @@ export class OdtParser {
             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 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'] || [],
-            },
+        const handlers = {
+            ...getInlineNodesHandlers(),
+            ...getBasicNodesHandlers(),
+            ...getListNodesHandlers(),
+            ...getTableNodesHandlers(),
             'change-start': {
-                custom(state) {
-                    state.textMarks.add({
-                        markName: 'change',
-                        markAttributes: {},
-                    });
-                },
+            // 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'],
-                        },
-                    });
-                },
+            // custom(state) {
+            //   state.textMarks.forEach((x) =>
+            //     x.markName === 'change' ? state.textMarks.delete(x) : x
+            //   );
+            // },
             },
-            'bookmark-start': {
-                custom(state, element) {
-                    state.textMarks.add({
-                        markName: 'bookmark',
-                        markAttributes: {
-                            id: element['@name'],
-                        },
+            'frame': (ctx, odtElement) => {
+                // 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 || '';
+                    ctx.openNode();
+                    ctx.closeNode('image', {
+                        src: odtElement.image['@href'],
+                        alt,
                     });
-                },
+                }
+                // },
             },
-            'bookmark-end': {
-                custom(state, element) {
-                    state.textMarks.forEach((x) => x.markName === 'bookmark' &&
-                        x.markAttributes.id === element['@name']
-                        ? state.textMarks.delete(x)
-                        : x);
-                },
+            'rect': () => {
+                // ignore: true,
             },
-            'annotation': {
-                ignore: true,
+            'annotation': () => {
+                // ignore: true,
             },
         };
-        const state = new OdtParseState(this.schema, tokens, stylesTree, contentTree['automatic-styles']);
-        state.handleElement('body', contentTree.body);
-        let doc;
-        do {
-            doc = state.closeNode();
-        } while (state.stack.length);
-        if (!doc) {
-            throw new Error('Incorrect stack handling');
-        }
-        return doc || null; //this.schema.topNodeType.createAndFill()!;
+        const ctx = new OdtStashContext(this.schema, handlers, stylesTree, contentTree['automatic-styles']);
+        ctx.openNode();
+        ctx.handle('body', contentTree.body);
+        return ctx.closeNode('doc');
     }
 }