@portabletext/plugin-markdown-shortcuts 4.0.22 → 4.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/plugin-markdown-shortcuts",
-  "version": "4.0.22",
+  "version": "4.0.24",
   "description": "Adds helpful Markdown shortcuts to the editor",
   "keywords": [
     "portabletext",
@@ -32,13 +32,12 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "src",
     "dist"
   ],
   "dependencies": {
-    "react-compiler-runtime": "1.0.0",
-    "@portabletext/plugin-character-pair-decorator": "^4.0.22",
-    "@portabletext/plugin-input-rule": "^1.0.22"
+    "react-compiler-runtime": "^1.0.0",
+    "@portabletext/plugin-character-pair-decorator": "^4.0.24",
+    "@portabletext/plugin-input-rule": "^1.0.24"
   },
   "devDependencies": {
     "@sanity/tsconfig": "^1.0.0",
@@ -46,19 +45,19 @@
     "@vitejs/plugin-react": "^5.0.4",
     "@vitest/browser": "^4.0.14",
     "@vitest/browser-playwright": "^4.0.14",
-    "babel-plugin-react-compiler": "1.0.0",
+    "babel-plugin-react-compiler": "^1.0.0",
     "eslint": "^9.39.1",
-    "eslint-plugin-react-hooks": "7.0.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
     "react": "^19.2.1",
     "typescript": "5.9.3",
     "typescript-eslint": "^8.48.0",
     "vitest": "^4.0.14",
-    "@portabletext/editor": "^3.3.2",
-    "racejar": "2.0.0"
+    "@portabletext/editor": "^3.3.4",
+    "racejar": "2.0.1"
   },
   "peerDependencies": {
     "react": "^18.3 || ^19",
-    "@portabletext/editor": "^3.3.2"
+    "@portabletext/editor": "^3.3.4"
   },
   "engines": {
     "node": ">=20.19 <22 || >=22.12"

package/src/behavior.markdown-shortcuts.ts

@@ -1,133 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {defineBehavior, raise} from '@portabletext/editor/behaviors'
-import * as selectors from '@portabletext/editor/selectors'
-
-export type ObjectWithOptionalKey = {
-  _type: string
-  _key?: string
-  [other: string]: unknown
-}
-
-export type MarkdownBehaviorsConfig = {
-  horizontalRuleObject?: ({
-    context,
-  }: {
-    context: Pick<EditorContext, 'schema' | 'keyGenerator'>
-  }) => ObjectWithOptionalKey | undefined
-  defaultStyle?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-}
-
-export function createMarkdownBehaviors(config: MarkdownBehaviorsConfig) {
-  const automaticHrOnPaste = defineBehavior({
-    on: 'clipboard.paste',
-    guard: ({snapshot, event}) => {
-      const text = event.originEvent.dataTransfer.getData('text/plain')
-      const hrRegExp = /^(---)$|^(—-)$|^(___)$|^(\*\*\*)$/
-      const hrCharacters = text.match(hrRegExp)?.[0]
-      const hrObject = config.horizontalRuleObject?.({
-        context: {
-          schema: snapshot.context.schema,
-          keyGenerator: snapshot.context.keyGenerator,
-        },
-      })
-      const focusBlock = selectors.getFocusBlock(snapshot)
-      const focusTextBlock = selectors.getFocusTextBlock(snapshot)
-
-      if (!hrCharacters || !hrObject || !focusBlock) {
-        return false
-      }
-
-      return {hrCharacters, hrObject, focusBlock, focusTextBlock}
-    },
-    actions: [
-      (_, {hrCharacters}) => [
-        raise({
-          type: 'insert.text',
-          text: hrCharacters,
-        }),
-      ],
-      ({snapshot}, {hrObject, focusBlock, focusTextBlock}) =>
-        focusTextBlock
-          ? [
-              raise({
-                type: 'insert.block',
-                block: {
-                  _type: snapshot.context.schema.block.name,
-                  children: focusTextBlock.node.children,
-                },
-                placement: 'after',
-              }),
-              raise({
-                type: 'insert.block',
-                block: hrObject,
-                placement: 'after',
-              }),
-              raise({
-                type: 'delete.block',
-                at: focusBlock.path,
-              }),
-            ]
-          : [
-              raise({
-                type: 'insert.block',
-                block: hrObject,
-                placement: 'after',
-              }),
-            ],
-    ],
-  })
-
-  const clearStyleOnBackspace = defineBehavior({
-    on: 'delete.backward',
-    guard: ({snapshot}) => {
-      const selectionCollapsed = selectors.isSelectionCollapsed(snapshot)
-      const focusTextBlock = selectors.getFocusTextBlock(snapshot)
-      const focusSpan = selectors.getFocusSpan(snapshot)
-
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan) {
-        return false
-      }
-
-      const atTheBeginningOfBLock =
-        focusTextBlock.node.children[0]._key === focusSpan.node._key &&
-        snapshot.context.selection?.focus.offset === 0
-
-      const defaultStyle = config.defaultStyle?.({
-        context: {schema: snapshot.context.schema},
-        schema: snapshot.context.schema,
-      })
-
-      if (
-        atTheBeginningOfBLock &&
-        defaultStyle &&
-        focusTextBlock.node.style !== defaultStyle
-      ) {
-        return {defaultStyle, focusTextBlock}
-      }
-
-      return false
-    },
-    actions: [
-      (_, {defaultStyle, focusTextBlock}) => [
-        raise({
-          type: 'block.set',
-          props: {style: defaultStyle},
-          at: focusTextBlock.path,
-        }),
-      ],
-    ],
-  })
-
-  const markdownBehaviors = [automaticHrOnPaste, clearStyleOnBackspace]
-
-  return markdownBehaviors
-}

