onchain-lexical-markdown 0.0.1

package/src/transformer/instance.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import {HeadingTagType} from '@lexical/rich-text';
+import {
+  $createBaseInstanceNode,
+  $createInstanceHeadingNode,
+  $isInstanceHeadingNode,
+  $isInstanceNode,
+  $isInstanceParagraphNode,
+  $isInstanceTitleNode,
+  InstanceHeadingNode,
+  InstanceNode,
+  InstanceParagraphNode,
+  InstanceTitleNode,
+} from 'onchain-lexical-instance';
+
+import {createBlockNode, ElementTransformer} from '../MarkdownTransformers';
+import {$convertToMarkdownString} from '../toMarkdownString';
+import {TransFormerGather} from '.';
+import {HEADING_REGEX, INS_SYMBOL, INSTANCE_START_REGEX} from './const';
+
+export const InstanceTransformer: ElementTransformer = {
+  dependencies: [InstanceNode],
+  export: (node, exportChildren) => {
+    if (!$isInstanceNode(node)) {
+      return null;
+    }
+    const serialNumber = node.getSerialNumber();
+    const level = serialNumber.split('-');
+    const markdown =
+      `<!--${INS_SYMBOL.repeat(level.length)}-->` +
+      $convertToMarkdownString(TransFormerGather.value, node) +
+      `\n<!---->`;
+    return markdown;
+  },
+  regExp: INSTANCE_START_REGEX,
+  replace: createBlockNode((match) => {
+    return $createBaseInstanceNode();
+  }),
+  type: 'element',
+};
+
+export const InstanceHeadingTransformer: ElementTransformer = {
+  dependencies: [InstanceHeadingNode, InstanceTitleNode, InstanceParagraphNode],
+  export: (node, exportChildren) => {
+    if ($isInstanceParagraphNode(node) && node.isTitle) {
+      const str = $convertToMarkdownString(TransFormerGather.value, node);
+      return str;
+    } else {
+      if (!$isInstanceHeadingNode(node)) {
+        return null;
+      }
+      const level = Number(node.getTag().slice(1));
+      let number = '';
+      const instanceNode = $isInstanceTitleNode(node) && node.getInstanceNode();
+      if (instanceNode && instanceNode.__instance) {
+        number = `${instanceNode.__instance.number} / `;
+      }
+      return '#'.repeat(level) + ' ' + number + exportChildren(node);
+    }
+  },
+  regExp: HEADING_REGEX,
+  replace: createBlockNode((match) => {
+    const tag = ('h' + match[1].length) as HeadingTagType;
+    return $createInstanceHeadingNode(tag);
+  }),
+  type: 'element',
+};

package/src/transformer/levelBasedControl.ts

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import {ElementNode} from 'lexical';
+import {
+  $isInstanceHeadingNode,
+  $isInstanceNode,
+  $isNumberDecoratorNode,
+  Instance,
+} from 'onchain-lexical-instance';
+
+export default class LevelBasedControl {
+  ancestor: Map<number, ElementNode> = new Map();
+  stack: ElementNode[] = [];
+  level1: Set<ElementNode> = new Set();
+  instanceMap?: Map<string, Instance>;
+  get children() {
+    return this.level1;
+  }
+
+  private collectLevel1(level: number, node: ElementNode) {
+    if (level === 1) {
+      this.level1.add(node);
+    }
+    return node;
+  }
+
+  reductionNodeHierarchy({
+    level,
+    isInstanceEnd,
+    nodes,
+  }: {
+    isInstanceEnd: boolean;
+    level: number;
+    nodes: ElementNode[];
+  }) {
+    if (isInstanceEnd) {
+      this.unstack();
+    } else {
+      this.insert(level, nodes);
+    }
+  }
+
+  private insert(level: number, nodes: ElementNode[]) {
+    if (level !== 0) {
+      const node = this.collectLevel1(level, nodes[0]);
+      this.stack.push(node);
+      this.ancestor.set(level, node);
+      const parent = this.ancestor.get(level - 1);
+      if (parent) {
+        parent.append(node);
+      }
+    } else {
+      const current = this.stack[this.stack.length - 1];
+      if (current) {
+        this.initTitle(current, nodes);
+        current.append(...nodes);
+      }
+    }
+  }
+
+  private unstack() {
+    this.stack.pop();
+  }
+
+  private initTitle(node: ElementNode, nodes: ElementNode[]) {
+    if ($isInstanceNode(node) && !node.__instance) {
+      const numberNode = node.getChildAtIndex(1);
+      const titleNode = nodes[0];
+      const title = titleNode.getTextContent().trim();
+      const [number, insDesc] = title.split(' / ');
+      let instance: Instance | undefined;
+      if (this.instanceMap && this.instanceMap.has(number)) {
+        instance = this.instanceMap.get(number)!;
+      } else if (number) {
+        instance = {
+          insDesc,
+          number,
+        } as Instance;
+      }
+      if ($isInstanceHeadingNode(titleNode)) {
+        nodes.shift();
+      }
+      if ($isNumberDecoratorNode(numberNode)) {
+        numberNode.__instance = instance;
+      }
+      node.__instance = instance;
+    }
+  }
+}

