@milkdown/preset-gfm 6.5.2 → 6.5.4

package/src/footnote/reference.ts

@@ -1,174 +1,178 @@
 /* Copyright 2021, Milkdown by Mirone. */
 
-import { commandsCtx, createCmd, createCmdKey, editorViewCtx, ThemeInputChipType } from '@milkdown/core';
-import { expectDomTypeError } from '@milkdown/exception';
-import { findSelectedNodeOfType } from '@milkdown/prose';
-import { InputRule } from '@milkdown/prose/inputrules';
-import { NodeSelection, Plugin, PluginKey } from '@milkdown/prose/state';
-import { EditorView } from '@milkdown/prose/view';
-import { createNode } from '@milkdown/utils';
+import type { ThemeInputChipType } from '@milkdown/core'
+import { commandsCtx, createCmd, createCmdKey, editorViewCtx } from '@milkdown/core'
+import { expectDomTypeError } from '@milkdown/exception'
+import { findSelectedNodeOfType } from '@milkdown/prose'
+import { InputRule } from '@milkdown/prose/inputrules'
+import { NodeSelection, Plugin, PluginKey } from '@milkdown/prose/state'
+import type { EditorView } from '@milkdown/prose/view'
+import { createNode } from '@milkdown/utils'
 
-import { getFootnoteDefId, getFootnoteRefId } from './utils';
+import { getFootnoteDefId, getFootnoteRefId } from './utils'
 