package/src/behavior.markdown.feature

@@ -1,108 +0,0 @@
-Feature: Markdown Behaviors
-
-  Background:
-    Given a global keymap
-
-  Scenario: Automatic blockquote
-    Given the text ">"
-    When "{Space}" is pressed
-    Then the text is "q:"
-
-  Scenario: Automatic blockquote not toggled by space in the beginning
-    Given the text ">"
-    When the caret is put before ">"
-    When "{Space}" is pressed
-    Then the text is " >"
-
-  Scenario: Automatic blockquote in non-empty block
-    Given the text ">foo"
-    When the caret is put before "f"
-    And "{Space}" is pressed
-    Then the text is "q:foo"
-
-  Scenario Outline: Automatic headings
-    Given the text <text>
-    When "{Space}" is pressed
-    Then the text is <new text>
-
-    Examples:
-      | text      | new text   |
-      | "#"       | "h1:"      |
-      | "##"      | "h2:"      |
-      | "###"     | "h3:"      |
-      | "####"    | "h4:"      |
-      | "#####"   | "h5:"      |
-      | "######"  | "h6:"      |
-      | "#######" | "####### " |
-
-  Scenario Outline: Automatic headings not toggled by space in the beginning
-    Given the text <text>
-    When the caret is put <position>
-    When "{Space}" is pressed
-    Then the text is <new text>
-
-    Examples:
-      | text  | position     | new text |
-      | "#"   | before "#"   | " #"     |
-      | "##"  | before "##"  | " ##"    |
-      | "###" | before "###" | " ###"   |
-
-  Scenario Outline: Automatic headings toggled by space mid-heading
-    Given the text <text>
-    When the caret is put <position>
-    When "{ArrowRight}" is pressed
-    When "{Space}" is pressed
-    Then the text is <new text>
-
-    Examples:
-      | text  | position     | new text |
-      | "##"  | before "##"  | "h1:#"   |
-      | "###" | before "###" | "h1:##"  |
-
-  Scenario Outline: Automatic headings in non-empty block
-    Given the text <text>
-    When the caret is put <position>
-    And "{Space}" is pressed
-    Then the text is <new text>
-
-    Examples:
-      | text         | position     | new text      |
-      | "foo"        | before "foo" | " foo"        |
-      | "#foo"       | before "foo" | "h1:foo"      |
-      | "##foo"      | before "foo" | "h2:foo"      |
-      | "###foo"     | before "foo" | "h3:foo"      |
-      | "####foo"    | before "foo" | "h4:foo"      |
-      | "#####foo"   | before "foo" | "h5:foo"      |
-      | "######foo"  | before "foo" | "h6:foo"      |
-      | "#######foo" | before "foo" | "####### foo" |
-
-  Scenario Outline: Clear style on Backspace
-    Given the text "foo"
-    When <style> is toggled
-    And "{Backspace}" is pressed 4 times
-    Then the text is ""
-
-    Examples:
-      | style |
-      | "h1"  |
-      | "h2"  |
-      | "h3"  |
-      | "h4"  |
-      | "h5"  |
-      | "h6"  |
-
-  Scenario Outline: Clear style on Backspace in empty block
-    Given the text "foo"
-    When <style> is toggled
-    And "{Backspace}" is pressed 4 times
-    And "bar" is typed
-    Then the text is "bar"
-
-    Examples:
-      | style |
-      | "h1"  |
-      | "h2"  |
-      | "h3"  |
-      | "h4"  |
-      | "h5"  |
-      | "h6"  |

