@milkdown/preset-gfm 6.5.2 → 6.5.4

package/src/table/index.ts

@@ -1,13 +1,13 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { BreakTable, InsertTable, NextCell, PrevCell } from './nodes';
+import { BreakTable, InsertTable, NextCell, PrevCell } from './nodes'
 
-export { BreakTable, InsertTable, NextCell, PrevCell, SupportedKeys, table } from './nodes';
-export { createTable } from './utils';
+export { BreakTable, InsertTable, NextCell, PrevCell, SupportedKeys, table } from './nodes'
+export { createTable } from './utils'
 
 export const commands = {
-    NextCell,
-    PrevCell,
-    BreakTable,
-    InsertTable,
-} as const;
-export type Commands = typeof commands;
+  NextCell,
+  PrevCell,
+  BreakTable,
+  InsertTable,
+} as const
+export type Commands = typeof commands

package/src/table/nodes/index.ts

@@ -1,186 +1,189 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { createCmd, createCmdKey, MarkdownNode, schemaCtx } from '@milkdown/core';
-import { InputRule } from '@milkdown/prose/inputrules';
-import { NodeType } from '@milkdown/prose/model';
-import { Selection, TextSelection } from '@milkdown/prose/state';
-import { createPlugin, createShortcut } from '@milkdown/utils';
+import type { MarkdownNode } from '@milkdown/core'
+import { createCmd, createCmdKey, schemaCtx } from '@milkdown/core'
+import { InputRule } from '@milkdown/prose/inputrules'
+import type { NodeType } from '@milkdown/prose/model'
+import { Selection, TextSelection } from '@milkdown/prose/state'
+import { createPlugin, createShortcut } from '@milkdown/utils'
 
-import { exitTable } from '../command';
-import { operatorPlugin } from '../operator-plugin';
-import { autoInsertZeroSpace } from '../plugin/auto-insert-zero-space';
-import { columnResizing } from '../plugin/column-resizing';
-import { goToNextCell } from '../plugin/commands';
-import { schema } from '../plugin/schema';
-import { tableEditing } from '../plugin/table-editing';
-import { createTable } from '../utils';
+import { exitTable } from '../command'
+import { operatorPlugin } from '../operator-plugin'
+import { autoInsertZeroSpace } from '../plugin/auto-insert-zero-space'
+import { columnResizing } from '../plugin/column-resizing'
+import { goToNextCell } from '../plugin/commands'
+import { schema } from '../plugin/schema'
+import { tableEditing } from '../plugin/table-editing'
+import { createTable } from '../utils'
 
 export const SupportedKeys = {
-    NextCell: 'NextCell',
-    PrevCell: 'PrevCell',
-    ExitTable: 'ExitTable',
-} as const;
-export type SupportedKeys = typeof SupportedKeys;
+  NextCell: 'NextCell',
+  PrevCell: 'PrevCell',
+  ExitTable: 'ExitTable',
+} as const
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type SupportedKeys = typeof SupportedKeys
 
-type Keys = keyof SupportedKeys;
+type Keys = keyof SupportedKeys
 