-export const ModifyFootnoteRef = createCmdKey<string>('ModifyFootnoteRef');
-const key = new PluginKey('MILKDOWN_FOOTNOTE_REF_INPUT');
+export const ModifyFootnoteRef = createCmdKey<string>('ModifyFootnoteRef')
+const key = new PluginKey('MILKDOWN_FOOTNOTE_REF_INPUT')
 
 export const footnoteReference = createNode((utils) => {
-    const id = 'footnote_reference';
+  const id = 'footnote_reference'
 
-    return {
-        id,
-        schema: (ctx) => ({
-            group: 'inline',
-            inline: true,
-            atom: true,
-            attrs: {
-                label: {
-                    default: '',
-                },
-            },
-            parseDOM: [
-                {
-                    tag: `sup[data-type="${id}"]`,
-                    getAttrs: (dom) => {
-                        if (!(dom instanceof HTMLElement)) {
-                            throw expectDomTypeError(dom);
-                        }
-                        return {
-                            label: dom.dataset['label'],
-                        };
-                    },
-                },
-            ],
-            toDOM: (node) => {
-                const label = node.attrs['label'];
-                const a = document.createElement('a');
-                const href = `#${getFootnoteDefId(label)}`;
-                a.href = href;
-                a.textContent = `[${label}]`;
-                a.onclick = (e) => {
-                    const view = ctx.get(editorViewCtx);
-                    if (view.editable) {
-                        e.preventDefault();
-                    }
-                };
-                a.ondblclick = () => {
-                    const view = ctx.get(editorViewCtx);
-                    if (view.editable) {
-                        window.location.href = href;
-                    }
-                };
-                return [
-                    'sup',
-                    {
-                        'data-label': label,
-                        'data-type': id,
-                        id: getFootnoteRefId(label),
-                    },
-                    a,
-                ];
-            },
-            parseMarkdown: {
-                match: ({ type }) => type === 'footnoteReference',
-                runner: (state, node, type) => {
-                    state.addNode(type, {
-                        label: node['label'] as string,
-                    });
-                },
-            },
-            toMarkdown: {
-                match: (node) => node.type.name === id,
-                runner: (state, node) => {
-                    state.addNode('footnoteReference', undefined, undefined, {
-                        label: node.attrs['label'],
-                        identifier: node.attrs['label'],
-                    });
-                },
-            },
-        }),
-        commands: (nodeType) => [
-            createCmd(ModifyFootnoteRef, (label = '') => (state, dispatch) => {
-                const node = findSelectedNodeOfType(state.selection, nodeType);
-                if (!node) return false;
-
-                const { tr } = state;
-                const _tr = tr.setNodeMarkup(node.pos, undefined, { ...node.node.attrs, label });
-                dispatch?.(_tr.setSelection(NodeSelection.create(_tr.doc, node.pos)));
+  return {
+    id,
+    schema: ctx => ({
+      group: 'inline',
+      inline: true,
+      atom: true,
+      attrs: {
+        label: {
+          default: '',
+        },
+      },
+      parseDOM: [
+        {
+          tag: `sup[data-type="${id}"]`,
+          getAttrs: (dom) => {
+            if (!(dom instanceof HTMLElement))
+              throw expectDomTypeError(dom)
 
-                return true;
-            }),
-        ],
-        inputRules: (nodeType) => [
-            new InputRule(/(?:\[\^)([^\]]+)(?:\])$/, (state, match, start, end) => {
-                const $start = state.doc.resolve(start);
-                const index = $start.index();
-                const $end = state.doc.resolve(end);
-                if (!$start.parent.canReplaceWith(index, $end.index(), nodeType)) {
-                    return null;
-                }
-                const label = match[1];
-                return state.tr.replaceRangeWith(
-                    start,
-                    end,
-                    nodeType.create({
-                        label,
-                    }),
-                );
-            }),
-        ],
-        prosePlugins: (type, ctx) => {
-            const inputChipRenderer = utils.themeManager.get<ThemeInputChipType>('input-chip', {
-                width: '12em',
-                placeholder: 'Input Footnote Label',
-                onUpdate: (value) => {
-                    ctx.get(commandsCtx).call(ModifyFootnoteRef, value);
-                },
-                isBindMode: true,
-            });
-            if (!inputChipRenderer) return [];
-            const shouldDisplay = (view: EditorView) =>
-                Boolean(type && findSelectedNodeOfType(view.state.selection, type));
-            const getCurrentLabel = (view: EditorView) => {
-                const result = findSelectedNodeOfType(view.state.selection, type);
-                if (!result) return;
+            return {
+              label: dom.dataset.label,
+            }
+          },
+        },
+      ],
+      toDOM: (node) => {
+        const label = node.attrs.label
+        const a = document.createElement('a')
+        const href = `#${getFootnoteDefId(label)}`
+        a.href = href
+        a.textContent = `[${label}]`
+        a.onclick = (e) => {
+          const view = ctx.get(editorViewCtx)
+          if (view.editable)
+            e.preventDefault()
+        }
+        a.ondblclick = () => {
+          const view = ctx.get(editorViewCtx)
+          if (view.editable)
+            window.location.href = href
+        }
+        return [
+          'sup',
+          {
+            'data-label': label,
+            'data-type': id,
+            'id': getFootnoteRefId(label),
+          },
+          a,
+        ]
+      },
+      parseMarkdown: {
+        match: ({ type }) => type === 'footnoteReference',
+        runner: (state, node, type) => {
+          state.addNode(type, {
+            label: node.label as string,
+          })
+        },
+      },
+      toMarkdown: {
+        match: node => node.type.name === id,
+        runner: (state, node) => {
+          state.addNode('footnoteReference', undefined, undefined, {
+            label: node.attrs.label,
+            identifier: node.attrs.label,
+          })
+        },
+      },
+    }),
+    commands: nodeType => [
+      createCmd(ModifyFootnoteRef, (label = '') => (state, dispatch) => {
+        const node = findSelectedNodeOfType(state.selection, nodeType)
+        if (!node)
+          return false
 
-                const value = result.node.attrs['label'];
-                return value;
-            };
-            const renderByView = (view: EditorView) => {
-                if (!view.editable) {
-                    return;
-                }
-                const display = shouldDisplay(view);
-                if (display) {
-                    inputChipRenderer.show(view);
-                    inputChipRenderer.update(getCurrentLabel(view));
-                } else {
-                    inputChipRenderer.hide();
-                }
-            };
-            return [
-                new Plugin({
-                    key,
-                    view: (editorView) => {
-                        inputChipRenderer.init(editorView);
-                        renderByView(editorView);
+        const { tr } = state
+        const _tr = tr.setNodeMarkup(node.pos, undefined, { ...node.node.attrs, label })
+        dispatch?.(_tr.setSelection(NodeSelection.create(_tr.doc, node.pos)))
 
-                        return {
-                            update: (view, prevState) => {
-                                const isEqualSelection =
-                                    prevState?.doc.eq(view.state.doc) && prevState.selection.eq(view.state.selection);
-                                if (isEqualSelection) return;
+        return true
+      }),
+    ],
+    inputRules: nodeType => [
+      new InputRule(/(?:\[\^)([^\]]+)(?:\])$/, (state, match, start, end) => {
+        const $start = state.doc.resolve(start)
+        const index = $start.index()
+        const $end = state.doc.resolve(end)
+        if (!$start.parent.canReplaceWith(index, $end.index(), nodeType))
+          return null
 
-                                renderByView(view);
-                            },
-                            destroy: () => {
-                                inputChipRenderer.destroy();
-                            },
-                        };
-                    },
-                }),
-            ];
+        const label = match[1]
+        return state.tr.replaceRangeWith(
+          start,
+          end,
+          nodeType.create({
+            label,
+          }),
+        )
+      }),
+    ],
+    prosePlugins: (type, ctx) => {
+      const inputChipRenderer = utils.themeManager.get<ThemeInputChipType>('input-chip', {
+        width: '12em',
+        placeholder: 'Input Footnote Label',
+        onUpdate: (value) => {
+          ctx.get(commandsCtx).call(ModifyFootnoteRef, value)
         },
-    };
-});
+        isBindMode: true,
+      })
+      if (!inputChipRenderer)
+        return []
+      const shouldDisplay = (view: EditorView) =>
+        Boolean(type && findSelectedNodeOfType(view.state.selection, type))
+      const getCurrentLabel = (view: EditorView) => {
+        const result = findSelectedNodeOfType(view.state.selection, type)
+        if (!result)
+          return
+
+        const value = result.node.attrs.label
+        return value
+      }
+      const renderByView = (view: EditorView) => {
+        if (!view.editable)
+          return
+
+        const display = shouldDisplay(view)
+        if (display) {
+          inputChipRenderer.show(view)
+          inputChipRenderer.update(getCurrentLabel(view))
+        }
+        else {
+          inputChipRenderer.hide()
+        }
+      }
+      return [
+        new Plugin({
+          key,
+          view: (editorView) => {
+            inputChipRenderer.init(editorView)
+            renderByView(editorView)
+
+            return {
+              update: (view, prevState) => {
+                const isEqualSelection
+                                    = prevState?.doc.eq(view.state.doc) && prevState.selection.eq(view.state.selection)
+                if (isEqualSelection)
+                  return
+
+                renderByView(view)
+              },
+              destroy: () => {
+                inputChipRenderer.destroy()
+              },
+            }
+          },
+        }),
+      ]
+    },
+  }
+})