package/src/behavior.markdown.test.tsx

@@ -1,63 +0,0 @@
-import {defineSchema} from '@portabletext/editor'
-import {parameterTypes} from '@portabletext/editor/test'
-import {
-  createTestEditor,
-  stepDefinitions,
-  type Context,
-} from '@portabletext/editor/test/vitest'
-import {Before} from 'racejar'
-import {Feature} from 'racejar/vitest'
-import behaviorMarkdownFeature from './behavior.markdown.feature?raw'
-import {MarkdownShortcutsPlugin} from './plugin.markdown-shortcuts'
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: (
-          <MarkdownShortcutsPlugin
-            defaultStyle={({context}) => context.schema.styles[0]?.name}
-            headingStyle={({context, props}) =>
-              context.schema.styles.find(
-                (style) => style.name === `h${props.level}`,
-              )?.name
-            }
-            blockquoteStyle={({context}) =>
-              context.schema.styles.find((style) => style.name === 'blockquote')
-                ?.name
-            }
-            unorderedList={({context}) =>
-              context.schema.lists.find((list) => list.name === 'bullet')?.name
-            }
-            orderedList={({context}) =>
-              context.schema.lists.find((list) => list.name === 'number')?.name
-            }
-          />
-        ),
-        schemaDefinition: defineSchema({
-          annotations: [{name: 'comment'}, {name: 'link'}],
-          decorators: [{name: 'em'}, {name: 'strong'}],
-          blockObjects: [{name: 'image'}, {name: 'break'}],
-          inlineObjects: [{name: 'stock-ticker'}],
-          lists: [{name: 'bullet'}, {name: 'number'}],
-          styles: [
-            {name: 'normal'},
-            {name: 'h1'},
-            {name: 'h2'},
-            {name: 'h3'},
-            {name: 'h4'},
-            {name: 'h5'},
-            {name: 'h6'},
-            {name: 'blockquote'},
-          ],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: behaviorMarkdownFeature,
-  stepDefinitions: stepDefinitions,
-  parameterTypes,
-})

package/src/global.d.ts

