@kerebron/extension-odt 0.5.2 → 0.5.4

package/src/node_handlers/list_node_handlers.ts

@@ -1,116 +1,117 @@
-import { ListNumbering } from '../lists.js';
 import {
   iterateChildren,
+  ListStyle,
   NodeHandler,
   OdtStashContext,
-  resolveStyle,
+  resolveListStyle,
 } from '../OdtParser.js';
+import { inchesToMm } from './basic_node_handlers.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 | number> = {};
+
+  let style: ListStyle = resolveListStyle(
+    ctx.stylesTree,
+    ctx.automaticStyles,
+    '',
+  );
+
+  for (let i = listTracker.listStack.length - 1; i >= 0; i--) {
+    const list = listTracker.listStack[i];
+    if (!style['@name']) {
+      style = resolveListStyle(
+        ctx.stylesTree,
+        ctx.automaticStyles,
+        list.styleName,
+      );
+    }
+  }
+
+  let nodeTypeName = 'bullet_list';
+  if (style) {
+    const numLevelStyle = style['list-level-style-number'].find(
+      (levelStyle) => parseInt(String(levelStyle['@level'])) === level,
+    );
+    if (numLevelStyle) {
+      attrs['type'] = numLevelStyle['@num-format'] || '1';
+      if (numLevelStyle['@start-value']) {
+        attrs['start'] = String(numLevelStyle['@start-value']);
+      }
+      nodeTypeName = 'ordered_list';
+      const marginLeft =
+        numLevelStyle['list-level-properties']['list-level-label-alignment'][
+          '@margin-left'
+        ];
+      if (marginLeft) {
+        attrs['odtMarginLeft'] = inchesToMm(marginLeft);
+      }
+    }
+    const bulletLevelStyle = style['list-level-style-bullet'].find(
+      (levelStyle) => parseInt(String(levelStyle['@level'])) === level,
+    );
+    if (bulletLevelStyle) {
+      const marginLeft =
+        bulletLevelStyle['list-level-properties']['list-level-label-alignment'][
+          '@margin-left'
+        ];
+      if (marginLeft) {
+        attrs['odtMarginLeft'] = inchesToMm(marginLeft);
+      }
+    }
+  }
+
+  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) => {
+    'list': (ctx: OdtStashContext, odtElement) => {
       const listTracker = ctx.listTracker;
-      const list = {
-        level: listTracker.listStack.length + 1,
-        odtElement,
-      };
-      listTracker.listStack.push(list);
-
-      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'],
-            )
-            : {};
-        }
-      }
+      listTracker.pushList(odtElement['@xml:id'], odtElement['@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['@xml:id']) {
+        attrs['id'] = odtElement['@xml: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();
 
-      const children = odtElement['list-item'].map((item) => ({
+      const children = odtElement['list-item'].map((item: any) => ({
         '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 +123,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,66 @@ 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);
-    }
+  const markCodeType = schema.marks.code;
 
-    paragraphsToMerge = null;
-  }
+  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);
+        const monospaced = child.marks.some((mark) =>
+          mark.type === markCodeType
+        );
+
+        if (child.type.name === 'node_bookmark') {
+          codeText += '\n';
+          codeSize += child.nodeSize;
+          continue;
+        }
 
-  function nodesToText(fragment: Fragment) {
-    if (fragment.content.length === 0) {
-      return '';
-    }
+        if (child.type.name === 'br') {
+          codeText += '\n';
+          codeSize += child.nodeSize;
+          continue;
+        }
 
-    let retVal = '';
+        if (monospaced) {
+          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;
+        if (codeText) {
+          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),
-          };
+          if (codeBlock) {
+            tr.replaceRangeWith(startPos, endPos, codeBlock);
+          }
         } else {
-          paragraphsToMerge = {
-            startPos: paragraphsToMerge.startPos,
-            endPos: pos + node.nodeSize,
-            innerText: paragraphsToMerge.innerText + '\n' +
-              nodesToText(node.content),
-          };
+          tr.replace(startPos, endPos);
         }
-        return;
       }
-    }
 
-    if (paragraphsToMerge !== null) {
-      flushCodeBlock();
+      if (codeSize > 0 && codeSize + 2 === node.nodeSize) {
+        // 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';
 
@@ -52,5 +51,5 @@ export const convertMathMl: Command = (state, dispatch): boolean => {
     dispatch(tr);
   }
 
-  return true;
+  return tr.docChanged;
 };

package/src/postprocess/fixContinuedLists.ts

@@ -1,109 +1,126 @@
-import { Fragment, Node, Slice } from 'prosemirror-model';
+import { Node } from 'prosemirror-model';
 import { Command } from 'prosemirror-state';
 
-import { nodeToTreeString } from '@kerebron/editor';
+import { ListNumbering } from '../lists.js';
 
 const ANY_LIST = ['ordered_list', 'bullet_list'];
 
-interface ListPos {
-  start: number;
-  end: number;
-  stitchingDepth: number;
-}
-
-function getListEndingMaxDepth(list: Node | null): number {
-  if (!list) {
-    return 0;
-  }
-
-  if (ANY_LIST.indexOf(list.type.name) === -1) {
-    return 0;
-  }
-
-  if (list.lastChild?.type.name === 'list_item') {
-    return 1 + getListEndingMaxDepth(list.lastChild?.lastChild);
-  }
+export const fixContinuedLists: Command = (state, dispatch): boolean => {
+  const doc: Node = state.doc;
+  let tr = state.tr;
 
-  return 0;
-}
+  const listNumberings: Map<string, ListNumbering> = new Map<
+    string,
+    ListNumbering
+  >();
 
-function convertToStitchingLevels(list: Node, array: Array<Slice> = []) {
-  if (ANY_LIST.indexOf(list.type.name) === -1) {
-    throw new Error(`Incorrect list type: ${list.type.name}`);
-  }
+  let topListId = '';
 
-  if (!list?.firstChild) {
-    return array;
-  }
+  function processContinuation(node: Node) {
+    let listNumbering = null;
 
-  const firstChildParagraph = list.firstChild.firstChild;
+    if (topListId && listNumberings.has(topListId)) {
+      listNumbering = listNumberings.get(topListId);
+    }
 
-  if (firstChildParagraph?.content.size === 0) {
-    if (list?.firstChild.children.length < 2) {
-      array.push(new Slice(Fragment.from([]), 0, 0));
-      // array.push(list.slice(list.firstChild.nodeSize, list.firstChild.nodeSize)) // empty slice
-      return array;
+    const cont = node.attrs['continue'];
+    if (cont) {
+      listNumbering = listNumberings.get(cont);
     }
 
-    const subList = list?.firstChild.child(1);
+    if (!listNumbering) {
+      listNumbering = new ListNumbering(topListId);
+    }
 
-    array.push(list.slice(list.firstChild.nodeSize, list.content.size));
+    listNumberings.set(topListId, listNumbering);
 
-    if (ANY_LIST.indexOf(subList?.type.name) > -1) {
-      convertToStitchingLevels(subList, array);
-    }
-  } else {
-    array.push(list.slice(0, list.content.size));
+    return { listNumbering };
   }
 
-  return array;
-}
-
-export const fixContinuedLists: Command = (state, dispatch): boolean => {
-  const doc: Node = state.doc;
-  let tr = state.tr;
+  let possibleContinue = true;
+  let level = 0;
+
+  function walk(
+    node: Node,
+    pos = 0,
+    depth = 0,
+  ) {
+    if ('list_item' === node.type.name) {
+      const listNumbering = listNumberings.get('_current');
+      const firstChild = node.content.firstChild;
+      if (firstChild && listNumbering) {
+        if (
+          firstChild.type.name === 'paragraph' &&
+          firstChild.content.childCount > 0
+        ) {
+          if (listNumbering.forceStart[level]) {
+            delete listNumbering.forceStart[level];
+
+            tr = tr.setNodeMarkup(tr.mapping.map(pos - 1), node.type, {
+              ...node.attrs,
+              value: listNumbering.levels[level],
+            });
+          }
 
-  let previousList: ListPos | null = null;
+          listNumbering.levels[level]++;
+        } else {
+          tr = tr.setNodeMarkup(tr.mapping.map(pos - 1), node.type, {
+            ...node.attrs,
+            type: 'none',
+          });
+          listNumbering.forceStart[level] = true;
+        }
+      }
+    }
 
-  // console.debug(nodeToTreeString(doc));
+    if (!ANY_LIST.includes(node.type.name)) {
+      node.forEach((child, offset) => {
+        walk(child, pos + offset + 1, depth + 1);
+      });
+    } else {
+      level++;
 
-  doc.forEach((child, childPos) => {
-    if (child.type.name === 'ordered_list') {
-      const start = childPos;
-      const end = start + child.nodeSize;
+      if (level === 1) {
+        topListId = node.attrs.id;
+        possibleContinue = true;
+      }
 
-      if (previousList) {
-        const stitchingLevels = convertToStitchingLevels(child);
+      const { listNumbering } = processContinuation(node);
 
-        if (stitchingLevels.length <= previousList.stitchingDepth) {
-          const betweenStart = previousList.end;
-          const betweenNodes = doc.slice(betweenStart, start);
+      listNumberings.set('_current', listNumbering);
 
-          tr = tr.delete(tr.mapping.map(betweenStart), tr.mapping.map(end));
+      if (!possibleContinue) {
+        listNumbering.levels[level] = 1;
+      }
 
-          let posToInsert = tr.mapping.map(previousList.end);
-          for (const level of stitchingLevels) {
-            posToInsert -= 1; // Before /OL token
-            tr = tr.replace(posToInsert, posToInsert, level);
-            posToInsert -= 1; // Before /LI token
-          }
-          if (betweenNodes.size > 0) {
-            tr = tr.replace(posToInsert, posToInsert, betweenNodes);
-          }
+      if (node.attrs.start) {
+        listNumbering.levels[level] = node.attrs.start;
+      }
 
-          previousList.stitchingDepth = getListEndingMaxDepth(child);
-          previousList.end = end;
-          return;
+      if ('ordered_list' === node.type.name) {
+        if (1 < listNumbering.levels[level]) {
+          tr = tr.setNodeMarkup(tr.mapping.map(pos - 1), node.type, {
+            ...node.attrs,
+            start: listNumbering.levels[level],
+            continue: undefined,
+          });
         }
       }
 
-      previousList = {
-        stitchingDepth: getListEndingMaxDepth(child),
-        start,
-        end,
-      };
+      node.forEach((child, offset) => {
+        walk(child, pos + offset + 1, depth + 1);
+      });
+
+      if (level === 1) {
+        listNumberings.set('_last', listNumbering);
+      }
+
+      level--;
+      possibleContinue = false;
     }
-  });
+  }
+
+  walk(doc);
 
   if (dispatch) {
     dispatch(tr);

package/src/postprocess/fixListsLevels.ts

@@ -0,0 +1,93 @@
+import { Fragment, Node } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+
+const ANY_LIST = ['ordered_list', 'bullet_list'];
+
+type LevelMargins = Array<number>;
+
+// Related tests:
+// test ./example-document.md
+export const fixListsLevels: Command = (state, dispatch): boolean => {
+  const doc: Node = state.doc;
+  const schema = state.schema;
+  const bulletListType = schema.nodes.bullet_list;
+  const listItemType = schema.nodes.list_item;
+  const paragraphType = schema.nodes.paragraph;
+
+  const tr = state.tr;
+
+  let level = 0;
+
+  let prevList: LevelMargins = [];
+  let curList: LevelMargins = [];
+  let fakeLevelGenerated = 0;
+
+  function walk(
+    node: Node,
+    pos = 0,
+    depth = 0,
+  ) {
+    if (!ANY_LIST.includes(node.type.name)) {
+      node.forEach((child, offset) => {
+        walk(child, pos + offset + 1, depth + 1);
+      });
+    } else {
+      const marginLeft = node.attrs['odtMarginLeft'] || 0;
+      if (level === 0) {
+        curList = [];
+        fakeLevelGenerated = 0;
+        if (prevList.length >= level) {
+          for (let i = 0; i < prevList.length; i++) {
+            if (
+              fakeLevelGenerated < prevList.length &&
+              marginLeft > prevList[fakeLevelGenerated]
+            ) {
+              curList[level + fakeLevelGenerated] =
+                prevList[fakeLevelGenerated];
+              fakeLevelGenerated++;
+            }
+          }
+        }
+      }
+
+      curList[level + fakeLevelGenerated] = marginLeft;
+
+      level++;
+
+      node.forEach((child, offset) => {
+        walk(child, pos + offset + 1, depth + 1);
+      });
+
+      level--;
+
+      if (level === 0 && !node.attrs.toc) {
+        prevList = curList;
+        for (let i = 0; i < fakeLevelGenerated; i++) {
+          const wrapper = bulletListType.create(
+            { type: 'none' },
+            listItemType.create(
+              null,
+              Fragment.from([
+                paragraphType.create(),
+                node,
+              ]),
+            ),
+          );
+          tr.replaceWith(
+            tr.mapping.map(pos),
+            tr.mapping.map(pos + node.nodeSize),
+            wrapper,
+          );
+        }
+      }
+    }
+  }
+
+  walk(doc);
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return tr.docChanged;
+};