@kerebron/extension-odt 0.5.2 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kerebron/extension-odt",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "license": "MIT",
   "module": "./esm/ExtensionOdt.js",
   "exports": {
@@ -14,8 +14,8 @@
     "src"
   ],
   "dependencies": {
-    "@kerebron/editor": "0.5.2",
-    "@kerebron/odt-wasm": "0.5.2",
+    "@kerebron/editor": "0.5.3",
+    "@kerebron/odt-wasm": "0.5.3",
     "prosemirror-model": "1.25.3",
     "prosemirror-state": "1.4.3"
   },

package/src/ExtensionOdt.ts

@@ -16,7 +16,8 @@ import {
 import { OdtParser, OdtParserConfig } from './OdtParser.js';
 import { getDefaultsPostProcessFilters } from './postprocess/postProcess.js';
 import { Command } from '@kerebron/editor/commands';
-import { InputRulesPlugin } from '@kerebron/editor/plugins/input-rules';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { urlRewrite } from './postprocess/urlRewrite.js';
 
 export interface OdtConfig extends OdtParserConfig {
   debug?: boolean;
@@ -37,8 +38,6 @@ export class ExtensionOdt extends Extension {
     editor: CoreEditor,
     schema: Schema,
   ): Record<string, Converter> {
-    const config = this.config;
-
     const odtConverter = {
       fromDoc: async (document: Node): Promise<Uint8Array> => {
         throw new Error('Not implemented');
@@ -53,118 +52,34 @@ export class ExtensionOdt extends Extension {
           this.config.postProcessCommands || [],
         );
 
-        const plugin = editor.state.plugins.find((plugin) =>
-          plugin instanceof InputRulesPlugin
-        );
-        if (plugin) {
-          // plugin.props.
-        }
+        let state = EditorState.create({ doc });
+        const dispatch = (tr: Transaction) => {
+          state = state.apply(tr);
+        };
 
-        const subEditor = editor.clone();
-        subEditor.setDocument(doc.toJSON());
-
-        let modified = false;
         if (this.urlFromRewriter) {
-          const imageNodes: Array<{ node: Node; pos: number }> = [];
-          subEditor.getDocument().descendants((node, pos) => {
-            if (node.type.name === 'image') {
-              imageNodes.push({ node, pos });
-            }
-          });
-
-          const linkNodes: Array<{ node: Node; pos: number }> = [];
-          subEditor.getDocument().descendants((node, pos) => {
-            if (node.marks.find((mark) => mark.type.name === 'link')) {
-              linkNodes.push({ node, pos });
-            }
-          });
-
-          const tr = subEditor.state.tr;
-
-          for (const { node, pos } of linkNodes) {
-            const linkMark = node.marks.find((mark) =>
-              mark.type.name === 'link'
-            );
-            if (!linkMark) {
-              continue;
-            }
-            let href = linkMark.attrs.href || '';
-            href = await this.urlFromRewriter(href, {
-              type: 'A',
-              dest: 'kerebron',
-            });
-            if (href !== linkMark.attrs.href) {
-              const newMarks = node.marks.map((mark) => {
-                if (mark.type.name === 'link') {
-                  const markType = this.editor.schema.marks['link'];
-                  return markType.create({ ...mark.attrs, href });
-                }
-                return mark;
-              });
-
-              const nodeType = this.editor.schema.nodes[node.type.name];
-              let replaceNode;
-              if (nodeType.isText) {
-                replaceNode = this.editor.schema.text(
-                  node.text || '',
-                  newMarks,
-                );
-              } else {
-                replaceNode = nodeType.create(
-                  node.attrs,
-                  node.content,
-                  newMarks,
-                );
-              }
-              tr.replaceWith(
-                tr.mapping.map(pos),
-                tr.mapping.map(pos + node.nodeSize),
-                replaceNode,
-              );
-            }
-          }
-
-          for (const { node, pos } of imageNodes) {
-            let src = node.attrs.src || '';
-
-            src = await this.urlFromRewriter(src, {
-              type: 'IMG',
-              dest: 'kerebron',
-              filesMap,
-            });
-
-            if (src !== node.attrs.src) {
-              const nodeType = this.editor.schema.nodes[node.type.name];
-              const replaceNode = nodeType.create(
-                { ...node.attrs, src },
-                node.content,
-                node.marks,
-              );
-              tr.replaceWith(
-                tr.mapping.map(pos),
-                tr.mapping.map(pos + node.nodeSize),
-                replaceNode,
-              );
-            }
-          }
-          subEditor.dispatchTransaction(tr), modified = true;
+          await urlRewrite(this.urlFromRewriter, filesMap, state, dispatch);
         }
 
         if (filterCommands.length > 0) {
           for (const filter of filterCommands) {
             filter(
-              subEditor.state,
-              (tr) => subEditor.dispatchTransaction(tr),
+              state,
+              (tr) => dispatch(tr),
             );
           }
-          modified = true;
         }
 
-        if (modified) {
-          return subEditor.getDocument();
+        if (this.config.debug) {
+          const event = new CustomEvent('odt:pmdoc:filtered', {
+            detail: {
+              doc: state.doc,
+            },
+          });
+          this.editor.dispatchEvent(event);
         }
 
-        return doc;
+        return state.doc;
       },
       odtToJson: (buffer: Uint8Array) => {
         const files = unzip(buffer);

package/src/OdtParser.ts

@@ -6,7 +6,6 @@ import {
 import { getListNodesHandlers } from './node_handlers/list_node_handlers.js';
 import { getTableNodesHandlers } from './node_handlers/table_node_handlers.js';
 import { ListTracker } from './lists.js';
-import { type UrlRewriter } from '@kerebron/editor';
 
 const COURIER_FONTS = ['Courier New', 'Courier', 'Roboto Mono'];
 
@@ -16,24 +15,24 @@ export interface OdtElement {
 
 export type NodeHandler = (ctx: OdtStashContext, value: any) => void;
 
-interface ListStyle {
+export interface ListStyle {
   '@name': string;
 }
 
-interface Style {
+export interface Style {
   '@name': string;
   '@parent-style-name'?: string;
   styles: string[];
 }
 
-interface StylesTree {
+export interface StylesTree {
   styles: {
     'list-style': Array<ListStyle>;
     'style': Array<Style>;
   };
 }
 
-interface AutomaticStyles {
+export interface AutomaticStyles {
   'style': Array<Style>;
 }
 
@@ -42,7 +41,7 @@ export function resolveStyle(
   automaticStyles: AutomaticStyles,
   name: string,
 ): Style {
-  let style: Style;
+  let style: Style | undefined;
 
   if (!style) {
     style = stylesTree.styles['list-style'].find((item) =>
@@ -59,6 +58,7 @@ export function resolveStyle(
   if (!style) {
     style = {
       '@name': name,
+      styles: [],
     };
   }
 
@@ -198,6 +198,10 @@ export class OdtStashContext {
     this.current.content = [];
   }
 
+  public dropNode() {
+    this.unstash();
+  }
+
   public closeNode(type: string, attrs = {}, marks = Mark.none) {
     const node = this.createNode(type, attrs, marks);
     this.unstash();
@@ -292,7 +296,7 @@ export class OdtParser {
       ...getListNodesHandlers(),
       ...getTableNodesHandlers(),
 
-      'change-start': {
+      'change-start': () => {
         // custom(state) {
         //   state.textMarks.add({
         //     markName: 'change',
@@ -300,13 +304,16 @@ export class OdtParser {
         //   });
         // },
       },
-      'change-end': {
+      'change-end': () => {
         // custom(state) {
         //   state.textMarks.forEach((x) =>
         //     x.markName === 'change' ? state.textMarks.delete(x) : x
         //   );
         // },
       },
+      'g': () => { // Test is: embedded-diagram-example.odt
+        // DrawG draw:g
+      },
       'frame': (ctx: OdtStashContext, odtElement: any) => {
         if (odtElement.object && odtElement.object['@href']) {
           const fullPath = odtElement.object['@href'].replace(/^\.\//, '') +

package/src/lists.ts

@@ -1,10 +1,8 @@
-import { OdtElement } from './OdtParser.js';
-
 export class ListNumbering {
   levels: { [level: number]: number } = {};
-  levelNodes: { [level: number]: Node } = {};
+  forceStart: { [level: number]: boolean } = {};
 
-  constructor() {
+  constructor(public readonly id: string) {
     for (let i = 0; i < 20; i++) {
       this.levels[i] = 1;
     }
@@ -16,20 +14,36 @@ export class ListNumbering {
     }
   }
 
-  setLevelNode(level: number, node: Node) {
-    this.levelNodes[level] = node;
+  clone(id: string): ListNumbering {
+    const retVal = new ListNumbering(id);
+
+    retVal.levels = structuredClone(retVal.levels);
+    retVal.forceStart = structuredClone(retVal.forceStart);
+
+    return retVal;
   }
 }
 
 export interface List {
   level: number;
-  odtElement: OdtElement;
+  id?: string;
+  styleName: string;
 }
 
 export class ListTracker {
   listStack: List[] = [];
 
-  listNumberings: Map<string, ListNumbering> = new Map<string, ListNumbering>();
-  lastNumbering?: ListNumbering;
-  preserveMinLevel = 999;
+  pushList(id?: string, styleName = ''): List {
+    const list: List = {
+      id,
+      styleName,
+      level: this.listStack.length + 1,
+    };
+    this.listStack.push(list);
+    return list;
+  }
+
+  getCurrentList(): List {
+    return this.listStack[this.listStack.length - 1];
+  }
 }

package/src/node_handlers/basic_node_handlers.ts

@@ -33,13 +33,11 @@ export function getInlineNodesHandlers(): Record<string, NodeHandler> {
       ctx.closeNode('br');
     },
     'soft-page-break': (ctx: OdtStashContext, odtElement: any) => {
-      ctx.openNode();
-      ctx.closeNode('br');
     },
 
     'bookmark': (ctx: OdtStashContext, element: any) => { // bookmark for parent para
       ctx.openNode();
-      ctx.closeNode('bookmark-node', {
+      ctx.closeNode('node_bookmark', {
         id: element['@name'],
       });
     },
@@ -74,7 +72,7 @@ export function getBasicNodesHandlers(): Record<string, NodeHandler> {
       );
     },
     'p': (ctx: OdtStashContext, value: any) => {
-      const attrs = {};
+      const attrs: Record<string, any> = {};
 
       const style = ctx.getElementStyle(value);
       const heading = style.styles.find((item) =>

package/src/node_handlers/list_node_handlers.ts

@@ -1,4 +1,3 @@
-import { ListNumbering } from '../lists.js';
 import {
   iterateChildren,
   NodeHandler,
@@ -6,91 +5,73 @@ import {
   resolveStyle,
 } from '../OdtParser.js';
 
+// https://docs.oasis-open.org/office/OpenDocument/v1.4/OpenDocument-v1.4-part3-schema.html#a_19_880_22__text_list_
+// The text:style-name attribute specifies the name of a list style that is applied to a list.
+// If this attribute is not included and therefore no list style is specified, one of the following actions is taken:
+//     •If a list is contained within another list, the list style defaults to the style of the surrounding list.
+//     •If there is no list style specified for the surrounding list, but the list's list items contain paragraphs that have paragraph styles attached specifying a list style, that list style is used.
+//     •An implementation-dependent default list style is used.
+// To determine which formatting properties are applied to a list, the list level and list style name are taken into account.
+function processListStyle(ctx: OdtStashContext, level: number) {
+  const listTracker = ctx.listTracker;
+  const attrs: Record<string, string> = {};
+
+  let style = {};
+  for (let i = listTracker.listStack.length - 1; i >= 0; i--) {
+    const list = listTracker.listStack[i];
+    if (!style['@style-name']) {
+      style = (list.styleName)
+        ? resolveStyle(
+          ctx.stylesTree,
+          ctx.automaticStyles,
+          list.styleName,
+        )
+        : {};
+    }
+  }
+
+  let nodeTypeName = 'bullet_list';
+  if (style) {
+    const numLevelStyle = style['list-level-style-number'].find(
+      (levelStyle) => parseInt(levelStyle['@level']) === level,
+    );
+    if (numLevelStyle) {
+      attrs['type'] = numLevelStyle['@num-format'] || '1';
+      if (numLevelStyle['@start-value']) {
+        attrs['start'] = numLevelStyle['@start-value'];
+      }
+      nodeTypeName = 'ordered_list';
+    }
+  }
+
+  return {
+    attrs,
+    nodeTypeName,
+  };
+}
+
+// https://docs.oasis-open.org/office/OpenDocument/v1.4/OpenDocument-v1.4-part3-schema.html#element-text_list
 export function getListNodesHandlers(): Record<string, NodeHandler> {
   return {
     'list': (ctx: OdtStashContext, odtElement: any) => {
       const listTracker = ctx.listTracker;
-      const list = {
-        level: listTracker.listStack.length + 1,
-        odtElement,
-      };
-      listTracker.listStack.push(list);
+      listTracker.pushList(odtElement['@id'], odtElement['@style-name']);
 
-      let style = {};
-      let listId = null;
-      for (let i = listTracker.listStack.length - 1; i >= 0; i--) {
-        const element = listTracker.listStack[i].odtElement;
-        if (!listId) {
-          if (element['@id']) {
-            listId = element['@id'];
-          }
-        }
-        if (!style['@style-name']) {
-          style = ('object' === typeof element && element['@style-name'])
-            ? resolveStyle(
-              ctx.stylesTree,
-              ctx.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';
-        }
-      }
+      const { nodeTypeName, attrs } = processListStyle(
+        ctx,
+        listTracker.getCurrentList().level,
+      );
 
       ctx.current.meta['list_type'] = nodeTypeName;
 
-      let listNumbering = null;
-
-      if (listId && listTracker.listNumberings.has(listId)) {
-        listNumbering = listTracker.listNumberings.get(listId);
+      if (odtElement['@id']) {
+        attrs['id'] = odtElement['@id'];
       }
-
-      let isContinue = false;
-      if (
-        odtElement['@continue-list'] &&
-        listTracker.listNumberings.has(odtElement['@continue-list'])
-      ) {
-        listNumbering = listTracker.listNumberings.get(
-          odtElement['@continue-list'],
-        );
-        isContinue = true;
+      if (odtElement['@continue-list']) {
+        attrs['continue'] = odtElement['@continue-list'];
       }
       if (odtElement['@continue-numbering']) {
-        listNumbering = listTracker.lastNumbering;
-        isContinue = true;
-      }
-
-      if (!listNumbering) {
-        listNumbering = new ListNumbering();
-      }
-
-      if (isContinue) {
-        listTracker.preserveMinLevel = 999;
-      }
-
-      if (listId) {
-        listTracker.listNumberings.set(listId, listNumbering);
-      }
-
-      listTracker.lastNumbering = listNumbering;
-
-      if (listTracker.preserveMinLevel <= list.level) {
-        listNumbering.clearAbove(list.level - 1);
-      }
-
-      if (nodeTypeName === 'ordered_list') {
-        attrs['start'] = listNumbering.levels[list.level] || 1;
+        attrs['continue'] = '_last';
       }
 
       ctx.openNode();
@@ -99,18 +80,14 @@ export function getListNodesHandlers(): Record<string, NodeHandler> {
         'list-item': item,
       }));
 
-      if (children) {
-        iterateChildren(children, (child) => {
-          ctx.handle(child.tag, child.value);
-        });
-
-        listNumbering.levels[list.level] += children.length;
-      }
-
-      ctx.closeNode(nodeTypeName, attrs);
+      iterateChildren(children, (child) => {
+        ctx.handle(child.tag, child.value);
+      });
 
-      if (listTracker.preserveMinLevel >= list.level) {
-        listTracker.preserveMinLevel = list.level;
+      if (ctx.current.content.length === 0) {
+        ctx.dropNode();
+      } else {
+        ctx.closeNode(nodeTypeName, attrs);
       }
 
       listTracker.listStack.pop();
@@ -122,7 +99,7 @@ export function getListNodesHandlers(): Record<string, NodeHandler> {
         (child) => ctx.handle(child.tag, child.value),
       );
 
-      const attrs = {};
+      const attrs: Record<string, string> = {};
       attrs.markup = '* ';
 
       ctx.closeNode('list_item', attrs);

package/src/postprocess/convertCodeParagraphsToCodeBlocks.ts

@@ -1,36 +1,8 @@
-import { Fragment, MarkType, Node } from 'prosemirror-model';
+import { Node } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
 
 import type { Command } from '@kerebron/editor/commands';
 
-function onlyHasCodeMarkedText(
-  paragraph: Node,
-  codeMarkType: MarkType,
-): boolean {
-  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;
-}
-
-interface ParagraphsToMerge {
-  startPos: number;
-  endPos: number;
-  innerText: string;
-}
-
 export const convertCodeParagraphsToCodeBlocks: Command = (
   state,
   dispatch,
@@ -39,80 +11,53 @@ export const convertCodeParagraphsToCodeBlocks: Command = (
   const schema = state.schema;
   let tr: Transaction = state.tr;
 
-  let paragraphsToMerge: ParagraphsToMerge | null = 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);
-
-    if (codeBlock) {
-      tr.replaceRangeWith(startPos, endPos, codeBlock);
-    }
-
-    paragraphsToMerge = null;
-  }
+  const markCodeType = schema.marks.code;
 
-  function nodesToText(fragment: Fragment) {
-    if (fragment.content.length === 0) {
-      return '';
-    }
+  doc.descendants((node, pos) => {
+    if (node.type.name === 'paragraph') {
+      let codeText = '';
+      let codeSize = 0;
+      for (let childNo = 0; childNo < node.childCount; childNo++) {
+        const child = node.child(childNo);
+
+        if (child.type.name === 'br') {
+          codeText += '\n';
+          codeSize += child.nodeSize;
+          continue;
+        }
 
-    let retVal = '';
+        if (child.marks.some((mark) => mark.type === markCodeType)) {
+          codeText += child.text || child.textBetween(0, child.content.size);
+          codeSize += child.nodeSize;
+          continue;
+        }
 
-    fragment.content.forEach((node) => {
-      if (node.isText) {
-        retVal += node.text;
-      } else {
-        retVal = '@TODO: node.type ' + node.type;
+        break;
       }
-    });
 
-    return retVal;
-  }
+      if (codeSize > 0) {
+        const startPos = tr.mapping.map(pos);
+        const endPos = tr.mapping.map(pos + 1 + codeSize);
 
-  doc.forEach((node, pos) => {
-    if (node.type.name === 'paragraph') {
-      const isCodeOnly = onlyHasCodeMarkedText(node, schema.marks.code);
-      const isEmpty = node.content.size === 0;
+        const textNode = schema.text(codeText);
+        const codeBlock = schema.nodes.code_block.createAndFill(null, [
+          textNode,
+        ]);
 
-      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),
-          };
+        if (codeBlock) {
+          tr = tr.replaceRangeWith(startPos, endPos, codeBlock);
         }
-        return;
       }
-    }
 
-    if (paragraphsToMerge !== null) {
-      flushCodeBlock();
+      if (codeSize > 0 && codeSize + 2 === node.nodeSize) {
+        // tr = tr.deleteRange(tr.mapping.map(pos), tr.mapping.map(pos))
+      }
     }
   });
 
-  if (paragraphsToMerge !== null) {
-    flushCodeBlock();
-  }
-
   if (dispatch) {
     dispatch(tr);
   }
 
-  return tr.steps.length > 0;
+  return tr.docChanged;
 };

package/src/postprocess/convertMathMl.ts

@@ -1,4 +1,3 @@
-import { off } from 'node:process';
 import { Node } from 'prosemirror-model';
 import { Command } from 'prosemirror-state';