-export const PrevCell = createCmdKey('PrevCell');
-export const NextCell = createCmdKey('NextCell');
-export const BreakTable = createCmdKey('BreakTable');
-export const InsertTable = createCmdKey('InsertTable');
+export const PrevCell = createCmdKey('PrevCell')
+export const NextCell = createCmdKey('NextCell')
+export const BreakTable = createCmdKey('BreakTable')
+export const InsertTable = createCmdKey('InsertTable')
 
 export const table = createPlugin<Keys, Record<string, unknown>, keyof typeof schema>((utils) => {
-    return {
-        schema: () => ({
-            node: {
-                table: {
-                    ...schema.table,
-                    parseMarkdown: {
-                        match: (node) => node.type === 'table',
-                        runner: (state, node, type) => {
-                            const align = node['align'] as (string | null)[];
-                            const children = (node.children as MarkdownNode[]).map((x, i) => ({
-                                ...x,
-                                align,
-                                isHeader: i === 0,
-                            }));
-                            state.openNode(type);
-                            state.next(children);
-                            state.closeNode();
-                        },
-                    },
-                    toMarkdown: {
-                        match: (node) => node.type.name === 'table',
-                        runner: (state, node) => {
-                            const firstLine = node.content.firstChild?.content;
-                            if (!firstLine) return;
-
-                            const align: (string | null)[] = [];
-                            firstLine.forEach((cell) => {
-                                align.push(cell.attrs['alignment']);
-                            });
-                            state.openNode('table', undefined, { align });
-                            state.next(node.content);
-                            state.closeNode();
-                        },
-                    },
-                },
-                table_row: {
-                    ...schema.table_row,
-                    parseMarkdown: {
-                        match: (node) => node.type === 'tableRow',
-                        runner: (state, node, type) => {
-                            const align = node['align'] as (string | null)[];
-                            const children = (node.children as MarkdownNode[]).map((x, i) => ({
-                                ...x,
-                                align: align[i],
-                                isHeader: node['isHeader'],
-                            }));
-                            state.openNode(type);
-                            state.next(children);
-                            state.closeNode();
-                        },
-                    },
-                    toMarkdown: {
-                        match: (node) => node.type.name === 'table_row',
-                        runner: (state, node) => {
-                            state.openNode('tableRow');
-                            state.next(node.content);
-                            state.closeNode();
-                        },
-                    },
-                },
-                table_cell: {
-                    ...schema.table_cell,
-                    parseMarkdown: {
-                        match: (node) => node.type === 'tableCell' && !node['isHeader'],
-                        runner: (state, node, type) => {
-                            const align = node['align'] as string;
-                            state
-                                .openNode(type, { alignment: align })
-                                .openNode(state.schema.nodes['paragraph'] as NodeType)
-                                .next(node.children)
-                                .closeNode()
-                                .closeNode();
-                        },
-                    },
-                    toMarkdown: {
-                        match: (node) => node.type.name === 'table_cell',
-                        runner: (state, node) => {
-                            state.openNode('tableCell').next(node.content).closeNode();
-                        },
-                    },
-                },
-                table_header: {
-                    ...schema.table_header,
-                    parseMarkdown: {
-                        match: (node) => node.type === 'tableCell' && !!node['isHeader'],
-                        runner: (state, node, type) => {
-                            const align = node['align'] as string;
-                            state.openNode(type, { alignment: align });
-                            state.openNode(state.schema.nodes['paragraph'] as NodeType);
-                            state.next(node.children);
-                            state.closeNode();
-                            state.closeNode();
-                        },
-                    },
-                    toMarkdown: {
-                        match: (node) => node.type.name === 'table_header',
-                        runner: (state, node) => {
-                            state.openNode('tableCell');
-                            state.next(node.content);
-                            state.closeNode();
-                        },
-                    },
-                },
+  return {
+    schema: () => ({
+      node: {
+        table: {
+          ...schema.table,
+          parseMarkdown: {
+            match: node => node.type === 'table',
+            runner: (state, node, type) => {
+              const align = node.align as (string | null)[]
+              const children = (node.children as MarkdownNode[]).map((x, i) => ({
+                ...x,
+                align,
+                isHeader: i === 0,
+              }))
+              state.openNode(type)
+              state.next(children)
+              state.closeNode()
             },
-        }),
-        inputRules: (nodeType, ctx) => [
-            new InputRule(/^\|\|\s$/, (state, _match, start, end) => {
-                const $start = state.doc.resolve(start);
-                if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType.table))
-                    return null;
-
-                const tableNode = createTable(ctx.get(schemaCtx));
-                const tr = state.tr.replaceRangeWith(start, end, tableNode).scrollIntoView();
-                return tr.setSelection(TextSelection.create(tr.doc, start + 3));
-            }),
-            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), nodeType.table))
-                    return null;
+          },
+          toMarkdown: {
+            match: node => node.type.name === 'table',
+            runner: (state, node) => {
+              const firstLine = node.content.firstChild?.content
+              if (!firstLine)
+                return
 
-                const tableNode = createTable(
-                    ctx.get(schemaCtx),
-                    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));
-            }),
-        ],
-        commands: (_, ctx) => [
-            createCmd(PrevCell, () => goToNextCell(-1)),
-            createCmd(NextCell, () => goToNextCell(1)),
-            createCmd(BreakTable, () => exitTable(ctx.get(schemaCtx).nodes['paragraph'] as NodeType)),
-            createCmd(InsertTable, () => (state, dispatch) => {
-                const { selection, tr } = state;
-                const { from } = selection;
-                const table = createTable(ctx.get(schemaCtx));
-                const _tr = tr.replaceSelectionWith(table);
-                const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true);
-                if (sel) {
-                    dispatch?.(_tr.setSelection(sel));
-                }
-                return true;
-            }),
-        ],
-        shortcuts: {
-            [SupportedKeys.NextCell]: createShortcut(NextCell, 'Mod-]'),
-            [SupportedKeys.PrevCell]: createShortcut(PrevCell, 'Mod-['),
-            [SupportedKeys.ExitTable]: createShortcut(BreakTable, 'Mod-Enter'),
+              const align: (string | null)[] = []
+              firstLine.forEach((cell) => {
+                align.push(cell.attrs.alignment)
+              })
+              state.openNode('table', undefined, { align })
+              state.next(node.content)
+              state.closeNode()
+            },
+          },
+        },
+        table_row: {
+          ...schema.table_row,
+          parseMarkdown: {
+            match: node => node.type === 'tableRow',
+            runner: (state, node, type) => {
+              const align = node.align as (string | null)[]
+              const children = (node.children as MarkdownNode[]).map((x, i) => ({
+                ...x,
+                align: align[i],
+                isHeader: node.isHeader,
+              }))
+              state.openNode(type)
+              state.next(children)
+              state.closeNode()
+            },
+          },
+          toMarkdown: {
+            match: node => node.type.name === 'table_row',
+            runner: (state, node) => {
+              state.openNode('tableRow')
+              state.next(node.content)
+              state.closeNode()
+            },
+          },
+        },
+        table_cell: {
+          ...schema.table_cell,
+          parseMarkdown: {
+            match: node => node.type === 'tableCell' && !node.isHeader,
+            runner: (state, node, type) => {
+              const align = node.align as string
+              state
+                .openNode(type, { alignment: align })
+                .openNode(state.schema.nodes.paragraph as NodeType)
+                .next(node.children)
+                .closeNode()
+                .closeNode()
+            },
+          },
+          toMarkdown: {
+            match: node => node.type.name === 'table_cell',
+            runner: (state, node) => {
+              state.openNode('tableCell').next(node.content).closeNode()
+            },
+          },
         },
