@kerebron/extension-odt 0.5.2 → 0.5.3

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/mergeCodeBlocks.ts

@@ -0,0 +1,98 @@
+import { Command } from 'prosemirror-state';
+
+const CODEBLOCK_START = ''; // gdocs
+const CODEBLOCK_END = '';
+
+// Related tests:
+// test ./code-blocks.md
+export const mergeCodeBlocks: Command = (state, dispatch): boolean => {
+  const schema = state.schema;
+  let tr = state.tr;
+
+  const codeBlockType = schema.nodes.code_block;
+  const paraBlockType = schema.nodes.paragraph;
+
+  const parent = state.doc;
+  let offset = 0;
+  for (let nodeNo = 0; nodeNo < parent.childCount; nodeNo++) {
+    const node = parent.nodeAt(offset);
+    if (!node) {
+      continue;
+    }
+
+    if (node.type !== codeBlockType) {
+      offset += node.nodeSize;
+      continue;
+    }
+
+    let codeTexts = [];
+    let codeSize = 0;
+    {
+      codeSize += node.nodeSize;
+      const text = node.text || node.textBetween(0, node.content.size);
+      codeTexts.push(text.endsWith('\n') ? text : text + '\n');
+    }
+
+    let nextPos = offset + node.nodeSize;
+    while (true) {
+      const next = state.doc.nodeAt(nextPos);
+      if (!next) {
+        break;
+      }
+
+      const currentPos = nextPos;
+      nextPos += next.nodeSize;
+
+      if (next.type === paraBlockType && next.childCount === 0) {
+        codeTexts.push('\n');
+        codeSize += next.nodeSize;
+        continue;
+      }
+
+      if (next.type === codeBlockType && node.attrs.lang === next.attrs.lang) {
+        const text = next.text || next.textBetween(0, next.content.size);
+        codeTexts.push(text.endsWith('\n') ? text : text + '\n');
+
+        codeSize += next.nodeSize;
+        continue;
+      }
+
+      break;
+    }
+
+    if (codeTexts.length > 1) {
+      const startPos = tr.mapping.map(offset);
+      const endPos = tr.mapping.map(offset + codeSize);
+
+      const codeText = codeTexts.join('').replace(/\n+$/gm, '\n');
+      const textNode = schema.text(codeText);
+      const codeBlock = schema.nodes.code_block.createAndFill(null, [textNode]);
+
+      if (codeBlock) {
+        tr = tr.replaceRangeWith(startPos, endPos, codeBlock);
+      }
+    }
+
+    offset += codeSize;
+  }
+
+  state.doc.descendants((node, pos) => {
+    if (
+      node.type === paraBlockType &&
+      [CODEBLOCK_START, CODEBLOCK_END].includes(
+        node.textBetween(0, node.content.size),
+      )
+    ) {
+      tr = tr.deleteRange(
+        tr.mapping.map(pos),
+        tr.mapping.map(pos + node.nodeSize),
+      );
+    }
+  });
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return tr.docChanged;
+};

package/src/postprocess/postProcess.ts

@@ -5,6 +5,7 @@ import { convertCodeParagraphsToCodeBlocks } from './convertCodeParagraphsToCode
 import { removeUnusedBookmarks } from './removeUnusedBookmarks.js';
 import { fixContinuedLists } from './fixContinuedLists.js';
 import { convertMathMl } from './convertMathMl.js';
+import { mergeCodeBlocks } from './mergeCodeBlocks.js';
 
 export interface PostProcessConfig {
   doc: Node;
@@ -15,9 +16,10 @@ export function getDefaultsPostProcessFilters(
   { doc, filesMap }: PostProcessConfig,
 ): Array<Command> {
   return [
-    convertCodeParagraphsToCodeBlocks,
     removeUnusedBookmarks,
+    convertCodeParagraphsToCodeBlocks,
     fixContinuedLists,
     convertMathMl,
+    mergeCodeBlocks,
   ];
 }

package/src/postprocess/removeUnusedBookmarks.ts

@@ -1,36 +1,49 @@
-import { Fragment, MarkType, Node, Schema } from 'prosemirror-model';
-import { Command } from 'prosemirror-state';
+import type { Node } from 'prosemirror-model';
+import type { 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';
-  }
+  const schema = state.schema;
+  let tr = state.tr;
+
+  const bookmarkNodeType = schema.nodes.node_bookmark;
+  const bookmarkMarkType = schema.marks.bookmark;
 
-  if (node.marks) {
-    // For text nodes, filter out the marks that match the condition
-    const newMarks = node.marks.filter((mark) => !condition(mark));
+  function walk(
+    node: Node,
+    pos = 0,
+    depth = 0,
+  ) {
+    if (node.type === bookmarkNodeType) {
+      console.log('del');
+      tr = tr.delete(
+        tr.mapping.map(pos - 1),
+        tr.mapping.map(pos + node.nodeSize - 1),
+      );
+      return;
+    }
 
-    // If marks were removed, return a new text node with the remaining marks
+    const newMarks = node.marks.filter((mark) =>
+      mark.type !== bookmarkMarkType
+    );
     if (newMarks.length !== node.marks.length) {
-      return node.mark(newMarks);
+      tr = tr.setNodeMarkup(
+        tr.mapping.map(pos),
+        null,
+        null,
+        newMarks,
+      );
     }
 
-    // Otherwise, return the original text node
-    return node;
+    node.forEach((child, offset, index) => {
+      walk(child, pos + offset + 1, depth + 1);
+    });
   }
 
-  // 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);
-  // }
+  walk(state.doc);
 
   if (dispatch) {
     dispatch(tr);
   }
 
-  return tr.steps.length > 0;
+  return tr.docChanged;
 };

package/src/postprocess/urlRewrite.ts

@@ -0,0 +1,95 @@
+import { Node } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+
+import { UrlRewriter } from '@kerebron/editor';
+
+export async function urlRewrite(
+  urlFromRewriter: UrlRewriter,
+  filesMap: Record<string, Uint8Array>,
+  state: EditorState,
+  dispatch: (tr: Transaction) => void,
+): Promise<boolean> {
+  const imageNodes: Array<{ node: Node; pos: number }> = [];
+  state.doc.descendants((node, pos) => {
+    if (node.type.name === 'image') {
+      imageNodes.push({ node, pos });
+    }
+  });
+
+  const linkNodes: Array<{ node: Node; pos: number }> = [];
+  state.doc.descendants((node, pos) => {
+    if (node.marks.find((mark) => mark.type.name === 'link')) {
+      linkNodes.push({ node, pos });
+    }
+  });
+
+  const tr = 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 urlFromRewriter(href, {
+      type: 'A',
+      dest: 'kerebron',
+    });
+    if (href !== linkMark.attrs.href) {
+      const newMarks = node.marks.map((mark) => {
+        if (mark.type.name === 'link') {
+          const markType = state.schema.marks['link'];
+          return markType.create({ ...mark.attrs, href });
+        }
+        return mark;
+      });
+
+      const nodeType = state.schema.nodes[node.type.name];
+      let replaceNode;
+      if (nodeType.isText) {
+        replaceNode = state.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 urlFromRewriter(src, {
+      type: 'IMG',
+      dest: 'kerebron',
+      filesMap,
+    });
+
+    if (src !== node.attrs.src) {
+      const nodeType = state.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,
+      );
+    }
+  }
+  dispatch(tr);
+
+  return tr.docChanged;
+}