@kerebron/extension-odt 0.0.8

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

@@ -0,0 +1,315 @@
+import { Mark, } from 'prosemirror-model';
+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) {
+    let style;
+    if (!style) {
+        style = stylesTree.styles['list-style'].find((item) => item['@name'] === name);
+    }
+    if (!style) {
+        style = stylesTree.styles['style'].find((item) => item['@name'] === name);
+    }
+    if (!style) {
+        style = automaticStyles.style.find((item) => item['@name'] === name);
+    }
+    if (!style) {
+        style = {};
+    }
+    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']];
+            style = {
+                ...parenStyle,
+                ...style,
+                styles,
+            };
+        }
+    }
+    return style;
+}
+class OdtParseState {
+    constructor(schema, stylesTree, automaticStyles) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "stylesTree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: stylesTree
+        });
+        Object.defineProperty(this, "automaticStyles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: automaticStyles
+        });
+        Object.defineProperty(this, "stack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.stack = [{
+                type: schema.topNodeType,
+                attrs: null,
+                content: [],
+                marks: Mark.none,
+            }];
+    }
+    top() {
+        return this.stack[this.stack.length - 1];
+    }
+    push(elt) {
+        if (this.stack.length)
+            this.top().content.push(elt);
+    }
+    // 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 node = this.schema.text(text, top.marks), merged;
+        // if (last && (merged = maybeMerge(last, node))) {
+        //   nodes[nodes.length - 1] = merged;
+        // } else
+        // console.log('addtext', node);
+        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);
+    }
+    // Removes the given mark from the set of active marks.
+    closeMark(mark) {
+        let top = this.top();
+        top.marks = mark.removeFromSet(top.marks);
+    }
+    // Add a node at the current position.
+    addNode(type, attrs, content) {
+        let top = this.top();
+        let node = type.createAndFill(attrs, content, top ? top.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() {
+        let info = this.stack.pop();
+        // console.log('closeNode', info.type.name, info.attrs);
+        return this.addNode(info.type, info.attrs, info.content);
+    }
+    handleElement(nodeType, element) {
+        const spec = 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);
+        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']);
+        }
+        if (spec.block) {
+            let block = spec.block;
+            if ('string' !== typeof block) {
+                block = block(element, style);
+            }
+            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();
+        }
+        else if (spec.node) {
+        }
+        else if (spec.mark) {
+            let 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) {
+            // console.log('aaaaaaaaaaaaaaaaaaaa', element);
+            this.addText(spec.text(element));
+        }
+        else {
+            if (children) {
+                iterateChildren(children, (nodeType, node) => {
+                    this.handleElement(nodeType, node);
+                });
+            }
+        }
+    }
+}
+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);
+            key = keys[0];
+            value = child[key];
+        }
+        if (!key) {
+            return;
+        }
+        callback(key, value);
+    }
+}
+function iterateEnum($value) {
+    if (!$value) {
+        return [];
+    }
+    return $value.map((item) => {
+        if ('string' === typeof item) {
+            return {
+                [item]: true,
+            };
+        }
+        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'],
+    },
+    '$value': {
+        children: (odtElement) => iterateEnum(odtElement),
+    },
+    '$text': {
+        text: (odtElement) => String(odtElement || ''),
+    },
+    's': {
+        text: (odtElement) => {
+            const chars = odtElement['@c'] || 1;
+            return '               '.substring(0, chars);
+        },
+    },
+    'tab': {
+        text: (odtElement) => '\t',
+    },
+    'table-of-content': {
+        children: (odtElement) => odtElement['index-body']['p'] || [],
+    },
+    'frame': {
+        ignore: true,
+    },
+    'rect': {
+        ignore: true,
+    },
+    'annotation': {
+        ignore: true,
+    },
+};
+export class OdtParser {
+    constructor(schema) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        // 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']);
+        state.handleElement('body', contentTree.body);
+        let doc;
+        do {
+            doc = state.closeNode();
+        } while (state.stack.length);
+        return doc || null; //this.schema.topNodeType.createAndFill()!;
+    }
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@kerebron/extension-odt",
+  "version": "0.0.8",
+  "license": "MIT",
+  "module": "./esm/extension-odt/src/ExtensionOdt.js",
+  "exports": {
+    ".": {
+      "import": "./esm/extension-odt/src/ExtensionOdt.js"
+    }
+  },
+  "scripts": {},
+  "dependencies": {
+    "prosemirror-keymap": "1.2.2",
+    "prosemirror-model": "1.24.1",
+    "prosemirror-state": "1.4.3",
+    "prosemirror-transform": "1.10.3",
+    "prosemirror-view": "1.33.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}