package/src/footnote/utils.ts

@@ -1,4 +1,4 @@
 /* Copyright 2021, Milkdown by Mirone. */
-export const getFootnoteRefId = (label: string) => `footnote-ref-${label}`;
+export const getFootnoteRefId = (label: string) => `footnote-ref-${label}`
 
-export const getFootnoteDefId = (label: string) => `footnote-def-${label}`;
+export const getFootnoteDefId = (label: string) => `footnote-def-${label}`

package/src/index.ts

@@ -1,93 +1,93 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { commands as commonmarkCommands, commonmark } from '@milkdown/preset-commonmark';
-import { $remark, AtomList } from '@milkdown/utils';
-import remarkGFM from 'remark-gfm';
+import { commonmark, commands as commonmarkCommands } from '@milkdown/preset-commonmark'
+import { $remark, AtomList } from '@milkdown/utils'
+import remarkGFM from 'remark-gfm'
 
-import { footnoteReference } from './footnote';
-import { footnoteDefinition } from './footnote/definition';
-import { strikeThrough, ToggleStrikeThrough } from './strike-through';
-import { table } from './table';
+import { footnoteReference } from './footnote'
+import { footnoteDefinition } from './footnote/definition'
+import { ToggleStrikeThrough, strikeThrough } from './strike-through'
+import { table } from './table'
 import {
-    LiftTaskListItem,
-    SinkTaskListItem,
-    SplitTaskListItem,
-    taskListItem,
-    TurnIntoTaskList,
-} from './task-list-item';
+  LiftTaskListItem,
+  SinkTaskListItem,
+  SplitTaskListItem,
+  TurnIntoTaskList,
+  taskListItem,
+} from './task-list-item'
 