-        prosePlugins: (_, ctx) => {
-            return [operatorPlugin(ctx, utils), autoInsertZeroSpace(), columnResizing(), tableEditing()];
+        table_header: {
+          ...schema.table_header,
+          parseMarkdown: {
+            match: node => node.type === 'tableCell' && !!node.isHeader,
+            runner: (state, node, type) => {
+              const align = node.align as string
+              state.openNode(type, { alignment: align })
+              state.openNode(state.schema.nodes.paragraph as NodeType)
+              state.next(node.children)
+              state.closeNode()
+              state.closeNode()
+            },
+          },
+          toMarkdown: {
+            match: node => node.type.name === 'table_header',
+            runner: (state, node) => {
+              state.openNode('tableCell')
+              state.next(node.content)
+              state.closeNode()
+            },
+          },
         },
-    };
-});
+      },
+    }),
+    inputRules: (nodeType, ctx) => [
+      new InputRule(/^\|\|\s$/, (state, _match, start, end) => {
+        const $start = state.doc.resolve(start)
+        if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType.table))
+          return null
+
+        const tableNode = createTable(ctx.get(schemaCtx))
+        const tr = state.tr.replaceRangeWith(start, end, tableNode).scrollIntoView()
+        return tr.setSelection(TextSelection.create(tr.doc, start + 3))
+      }),
+      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), nodeType.table))
+          return null
+
+        const tableNode = createTable(
+          ctx.get(schemaCtx),
+          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))
+      }),
+    ],
+    commands: (_, ctx) => [
+      createCmd(PrevCell, () => goToNextCell(-1)),
+      createCmd(NextCell, () => goToNextCell(1)),
+      createCmd(BreakTable, () => exitTable(ctx.get(schemaCtx).nodes.paragraph as NodeType)),
+      createCmd(InsertTable, () => (state, dispatch) => {
+        const { selection, tr } = state
+        const { from } = selection
+        const table = createTable(ctx.get(schemaCtx))
+        const _tr = tr.replaceSelectionWith(table)
+        const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true)
+        if (sel)
+          dispatch?.(_tr.setSelection(sel))
+
+        return true
+      }),
+    ],
+    shortcuts: {
+      [SupportedKeys.NextCell]: createShortcut(NextCell, 'Mod-]'),
+      [SupportedKeys.PrevCell]: createShortcut(PrevCell, 'Mod-['),
+      [SupportedKeys.ExitTable]: createShortcut(BreakTable, 'Mod-Enter'),
+    },
+    prosePlugins: (_, ctx) => {
+      return [operatorPlugin(ctx, utils), autoInsertZeroSpace(), columnResizing(), tableEditing()]
+    },
+  }
+})

