@milkdown/preset-gfm 6.5.4 → 7.0.0-next.0

package/src/footnote/definition.ts

@@ -1,187 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-
-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 { wrappingInputRule } 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'
-
-const key = new PluginKey('MILKDOWN_FOOTNOTE_DEF_INPUT')
-export const ModifyFootnoteDef = createCmdKey<string>('ModifyFootnoteDef')
-
-export const footnoteDefinition = createNode((utils) => {
-  const id = 'footnote_definition'
-  const markdownId = 'footnoteDefinition'
-
-  return {
-    id,
-    schema: ctx => ({
-      group: 'block',
-      content: 'block+',
-      defining: true,
-      attrs: {
-        label: {
-          default: '',
-        },
-      },
-      parseDOM: [
-        {
-          tag: `div[data-type="${id}"]`,
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement))
-              throw expectDomTypeError(dom)
-
-            return {
-              label: dom.dataset.label,
-            }
-          },
-          contentElement: 'dd',
-        },
-      ],
-      toDOM: (node) => {
-        const label = node.attrs.label
-        const className = utils.getClassName(node.attrs, 'footnote-definition')
-
-        const dt = document.createElement('dt')
-        dt.textContent = `[${label}]:`
-        dt.onclick = () => {
-          const view = ctx.get(editorViewCtx)
-          const selection = NodeSelection.create(view.state.doc, view.state.selection.from - 2)
-          view.dispatch(view.state.tr.setSelection(selection))
-        }
-
-        const a = document.createElement('a')
-        a.href = `#${getFootnoteRefId(label)}`
-        a.contentEditable = 'false'
-        a.textContent = '↩'
-        a.onmousedown = (e) => {
-          e.preventDefault()
-        }
-
-        return [
-          'div',
-          {
-            'class': className,
-            'data-label': label,
-            'data-type': id,
-            'id': getFootnoteDefId(label),
-          },
-          ['div', { class: 'footnote-definition_content' }, dt, ['dd', 0]],
-          ['div', { class: 'footnote-definition_anchor' }, a],
-        ]
-      },
-      parseMarkdown: {
-        match: ({ type }) => type === markdownId,
-        runner: (state, node, type) => {
-          state
-            .openNode(type, {
-              label: node.label as string,
-            })
-            .next(node.children)
-            .closeNode()
-        },
-      },
-      toMarkdown: {
-        match: node => node.type.name === id,
-        runner: (state, node) => {
-          state
-            .openNode(markdownId, undefined, {
-              label: node.attrs.label,
-              identifier: node.attrs.label,
-            })
-            .next(node.content)
-            .closeNode()
-        },
-      },
-    }),
-    commands: nodeType => [
-      createCmd(ModifyFootnoteDef, (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 true
-      }),
-    ],
-    inputRules: nodeType => [
-      wrappingInputRule(
-        /(?:\[\^)([^:]+)(?::)$/,
-        nodeType,
-        (match) => {
-          const label = match[1] ?? 'footnote'
-          return {
-            label,
-          }
-        },
-        () => false,
-      ),
-    ],
-    prosePlugins: (type, ctx) => {
-      return [
-        new Plugin({
-          key,
-          view: (editorView) => {
-            const inputChipRenderer = utils.themeManager.get<ThemeInputChipType>('input-chip', {
-              width: '12em',
-              placeholder: 'Input Footnote Label',
-              onUpdate: (value) => {
-                ctx.get(commandsCtx).call(ModifyFootnoteDef, 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()
-              }
-            }
-            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/reference.ts

@@ -1,178 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-
-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'
-
-export const ModifyFootnoteRef = createCmdKey<string>('ModifyFootnoteRef')
-const key = new PluginKey('MILKDOWN_FOOTNOTE_REF_INPUT')
-
-export const footnoteReference = createNode((utils) => {
-  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 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
-
-        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 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-export const getFootnoteRefId = (label: string) => `footnote-ref-${label}`
-
-export const getFootnoteDefId = (label: string) => `footnote-def-${label}`

package/src/strike-through.ts

@@ -1,43 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-import { createCmd, createCmdKey } from '@milkdown/core'
-import { toggleMark } from '@milkdown/prose/commands'
-import { createMark, createShortcut } from '@milkdown/utils'
-
-import { SupportedKeys } from './supported-keys'
-
-type Keys = SupportedKeys['StrikeThrough']
-
-export const ToggleStrikeThrough = createCmdKey('ToggleStrikeThrough')
-
-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'),
-    },
-  }
-})

package/src/supported-keys.ts

@@ -1,13 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-import { SupportedKeys as CommonmarkKeys } from '@milkdown/preset-commonmark'
-
-import { SupportedKeys as TableKeys } from './table'
-
-export const 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,20 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-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'
-
-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
-      }

package/src/table/index.ts

@@ -1,13 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-import { BreakTable, InsertTable, NextCell, PrevCell } from './nodes'
-
-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

package/src/table/nodes/index.ts

@@ -1,189 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-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'
-
-export const 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
-
-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()
-            },
-          },
-        },
-      },
-    }),
-    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()]
-    },
-  }
-})