@kerebron/extension-odt 0.5.2 → 0.5.4

package/src/postprocess/mergeCodeBlocks.ts

@@ -0,0 +1,114 @@
+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;
+      }
+
+      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 &&
+        node.attrs.lang !== 'mathml'
+      ) {
+        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);
+
+      let codeText = codeTexts.join('').replace(/\n+$/gm, '\n');
+
+      const lines = codeText.split('\n');
+      let emptyCount = 0;
+      for (emptyCount = 0; emptyCount < lines.length; emptyCount++) {
+        if (lines[emptyCount].trim()) {
+          break;
+        }
+      }
+      lines.splice(0, emptyCount);
+
+      codeText = lines.join('\n');
+
+      const textNode = schema.text(codeText);
+      const codeBlock = schema.nodes.code_block.createAndFill({
+        lang: node.attrs.lang,
+      }, [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,8 @@ import { convertCodeParagraphsToCodeBlocks } from './convertCodeParagraphsToCode
 import { removeUnusedBookmarks } from './removeUnusedBookmarks.js';
 import { fixContinuedLists } from './fixContinuedLists.js';
 import { convertMathMl } from './convertMathMl.js';
+import { mergeCodeBlocks } from './mergeCodeBlocks.js';
+import { fixListsLevels } from './fixListsLevels.js';
 
 export interface PostProcessConfig {
   doc: Node;
@@ -15,9 +17,11 @@ export function getDefaultsPostProcessFilters(
   { doc, filesMap }: PostProcessConfig,
 ): Array<Command> {
   return [
+    // removeUnusedBookmarks,
     convertCodeParagraphsToCodeBlocks,
-    removeUnusedBookmarks,
+    fixListsLevels,
     fixContinuedLists,
     convertMathMl,
+    mergeCodeBlocks,
   ];
 }

package/src/postprocess/removeUnusedBookmarks.ts

@@ -1,36 +1,48 @@
-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) {
+      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;
+}