@milkdown/preset-gfm 7.15.1 → 7.15.3

package/lib/index.js

@@ -66,7 +66,10 @@ withMeta(toggleStrikethroughCommand, {
   group: "Strikethrough"
 });
 const strikethroughInputRule = $inputRule((ctx) => {
-  return markRule(/~([^~]+)~$/, strikethroughSchema.type(ctx));
+  return markRule(
+    new RegExp("(?<![\\w:/])(~{1,2})(.+?)\\1(?!\\w|\\/)"),
+    strikethroughSchema.type(ctx)
+  );
 });
 withMeta(strikethroughInputRule, {
   displayName: "InputRule<strikethrough>",
@@ -288,86 +291,45 @@ function findTable($pos) {
     (node) => node.type.spec.tableRole === "table"
   )($pos);
 }
-function getCellsInCol(columnIndex, selection) {
+function getCellsInCol(columnIndexes, selection) {
   const table = findTable(selection.$from);
   if (!table) return void 0;
   const map = TableMap.get(table.node);
-  if (columnIndex < 0 || columnIndex >= map.width) return void 0;
-  return map.cellsInRect({
-    left: columnIndex,
-    right: columnIndex + 1,
-    top: 0,
-    bottom: map.height
-  }).map((pos) => {
-    const node = table.node.nodeAt(pos);
-    if (!node) return void 0;
-    const start = pos + table.start;
-    return {
-      pos: start,
-      start: start + 1,
-      node
-    };
-  }).filter((x) => x != null);
+  const indexes = Array.isArray(columnIndexes) ? columnIndexes : [columnIndexes];
+  return indexes.filter((index) => index >= 0 && index <= map.width - 1).flatMap((index) => {
+    const cells = map.cellsInRect({
+      left: index,
+      right: index + 1,
+      top: 0,
+      bottom: map.height
+    });
+    return cells.map((nodePos) => {
+      const node = table.node.nodeAt(nodePos);
+      const pos = nodePos + table.start;
+      return { pos, start: pos + 1, node, depth: table.depth + 2 };
+    });
+  });
 }
 function getCellsInRow(rowIndex, selection) {
   const table = findTable(selection.$from);
-  if (!table) return void 0;
-  const map = TableMap.get(table.node);
-  if (rowIndex < 0 || rowIndex >= map.height) return void 0;
-  return map.cellsInRect({
-    left: 0,
-    right: map.width,
-    top: rowIndex,
-    bottom: rowIndex + 1
-  }).map((pos) => {
-    const node = table.node.nodeAt(pos);
-    if (!node) return void 0;
-    const start = pos + table.start;
-    return {
-      pos: start,
-      start: start + 1,
-      node
-    };
-  }).filter((x) => x != null);
-}
-function getAllCellsInTable(selection) {
-  const table = findTable(selection.$from);
-  if (!table) return;
-  const map = TableMap.get(table.node);
-  const cells = map.cellsInRect({
-    left: 0,
-    right: map.width,
-    top: 0,
-    bottom: map.height
-  });
-  return cells.map((nodePos) => {
-    const node = table.node.nodeAt(nodePos);
-    const pos = nodePos + table.start;
-    return { pos, start: pos + 1, node };
-  });
-}
-function selectTable(tr) {
-  const cells = getAllCellsInTable(tr.selection);
-  if (cells && cells[0]) {
-    const $firstCell = tr.doc.resolve(cells[0].pos);
-    const last = cells[cells.length - 1];
-    if (last) {
-      const $lastCell = tr.doc.resolve(last.pos);
-      return cloneTr(tr.setSelection(new CellSelection($lastCell, $firstCell)));
-    }
+  if (!table) {
+    return;
   }
-  return tr;
-}
-function addRowWithAlignment(ctx, tr, { map, tableStart, table }, row) {
-  const rowPos = Array(row).fill(0).reduce((acc, _, i) => {
-    return acc + table.child(i).nodeSize;
-  }, tableStart);
-  const cells = Array(map.width).fill(0).map((_, col) => {
-    const headerCol = table.nodeAt(map.map[col]);
-    return tableCellSchema.type(ctx).createAndFill({ alignment: headerCol?.attrs.alignment });
+  const map = TableMap.get(table.node);
+  const indexes = Array.isArray(rowIndex) ? rowIndex : [rowIndex];
+  return indexes.filter((index) => index >= 0 && index <= map.height - 1).flatMap((index) => {
+    const cells = map.cellsInRect({
+      left: 0,
+      right: map.width,
+      top: index,
+      bottom: index + 1
+    });
+    return cells.map((nodePos) => {
+      const node = table.node.nodeAt(nodePos);
+      const pos = nodePos + table.start;
+      return { pos, start: pos + 1, node, depth: table.depth + 2 };
+    });
   });
-  tr.insert(rowPos, tableRowSchema.type(ctx).create(null, cells));
-  return tr;
 }
 function selectLine(type) {
   return (index, pos) => (tr) => {
@@ -409,12 +371,18 @@ function selectLine(type) {
 }
 const selectRow = selectLine("row");
 const selectCol = selectLine("col");
-function transpose(array) {
-  return array[0].map((_, i) => {
-    return array.map((column) => column[i]);
+function addRowWithAlignment(ctx, tr, { map, tableStart, table }, row) {
+  const rowPos = Array(row).fill(0).reduce((acc, _, i) => {
+    return acc + table.child(i).nodeSize;
+  }, tableStart);
+  const cells = Array(map.width).fill(0).map((_, col) => {
+    const headerCol = table.nodeAt(map.map[col]);
+    return tableCellSchema.type(ctx).createAndFill({ alignment: headerCol?.attrs.alignment });
   });
+  tr.insert(rowPos, tableRowSchema.type(ctx).create(null, cells));
+  return tr;
 }
-function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
+function convertRowsToTable(tableNode, arrayOfNodes) {
   const rowsPM = [];
   const map = TableMap.get(tableNode);
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
@@ -441,27 +409,108 @@ function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
   );
   return newTable;
 }
-function convertTableNodeToArrayOfRows(tableNode) {
+function convertTableToRows(tableNode) {
   const map = TableMap.get(tableNode);
   const rows = [];
-  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
-    const rowCells = [];
-    const seen = {};
-    for (let colIndex = 0; colIndex < map.width; colIndex++) {
-      const cellPos = map.map[rowIndex * map.width + colIndex];
-      const cell = tableNode.nodeAt(cellPos);
-      const rect = map.findCell(cellPos);
-      if (seen[cellPos] || rect.top !== rowIndex) {
-        rowCells.push(null);
-        continue;
+  const rowCount = map.height;
+  const colCount = map.width;
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    const row = [];
+    for (let colIndex = 0; colIndex < colCount; colIndex++) {
+      let cellIndex = rowIndex * colCount + colIndex;
+      let cellPos = map.map[cellIndex];
+      if (rowIndex > 0) {
+        const topCellIndex = cellIndex - colCount;
+        const topCellPos = map.map[topCellIndex];
+        if (cellPos === topCellPos) {
+          row.push(null);
+          continue;
+        }
+      }
+      if (colIndex > 0) {
+        const leftCellIndex = cellIndex - 1;
+        const leftCellPos = map.map[leftCellIndex];
+        if (cellPos === leftCellPos) {
+          row.push(null);
+          continue;
+        }
+      }
+      if (!cellPos) {
+        row.push(null);
+      } else {
+        row.push(tableNode.nodeAt(cellPos));
       }
-      seen[cellPos] = true;
-      rowCells.push(cell);
     }
-    rows.push(rowCells);
+    rows.push(row);
   }
   return rows;
 }
+function getSelectionRangeInRow(tr, startRowIndex, endRowIndex = startRowIndex) {
+  let startIndex = startRowIndex;
+  let endIndex = endRowIndex;
+  for (let i = startRowIndex; i >= 0; i--) {
+    const cells = getCellsInRow(i, tr.selection);
+    if (cells) {
+      cells.forEach((cell) => {
+        const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
+        if (maybeEndIndex >= startIndex) {
+          startIndex = i;
+        }
+        if (maybeEndIndex > endIndex) {
+          endIndex = maybeEndIndex;
+        }
+      });
+    }
+  }
+  for (let i = startRowIndex; i <= endIndex; i++) {
+    const cells = getCellsInRow(i, tr.selection);
+    if (cells) {
+      cells.forEach((cell) => {
+        const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
+        if (cell.node.attrs.rowspan > 1 && maybeEndIndex > endIndex) {
+          endIndex = maybeEndIndex;
+        }
+      });
+    }
+  }
+  const indexes = [];
+  for (let i = startIndex; i <= endIndex; i++) {
+    const maybeCells = getCellsInRow(i, tr.selection);
+    if (maybeCells && maybeCells.length > 0) {
+      indexes.push(i);
+    }
+  }
+  startIndex = indexes[0];
+  endIndex = indexes[indexes.length - 1];
+  const firstSelectedRowCells = getCellsInRow(startIndex, tr.selection);
+  const firstColumnCells = getCellsInCol(0, tr.selection);
+  if (!firstSelectedRowCells || !firstColumnCells) {
+    return;
+  }
+  const $anchor = tr.doc.resolve(
+    firstSelectedRowCells[firstSelectedRowCells.length - 1].pos
+  );
+  let headCell;
+  for (let i = endIndex; i >= startIndex; i--) {
+    const rowCells = getCellsInRow(i, tr.selection);
+    if (rowCells && rowCells.length > 0) {
+      for (let j = firstColumnCells.length - 1; j >= 0; j--) {
+        if (firstColumnCells[j].pos === rowCells[0].pos) {
+          headCell = rowCells[0];
+          break;
+        }
+      }
+      if (headCell) {
+        break;
+      }
+    }
+  }
+  if (!headCell) {
+    return;
+  }
+  const $head = tr.doc.resolve(headCell.pos);
+  return { $anchor, $head, indexes };
+}
 function moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, directionOverride) {
   const direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
   const rowsExtracted = rows.splice(indexesOrigin[0], indexesOrigin.length);
@@ -473,168 +522,165 @@ function moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, directionOverr
   rows.splice(target, 0, ...rowsExtracted);
   return rows;
 }
-function moveTableColumn(table, indexesOrigin, indexesTarget, direction) {
-  let rows = transpose(convertTableNodeToArrayOfRows(table.node));
-  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget);
-  rows = transpose(rows);
-  return convertArrayOfRowsToTableNode(table.node, rows);
+function moveRow(moveRowParams) {
+  const { tr, origin, target, select, pos } = moveRowParams;
+  const $pos = tr.doc.resolve(pos);
+  const table = findTable($pos);
+  if (!table) return false;
+  const indexesOriginRow = getSelectionRangeInRow(tr, origin)?.indexes;
+  const indexesTargetRow = getSelectionRangeInRow(tr, target)?.indexes;
+  if (!indexesOriginRow || !indexesTargetRow) return false;
+  if (indexesOriginRow.includes(target)) return false;
+  const newTable = moveTableRow(
+    table.node,
+    indexesOriginRow,
+    indexesTargetRow
+  );
+  tr.replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
+  if (!select) return true;
+  const map = TableMap.get(newTable);
+  const start = table.start;
+  const index = target;
+  const lastCell = map.positionAt(index, map.width - 1, newTable);
+  const $lastCell = tr.doc.resolve(start + lastCell);
+  const firstCell = map.positionAt(index, 0, newTable);
+  const $firstCell = tr.doc.resolve(start + firstCell);
+  tr.setSelection(CellSelection.rowSelection($lastCell, $firstCell));
+  return true;
 }
 function moveTableRow(table, indexesOrigin, indexesTarget, direction) {
-  let rows = convertTableNodeToArrayOfRows(table.node);
+  let rows = convertTableToRows(table);
   rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget);
-  return convertArrayOfRowsToTableNode(table.node, rows);
+  return convertRowsToTable(table, rows);
 }
-function getSelectionRangeInColumn(columnIndex, tr) {
-  let startIndex = columnIndex;
-  let endIndex = columnIndex;
-  for (let i = columnIndex; i >= 0; i--) {
+function getSelectionRangeInCol(tr, startColIndex, endColIndex = startColIndex) {
+  let startIndex = startColIndex;
+  let endIndex = endColIndex;
+  for (let i = startColIndex; i >= 0; i--) {
     const cells = getCellsInCol(i, tr.selection);
     if (cells) {
       cells.forEach((cell) => {
         const maybeEndIndex = cell.node.attrs.colspan + i - 1;
-        if (maybeEndIndex >= startIndex) startIndex = i;
-        if (maybeEndIndex > endIndex) endIndex = maybeEndIndex;
+        if (maybeEndIndex >= startIndex) {
+          startIndex = i;
+        }
+        if (maybeEndIndex > endIndex) {
+          endIndex = maybeEndIndex;
+        }
       });
     }
   }
-  for (let i = columnIndex; i <= endIndex; i++) {
+  for (let i = startColIndex; i <= endIndex; i++) {
     const cells = getCellsInCol(i, tr.selection);
     if (cells) {
       cells.forEach((cell) => {
         const maybeEndIndex = cell.node.attrs.colspan + i - 1;
-        if (cell.node.attrs.colspan > 1 && maybeEndIndex > endIndex)
+        if (cell.node.attrs.colspan > 1 && maybeEndIndex > endIndex) {
           endIndex = maybeEndIndex;
+        }
       });
     }
   }
   const indexes = [];
   for (let i = startIndex; i <= endIndex; i++) {
     const maybeCells = getCellsInCol(i, tr.selection);
-    if (maybeCells && maybeCells.length) indexes.push(i);
+    if (maybeCells && maybeCells.length > 0) {
+      indexes.push(i);
+    }
   }
   startIndex = indexes[0];
   endIndex = indexes[indexes.length - 1];
   const firstSelectedColumnCells = getCellsInCol(startIndex, tr.selection);
   const firstRowCells = getCellsInRow(0, tr.selection);
+  if (!firstSelectedColumnCells || !firstRowCells) {
+    return;
+  }
   const $anchor = tr.doc.resolve(
     firstSelectedColumnCells[firstSelectedColumnCells.length - 1].pos
   );
   let headCell;
   for (let i = endIndex; i >= startIndex; i--) {
     const columnCells = getCellsInCol(i, tr.selection);
-    if (columnCells && columnCells.length) {
+    if (columnCells && columnCells.length > 0) {
       for (let j = firstRowCells.length - 1; j >= 0; j--) {
         if (firstRowCells[j].pos === columnCells[0].pos) {
           headCell = columnCells[0];
           break;
         }
       }
-      if (headCell) break;
-    }
-  }
-  const $head = tr.doc.resolve(headCell.pos);
-  return { $anchor, $head, indexes };
-}
-function getSelectionRangeInRow(rowIndex, tr) {
-  let startIndex = rowIndex;
-  let endIndex = rowIndex;
-  for (let i = rowIndex; i >= 0; i--) {
-    const cells = getCellsInRow(i, tr.selection);
-    cells.forEach((cell) => {
-      const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
-      if (maybeEndIndex >= startIndex) startIndex = i;
-      if (maybeEndIndex > endIndex) endIndex = maybeEndIndex;
-    });
-  }
-  for (let i = rowIndex; i <= endIndex; i++) {
-    const cells = getCellsInRow(i, tr.selection);
-    cells.forEach((cell) => {
-      const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
-      if (cell.node.attrs.rowspan > 1 && maybeEndIndex > endIndex)
-        endIndex = maybeEndIndex;
-    });
-  }
-  const indexes = [];
-  for (let i = startIndex; i <= endIndex; i++) {
-    const maybeCells = getCellsInRow(i, tr.selection);
-    if (maybeCells && maybeCells.length) indexes.push(i);
-  }
-  startIndex = indexes[0];
-  endIndex = indexes[indexes.length - 1];
-  const firstSelectedRowCells = getCellsInRow(startIndex, tr.selection);
-  const firstColumnCells = getCellsInCol(0, tr.selection);
-  const $anchor = tr.doc.resolve(
-    firstSelectedRowCells[firstSelectedRowCells.length - 1].pos
-  );
-  let headCell;
-  for (let i = endIndex; i >= startIndex; i--) {
-    const rowCells = getCellsInRow(i, tr.selection);
-    if (rowCells && rowCells.length) {
-      for (let j = firstColumnCells.length - 1; j >= 0; j--) {
-        if (firstColumnCells[j].pos === rowCells[0].pos) {
-          headCell = rowCells[0];
-          break;
-        }
+      if (headCell) {
+        break;
       }
-      if (headCell) break;
     }
   }
+  if (!headCell) {
+    return;
+  }
   const $head = tr.doc.resolve(headCell.pos);
   return { $anchor, $head, indexes };
 }
+function transpose(array) {
+  return array[0].map((_, i) => array.map((column) => column[i]));
+}
 function moveCol(moveColParams) {
-  const { tr, origin, target, select = true, pos } = moveColParams;
-  const $pos = pos != null ? tr.doc.resolve(pos) : tr.selection.$from;
+  const { tr, origin, target, select, pos } = moveColParams;
+  const $pos = tr.doc.resolve(pos);
   const table = findTable($pos);
-  if (!table) return tr;
-  const { indexes: indexesOriginColumn } = getSelectionRangeInColumn(origin, tr);
-  const { indexes: indexesTargetColumn } = getSelectionRangeInColumn(target, tr);
-  if (indexesOriginColumn.includes(target)) return tr;
-  const newTable = moveTableColumn(
-    table,
+  if (!table) return false;
+  const indexesOriginColumn = getSelectionRangeInCol(tr, origin)?.indexes;
+  const indexesTargetColumn = getSelectionRangeInCol(tr, target)?.indexes;
+  if (!indexesOriginColumn || !indexesTargetColumn) return false;
+  if (indexesOriginColumn.includes(target)) return false;
+  const newTable = moveTableCol(
+    table.node,
     indexesOriginColumn,
     indexesTargetColumn
   );
-  const _tr = cloneTr(tr).replaceWith(
-    table.pos,
-    table.pos + table.node.nodeSize,
-    newTable
-  );
-  if (!select) return _tr;
+  tr.replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
+  if (!select) return true;
   const map = TableMap.get(newTable);
   const start = table.start;
   const index = target;
   const lastCell = map.positionAt(map.height - 1, index, newTable);
-  const $lastCell = _tr.doc.resolve(start + lastCell);
-  const createCellSelection = CellSelection.colSelection;
+  const $lastCell = tr.doc.resolve(start + lastCell);
   const firstCell = map.positionAt(0, index, newTable);
-  const $firstCell = _tr.doc.resolve(start + firstCell);
-  return _tr.setSelection(createCellSelection($lastCell, $firstCell));
+  const $firstCell = tr.doc.resolve(start + firstCell);
+  tr.setSelection(CellSelection.colSelection($lastCell, $firstCell));
+  return true;
 }
-function moveRow(moveRowParams) {
-  const { tr, origin, target, select = true, pos } = moveRowParams;
-  const $pos = pos != null ? tr.doc.resolve(pos) : tr.selection.$from;
-  const table = findTable($pos);
-  if (!table) return tr;
-  const { indexes: indexesOriginRow } = getSelectionRangeInRow(origin, tr);
-  const { indexes: indexesTargetRow } = getSelectionRangeInRow(target, tr);
-  if (indexesOriginRow.includes(target)) return tr;
-  const newTable = moveTableRow(table, indexesOriginRow, indexesTargetRow);
-  const _tr = cloneTr(tr).replaceWith(
-    table.pos,
-    table.pos + table.node.nodeSize,
-    newTable
-  );
-  if (!select) return _tr;
-  const map = TableMap.get(newTable);
-  const start = table.start;
-  const index = target;
-  const lastCell = map.positionAt(index, map.width - 1, newTable);
-  const $lastCell = _tr.doc.resolve(start + lastCell);
-  const createCellSelection = CellSelection.rowSelection;
-  const firstCell = map.positionAt(index, 0, newTable);
-  const $firstCell = _tr.doc.resolve(start + firstCell);
-  return _tr.setSelection(createCellSelection($lastCell, $firstCell));
+function moveTableCol(table, indexesOrigin, indexesTarget, direction) {
+  let rows = transpose(convertTableToRows(table));
+  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget);
+  rows = transpose(rows);
+  return convertRowsToTable(table, rows);
+}
+function getAllCellsInTable(selection) {
+  const table = findTable(selection.$from);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  const cells = map.cellsInRect({
+    left: 0,
+    right: map.width,
+    top: 0,
+    bottom: map.height
+  });
+  return cells.map((nodePos) => {
+    const node = table.node.nodeAt(nodePos);
+    const pos = nodePos + table.start;
+    return { pos, start: pos + 1, node };
+  });
+}
+function selectTable(tr) {
+  const cells = getAllCellsInTable(tr.selection);
+  if (cells && cells[0]) {
+    const $firstCell = tr.doc.resolve(cells[0].pos);
+    const last = cells[cells.length - 1];
+    if (last) {
+      const $lastCell = tr.doc.resolve(last.pos);
+      return cloneTr(tr.setSelection(new CellSelection($lastCell, $firstCell)));
+    }
+  }
+  return tr;
 }
 const goToPrevTableCellCommand = $command(
   "GoToPrevTableCell",
@@ -695,10 +741,17 @@ const moveRowCommand = $command(
   "MoveRow",
   () => ({ from, to, pos } = {}) => (state, dispatch) => {
     const { tr } = state;
-    const result = dispatch?.(
-      moveRow({ tr, origin: from ?? 0, target: to ?? 0, pos, select: true })
-    );
-    return Boolean(result);
+    if (moveRow({
+      tr,
+      origin: from ?? 0,
+      target: to ?? 0,
+      pos: pos ?? state.selection.from,
+      select: true
+    })) {
+      dispatch?.(tr);
+      return true;
+    }
+    return false;
   }
 );
 withMeta(moveRowCommand, {
@@ -709,10 +762,17 @@ const moveColCommand = $command(
   "MoveCol",
   () => ({ from, to, pos } = {}) => (state, dispatch) => {
     const { tr } = state;
-    const result = dispatch?.(
-      moveCol({ tr, origin: from ?? 0, target: to ?? 0, pos, select: true })
-    );
-    return Boolean(result);
+    if (moveCol({
+      tr,
+      origin: from ?? 0,
+      target: to ?? 0,
+      pos: pos ?? state.selection.from,
+      select: true
+    })) {
+      dispatch?.(tr);
+      return true;
+    }
+    return false;
   }
 );
 withMeta(moveColCommand, {