@milkdown/preset-commonmark 6.5.2 → 6.5.3

package/src/node/list-item.ts

@@ -1,158 +1,157 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { createCmd, createCmdKey } from '@milkdown/core';
-import { expectDomTypeError } from '@milkdown/exception';
-import { getNodeFromSchema } from '@milkdown/prose';
-import { wrappingInputRule } from '@milkdown/prose/inputrules';
-import { NodeType } from '@milkdown/prose/model';
-import { liftListItem, sinkListItem, splitListItem } from '@milkdown/prose/schema-list';
-import { EditorState, Plugin, PluginKey, Transaction } from '@milkdown/prose/state';
-import { createNode, createShortcut } from '@milkdown/utils';
+import { createCmd, createCmdKey } from '@milkdown/core'
+import { expectDomTypeError } from '@milkdown/exception'
+import { getNodeFromSchema } from '@milkdown/prose'
+import { wrappingInputRule } from '@milkdown/prose/inputrules'
+import type { NodeType } from '@milkdown/prose/model'
+import { liftListItem, sinkListItem, splitListItem } from '@milkdown/prose/schema-list'
+import type { EditorState, Transaction } from '@milkdown/prose/state'
+import { Plugin, PluginKey } from '@milkdown/prose/state'
+import { createNode, createShortcut } from '@milkdown/utils'
 
-import { SupportedKeys } from '../supported-keys';
+import { SupportedKeys } from '../supported-keys'
 
-type Keys = SupportedKeys['SinkListItem'] | SupportedKeys['LiftListItem'] | SupportedKeys['NextListItem'];
+type Keys = SupportedKeys['SinkListItem'] | SupportedKeys['LiftListItem'] | SupportedKeys['NextListItem']
 
-const id = 'list_item';
+const id = 'list_item'
 
-export const SplitListItem = createCmdKey('SplitListItem');
-export const SinkListItem = createCmdKey('SinkListItem');
-export const LiftListItem = createCmdKey('LiftListItem');
+export const SplitListItem = createCmdKey('SplitListItem')
+export const SinkListItem = createCmdKey('SinkListItem')
+export const LiftListItem = createCmdKey('LiftListItem')
 
-const keepListOrderPluginKey = new PluginKey('MILKDOWN_KEEP_LIST_ORDER');
+const keepListOrderPluginKey = new PluginKey('MILKDOWN_KEEP_LIST_ORDER')
 
 const createKeepListOrderPlugin = (type: NodeType) => {
-    const walkThrough = (state: EditorState, callback: (tr: Transaction) => void) => {
-        const orderedListType = getNodeFromSchema('ordered_list', state.schema);
-        let tr = state.tr;
-        state.doc.descendants((node, pos, parent, index) => {
-            if (node.type === type && parent?.type === orderedListType) {
-                let changed = false;
-                const attrs = { ...node.attrs };
-                if (node.attrs['listType'] !== 'ordered') {
-                    attrs['listType'] = 'ordered';
-                    changed = true;
-                }
+  const walkThrough = (state: EditorState, callback: (tr: Transaction) => void) => {
+    const orderedListType = getNodeFromSchema('ordered_list', state.schema)
+    let tr = state.tr
+    state.doc.descendants((node, pos, parent, index) => {
+      if (node.type === type && parent?.type === orderedListType) {
+        let changed = false
+        const attrs = { ...node.attrs }
+        if (node.attrs.listType !== 'ordered') {
+          attrs.listType = 'ordered'
+          changed = true
+        }
 
-                const base = parent?.maybeChild(0);
-                if (base && base.type === type && base.attrs['listType'] === 'ordered') {
-                    attrs['label'] = `${index + 1}.`;
-                    changed = true;
-                }
+        const base = parent?.maybeChild(0)
+        if (base && base.type === type && base.attrs.listType === 'ordered') {
+          attrs.label = `${index + 1}.`
+          changed = true
+        }
 
-                if (node.attrs['label'] === '•') {
-                    attrs['label'] = `${index + 1}.`;
-                    changed = true;
-                }
+        if (node.attrs.label === '•') {
+          attrs.label = `${index + 1}.`
+          changed = true
+        }
 
-                if (changed) {
-                    tr = tr.setNodeMarkup(pos, undefined, attrs);
-                }
-            }
-        });
-        callback(tr);
-    };
-    return new Plugin({
-        key: keepListOrderPluginKey,
-        appendTransaction: (transactions, _oldState, nextState) => {
-            let tr: Transaction | null = null;
-            if (transactions.some((transaction) => transaction.docChanged)) {
-                walkThrough(nextState, (t) => {
-                    tr = t;
-                });
-            }
+        if (changed)
+          tr = tr.setNodeMarkup(pos, undefined, attrs)
+      }
+    })
+    callback(tr)
+  }
+  return new Plugin({
+    key: keepListOrderPluginKey,
+    appendTransaction: (transactions, _oldState, nextState) => {
+      let tr: Transaction | null = null
+      if (transactions.some(transaction => transaction.docChanged)) {
+        walkThrough(nextState, (t) => {
+          tr = t
+        })
+      }
 
-            return tr;
-        },
-    });
-};
+      return tr
+    },
+  })
+}
 