package/src/table/operator-plugin/actions.ts

@@ -1,115 +1,116 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Ctx, ThemeIcon, themeManagerCtx } from '@milkdown/core';
-import { Command } from '@milkdown/prose/state';
-import { EditorView } from '@milkdown/prose/view';
+import type { Ctx } from '@milkdown/core'
+import { ThemeIcon, themeManagerCtx } from '@milkdown/core'
+import type { Command } from '@milkdown/prose/state'
+import type { EditorView } from '@milkdown/prose/view'
 
 import {
-    addColumnAfter,
-    addColumnBefore,
-    deleteColumn,
-    deleteRow,
-    deleteTable,
-    isInTable,
-    selectedRect,
-    setCellAttr,
-} from '../plugin';
-import { addRowWithAlignment } from '../utils';
-import { getCellSelection, isFirstRowSelected } from './helper';
+  addColumnAfter,
+  addColumnBefore,
+  deleteColumn,
+  deleteRow,
+  deleteTable,
+  isInTable,
+  selectedRect,
+  setCellAttr,
+} from '../plugin'
+import { addRowWithAlignment } from '../utils'
+import { getCellSelection, isFirstRowSelected } from './helper'
 
-export type Item = {
-    $: HTMLElement;
-    command: (e: Event, view: EditorView) => Command;
-    disable?: (view: EditorView) => boolean;
-};
+export interface Item {
+  $: HTMLElement
+  command: (e: Event, view: EditorView) => Command
+  disable?: (view: EditorView) => boolean
+}
 
 export enum Action {
-    AddColLeft,
-    AddColRight,
-    AddRowTop,
-    AddRowBottom,
-    AlignLeft,
-    AlignCenter,
-    AlignRight,
-    Delete,
+  AddColLeft,
+  AddColRight,
+  AddRowTop,
+  AddRowBottom,
+  AlignLeft,
+  AlignCenter,
+  AlignRight,
+  Delete,
 }
 
-export const createActions: (ctx: Ctx) => Record<Action, Item> = (ctx) => ({
-    [Action.AddColLeft]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'leftArrow')?.dom as HTMLElement,
-        command: () => addColumnBefore,
-        disable: (view) => !getCellSelection(view).isColSelection(),
-    },
-    [Action.AddColRight]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'rightArrow')?.dom as HTMLElement,
-        command: () => addColumnAfter,
-        disable: (view) => !getCellSelection(view).isColSelection(),
-    },
-    [Action.AddRowTop]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'upArrow')?.dom as HTMLElement,
-        command: () => (state, dispatch) => {
-            if (!isInTable(state)) return false;
-            if (dispatch) {
-                const rect = selectedRect(state);
-                dispatch(addRowWithAlignment(state.tr, rect, rect.top));
-            }
-            return true;
-        },
-        disable: (view) =>
-            !getCellSelection(view).isRowSelection() ||
-            getCellSelection(view).$head.parent.type.name === 'table_header',
-    },
-    [Action.AddRowBottom]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'downArrow')?.dom as HTMLElement,
-        command: () => (state, dispatch) => {
-            if (!isInTable(state)) return false;
-            if (dispatch) {
-                const rect = selectedRect(state);
-                dispatch(addRowWithAlignment(state.tr, rect, rect.bottom));
-            }
-            return true;
-        },
-        disable: (view) => !getCellSelection(view).isRowSelection(),
+export const createActions: (ctx: Ctx) => Record<Action, Item> = ctx => ({
+  [Action.AddColLeft]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'leftArrow')?.dom as HTMLElement,
+    command: () => addColumnBefore,
+    disable: view => !getCellSelection(view).isColSelection(),
+  },
+  [Action.AddColRight]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'rightArrow')?.dom as HTMLElement,
+    command: () => addColumnAfter,
+    disable: view => !getCellSelection(view).isColSelection(),
+  },
+  [Action.AddRowTop]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'upArrow')?.dom as HTMLElement,
+    command: () => (state, dispatch) => {
+      if (!isInTable(state))
+        return false
+      if (dispatch) {
+        const rect = selectedRect(state)
+        dispatch(addRowWithAlignment(state.tr, rect, rect.top))
+      }
+      return true
     },