@@ -1,4 +0,0 @@
-declare module '*.feature?raw' {
-  const content: string
-  export default content
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './plugin.markdown-shortcuts'

package/src/plugin.markdown-shortcuts.tsx

@@ -1,233 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {useEditor} from '@portabletext/editor'
-import {CharacterPairDecoratorPlugin} from '@portabletext/plugin-character-pair-decorator'
-import {InputRulePlugin} from '@portabletext/plugin-input-rule'
-import {useEffect, useMemo} from 'react'
-import {
-  createMarkdownBehaviors,
-  type MarkdownBehaviorsConfig,
-  type ObjectWithOptionalKey,
-} from './behavior.markdown-shortcuts'
-import {createBlockquoteRule} from './rule.blockquote'
-import {createHeadingRule} from './rule.heading'
-import {createHorizontalRuleRule} from './rule.horizontal-rule'
-import {createMarkdownLinkRule} from './rule.markdown-link'
-import {createOrderedListRule} from './rule.ordered-list'
-import {createUnorderedListRule} from './rule.unordered-list'
-
-/**
- * @public
- */
-export type MarkdownShortcutsPluginProps = MarkdownBehaviorsConfig & {
-  blockquoteStyle?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  defaultStyle?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  headingStyle?: ({
-    context,
-    schema,
-    props,
-    level,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-    props: {level: number}
-    /**
-     * @deprecated Use `props.level` instead
-     */
-    level: number
-  }) => string | undefined
-  linkObject?: ({
-    context,
-    props,
-  }: {
-    context: Pick<EditorContext, 'schema' | 'keyGenerator'>
-    props: {href: string}
-  }) => ObjectWithOptionalKey | undefined
-  unorderedList?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  orderedList?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  boldDecorator?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  codeDecorator?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  italicDecorator?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-  strikeThroughDecorator?: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-}
-
-/**
- * @public
- */
-export function MarkdownShortcutsPlugin({
-  blockquoteStyle,
-  boldDecorator,
-  codeDecorator,
-  defaultStyle,
-  headingStyle,
-  horizontalRuleObject,
-  linkObject,
-  italicDecorator,
-  orderedList,
-  strikeThroughDecorator,
-  unorderedList,
-}: MarkdownShortcutsPluginProps) {
-  const editor = useEditor()
-
-  useEffect(() => {
-    const behaviors = createMarkdownBehaviors({
-      defaultStyle,
-    })
-
-    const unregisterBehaviors = behaviors.map((behavior) =>
-      editor.registerBehavior({behavior}),
-    )
-
-    return () => {
-      for (const unregisterBehavior of unregisterBehaviors) {
-        unregisterBehavior()
-      }
-    }
-  }, [defaultStyle, editor])
-
-  const inputRules = useMemo(() => {
-    const rules = []
-    if (blockquoteStyle) {
-      rules.push(createBlockquoteRule({blockquoteStyle}))
-    }
-    if (headingStyle) {
-      rules.push(createHeadingRule({headingStyle}))
-    }
-    if (horizontalRuleObject) {
-      rules.push(createHorizontalRuleRule({horizontalRuleObject}))
-    }
-    if (linkObject) {
-      rules.push(createMarkdownLinkRule({linkObject}))
-    }
-    if (orderedList) {
-      rules.push(createOrderedListRule({orderedList}))
-    }
-    if (unorderedList) {
-      rules.push(createUnorderedListRule({unorderedList}))
-    }
-    return rules.length > 0 ? rules : null
-  }, [
-    blockquoteStyle,
-    headingStyle,
-    horizontalRuleObject,
-    linkObject,
-    orderedList,
-    unorderedList,
-  ])
-
-  return (
-    <>
-      {boldDecorator ? (
-        <>
-          <CharacterPairDecoratorPlugin
-            decorator={boldDecorator}
-            pair={{char: '*', amount: 2}}
-          />
-          <CharacterPairDecoratorPlugin
-            decorator={boldDecorator}
-            pair={{char: '_', amount: 2}}
-          />
-        </>
-      ) : null}
-      {codeDecorator ? (
-        <CharacterPairDecoratorPlugin
-          decorator={codeDecorator}
-          pair={{char: '`', amount: 1}}
-        />
-      ) : null}
-      {italicDecorator ? (
-        <>
-          <CharacterPairDecoratorPlugin
-            decorator={italicDecorator}
-            pair={{char: '*', amount: 1}}
-          />
-          <CharacterPairDecoratorPlugin
-            decorator={italicDecorator}
-            pair={{char: '_', amount: 1}}
-          />
-        </>
-      ) : null}
-      {strikeThroughDecorator ? (
-        <CharacterPairDecoratorPlugin
-          decorator={strikeThroughDecorator}
-          pair={{char: '~', amount: 2}}
-        />
-      ) : null}
-      {inputRules ? <InputRulePlugin rules={inputRules} /> : null}
-    </>
-  )
-}

package/src/rule.blockquote.ts

@@ -1,63 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {raise} from '@portabletext/editor/behaviors'
-import {getPreviousInlineObject} from '@portabletext/editor/selectors'
-import {defineInputRule} from '@portabletext/plugin-input-rule'
-
-export function createBlockquoteRule(config: {
-  blockquoteStyle: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-}) {
-  return defineInputRule({
-    on: /^> /,
-    guard: ({snapshot, event}) => {
-      const style = config.blockquoteStyle({
-        context: {schema: snapshot.context.schema},
-        schema: snapshot.context.schema,
-      })
-
-      if (!style) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-
-      if (previousInlineObject) {
-        return false
-      }
-
-      const match = event.matches.at(0)
-
-      if (!match) {
-        return false
-      }
-
-      return {style, match}
-    },
-    actions: [
-      ({event}, {style, match}) => [
-        raise({
-          type: 'block.unset',
-          props: ['listItem', 'level'],
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'block.set',
-          props: {style},
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'delete',
-          at: match.targetOffsets,
-        }),
-      ],
-    ],
-  })
-}

package/src/rule.heading.ts

@@ -1,74 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {raise} from '@portabletext/editor/behaviors'
-import {getPreviousInlineObject} from '@portabletext/editor/selectors'
-import {defineInputRule} from '@portabletext/plugin-input-rule'
-
-export function createHeadingRule(config: {
-  headingStyle: ({
-    context,
-    schema,
-    props,
-    level,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-    props: {level: number}
-    /**
-     * @deprecated Use `props.level` instead
-     */
-    level: number
-  }) => string | undefined
-}) {
-  return defineInputRule({
-    on: /^#+ /,
-    guard: ({snapshot, event}) => {
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-
-      if (previousInlineObject) {
-        return false
-      }
-
-      const match = event.matches.at(0)
-
-      if (!match) {
-        return false
-      }
-
-      const level = match.text.length - 1
-
-      const style = config.headingStyle({
-        context: {schema: snapshot.context.schema},
-        schema: snapshot.context.schema,
-        props: {level},
-        level,
-      })
-
-      if (!style) {
-        return false
-      }
-
-      return {match, style}
-    },
-    actions: [
-      ({event}, {match, style}) => [
-        raise({
-          type: 'block.unset',
-          props: ['listItem', 'level'],
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'block.set',
-          props: {style},
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'delete',
-          at: match.targetOffsets,
-        }),
-      ],
-    ],
-  })
-}

package/src/rule.horizontal-rule.ts

@@ -1,64 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {raise} from '@portabletext/editor/behaviors'
-import {getPreviousInlineObject} from '@portabletext/editor/selectors'
-import {defineInputRule} from '@portabletext/plugin-input-rule'
-import type {ObjectWithOptionalKey} from './behavior.markdown-shortcuts'
-
-export function createHorizontalRuleRule(config: {
-  horizontalRuleObject: ({
-    context,
-  }: {
-    context: Pick<EditorContext, 'schema' | 'keyGenerator'>
-  }) => ObjectWithOptionalKey | undefined
-}) {
-  return defineInputRule({
-    on: /^(---)|^(—-)|^(___)|^(\*\*\*)/,
-    guard: ({snapshot, event}) => {
-      const hrObject = config.horizontalRuleObject({
-        context: {
-          schema: snapshot.context.schema,
-          keyGenerator: snapshot.context.keyGenerator,
-        },
-      })
-
-      if (!hrObject) {
-        // If no horizontal rule object is provided, then we can safely skip
-        // this rule.
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-
-      if (previousInlineObject) {
-        // Input Rules only look at the plain text of the text block. This
-        // means that the RegExp is matched even if there is a leading inline
-        // object.
-        return false
-      }
-
-      // In theory, an Input Rule could return multiple matches. But in this
-      // case we only expect one match.
-      const match = event.matches.at(0)
-
-      if (!match) {
-        return false
-      }
-
-      return {hrObject, match}
-    },
-    actions: [
-      (_, {hrObject, match}) => [
-        raise({
-          type: 'insert.block',
-          block: hrObject,
-          placement: 'before',
-          select: 'none',
-        }),
-        raise({
-          type: 'delete',
-          at: match.targetOffsets,
-        }),
-      ],
-    ],
-  })
-}

package/src/rule.markdown-link.feature

@@ -1,56 +0,0 @@
-Feature: Markdown Link Rule
-
-  Background:
-    Given a global keymap
-
-  Scenario Outline: Transform markdown Link into annotation
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-    And <annotated> has <marks>
-
-    Examples:
-      | text          | inserted text | new text          | annotated | marks      |
-      | "[foo](bar"   | ")"           | "foo,new"         | "foo"     | marks "k4" |
-      | "[[foo](bar"  | ")"           | "[,foo,new"       | "foo"     | marks "k4" |
-      | "[f[oo](bar"  | ")"           | "[f,oo,new"       | "oo"      | marks "k4" |
-      | "[f[]oo](bar" | ")"           | "[f[]oo](bar)new" | ""        | no marks   |
-
-  Scenario: Preserving decorator in link text
-    Given the text "[foo](bar"
-    And "strong" around "foo"
-    When ")" is inserted
-    And "new" is typed
-    Then the text is "foo,new"
-    And "foo" has marks "strong,k6"
-
-  Scenario: Preserving decorators in link text
-    Given the text "[foo](bar"
-    And "strong" around "foo"
-    And "em" around "oo"
-    When ")" is inserted
-    And "new" is typed
-    Then the text is "f,oo,new"
-    And "f" has marks "strong,k7"
-    And "oo" has marks "strong,em,k7"
-
-  Scenario: Overwriting other links
-    Given the text "[foo](bar"
-    And a "link" "l1" around "foo"
-    When the caret is put after "bar"
-    And ")" is inserted
-    And "new" is typed
-    Then the text is "foo,new"
-    And "foo" has an annotation different than "l1"
-
-  Scenario: Preserving other annotations
-    Given the text "[foo](bar"
-    And a "link" "l1" around "foo"
-    And a "comment" "c1" around "foo"
-    When the caret is put after "bar"
-    And ")" is inserted
-    And "new" is typed
-    Then the text is "foo,new"
-    And "foo" has an annotation different than "l1"
-    And "foo" has marks "c1,k9"

package/src/rule.markdown-link.test.tsx

@@ -1,44 +0,0 @@
-import {defineSchema} from '@portabletext/editor'
-import {parameterTypes} from '@portabletext/editor/test'
-import {
-  createTestEditor,
-  stepDefinitions,
-  type Context,
-} from '@portabletext/editor/test/vitest'
-import {InputRulePlugin} from '@portabletext/plugin-input-rule'
-import {Before} from 'racejar'
-import {Feature} from 'racejar/vitest'
-import {createMarkdownLinkRule} from './rule.markdown-link'
-import markdownLinkFeature from './rule.markdown-link.feature?raw'
-
-const markdownLinkRule = createMarkdownLinkRule({
-  linkObject: ({props}) => ({
-    _type: 'link',
-    href: props.href,
-  }),
-})
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: (
-          <>
-            <InputRulePlugin rules={[markdownLinkRule]} />
-          </>
-        ),
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}, {name: 'em'}],
-          annotations: [{name: 'link'}, {name: 'comment'}],
-          inlineObjects: [{name: 'stock-ticker'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: markdownLinkFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/rule.markdown-link.ts

@@ -1,108 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {raise, type BehaviorAction} from '@portabletext/editor/behaviors'
-import {defineInputRule} from '@portabletext/plugin-input-rule'
-import type {ObjectWithOptionalKey} from './behavior.markdown-shortcuts'
-
-export function createMarkdownLinkRule(config: {
-  linkObject: ({
-    context,
-    props,
-  }: {
-    context: Pick<EditorContext, 'schema' | 'keyGenerator'>
-    props: {href: string}
-  }) => ObjectWithOptionalKey | undefined
-}) {
-  return defineInputRule({
-    on: /\[([^[\]]+)]\((.+)\)/,
-    actions: [
-      ({snapshot, event}) => {
-        const newText = event.textBefore + event.textInserted
-        let textLengthDelta = 0
-        const actions: Array<BehaviorAction> = []
-
-        for (const match of event.matches.reverse()) {
-          const textMatch = match.groupMatches.at(0)
-          const hrefMatch = match.groupMatches.at(1)
-
-          if (textMatch === undefined || hrefMatch === undefined) {
-            continue
-          }
-
-          textLengthDelta =
-            textLengthDelta -
-            (match.targetOffsets.focus.offset -
-              match.targetOffsets.anchor.offset -
-              textMatch.text.length)
-
-          const linkObject = config.linkObject({
-            context: {
-              schema: snapshot.context.schema,
-              keyGenerator: snapshot.context.keyGenerator,
-            },
-            props: {href: hrefMatch.text},
-          })
-
-          if (!linkObject) {
-            continue
-          }
-
-          const {_type, _key, ...value} = linkObject
-
-          const leftSideOffsets = {
-            anchor: match.targetOffsets.anchor,
-            focus: textMatch.targetOffsets.anchor,
-          }
-          const rightSideOffsets = {
-            anchor: textMatch.targetOffsets.focus,
-            focus: match.targetOffsets.focus,
-          }
-
-          actions.push(
-            raise({
-              type: 'select',
-              at: textMatch.targetOffsets,
-            }),
-          )
-          actions.push(
-            raise({
-              type: 'annotation.add',
-              annotation: {
-                name: _type,
-                _key,
-                value,
-              },
-            }),
-          )
-          actions.push(
-            raise({
-              type: 'delete',
-              at: rightSideOffsets,
-            }),
-          )
-          actions.push(
-            raise({
-              type: 'delete',
-              at: leftSideOffsets,
-            }),
-          )
-        }
-
-        const endCaretPosition = {
-          path: event.focusBlock.path,
-          offset: newText.length - textLengthDelta * -1,
-        }
-
-        return [
-          ...actions,
-          raise({
-            type: 'select',
-            at: {
-              anchor: endCaretPosition,
-              focus: endCaretPosition,
-            },
-          }),
-        ]
-      },
-    ],
-  })
-}

package/src/rule.ordered-list.ts

@@ -1,66 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {raise} from '@portabletext/editor/behaviors'
-import {getPreviousInlineObject} from '@portabletext/editor/selectors'
-import {defineInputRule} from '@portabletext/plugin-input-rule'
-
-export function createOrderedListRule(config: {
-  orderedList: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-}) {
-  return defineInputRule({
-    on: /^1\. /,
-    guard: ({snapshot, event}) => {
-      const orderedList = config.orderedList({
-        context: {schema: snapshot.context.schema},
-        schema: snapshot.context.schema,
-      })
-
-      if (!orderedList) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-
-      if (previousInlineObject) {
-        return false
-      }
-
-      const match = event.matches.at(0)
-
-      if (!match) {
-        return false
-      }
-
-      return {match, orderedList}
-    },
-    actions: [
-      ({event}, {match, orderedList}) => [
-        raise({
-          type: 'block.unset',
-          props: ['style'],
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'block.set',
-          props: {
-            listItem: orderedList,
-            level: event.focusBlock.node.level ?? 1,
-          },
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'delete',
-          at: match.targetOffsets,
-        }),
-      ],
-    ],
-  })
-}

package/src/rule.unordered-list.ts

@@ -1,66 +0,0 @@
-import type {EditorContext} from '@portabletext/editor'
-import {raise} from '@portabletext/editor/behaviors'
-import {getPreviousInlineObject} from '@portabletext/editor/selectors'
-import {defineInputRule} from '@portabletext/plugin-input-rule'
-
-export function createUnorderedListRule(config: {
-  unorderedList: ({
-    context,
-    schema,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-    /**
-     * @deprecated Use `context.schema` instead
-     */
-    schema: EditorContext['schema']
-  }) => string | undefined
-}) {
-  return defineInputRule({
-    on: /^(-|\*) /,
-    guard: ({snapshot, event}) => {
-      const unorderedList = config.unorderedList({
-        context: {schema: snapshot.context.schema},
-        schema: snapshot.context.schema,
-      })
-
-      if (!unorderedList) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-
-      if (previousInlineObject) {
-        return false
-      }
-
-      const match = event.matches.at(0)
-
-      if (!match) {
-        return false
-      }
-
-      return {match, unorderedList}
-    },
-    actions: [
-      ({event}, {match, unorderedList}) => [
-        raise({
-          type: 'block.unset',
-          props: ['style'],
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'block.set',
-          props: {
-            listItem: unorderedList,
-            level: event.focusBlock.node.level ?? 1,
-          },
-          at: event.focusBlock.path,
-        }),
-        raise({
-          type: 'delete',
-          at: match.targetOffsets,
-        }),
-      ],
-    ],
-  })
-}