-export * from './footnote';
-export * from './strike-through';
-export { SupportedKeys } from './supported-keys';
+export * from './footnote'
+export * from './strike-through'
+export { SupportedKeys } from './supported-keys'
 export {
-    BreakTable,
-    // command
-    createTable,
-    InsertTable,
-    NextCell,
-    PrevCell,
-    // gather
-    table,
-} from './table';
-export * from './task-list-item';
+  BreakTable,
+  // command
+  createTable,
+  InsertTable,
+  NextCell,
+  PrevCell,
+  // gather
+  table,
+} from './table'
+export * from './task-list-item'
 export {
-    blockquote,
-    bulletList,
-    codeFence,
-    codeInline,
-    commonmark,
-    // gather
-    commonmarkNodes,
-    commonmarkPlugins,
-    // node
-    doc,
-    em,
-    HardbreakFilterPluginKey as hardbreak,
-    heading,
-    hr,
-    image,
-    // command
-    InsertHardbreak,
-    InsertHr,
-    InsertImage,
-    LiftListItem,
-    link,
-    listItem,
-    ModifyImage,
-    ModifyLink,
-    orderedList,
-    paragraph,
-    SinkListItem,
-    SplitListItem,
-    strong,
-    text,
-    ToggleBold,
-    ToggleInlineCode,
-    ToggleItalic,
-    ToggleLink,
-    TurnIntoCodeFence,
-    TurnIntoHeading,
-    TurnIntoText,
-    WrapInBlockquote,
-    WrapInBulletList,
-    WrapInOrderedList,
-} from '@milkdown/preset-commonmark';
+  blockquote,
+  bulletList,
+  codeFence,
+  codeInline,
+  commonmark,
+  // gather
+  commonmarkNodes,
+  commonmarkPlugins,
+  // node
+  doc,
+  em,
+  HardbreakFilterPluginKey as hardbreak,
+  heading,
+  hr,
+  image,
+  // command
+  InsertHardbreak,
+  InsertHr,
+  InsertImage,
+  LiftListItem,
+  link,
+  listItem,
+  ModifyImage,
+  ModifyLink,
+  orderedList,
+  paragraph,
+  SinkListItem,
+  SplitListItem,
+  strong,
+  text,
+  ToggleBold,
+  ToggleInlineCode,
+  ToggleItalic,
+  ToggleLink,
+  TurnIntoCodeFence,
+  TurnIntoHeading,
+  TurnIntoText,
+  WrapInBlockquote,
+  WrapInBulletList,
+  WrapInOrderedList,
+} from '@milkdown/preset-commonmark'
 
 export const gfm = AtomList.create([
-    ...commonmark,
-    $remark(() => remarkGFM),
-    table(),
-    strikeThrough(),
-    taskListItem(),
-    footnoteReference(),
-    footnoteDefinition(),
-]);
+  ...commonmark,
+  $remark(() => remarkGFM),
+  table(),
+  strikeThrough(),
+  taskListItem(),
+  footnoteReference(),
+  footnoteDefinition(),
+])
 
 export const commands = {
-    ...commonmarkCommands,
-    ToggleStrikeThrough,
-    TurnIntoTaskList,
-    SinkTaskListItem,
-    LiftTaskListItem,
-    SplitTaskListItem,
-} as const;
-export type Commands = typeof commands;
+  ...commonmarkCommands,
+  ToggleStrikeThrough,
+  TurnIntoTaskList,
+  SinkTaskListItem,
+  LiftTaskListItem,
+  SplitTaskListItem,
+} as const
+export type Commands = typeof commands

package/src/strike-through.ts

@@ -1,43 +1,43 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { createCmd, createCmdKey } from '@milkdown/core';
-import { toggleMark } from '@milkdown/prose/commands';
-import { createMark, createShortcut } from '@milkdown/utils';
+import { createCmd, createCmdKey } from '@milkdown/core'
+import { toggleMark } from '@milkdown/prose/commands'
+import { createMark, createShortcut } from '@milkdown/utils'
 
-import { SupportedKeys } from './supported-keys';
+import { SupportedKeys } from './supported-keys'
 
-type Keys = SupportedKeys['StrikeThrough'];
+type Keys = SupportedKeys['StrikeThrough']
 
-export const ToggleStrikeThrough = createCmdKey('ToggleStrikeThrough');
+export const ToggleStrikeThrough = createCmdKey('ToggleStrikeThrough')
 