-    [Action.AlignLeft]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'alignLeft')?.dom as HTMLElement,
-        command: () => setCellAttr('alignment', 'left'),
-        disable: (view) => !getCellSelection(view).isColSelection(),
+    disable: view =>
+      !getCellSelection(view).isRowSelection()
+            || getCellSelection(view).$head.parent.type.name === 'table_header',
+  },
+  [Action.AddRowBottom]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'downArrow')?.dom as HTMLElement,
+    command: () => (state, dispatch) => {
+      if (!isInTable(state))
+        return false
+      if (dispatch) {
+        const rect = selectedRect(state)
+        dispatch(addRowWithAlignment(state.tr, rect, rect.bottom))
+      }
+      return true
     },
-    [Action.AlignCenter]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'alignCenter')?.dom as HTMLElement,
-        command: () => setCellAttr('alignment', 'center'),
-        disable: (view) => !getCellSelection(view).isColSelection(),
-    },
-    [Action.AlignRight]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'alignRight')?.dom as HTMLElement,
-        command: () => setCellAttr('alignment', 'right'),
-        disable: (view) => !getCellSelection(view).isColSelection(),
-    },
-    [Action.Delete]: {
-        $: ctx.get(themeManagerCtx).get(ThemeIcon, 'delete')?.dom as HTMLElement,
-        command: (_, view) => {
-            const selection = getCellSelection(view);
-            const isCol = selection.isColSelection();
-            const isRow = selection.isRowSelection();
-            if (isCol && isRow) {
-                return deleteTable;
-            }
+    disable: view => !getCellSelection(view).isRowSelection(),
+  },
+  [Action.AlignLeft]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'alignLeft')?.dom as HTMLElement,
+    command: () => setCellAttr('alignment', 'left'),
+    disable: view => !getCellSelection(view).isColSelection(),
+  },
+  [Action.AlignCenter]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'alignCenter')?.dom as HTMLElement,
+    command: () => setCellAttr('alignment', 'center'),
+    disable: view => !getCellSelection(view).isColSelection(),
+  },
+  [Action.AlignRight]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'alignRight')?.dom as HTMLElement,
+    command: () => setCellAttr('alignment', 'right'),
+    disable: view => !getCellSelection(view).isColSelection(),
+  },
+  [Action.Delete]: {
+    $: ctx.get(themeManagerCtx).get(ThemeIcon, 'delete')?.dom as HTMLElement,
+    command: (_, view) => {
+      const selection = getCellSelection(view)
+      const isCol = selection.isColSelection()
+      const isRow = selection.isRowSelection()
+      if (isCol && isRow)
+        return deleteTable
 
-            if (isCol) {
-                return deleteColumn;
-            }
+      if (isCol)
+        return deleteColumn
+
+      return deleteRow
+    },
+    disable: (view) => {
+      const selection = getCellSelection(view)
+      if (selection.isRowSelection()) {
+        if (selection.isColSelection())
+          return false
 
-            return deleteRow;
-        },
-        disable: (view) => {
-            const selection = getCellSelection(view);
-            if (selection.isRowSelection()) {
-                if (selection.isColSelection()) {
-                    return false;
-                }
-                return isFirstRowSelected(selection);
-            }
-            return false;
-        },
+        return isFirstRowSelected(selection)
+      }
+      return false
     },
-});
+  },
+})