@kerebron/extension-odt 0.4.28 → 0.4.30

package/src/postprocess/convertCodeParagraphsToCodeBlocks.ts

@@ -0,0 +1,118 @@
+import { Fragment, MarkType, 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,
+): boolean => {
+  const doc: Node = state.doc;
+  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;
+  }
+
+  function nodesToText(fragment: 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;
+};

package/src/postprocess/convertMathMl.ts

@@ -0,0 +1,56 @@
+import { off } from 'node:process';
+import { Node } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+
+// Related tests:
+// test ./example-document.md
+export const convertMathMl: Command = (state, dispatch): boolean => {
+  const doc: Node = state.doc;
+  const schema = state.schema;
+  const mathType = schema.nodes.math;
+  const codeBlockType = schema.nodes.code_block;
+
+  if (!mathType || !codeBlockType) {
+    return false;
+  }
+
+  let modified = false;
+
+  const tr = state.tr;
+
+  doc.forEach((parentNode, offset, index) => {
+    if (parentNode.childCount !== 1) {
+      return;
+    }
+
+    const parentPos = offset;
+
+    const node = parentNode.child(0);
+
+    if (node.type !== mathType) return;
+    if (node.attrs.content.length === 0) return;
+
+    const codeBlock = codeBlockType.create(
+      {
+        lang: node.attrs.lang,
+      },
+      schema.text(node.attrs.content),
+    );
+
+    tr.replaceWith(
+      tr.mapping.map(parentPos),
+      tr.mapping.map(parentPos + parentNode.nodeSize),
+      codeBlock,
+    );
+
+    modified = true;
+  });
+
+  if (!modified) return false;
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return true;
+};

package/src/postprocess/fixContinuedLists.ts

@@ -0,0 +1,113 @@
+import { Fragment, Node, Slice } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+
+import { nodeToTreeString } from '@kerebron/editor';
+
+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);
+  }
+
+  return 0;
+}
+
+function convertToStitchingLevels(list: Node, array: Array<Slice> = []) {
+  if (ANY_LIST.indexOf(list.type.name) === -1) {
+    throw new Error(`Incorrect list type: ${list.type.name}`);
+  }
+
+  if (!list?.firstChild) {
+    return array;
+  }
+
+  const firstChildParagraph = list.firstChild.firstChild;
+
+  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 subList = list?.firstChild.child(1);
+
+    array.push(list.slice(list.firstChild.nodeSize, list.content.size));
+
+    if (ANY_LIST.indexOf(subList?.type.name) > -1) {
+      convertToStitchingLevels(subList, array);
+    }
+  } else {
+    array.push(list.slice(0, list.content.size));
+  }
+
+  return array;
+}
+
+export const fixContinuedLists: Command = (state, dispatch): boolean => {
+  const doc: Node = state.doc;
+  let tr = state.tr;
+
+  let previousList: ListPos | null = null;
+
+  // console.debug(nodeToTreeString(doc));
+
+  doc.forEach((child, childPos) => {
+    if (child.type.name === 'ordered_list') {
+      const start = childPos;
+      const end = start + child.nodeSize;
+
+      if (previousList) {
+        const stitchingLevels = convertToStitchingLevels(child);
+
+        if (stitchingLevels.length <= previousList.stitchingDepth) {
+          const betweenStart = previousList.end;
+          const betweenNodes = doc.slice(betweenStart, start);
+
+          tr = tr.delete(tr.mapping.map(betweenStart), tr.mapping.map(end));
+
+          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);
+          }
+
+          previousList.stitchingDepth = getListEndingMaxDepth(child);
+          previousList.end = end;
+          return;
+        }
+      }
+
+      previousList = {
+        stitchingDepth: getListEndingMaxDepth(child),
+        start,
+        end,
+      };
+    }
+  });
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return tr.steps.length > 0;
+};

package/src/postprocess/postProcess.ts

@@ -0,0 +1,23 @@
+import type { Node } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+
+import { convertCodeParagraphsToCodeBlocks } from './convertCodeParagraphsToCodeBlocks.js';
+import { removeUnusedBookmarks } from './removeUnusedBookmarks.js';
+import { fixContinuedLists } from './fixContinuedLists.js';
+import { convertMathMl } from './convertMathMl.js';
+
+export interface PostProcessConfig {
+  doc: Node;
+  filesMap: Record<string, Uint8Array>;
+}
+
+export function getDefaultsPostProcessFilters(
+  { doc, filesMap }: PostProcessConfig,
+): Array<Command> {
+  return [
+    convertCodeParagraphsToCodeBlocks,
+    removeUnusedBookmarks,
+    fixContinuedLists,
+    convertMathMl,
+  ];
+}

package/src/postprocess/removeUnusedBookmarks.ts

@@ -0,0 +1,36 @@
+import { Fragment, MarkType, Node, Schema } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+
+export const removeUnusedBookmarks: Command = (state, dispatch): boolean => {
+  return false;
+  function condition(mark) {
+    console.log('rrrr', mark.type.name);
+    return mark.type.name === 'bookmark';
+  }
+
+  if (node.marks) {
+    // For text nodes, filter out the marks that match the condition
+    const newMarks = node.marks.filter((mark) => !condition(mark));
+
+    // If marks were removed, return a new text node with the remaining marks
+    if (newMarks.length !== node.marks.length) {
+      return node.mark(newMarks);
+    }
+
+    // Otherwise, return the original text node
+    return node;
+  }
+
+  // if (Array.isArray(node.content)) {
+  //   const content: Node[] = node.content.content.map(childNode => removeUnusedBookmarks(childNode));
+  // return node.copy(content);
+  // } else {
+  // console.log('node.content', node.content);
+  // }
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return tr.steps.length > 0;
+};