-export const listItem = createNode<Keys>((utils) => ({
-    id,
-    schema: () => ({
-        group: 'listItem',
-        content: 'paragraph block*',
-        attrs: {
-            label: {
-                default: '•',
-            },
-            listType: {
-                default: 'bullet',
-            },
-            spread: {
-                default: 'true',
-            },
-        },
-        defining: true,
-        parseDOM: [
-            {
-                tag: 'li.list-item',
-                getAttrs: (dom) => {
-                    if (!(dom instanceof HTMLElement)) {
-                        throw expectDomTypeError(dom);
-                    }
-                    return {
-                        label: dom.dataset['label'],
-                        listType: dom.dataset['list-type'],
-                        spread: dom.dataset['spread'],
-                    };
-                },
-                contentElement: (dom) => {
-                    if (!(dom instanceof HTMLElement)) {
-                        throw expectDomTypeError(dom);
-                    }
+export const listItem = createNode<Keys>(utils => ({
+  id,
+  schema: () => ({
+    group: 'listItem',
+    content: 'paragraph block*',
+    attrs: {
+      label: {
+        default: '•',
+      },
+      listType: {
+        default: 'bullet',
+      },
+      spread: {
+        default: 'true',
+      },
+    },
+    defining: true,
+    parseDOM: [
+      {
+        tag: 'li.list-item',
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement))
+            throw expectDomTypeError(dom)
 
-                    const body = dom.querySelector<HTMLElement>('.list-item_body');
-                    if (!body) {
-                        return dom;
-                    }
-                    return body;
-                },
-            },
-            { tag: 'li' },
-        ],
-        toDOM: (node) => {
-            return [
-                'li',
-                {
-                    class: utils.getClassName(node.attrs, 'list-item'),
-                    'data-label': node.attrs['label'],
-                    'data-list-type': node.attrs['listType'],
-                    'data-spread': node.attrs['spread'],
-                },
-                ['div', { class: utils.getClassName(node.attrs, 'list-item_label') }, node.attrs['label']],
-                ['div', { class: utils.getClassName(node.attrs, 'list-item_body') }, 0],
-            ];
-        },
-        parseMarkdown: {
-            match: ({ type, checked }) => type === 'listItem' && checked === null,
-            runner: (state, node, type) => {
-                const label = node['label'] != null ? `${node['label']}.` : '•';
-                const listType = node['label'] != null ? 'ordered' : 'bullet';
-                const spread = node['spread'] != null ? `${node['spread']}` : 'true';
-                state.openNode(type, { label, listType, spread });
-                state.next(node.children);
-                state.closeNode();
-            },
+          return {
+            label: dom.dataset.label,
+            listType: dom.dataset['list-type'],
+            spread: dom.dataset.spread,
+          }
         },
-        toMarkdown: {
-            match: (node) => node.type.name === id,
-            runner: (state, node) => {
-                state.openNode('listItem', undefined, { spread: node.attrs['spread'] === 'true' });
-                state.next(node.content);
-                state.closeNode();
-            },
+        contentElement: (dom) => {
+          if (!(dom instanceof HTMLElement))
+            throw expectDomTypeError(dom)
+
+          const body = dom.querySelector<HTMLElement>('.list-item_body')
+          if (!body)
+            return dom
+
+          return body
         },
-    }),
-    inputRules: (nodeType) => [wrappingInputRule(/^\s*([-+*])\s$/, nodeType)],
-    commands: (nodeType) => [
-        createCmd(SplitListItem, () => splitListItem(nodeType)),
-        createCmd(SinkListItem, () => sinkListItem(nodeType)),
-        createCmd(LiftListItem, () => liftListItem(nodeType)),
+      },
+      { tag: 'li' },
     ],
-    shortcuts: {
-        [SupportedKeys.NextListItem]: createShortcut(SplitListItem, 'Enter'),
-        [SupportedKeys.SinkListItem]: createShortcut(SinkListItem, 'Mod-]'),
-        [SupportedKeys.LiftListItem]: createShortcut(LiftListItem, 'Mod-['),
+    toDOM: (node) => {
+      return [
+        'li',
+        {
+          'class': utils.getClassName(node.attrs, 'list-item'),
+          'data-label': node.attrs.label,
+          'data-list-type': node.attrs.listType,
+          'data-spread': node.attrs.spread,
+        },
+        ['div', { class: utils.getClassName(node.attrs, 'list-item_label') }, node.attrs.label],
+        ['div', { class: utils.getClassName(node.attrs, 'list-item_body') }, 0],
+      ]
+    },
+    parseMarkdown: {
+      match: ({ type, checked }) => type === 'listItem' && checked === null,
+      runner: (state, node, type) => {
+        const label = node.label != null ? `${node.label}.` : '•'
+        const listType = node.label != null ? 'ordered' : 'bullet'
+        const spread = node.spread != null ? `${node.spread}` : 'true'
+        state.openNode(type, { label, listType, spread })
+        state.next(node.children)
+        state.closeNode()
+      },
+    },
+    toMarkdown: {
+      match: node => node.type.name === id,
+      runner: (state, node) => {
+        state.openNode('listItem', undefined, { spread: node.attrs.spread === 'true' })
+        state.next(node.content)
+        state.closeNode()
+      },
     },
-    prosePlugins: (nodeType) => [createKeepListOrderPlugin(nodeType)],
-}));
+  }),
+  inputRules: nodeType => [wrappingInputRule(/^\s*([-+*])\s$/, nodeType)],
+  commands: nodeType => [
+    createCmd(SplitListItem, () => splitListItem(nodeType)),
+    createCmd(SinkListItem, () => sinkListItem(nodeType)),
+    createCmd(LiftListItem, () => liftListItem(nodeType)),
+  ],
+  shortcuts: {
+    [SupportedKeys.NextListItem]: createShortcut(SplitListItem, 'Enter'),
+    [SupportedKeys.SinkListItem]: createShortcut(SinkListItem, 'Mod-]'),
+    [SupportedKeys.LiftListItem]: createShortcut(LiftListItem, 'Mod-['),
+  },
+  prosePlugins: nodeType => [createKeepListOrderPlugin(nodeType)],
+}))

package/src/node/ordered-list.ts

@@ -1,79 +1,79 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { createCmd, createCmdKey } from '@milkdown/core';
-import { expectDomTypeError } from '@milkdown/exception';
-import { wrapIn } from '@milkdown/prose/commands';
-import { wrappingInputRule } from '@milkdown/prose/inputrules';
-import { createNode, createShortcut } from '@milkdown/utils';
+import { createCmd, createCmdKey } from '@milkdown/core'
+import { expectDomTypeError } from '@milkdown/exception'
+import { wrapIn } from '@milkdown/prose/commands'
+import { wrappingInputRule } from '@milkdown/prose/inputrules'
+import { createNode, createShortcut } from '@milkdown/utils'
 
-import { SupportedKeys } from '../supported-keys';
+import { SupportedKeys } from '../supported-keys'
 
-type Keys = SupportedKeys['OrderedList'];
+type Keys = SupportedKeys['OrderedList']
 
-export const WrapInOrderedList = createCmdKey('WrapInOrderedList');
+export const WrapInOrderedList = createCmdKey('WrapInOrderedList')
 
-const id = 'ordered_list';
-export const orderedList = createNode<Keys>((utils) => ({
-    id,
-    schema: () => ({
-        content: 'listItem+',
-        group: 'block',
-        attrs: {
-            order: {
-                default: 1,
-            },
-            spread: {
-                default: false,
-            },
-        },
-        parseDOM: [
-            {
-                tag: 'ol',
-                getAttrs: (dom) => {
-                    if (!(dom instanceof HTMLElement)) {
-                        throw expectDomTypeError(dom);
-                    }
-                    return {
-                        spread: dom.dataset['spread'],
-                        order: dom.hasAttribute('start') ? Number(dom.getAttribute('start')) : 1,
-                    };
-                },
-            },
-        ],
-        toDOM: (node) => [
-            'ol',
-            {
-                ...(node.attrs['order'] === 1 ? {} : node.attrs['order']),
-                'data-spread': node.attrs['spread'],
-                class: utils.getClassName(node.attrs, 'ordered-list'),
-            },
-            0,
-        ],
-        parseMarkdown: {
-            match: ({ type, ordered }) => type === 'list' && !!ordered,
-            runner: (state, node, type) => {
-                const spread = node['spread'] != null ? `${node['spread']}` : 'true';
-                state.openNode(type, { spread }).next(node.children).closeNode();
-            },
-        },
-        toMarkdown: {
-            match: (node) => node.type.name === id,
-            runner: (state, node) => {
-                state.openNode('list', undefined, { ordered: true, start: 1, spread: node.attrs['spread'] === 'true' });
-                state.next(node.content);
-                state.closeNode();
-            },
+const id = 'ordered_list'
+export const orderedList = createNode<Keys>(utils => ({
+  id,
+  schema: () => ({
+    content: 'listItem+',
+    group: 'block',
+    attrs: {
+      order: {
+        default: 1,
+      },
+      spread: {
+        default: false,
+      },
+    },
+    parseDOM: [
+      {
+        tag: 'ol',
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement))
+            throw expectDomTypeError(dom)
+
+          return {
+            spread: dom.dataset.spread,
+            order: dom.hasAttribute('start') ? Number(dom.getAttribute('start')) : 1,
+          }
         },
-    }),
-    inputRules: (nodeType) => [
-        wrappingInputRule(
-            /^(\d+)\.\s$/,
-            nodeType,
-            (match) => ({ order: Number(match[1]) }),
-            (match, node) => node.childCount + node.attrs['order'] === Number(match[1]),
-        ),
+      },
+    ],
+    toDOM: node => [
+      'ol',
+      {
+        ...(node.attrs.order === 1 ? {} : node.attrs.order),
+        'data-spread': node.attrs.spread,
+        'class': utils.getClassName(node.attrs, 'ordered-list'),
+      },
+      0,
     ],
-    commands: (nodeType) => [createCmd(WrapInOrderedList, () => wrapIn(nodeType))],
-    shortcuts: {
-        [SupportedKeys.OrderedList]: createShortcut(WrapInOrderedList, 'Mod-Alt-7'),
+    parseMarkdown: {
+      match: ({ type, ordered }) => type === 'list' && !!ordered,
+      runner: (state, node, type) => {
+        const spread = node.spread != null ? `${node.spread}` : 'true'
+        state.openNode(type, { spread }).next(node.children).closeNode()
+      },
+    },
+    toMarkdown: {
+      match: node => node.type.name === id,
+      runner: (state, node) => {
+        state.openNode('list', undefined, { ordered: true, start: 1, spread: node.attrs.spread === 'true' })
+        state.next(node.content)
+        state.closeNode()
+      },
     },
-}));
+  }),
+  inputRules: nodeType => [
+    wrappingInputRule(
+      /^(\d+)\.\s$/,
+      nodeType,
+      match => ({ order: Number(match[1]) }),
+      (match, node) => node.childCount + node.attrs.order === Number(match[1]),
+    ),
+  ],
+  commands: nodeType => [createCmd(WrapInOrderedList, () => wrapIn(nodeType))],
+  shortcuts: {
+    [SupportedKeys.OrderedList]: createShortcut(WrapInOrderedList, 'Mod-Alt-7'),
+  },
+}))

package/src/node/paragraph.ts

@@ -1,60 +1,62 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { createCmd, createCmdKey } from '@milkdown/core';
-import { setBlockType } from '@milkdown/prose/commands';
-import { Fragment, Node } from '@milkdown/prose/model';
-import { createNode, createShortcut } from '@milkdown/utils';
+import { createCmd, createCmdKey } from '@milkdown/core'
+import { setBlockType } from '@milkdown/prose/commands'
+import type { Node } from '@milkdown/prose/model'
+import { Fragment } from '@milkdown/prose/model'
+import { createNode, createShortcut } from '@milkdown/utils'
 
-import { SupportedKeys } from '../supported-keys';
+import { SupportedKeys } from '../supported-keys'
 
-type Keys = SupportedKeys['Text'];
+type Keys = SupportedKeys['Text']
 
-export const TurnIntoText = createCmdKey('TurnIntoText');
+export const TurnIntoText = createCmdKey('TurnIntoText')
 
-const id = 'paragraph';
+const id = 'paragraph'
 export const paragraph = createNode<Keys>((utils) => {
-    return {
-        id,
-        schema: () => ({
-            content: 'inline*',
-            group: 'block',
-            parseDOM: [{ tag: 'p' }],
-            toDOM: (node) => ['p', { class: utils.getClassName(node.attrs, id) }, 0],
-            parseMarkdown: {
-                match: (node) => node.type === 'paragraph',
-                runner: (state, node, type) => {
-                    state.openNode(type);
-                    if (node.children) {
-                        state.next(node.children);
-                    } else {
-                        state.addText(node['value'] as string);
-                    }
-                    state.closeNode();
-                },
-            },
-            toMarkdown: {
-                match: (node) => node.type.name === 'paragraph',
-                runner: (state, node) => {
-                    state.openNode('paragraph');
-                    const lastIsHardbreak = node.childCount >= 1 && node.lastChild?.type.name === 'hardbreak';
-                    if (lastIsHardbreak) {
-                        const contentArr: Node[] = [];
-                        node.content.forEach((n, _, i) => {
-                            if (i === node.childCount - 1) {
-                                return;
-                            }
-                            contentArr.push(n);
-                        });
-                        state.next(Fragment.fromArray(contentArr));
-                    } else {
-                        state.next(node.content);
-                    }
-                    state.closeNode();
-                },
-            },
-        }),
-        commands: (nodeType) => [createCmd(TurnIntoText, () => setBlockType(nodeType))],
-        shortcuts: {
-            [SupportedKeys.Text]: createShortcut(TurnIntoText, 'Mod-Alt-0'),
+  return {
+    id,
+    schema: () => ({
+      content: 'inline*',
+      group: 'block',
+      parseDOM: [{ tag: 'p' }],
+      toDOM: node => ['p', { class: utils.getClassName(node.attrs, id) }, 0],
+      parseMarkdown: {
+        match: node => node.type === 'paragraph',
+        runner: (state, node, type) => {
+          state.openNode(type)
+          if (node.children)
+            state.next(node.children)
+          else
+            state.addText(node.value as string)
+
+          state.closeNode()
+        },
+      },
+      toMarkdown: {
+        match: node => node.type.name === 'paragraph',
+        runner: (state, node) => {
+          state.openNode('paragraph')
+          const lastIsHardbreak = node.childCount >= 1 && node.lastChild?.type.name === 'hardbreak'
+          if (lastIsHardbreak) {
+            const contentArr: Node[] = []
+            node.content.forEach((n, _, i) => {
+              if (i === node.childCount - 1)
+                return
+
+              contentArr.push(n)
+            })
+            state.next(Fragment.fromArray(contentArr))
+          }
+          else {
+            state.next(node.content)
+          }
+          state.closeNode()
         },
-    };
-});
+      },
+    }),
+    commands: nodeType => [createCmd(TurnIntoText, () => setBlockType(nodeType))],
+    shortcuts: {
+      [SupportedKeys.Text]: createShortcut(TurnIntoText, 'Mod-Alt-0'),
+    },
+  }
+})