package/src/transformer/table.ts

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import {ElementTransformer} from '@lexical/markdown';
+import {
+  $createTableCellNode,
+  $createTableNode,
+  $createTableRowNode,
+  $isTableCellNode,
+  $isTableNode,
+  $isTableRowNode,
+  TableCellHeaderStates,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+} from '@lexical/table';
+import {$isParagraphNode, $isTextNode, LexicalNode} from 'lexical';
+
+import {$convertFromMarkdownString, TransFormerGather} from '..';
+import {$convertToMarkdownString} from '../toMarkdownString';
+
+const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
+const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-*:? ?)+\|\s?$/;
+
+export const TABLE: ElementTransformer = {
+  dependencies: [TableNode, TableRowNode, TableCellNode],
+  export: (node: LexicalNode) => {
+    if (!$isTableNode(node)) {
+      return null;
+    }
+
+    const output: string[] = [];
+
+    for (const row of node.getChildren()) {
+      const rowOutput = [];
+      if (!$isTableRowNode(row)) {
+        continue;
+      }
+
+      let isHeaderRow = false;
+      for (const cell of row.getChildren()) {
+        // It's TableCellNode so it's just to make flow happy
+        if ($isTableCellNode(cell)) {
+          rowOutput.push(
+            $convertToMarkdownString(TransFormerGather.value, cell)
+              .replace(/\n/g, '\\n')
+              .trim(),
+          );
+          if (cell.__headerState === TableCellHeaderStates.ROW) {
+            isHeaderRow = true;
+          }
+        }
+      }
+
+      output.push(`| ${rowOutput.join(' | ')} |`);
+      if (isHeaderRow) {
+        output.push(`| ${rowOutput.map((_) => '---').join(' | ')} |`);
+      }
+    }
+
+    return output.join('\n');
+  },
+  regExp: TABLE_ROW_REG_EXP,
+  replace: (parentNode, _1, match) => {
+    // Header row
+    if (TABLE_ROW_DIVIDER_REG_EXP.test(match[0])) {
+      const table = parentNode.getPreviousSibling();
+      if (!table || !$isTableNode(table)) {
+        return;
+      }
+
+      const rows = table.getChildren();
+      const lastRow = rows[rows.length - 1];
+      if (!lastRow || !$isTableRowNode(lastRow)) {
+        return;
+      }
+
+      // Add header state to row cells
+      lastRow.getChildren().forEach((cell) => {
+        if (!$isTableCellNode(cell)) {
+          return;
+        }
+        cell.setHeaderStyles(
+          TableCellHeaderStates.ROW,
+          TableCellHeaderStates.ROW,
+        );
+      });
+
+      // Remove line
+      parentNode.remove();
+      return;
+    }
+
+    const matchCells = mapToTableCells(match[0]);
+
+    if (matchCells == null) {
+      return;
+    }
+
+    const rows = [matchCells];
+    let sibling = parentNode.getPreviousSibling();
+    let maxCells = matchCells.length;
+
+    while (sibling) {
+      if (!$isParagraphNode(sibling)) {
+        break;
+      }
+
+      if (sibling.getChildrenSize() !== 1) {
+        break;
+      }
+
+      const firstChild = sibling.getFirstChild();
+
+      if (!$isTextNode(firstChild)) {
+        break;
+      }
+
+      const cells = mapToTableCells(firstChild.getTextContent());
+
+      if (cells == null) {
+        break;
+      }
+
+      maxCells = Math.max(maxCells, cells.length);
+      rows.unshift(cells);
+      const previousSibling = sibling.getPreviousSibling();
+      sibling.remove();
+      sibling = previousSibling;
+    }
+
+    const table = $createTableNode();
+
+    for (const cells of rows) {
+      const tableRow = $createTableRowNode();
+      table.append(tableRow);
+
+      for (let i = 0; i < maxCells; i++) {
+        tableRow.append(i < cells.length ? cells[i] : $createTableCell(''));
+      }
+    }
+
+    const previousSibling = parentNode.getPreviousSibling();
+    if (
+      $isTableNode(previousSibling) &&
+      getTableColumnsSize(previousSibling) === maxCells
+    ) {
+      previousSibling.append(...table.getChildren());
+      parentNode.remove();
+    } else {
+      parentNode.replace(table);
+    }
+
+    table.selectEnd();
+  },
+  type: 'element',
+};
+
+function getTableColumnsSize(table: TableNode) {
+  const row = table.getFirstChild();
+  return $isTableRowNode(row) ? row.getChildrenSize() : 0;
+}
+
+const $createTableCell = (textContent: string): TableCellNode => {
+  textContent = textContent.replace(/\\n/g, '\n');
+  const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
+  $convertFromMarkdownString(textContent, TransFormerGather.value, cell);
+  return cell;
+};
+
+const mapToTableCells = (textContent: string): Array<TableCellNode> | null => {
+  const match = textContent.match(TABLE_ROW_REG_EXP);
+  if (!match || !match[1]) {
+    return null;
+  }
+  return match[1].split('|').map((text) => $createTableCell(text));
+};

package/src/transformer/utils.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export function getInstanceLevel(match?: string[] | null) {
+  if (match && match.length) {
+    const level = match[2].length;
+    return {
+      isInstance: true,
+      level,
+    };
+  }
+  return {
+    isInstance: false,
+    level: 0,
+  };
+}