@milkdown/preset-gfm 7.2.3 → 7.3.0

package/src/node/table/index.ts

@@ -175,18 +175,19 @@ withMeta(tableHeaderSchema.ctx, {
 
 /// A input rule for creating table.
 /// For example, `|2x2|` will create a 2x2 table.
-export const insertTableInputRule = $inputRule(() => new InputRule(
+export const insertTableInputRule = $inputRule(ctx => new InputRule(
   /^\|(?<col>\d+)[xX](?<row>\d+)\|\s$/, (state, match, start, end) => {
     const $start = state.doc.resolve(start)
-    if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), tableSchema.type()))
+    if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), tableSchema.type(ctx)))
       return null
 
     const tableNode = createTable(
+      ctx,
       Number(match.groups?.row),
       Number(match.groups?.col),
     )
-    const tr = state.tr.replaceRangeWith(start, end, tableNode).scrollIntoView()
-    return tr.setSelection(TextSelection.create(tr.doc, start + 3))
+    const tr = state.tr.replaceRangeWith(start, end, tableNode)
+    return tr.setSelection(TextSelection.create(tr.doc, start + 3)).scrollIntoView()
   },
 ))
 
@@ -214,14 +215,14 @@ withMeta(goToNextTableCellCommand, {
 /// A command for splitting current table into two tables.
 /// If the selection is at the end of the table,
 /// it will just quit the table and insert a new paragraph node.
-export const breakTableCommand = $command('BreakTable', () => () => (state, dispatch) => {
+export const breakTableCommand = $command('BreakTable', ctx => () => (state, dispatch) => {
   if (!isInTable(state))
     return false
 
   const { $head } = state.selection
   const pos = $head.after()
   const tr = state.tr
-    .replaceWith(pos, pos, paragraphSchema.type().createAndFill()!)
+    .replaceWith(pos, pos, paragraphSchema.type(ctx).createAndFill()!)
 
   tr.setSelection(Selection.near(tr.doc.resolve(pos), 1)).scrollIntoView()
   dispatch?.(tr)
@@ -236,14 +237,16 @@ withMeta(breakTableCommand, {
 /// A command for inserting a table.
 /// You can specify the number of rows and columns.
 /// By default, it will insert a 3x3 table.
-export const insertTableCommand = $command('InsertTable', () => ({ row, col }: { row?: number; col?: number } = {}) => (state, dispatch) => {
+export const insertTableCommand = $command('InsertTable', ctx => ({ row, col }: { row?: number; col?: number } = {}) => (state, dispatch) => {
   const { selection, tr } = state
   const { from } = selection
-  const table = createTable(row, col)
+  const table = createTable(ctx, row, col)
   const _tr = tr.replaceSelectionWith(table)
   const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true)
   if (sel)
-    dispatch?.(_tr.setSelection(sel))
+    _tr.setSelection(sel)
+
+  dispatch?.(_tr)
 
   return true
 })
@@ -363,12 +366,12 @@ withMeta(addColAfterCommand, {
 })
 
 /// A command for adding a row before the current row.
-export const addRowBeforeCommand = $command('AddRowBefore', () => () => (state, dispatch) => {
+export const addRowBeforeCommand = $command('AddRowBefore', ctx => () => (state, dispatch) => {
   if (!isInTable(state))
     return false
   if (dispatch) {
     const rect = selectedRect(state)
-    dispatch(addRowWithAlignment(state.tr, rect, rect.top))
+    dispatch(addRowWithAlignment(ctx, state.tr, rect, rect.top))
   }
   return true
 })
@@ -379,12 +382,12 @@ withMeta(addRowBeforeCommand, {
 })
 
 /// A command for adding a row after the current row.
-export const addRowAfterCommand = $command('AddRowAfter', () => () => (state, dispatch) => {
+export const addRowAfterCommand = $command('AddRowAfter', ctx => () => (state, dispatch) => {
   if (!isInTable(state))
     return false
   if (dispatch) {
     const rect = selectedRect(state)
-    dispatch(addRowWithAlignment(state.tr, rect, rect.bottom))
+    dispatch(addRowWithAlignment(ctx, state.tr, rect, rect.bottom))
   }
   return true
 })

package/src/node/table/utils.ts

@@ -7,6 +7,7 @@ import type { Selection, Transaction } from '@milkdown/prose/state'
 import type { TableRect } from '@milkdown/prose/tables'
 import { CellSelection, TableMap } from '@milkdown/prose/tables'
 
+import type { Ctx } from '@milkdown/ctx'
 import { tableCellSchema, tableHeaderSchema, tableRowSchema, tableSchema } from '.'
 
 /// @internal
@@ -17,20 +18,20 @@ export interface CellPos {
 }
 
 /// @internal
-export const createTable = (rowsCount = 3, colsCount = 3): Node => {
+export const createTable = (ctx: Ctx, rowsCount = 3, colsCount = 3): Node => {
   const cells = Array(colsCount)
     .fill(0)
-    .map(() => tableCellSchema.type().createAndFill()!)
+    .map(() => tableCellSchema.type(ctx).createAndFill()!)
 
   const headerCells = Array(colsCount)
     .fill(0)
-    .map(() => tableHeaderSchema.type().createAndFill()!)
+    .map(() => tableHeaderSchema.type(ctx).createAndFill()!)
 
   const rows = Array(rowsCount)
     .fill(0)
-    .map((_, i) => tableRowSchema.type().create(null, i === 0 ? headerCells : cells))
+    .map((_, i) => tableRowSchema.type(ctx).create(null, i === 0 ? headerCells : cells))
 
-  return tableSchema.type().create(null, rows)
+  return tableSchema.type(ctx).create(null, rows)
 }
 
 /// Find the table node with position information for current selection.
@@ -122,7 +123,7 @@ export const selectTable = (tr: Transaction) => {
 }
 
 /// @internal
-export function addRowWithAlignment(tr: Transaction, { map, tableStart, table }: TableRect, row: number) {
+export function addRowWithAlignment(ctx: Ctx, tr: Transaction, { map, tableStart, table }: TableRect, row: number) {
   const rowPos = Array(row)
     .fill(0)
     .reduce((acc, _, i) => {
@@ -133,10 +134,10 @@ export function addRowWithAlignment(tr: Transaction, { map, tableStart, table }:
     .fill(0)
     .map((_, col) => {
       const headerCol = table.nodeAt(map.map[col] as number)
-      return tableCellSchema.type().createAndFill({ alignment: headerCol?.attrs.alignment }) as Node
+      return tableCellSchema.type(ctx).createAndFill({ alignment: headerCol?.attrs.alignment }) as Node
     })
 
-  tr.insert(rowPos, tableRowSchema.type().create(null, cells))
+  tr.insert(rowPos, tableRowSchema.type(ctx).create(null, cells))
   return tr
 }
 

package/src/plugin/auto-insert-zero-space-plugin.ts

@@ -9,10 +9,10 @@ import { withMeta } from '../__internal__'
 
 /// This plugin is used to fix the bug of IME composing in table in Safari browser.
 /// original discussion in https://discuss.prosemirror.net/t/ime-composing-problems-on-td-or-th-element-in-safari-browser/4501
-export const autoInsertZeroSpaceInTablePlugin = $prose(() => {
+export const autoInsertZeroSpaceInTablePlugin = $prose((ctx) => {
   const pluginKey = new PluginKey('MILKDOWN_AUTO_INSERT_ZERO_SPACE')
 
-  const isParagraph = (node: Node) => node.type === paragraphSchema.type()
+  const isParagraph = (node: Node) => node.type === paragraphSchema.type(ctx)
 
   const isEmptyParagraph = (node: Node) => isParagraph(node) && node.nodeSize === 2
 

package/src/plugin/remark-gfm-plugin.ts

@@ -4,9 +4,14 @@ import remarkGFM from 'remark-gfm'
 import { withMeta } from '../__internal__'
 
 /// This plugin is wrapping the [remark-gfm](https://github.com/remarkjs/remark-gfm).
-export const remarkGFMPlugin = $remark(() => remarkGFM)
+export const remarkGFMPlugin = $remark('remarkGFM', () => remarkGFM)
 
-withMeta(remarkGFMPlugin, {
+withMeta(remarkGFMPlugin.plugin, {
   displayName: 'Remark<remarkGFMPlugin>',
   group: 'Remark',
 })
+
+withMeta(remarkGFMPlugin.options, {
+  displayName: 'RemarkConfig<remarkGFMPlugin>',
+  group: 'Remark',
+})