package/src/node/text.ts

@@ -1,21 +1,21 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { createNode } from '@milkdown/utils';
+import { createNode } from '@milkdown/utils'
 
 export const text = createNode(() => ({
-    id: 'text',
-    schema: () => ({
-        group: 'inline',
-        parseMarkdown: {
-            match: ({ type }) => type === 'text',
-            runner: (state, node) => {
-                state.addText(node['value'] as string);
-            },
-        },
-        toMarkdown: {
-            match: (node) => node.type.name === 'text',
-            runner: (state, node) => {
-                state.addNode('text', undefined, node.text as string);
-            },
-        },
-    }),
-}));
+  id: 'text',
+  schema: () => ({
+    group: 'inline',
+    parseMarkdown: {
+      match: ({ type }) => type === 'text',
+      runner: (state, node) => {
+        state.addText(node.value as string)
+      },
+    },
+    toMarkdown: {
+      match: node => node.type.name === 'text',
+      runner: (state, node) => {
+        state.addNode('text', undefined, node.text as string)
+      },
+    },
+  }),
+}))

package/src/plugin/add-order-in-list.ts

@@ -1,19 +1,19 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Node } from 'unist';
-import { Parent, visit } from 'unist-util-visit';
+import type { Node } from 'unist'
+import type { Parent } from 'unist-util-visit'
+import { visit } from 'unist-util-visit'
 
 export const addOrderInList = () => {
-    function transformer(ast: Node) {
-        visit(ast, 'list', (node: Parent & { ordered?: boolean; start?: number }) => {
-            if (node.ordered) {
-                const start = node.start ?? 1;
-                node.children.forEach((child, index) => {
-                    (child as Node & { label: number }).label = index + start;
-                });
-                return;
-            }
-        });
-    }
+  function transformer(ast: Node) {
+    visit(ast, 'list', (node: Parent & { ordered?: boolean; start?: number }) => {
+      if (node.ordered) {
+        const start = node.start ?? 1
+        node.children.forEach((child, index) => {
+          (child as Node & { label: number }).label = index + start
+        })
+      }
+    })
+  }
 
-    return transformer;
-};
+  return transformer
+}