-const id = 'strike_through';
+const id = 'strike_through'
 export const strikeThrough = createMark<Keys>((utils) => {
-    return {
-        id,
-        schema: () => ({
-            inclusive: false,
-            parseDOM: [
-                { tag: 'del' },
-                { style: 'text-decoration', getAttrs: (value) => (value === 'line-through') as false },
-            ],
-            toDOM: (mark) => ['del', { class: utils.getClassName(mark.attrs, 'strike-through') }],
-            parseMarkdown: {
-                match: (node) => node.type === 'delete',
-                runner: (state, node, markType) => {
-                    state.openMark(markType);
-                    state.next(node.children);
-                    state.closeMark(markType);
-                },
-            },
-            toMarkdown: {
-                match: (mark) => mark.type.name === id,
-                runner: (state, mark) => {
-                    state.withMark(mark, 'delete');
-                },
-            },
-        }),
-        commands: (markType) => [createCmd(ToggleStrikeThrough, () => toggleMark(markType))],
-        shortcuts: {
-            [SupportedKeys.StrikeThrough]: createShortcut(ToggleStrikeThrough, 'Mod-Alt-x'),
+  return {
+    id,
+    schema: () => ({
+      inclusive: false,
+      parseDOM: [
+        { tag: 'del' },
+        { style: 'text-decoration', getAttrs: value => (value === 'line-through') as false },
+      ],
+      toDOM: mark => ['del', { class: utils.getClassName(mark.attrs, 'strike-through') }],
+      parseMarkdown: {
+        match: node => node.type === 'delete',
+        runner: (state, node, markType) => {
+          state.openMark(markType)
+          state.next(node.children)
+          state.closeMark(markType)
         },
-    };
-});
+      },
+      toMarkdown: {
+        match: mark => mark.type.name === id,
+        runner: (state, mark) => {
+          state.withMark(mark, 'delete')
+        },
+      },
+    }),
+    commands: markType => [createCmd(ToggleStrikeThrough, () => toggleMark(markType))],
+    shortcuts: {
+      [SupportedKeys.StrikeThrough]: createShortcut(ToggleStrikeThrough, 'Mod-Alt-x'),
+    },
+  }
+})

package/src/supported-keys.ts

@@ -1,12 +1,13 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { SupportedKeys as CommonmarkKeys } from '@milkdown/preset-commonmark';
+import { SupportedKeys as CommonmarkKeys } from '@milkdown/preset-commonmark'
 
-import { SupportedKeys as TableKeys } from './table';
+import { SupportedKeys as TableKeys } from './table'
 
 export const SupportedKeys = {
-    ...CommonmarkKeys,
-    ...TableKeys,
-    StrikeThrough: 'StrikeThrough',
-    TaskList: 'TaskList',
-} as const;
-export type SupportedKeys = typeof SupportedKeys;
+  ...CommonmarkKeys,
+  ...TableKeys,
+  StrikeThrough: 'StrikeThrough',
+  TaskList: 'TaskList',
+} as const
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type SupportedKeys = typeof SupportedKeys

package/src/table/command.ts

@@ -1,19 +1,20 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Node, NodeType } from '@milkdown/prose/model';
-import { Command, Selection } from '@milkdown/prose/state';
+import type { Node, NodeType } from '@milkdown/prose/model'
+import type { Command } from '@milkdown/prose/state'
+import { Selection } from '@milkdown/prose/state'
 
-import { isInTable } from './plugin/util';
+import { isInTable } from './plugin/util'
 
-export const exitTable =
-    (node: NodeType): Command =>
-    (state, dispatch) => {
-        if (!isInTable(state)) {
-            return false;
-        }
-        const { $head } = state.selection;
-        const pos = $head.after();
-        const tr = state.tr.replaceWith(pos, pos, node.createAndFill() as Node);
-        tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));
-        dispatch?.(tr.scrollIntoView());
-        return true;
-    };
+export const exitTable
+    = (node: NodeType): Command =>
+      (state, dispatch) => {
+        if (!isInTable(state))
+          return false
+
+        const { $head } = state.selection
+        const pos = $head.after()
+        const tr = state.tr.replaceWith(pos, pos, node.createAndFill() as Node)
+        tr.setSelection(Selection.near(tr.doc.resolve(pos), 1))
+        dispatch?.(tr.scrollIntoView())
+        return true
+      }