@milkdown/preset-commonmark 7.1.0 → 7.1.2-next.0

package/src/node/code-block.ts

@@ -4,6 +4,7 @@ import { expectDomTypeError } from '@milkdown/exception'
 import { setBlockType } from '@milkdown/prose/commands'
 import { textblockTypeInputRule } from '@milkdown/prose/inputrules'
 import { $command, $inputRule, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// HTML attributes for code block node.
 export const codeBlockAttr = $nodeAttr('codeBlock', () => ({
@@ -11,6 +12,11 @@ export const codeBlockAttr = $nodeAttr('codeBlock', () => ({
   code: {},
 }))
 
+withMeta(codeBlockAttr, {
+  displayName: 'Attr<codeBlock>',
+  group: 'CodeBlock',
+})
+
 /// Schema for code block node.
 export const codeBlockSchema = $nodeSchema('code_block', (ctx) => {
   return {
@@ -70,16 +76,36 @@ export const codeBlockSchema = $nodeSchema('code_block', (ctx) => {
   }
 })
 
+withMeta(codeBlockSchema.node, {
+  displayName: 'NodeSchema<codeBlock>',
+  group: 'CodeBlock',
+})
+
+withMeta(codeBlockSchema.ctx, {
+  displayName: 'NodeSchemaCtx<codeBlock>',
+  group: 'CodeBlock',
+})
+
 /// A input rule for creating code block.
 /// For example, ` ```javascript ` will create a code block with language javascript.
 export const createCodeBlockInputRule = $inputRule(() => textblockTypeInputRule(/^```(?<language>[a-z]*)?[\s\n]$/, codeBlockSchema.type(), match => ({
   language: match.groups?.language ?? '',
 })))
 
+withMeta(createCodeBlockInputRule, {
+  displayName: 'InputRule<createCodeBlockInputRule>',
+  group: 'CodeBlock',
+})
+
 /// A command for creating code block.
 /// You can pass the language of the code block as the parameter.
 export const createCodeBlockCommand = $command('CreateCodeBlock', () => (language = '') => setBlockType(codeBlockSchema.type(), { language }))
 
+withMeta(createCodeBlockCommand, {
+  displayName: 'Command<createCodeBlockCommand>',
+  group: 'CodeBlock',
+})
+
 /// A command for updating the code block language of the target position.
 export const updateCodeBlockLanguageCommand = $command('UpdateCodeBlockLanguage', () => ({ pos, language }: { pos: number; language: string } = { pos: -1, language: '' }) => (state, dispatch) => {
   if (pos >= 0) {
@@ -90,6 +116,11 @@ export const updateCodeBlockLanguageCommand = $command('UpdateCodeBlockLanguage'
   return false
 })
 
+withMeta(updateCodeBlockLanguageCommand, {
+  displayName: 'Command<updateCodeBlockLanguageCommand>',
+  group: 'CodeBlock',
+})
+
 /// Keymap for code block.
 /// - `Mod-Alt-c`: Create a code block.
 export const codeBlockKeymap = $useKeymap('codeBlockKeymap', {
@@ -101,3 +132,13 @@ export const codeBlockKeymap = $useKeymap('codeBlockKeymap', {
     },
   },
 })
+
+withMeta(codeBlockKeymap.ctx, {
+  displayName: 'KeymapCtx<codeBlock>',
+  group: 'CodeBlock',
+})
+
+withMeta(codeBlockKeymap.shortcuts, {
+  displayName: 'Keymap<codeBlock>',
+  group: 'CodeBlock',
+})

package/src/node/doc.ts

@@ -1,5 +1,6 @@
 /* Copyright 2021, Milkdown by Mirone. */
 import { $node } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// The top-level document node.
 export const docSchema = $node('doc', () => ({
@@ -18,3 +19,8 @@ export const docSchema = $node('doc', () => ({
     },
   },
 }))
+
+withMeta(docSchema, {
+  displayName: 'NodeSchema<doc>',
+  group: 'Doc',
+})

package/src/node/hardbreak.ts

@@ -2,6 +2,7 @@
 import { commandsCtx } from '@milkdown/core'
 import { Selection } from '@milkdown/prose/state'
 import { $command, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// HTML attributes for the hardbreak node.
 ///
@@ -13,6 +14,11 @@ export const hardbreakAttr = $nodeAttr('hardbreak', (node) => {
   }
 })
 
+withMeta(hardbreakAttr, {
+  displayName: 'Attr<hardbreak>',
+  group: 'Hardbreak',
+})
+
 /// Hardbreak node schema.
 export const hardbreakSchema = $nodeSchema('hardbreak', ctx => ({
   inline: true,
@@ -31,6 +37,7 @@ export const hardbreakSchema = $nodeSchema('hardbreak', ctx => ({
       state.addNode(type, { isInline: Boolean(node.data?.isInline) })
     },
   },
+  leafText: () => '\n',
   toMarkdown: {
     match: node => node.type.name === 'hardbreak',
     runner: (state, node) => {
@@ -43,6 +50,16 @@ export const hardbreakSchema = $nodeSchema('hardbreak', ctx => ({
   },
 }))
 
+withMeta(hardbreakSchema.node, {
+  displayName: 'NodeSchema<hardbreak>',
+  group: 'Hardbreak',
+})
+
+withMeta(hardbreakSchema.ctx, {
+  displayName: 'NodeSchemaCtx<hardbreak>',
+  group: 'Hardbreak',
+})
+
 /// Command to insert a hardbreak.
 export const insertHardbreakCommand = $command('InsertHardbreak', () => () => (state, dispatch) => {
   const { selection, tr } = state
@@ -63,6 +80,11 @@ export const insertHardbreakCommand = $command('InsertHardbreak', () => () => (s
   return true
 })
 
+withMeta(insertHardbreakCommand, {
+  displayName: 'Command<insertHardbreakCommand>',
+  group: 'Hardbreak',
+})
+
 /// Keymap for the hardbreak node.
 /// - `Shift-Enter` - Insert a hardbreak.
 export const hardbreakKeymap = $useKeymap('hardbreakKeymap', {
@@ -74,3 +96,13 @@ export const hardbreakKeymap = $useKeymap('hardbreakKeymap', {
     },
   },
 })
+
+withMeta(hardbreakKeymap.ctx, {
+  displayName: 'KeymapCtx<hardbreak>',
+  group: 'Hardbreak',
+})
+
+withMeta(hardbreakKeymap.shortcuts, {
+  displayName: 'Keymap<hardbreak>',
+  group: 'Hardbreak',
+})

package/src/node/heading.ts

@@ -4,8 +4,9 @@ import { expectDomTypeError } from '@milkdown/exception'
 import { setBlockType } from '@milkdown/prose/commands'
 import { textblockTypeInputRule } from '@milkdown/prose/inputrules'
 import type { Node } from '@milkdown/prose/model'
-import { Fragment } from '@milkdown/prose/model'
 import { $command, $ctx, $inputRule, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import slugify from '@sindresorhus/slugify'
+import { serializeText, withMeta } from '../__internal__'
 import { paragraphSchema } from './paragraph'
 
 const headingIndex = Array(6)
@@ -13,19 +14,25 @@ const headingIndex = Array(6)
   .map((_, i) => i + 1)
 
 const defaultHeadingIdGenerator = (node: Node) =>
-  node.textContent
-    .replace(/[\p{P}\p{S}]/gu, '')
-    .replace(/\s/g, '-')
-    .toLowerCase()
-    .trim()
+  slugify(node.textContent)
 
 /// This is a slice contains a function to generate heading id.
 /// You can configure it to generate id in your own way.
 export const headingIdGenerator = $ctx(defaultHeadingIdGenerator, 'headingIdGenerator')
 
+withMeta(headingIdGenerator, {
+  displayName: 'Ctx<HeadingIdGenerator>',
+  group: 'Heading',
+})
+
 /// HTML attributes for heading node.
 export const headingAttr = $nodeAttr('heading')
 
+withMeta(headingAttr, {
+  displayName: 'Attr<heading>',
+  group: 'Heading',
+})
+
 /// Schema for heading node.
 export const headingSchema = $nodeSchema('heading', (ctx) => {
   const getId = ctx.get(headingIdGenerator.key)
@@ -73,26 +80,23 @@ export const headingSchema = $nodeSchema('heading', (ctx) => {
       match: node => node.type.name === 'heading',
       runner: (state, node) => {
         state.openNode('heading', undefined, { depth: node.attrs.level })
-        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)
-        }
+        serializeText(state, node)
         state.closeNode()
       },
     },
   }
 })
 
+withMeta(headingSchema.node, {
+  displayName: 'NodeSchema<heading>',
+  group: 'Heading',
+})
+
+withMeta(headingSchema.ctx, {
+  displayName: 'NodeSchemaCtx<heading>',
+  group: 'Heading',
+})
+
 /// This input rule can turn the selected block into heading.
 /// You can input numbers of `#` and a `space` to create heading.
 export const wrapInHeadingInputRule = $inputRule((ctx) => {
@@ -113,6 +117,11 @@ export const wrapInHeadingInputRule = $inputRule((ctx) => {
   })
 })
 
+withMeta(wrapInHeadingInputRule, {
+  displayName: 'InputRule<wrapInHeadingInputRule>',
+  group: 'Heading',
+})
+
 /// This command can turn the selected block into heading.
 /// You can pass the level of heading to this command.
 /// By default, the level is 1, which means it will create a `h1` element.
@@ -127,6 +136,11 @@ export const wrapInHeadingCommand = $command('WrapInHeading', () => {
   }
 })
 
+withMeta(wrapInHeadingCommand, {
+  displayName: 'Command<wrapInHeadingCommand>',
+  group: 'Heading',
+})
+
 /// This command can downgrade the selected heading.
 /// For example, if you have a `h2` element, and you call this command, you will get a `h1` element.
 /// If the element is already a `h1` element, it will turn it into a `p` element.
@@ -150,6 +164,11 @@ export const downgradeHeadingCommand = $command('DowngradeHeading', () => () =>
     return true
   })
 
+withMeta(downgradeHeadingCommand, {
+  displayName: 'Command<downgradeHeadingCommand>',
+  group: 'Heading',
+})
+
 /// Keymap for heading node.
 /// - `<Mod-Alt-{1-6}>`: Turn the selected block into `h{1-6}` element.
 /// - `<Delete>/<Backspace>`: Downgrade the selected heading.
@@ -204,3 +223,13 @@ export const headingKeymap = $useKeymap('headingKeymap', {
     },
   },
 })
+
+withMeta(headingKeymap.ctx, {
+  displayName: 'KeymapCtx<heading>',
+  group: 'Heading',
+})
+
+withMeta(headingKeymap.shortcuts, {
+  displayName: 'Keymap<heading>',
+  group: 'Heading',
+})

package/src/node/hr.ts

@@ -2,11 +2,17 @@
 import { InputRule } from '@milkdown/prose/inputrules'
 import { Selection } from '@milkdown/prose/state'
 import { $command, $inputRule, $nodeAttr, $nodeSchema } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 import { paragraphSchema } from './paragraph'
 
 /// HTML attributes for the hr node.
 export const hrAttr = $nodeAttr('hr')
 
+withMeta(hrAttr, {
+  displayName: 'Attr<hr>',
+  group: 'Hr',
+})
+
 /// Hr node schema.
 export const hrSchema = $nodeSchema('hr', ctx => ({
   group: 'block',
@@ -26,6 +32,16 @@ export const hrSchema = $nodeSchema('hr', ctx => ({
   },
 }))
 
+withMeta(hrSchema.node, {
+  displayName: 'NodeSchema<hr>',
+  group: 'Hr',
+})
+
+withMeta(hrSchema.ctx, {
+  displayName: 'NodeSchemaCtx<hr>',
+  group: 'Hr',
+})
+
 /// Input rule to insert a hr.
 /// For example, `---` will be converted to a hr.
 export const insertHrInputRule = $inputRule(() => new InputRule(
@@ -39,6 +55,11 @@ export const insertHrInputRule = $inputRule(() => new InputRule(
   },
 ))
 
+withMeta(insertHrInputRule, {
+  displayName: 'InputRule<insertHrInputRule>',
+  group: 'Hr',
+})
+
 /// Command to insert a hr.
 export const insertHrCommand = $command('InsertHr', () => () => (state, dispatch) => {
   if (!dispatch)
@@ -59,3 +80,8 @@ export const insertHrCommand = $command('InsertHr', () => () => (state, dispatch
   dispatch(_tr.setSelection(sel).scrollIntoView())
   return true
 })
+
+withMeta(insertHrCommand, {
+  displayName: 'Command<insertHrCommand>',
+  group: 'Hr',
+})

package/src/node/html.ts

@@ -1,8 +1,14 @@
 /* Copyright 2021, Milkdown by Mirone. */
 import { $nodeAttr, $nodeSchema } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 export const htmlAttr = $nodeAttr('html')
 
+withMeta(htmlAttr, {
+  displayName: 'Attr<html>',
+  group: 'Html',
+})
+
 export const htmlSchema = $nodeSchema('html', (ctx) => {
   return {
     atom: true,
@@ -45,3 +51,13 @@ export const htmlSchema = $nodeSchema('html', (ctx) => {
     },
   }
 })
+
+withMeta(htmlSchema.node, {
+  displayName: 'NodeSchema<html>',
+  group: 'Html',
+})
+
+withMeta(htmlSchema.ctx, {
+  displayName: 'NodeSchemaCtx<html>',
+  group: 'Html',
+})

package/src/node/image.ts

@@ -3,10 +3,16 @@ import { expectDomTypeError } from '@milkdown/exception'
 import { findSelectedNodeOfType } from '@milkdown/prose'
 import { InputRule } from '@milkdown/prose/inputrules'
 import { $command, $inputRule, $nodeAttr, $nodeSchema } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// HTML attributes for image node.
 export const imageAttr = $nodeAttr('image')
 
+withMeta(imageAttr, {
+  displayName: 'Attr<image>',
+  group: 'Image',
+})
+
 /// Schema for image node.
 export const imageSchema = $nodeSchema('image', (ctx) => {
   return {
@@ -67,6 +73,16 @@ export const imageSchema = $nodeSchema('image', (ctx) => {
   }
 })
 
+withMeta(imageSchema.node, {
+  displayName: 'NodeSchema<image>',
+  group: 'Image',
+})
+
+withMeta(imageSchema.ctx, {
+  displayName: 'NodeSchemaCtx<image>',
+  group: 'Image',
+})
+
 /// @internal
 export type UpdateImageCommandPayload = {
   src?: string
@@ -91,6 +107,11 @@ export const insertImageCommand = $command('InsertImage', () => (payload: Update
     return true
   })
 
+withMeta(insertImageCommand, {
+  displayName: 'Command<insertImageCommand>',
+  group: 'Image',
+})
+
 /// This command will update the selected image node.
 /// You can pass a payload to update `src`, `alt` and `title` for the image node.
 export const updateImageCommand = $command('UpdateImage', () => (payload: UpdateImageCommandPayload = {}) => (state, dispatch) => {
@@ -113,6 +134,11 @@ export const updateImageCommand = $command('UpdateImage', () => (payload: Update
   return true
 })
 
+withMeta(updateImageCommand, {
+  displayName: 'Command<updateImageCommand>',
+  group: 'Image',
+})
+
 /// This input rule will insert a image node.
 /// You can input `![alt](src "title")` to insert a image node.
 /// The `title` is optional.
@@ -126,3 +152,8 @@ export const insertImageInputRule = $inputRule(() => new InputRule(
     return null
   },
 ))
+
+withMeta(insertImageInputRule, {
+  displayName: 'InputRule<insertImageInputRule>',
+  group: 'Image',
+})

package/src/node/list-item.ts

@@ -3,10 +3,16 @@ import { commandsCtx } from '@milkdown/core'
 import { expectDomTypeError } from '@milkdown/exception'
 import { liftListItem, sinkListItem, splitListItem } from '@milkdown/prose/schema-list'
 import { $command, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// HTML attributes for list item node.
 export const listItemAttr = $nodeAttr('listItem')
 
+withMeta(listItemAttr, {
+  displayName: 'Attr<listItem>',
+  group: 'ListItem',
+})
+
 /// Schema for list item node.
 export const listItemSchema = $nodeSchema('list_item', ctx => ({
   group: 'listItem',
@@ -69,6 +75,16 @@ export const listItemSchema = $nodeSchema('list_item', ctx => ({
   },
 }))
 
+withMeta(listItemSchema.node, {
+  displayName: 'NodeSchema<listItem>',
+  group: 'ListItem',
+})
+
+withMeta(listItemSchema.ctx, {
+  displayName: 'NodeSchemaCtx<listItem>',
+  group: 'ListItem',
+})
+
 /// The command to sink list item.
 ///
 /// For example:
@@ -83,6 +99,11 @@ export const listItemSchema = $nodeSchema('list_item', ctx => ({
 /// ```
 export const sinkListItemCommand = $command('SinkListItem', () => () => sinkListItem(listItemSchema.type()))
 
+withMeta(sinkListItemCommand, {
+  displayName: 'Command<sinkListItemCommand>',
+  group: 'ListItem',
+})
+
 /// The command to lift list item.
 ///
 /// For example:
@@ -97,6 +118,11 @@ export const sinkListItemCommand = $command('SinkListItem', () => () => sinkList
 /// ```
 export const liftListItemCommand = $command('SplitListItem', () => () => liftListItem(listItemSchema.type()))
 
+withMeta(liftListItemCommand, {
+  displayName: 'Command<liftListItemCommand>',
+  group: 'ListItem',
+})
+
 /// The command to split a list item.
 ///
 /// For example:
@@ -112,6 +138,11 @@ export const liftListItemCommand = $command('SplitListItem', () => () => liftLis
 /// ```
 export const splitListItemCommand = $command('SplitListItem', () => () => splitListItem(listItemSchema.type()))
 
+withMeta(splitListItemCommand, {
+  displayName: 'Command<splitListItemCommand>',
+  group: 'ListItem',
+})
+
 /// Keymap for list item node.
 /// - `<Enter>`: Split the current list item.
 /// - `<Tab>/<Mod-]>`: Sink the current list item.
@@ -139,3 +170,13 @@ export const listItemKeymap = $useKeymap('listItemKeymap', {
     },
   },
 })
+
+withMeta(listItemKeymap.ctx, {
+  displayName: 'KeymapCtx<listItem>',
+  group: 'ListItem',
+})
+
+withMeta(listItemKeymap.shortcuts, {
+  displayName: 'Keymap<listItem>',
+  group: 'ListItem',
+})

package/src/node/ordered-list.ts

@@ -4,10 +4,16 @@ import { expectDomTypeError } from '@milkdown/exception'
 import { wrapIn } from '@milkdown/prose/commands'
 import { wrappingInputRule } from '@milkdown/prose/inputrules'
 import { $command, $inputRule, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// HTML attributes for ordered list node.
 export const orderedListAttr = $nodeAttr('orderedList')
 
+withMeta(orderedListAttr, {
+  displayName: 'Attr<orderedList>',
+  group: 'OrderedList',
+})
+
 /// Schema for ordered list node.
 export const orderedListSchema = $nodeSchema('ordered_list', ctx => ({
   content: 'listItem+',
@@ -60,6 +66,16 @@ export const orderedListSchema = $nodeSchema('ordered_list', ctx => ({
   },
 }))
 
+withMeta(orderedListSchema.node, {
+  displayName: 'NodeSchema<orderedList>',
+  group: 'OrderedList',
+})
+
+withMeta(orderedListSchema.ctx, {
+  displayName: 'NodeSchemaCtx<orderedList>',
+  group: 'OrderedList',
+})
+
 /// Input rule for wrapping a block in ordered list node.
 export const wrapInOrderedListInputRule = $inputRule(() => wrappingInputRule(
   /^\s*(\d+)\.\s$/,
@@ -68,9 +84,19 @@ export const wrapInOrderedListInputRule = $inputRule(() => wrappingInputRule(
   (match, node) => node.childCount + node.attrs.order === Number(match[1]),
 ))
 
+withMeta(wrapInOrderedListInputRule, {
+  displayName: 'InputRule<wrapInOrderedListInputRule>',
+  group: 'OrderedList',
+})
+
 /// Command for wrapping a block in ordered list node.
 export const wrapInOrderedListCommand = $command('WrapInOrderedList', () => () => wrapIn(orderedListSchema.type()))
 
+withMeta(wrapInOrderedListCommand, {
+  displayName: 'Command<wrapInOrderedListCommand>',
+  group: 'OrderedList',
+})
+
 /// Keymap for ordered list node.
 /// - `Mod-Alt-7`: Wrap a block in ordered list.
 export const orderedListKeymap = $useKeymap('orderedListKeymap', {
@@ -82,3 +108,13 @@ export const orderedListKeymap = $useKeymap('orderedListKeymap', {
     },
   },
 })
+
+withMeta(orderedListKeymap.ctx, {
+  displayName: 'KeymapCtx<orderedList>',
+  group: 'OrderedList',
+})
+
+withMeta(orderedListKeymap.shortcuts, {
+  displayName: 'Keymap<orderedList>',
+  group: 'OrderedList',
+})

package/src/node/paragraph.ts

@@ -1,13 +1,17 @@
 /* Copyright 2021, Milkdown by Mirone. */
 import { commandsCtx } from '@milkdown/core'
 import { setBlockType } from '@milkdown/prose/commands'
-import type { Node } from '@milkdown/prose/model'
-import { Fragment } from '@milkdown/prose/model'
 import { $command, $nodeAttr, $nodeSchema, $useKeymap } from '@milkdown/utils'
+import { serializeText, withMeta } from '../__internal__'
 
 /// HTML attributes for paragraph node.
 export const paragraphAttr = $nodeAttr('paragraph')
 
+withMeta(paragraphAttr, {
+  displayName: 'Attr<paragraph>',
+  group: 'Paragraph',
+})
+
 /// Schema for paragraph node.
 export const paragraphSchema = $nodeSchema('paragraph', ctx => ({
   content: 'inline*',
@@ -31,28 +35,29 @@ export const paragraphSchema = $nodeSchema('paragraph', ctx => ({
     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)
-      }
+      serializeText(state, node)
       state.closeNode()
     },
   },
 }))
 
+withMeta(paragraphSchema.node, {
+  displayName: 'NodeSchema<paragraph>',
+  group: 'Paragraph',
+})
+withMeta(paragraphSchema.ctx, {
+  displayName: 'NodeSchemaCtx<paragraph>',
+  group: 'Paragraph',
+})
+
 /// This command can turn the selected block into paragraph.
 export const turnIntoTextCommand = $command('TurnIntoText', () => () => setBlockType(paragraphSchema.type()))
 
+withMeta(turnIntoTextCommand, {
+  displayName: 'Command<turnIntoTextCommand>',
+  group: 'Paragraph',
+})
+
 /// Keymap for paragraph node.
 /// - `<Mod-Alt-0>`: Turn the selected block into paragraph.
 export const paragraphKeymap = $useKeymap('paragraphKeymap', {
@@ -64,3 +69,13 @@ export const paragraphKeymap = $useKeymap('paragraphKeymap', {
     },
   },
 })
+
+withMeta(paragraphKeymap.ctx, {
+  displayName: 'KeymapCtx<paragraph>',
+  group: 'Paragraph',
+})
+
+withMeta(paragraphKeymap.shortcuts, {
+  displayName: 'Keymap<paragraph>',
+  group: 'Paragraph',
+})

package/src/node/text.ts

@@ -1,5 +1,6 @@
 /* Copyright 2021, Milkdown by Mirone. */
 import { $node } from '@milkdown/utils'
+import { withMeta } from '../__internal__'
 
 /// The bottom-level node.
 export const textSchema = $node('text', () => ({
@@ -17,3 +18,8 @@ export const textSchema = $node('text', () => ({
     },
   },
 }))
+
+withMeta(textSchema, {
+  displayName: 'NodeSchema<text>',
+  group: 'Text',
+})